Add the harness, envs, per-bot models and chat attachments

- Harness: providers, model catalog synced hourly, automatic free picks,
  cooldowns, tool loop with context trimming, MCP computer tools
- Bots queue runs replies and tasks through the harness; jobs wait
  (attempt refunded) while every model is resting
- Envs: Settings > Environment, scoped general/workspace/computer,
  written to computers and redacted from tool output
- Models: Settings > Models, per-harness provider select defaulting to
  OpenRouter, and a models modal on each bot's chat (the coordinator's
  edits the defaults)
- Chat: thinking row while a reply runs, file attachments (upload,
  paste, drop) that replies read as images, audio and document text
- Fix media uploads failing after a user's first file, and private
  files being served from the public media path

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/utils/attachment-file-kind.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import attachmentFileKind from "./attachment-file-kind";
+
+describe("attachmentFileKind", () => {
+    test("reads the browser's type", () => {
+        expect(attachmentFileKind({ mime: "image/png", name: "shot.png" })).toEqual({ media_type: "image", ext: "png" });
+        expect(attachmentFileKind({ mime: "audio/mpeg", name: "memo.mp3" })).toEqual({ media_type: "audio", ext: "mp3" });
+        expect(attachmentFileKind({ mime: "application/pdf", name: "a.pdf" })).toEqual({ media_type: "document", ext: "pdf" });
+    });
+
+    test("falls back to the name when the type is vague", () => {
+        expect(attachmentFileKind({ mime: "", name: "notes.md" })).toEqual({ media_type: "document", ext: "md" });
+        expect(attachmentFileKind({ mime: "application/octet-stream", name: "clip.m4a" })).toEqual({ media_type: "audio", ext: "m4a" });
+    });
+
+    test("keeps SVG as a document, not an image to resize", () => {
+        expect(attachmentFileKind({ mime: "image/svg+xml", name: "logo.svg" }).media_type).toBe("document");
+    });
+
+    test("never stores a strange extension", () => {
+        expect(attachmentFileKind({ mime: "", name: "noext" }).ext).toBe("bin");
+        expect(attachmentFileKind({ mime: "", name: "x.p/../df" }).ext).toBe("df");
+    });
+});

src/utils/attachment-file-kind.ts

@@ -0,0 +1,38 @@
+import type { MediaType } from "@/src/types";
+
+type Params = {
+    /**
+     * The browser's type, often empty or `application/octet-stream`.
+     */
+    mime?: string;
+    name: string;
+};
+
+const AudioExtensions = ["mp3", "wav", "m4a", "ogg", "oga", "webm", "flac", "aac", "opus"];
+const VideoExtensions = ["mp4", "mov", "mkv", "avi", "m4v"];
+const ImageExtensions = ["jpg", "jpeg", "png", "webp", "gif", "bmp", "tiff", "tif", "avif"];
+
+/**
+ * What a chat attachment is, from its type and name: its media type and
+ * the extension to store it under (the name's, else the type's).
+ */
+export default function attachmentFileKind({ mime = "", name }: Params): {
+    media_type: MediaType;
+    ext: string;
+} {
+    const type = mime.toLowerCase().split(";")[0]!.trim();
+    const from_name = name.includes(".") ? name.split(".").pop()!.toLowerCase() : "";
+    const from_type = type.split("/").pop()?.split("+")[0] || "";
+    const ext = (from_name || (from_type == "octet-stream" ? "" : from_type) || "bin").replace(/[^a-z0-9]/g, "") || "bin";
+
+    if (type.startsWith("image/") && type != "image/svg+xml") return { media_type: "image", ext };
+    if (type.startsWith("audio/")) return { media_type: "audio", ext };
+    if (type.startsWith("video/")) {
+        return { media_type: ext == "webm" && !from_name ? "audio" : "video", ext };
+    }
+    if (ImageExtensions.includes(from_name)) return { media_type: "image", ext };
+    if (AudioExtensions.includes(from_name)) return { media_type: "audio", ext };
+    if (VideoExtensions.includes(from_name)) return { media_type: "video", ext };
+
+    return { media_type: "document", ext };
+}

src/utils/redact-secrets.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import redactSecrets from "./redact-secrets";
+
+describe("redactSecrets", () => {
+    test("replaces every occurrence with the key", () => {
+        expect(
+            redactSecrets({
+                text: "token=ghp_abc123 and again ghp_abc123",
+                secrets: [{ key: "GITHUB_TOKEN", value: "ghp_abc123" }],
+            }),
+        ).toBe("token=[GITHUB_TOKEN] and again [GITHUB_TOKEN]");
+    });
+
+    test("replaces longer values first", () => {
+        expect(
+            redactSecrets({
+                text: "secret-long",
+                secrets: [
+                    { key: "SHORT", value: "secret" },
+                    { key: "LONG", value: "secret-long" },
+                ],
+            }),
+        ).toBe("[LONG]");
+    });
+
+    test("leaves very short values alone", () => {
+        expect(
+            redactSecrets({ text: "a 1 b", secrets: [{ key: "PIN", value: "1" }] }),
+        ).toBe("a 1 b");
+    });
+});

src/utils/redact-secrets.ts

@@ -0,0 +1,26 @@
+type Params = {
+    text: string;
+    /**
+     * Secret values by the key they're shown as.
+     */
+    secrets: { key: string; value: string }[];
+};
+
+/**
+ * Replaces every secret value in `text` with `[KEY]`, longest first so a
+ * value inside another is never half replaced. Values under 4 characters
+ * are left alone: too likely to match ordinary text.
+ */
+export default function redactSecrets({ text, secrets }: Params) {
+    const usable = secrets
+        .filter((secret) => secret.value.length >= 4)
+        .sort((a, b) => b.value.length - a.value.length);
+
+    let redacted = text;
+
+    for (const secret of usable) {
+        redacted = redacted.split(secret.value).join(`[${secret.key}]`);
+    }
+
+    return redacted;
+}