@stevecastaneda/paseo-progress 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "A live progress dashboard per worktree for Paseo, drawn from a file agents write with the paseo-progress command.",
   "license": "MIT",
   "author": "Steve Castaneda",
@@ -43,21 +43,20 @@
     "test": "node --test \"*/*.test.ts\"",
     "dev": "node ../scripts/dev.mjs",
     "check:install": "node ../scripts/check-install.mjs",
-    "build:cli": "rm -rf dist && tsc -p tsconfig.cli.json",
+    "build:cli": "rm -rf dist && esbuild server/cli.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/server/cli.js --log-level=warning",
     "prepack": "npm run build:cli",
     "postpack": "rm -rf dist"
   },
   "devDependencies": {
+    "@getpaseo/client": "^0.9.2",
     "@getpaseo/plugin": "^0.9.2",
     "@tanstack/react-query": "^5.90.11",
     "@types/node": "^20.9.0",
     "@types/react": "~19.2.0",
+    "esbuild": "^0.25.12",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "@getpaseo/client": "^0.9.2",
+    "typescript": "^5.9.3",
     "zod": "^4.4.3"
   }
 }

package/dist/server/launcher.js

@@ -1,90 +0,0 @@
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { delimiter, dirname, join } from "node:path";
-export const PLUGIN_ID = "progress";
-// The launcher never names a plugin folder. Each run asks Paseo which copy of
-// the plugin it is running, so updates and `npm run dev` switches keep working.
-export function launcherScript() {
-    return `#!/usr/bin/env node
-// Written by the ${PLUGIN_ID} Paseo plugin. Runs the progress command from the
-// copy of the plugin Paseo is running now.
-const [major, minor] = process.versions.node.split(".").map(Number);
-if (major < 22 || (major === 22 && minor < 18)) {
-  console.error("paseo-progress needs Node.js 22.18 or later; this is " + process.version + ".");
-  process.exit(1);
-}
-// Not require: a package.json with "type": "module" above this folder makes Node load it as ESM.
-const { spawnSync } = process.getBuiltinModule("node:child_process");
-const { existsSync } = process.getBuiltinModule("node:fs");
-const { join } = process.getBuiltinModule("node:path");
-
-function pluginDirectory() {
-  if (process.env.PASEO_PROGRESS_PLUGIN_DIR) return process.env.PASEO_PROGRESS_PLUGIN_DIR;
-  const clis = [process.env.PASEO_BIN, "paseo", "/Applications/Paseo.app/Contents/Resources/bin/paseo"].filter(Boolean);
-  for (const cli of clis) {
-    const result = spawnSync(cli, ["plugin", "ls", "${PLUGIN_ID}", "--json"], { encoding: "utf8" });
-    if (result.error || result.status !== 0) continue;
-    try {
-      const plugin = JSON.parse(result.stdout).find((entry) => entry.id === "${PLUGIN_ID}");
-      return plugin && plugin.path;
-    } catch {
-      return undefined;
-    }
-  }
-  return undefined;
-}
-
-// An npm install puts the plugin under node_modules, where Node won't run
-// TypeScript, so the npm package carries the command compiled to dist/.
-const directory = pluginDirectory();
-const entry = directory && [join(directory, "dist", "server", "cli.js"), join(directory, "server", "cli.ts")].find((path) => existsSync(path));
-if (!entry) {
-  console.error("The ${PLUGIN_ID} plugin is not installed in Paseo, or Paseo is not reachable. Check with: paseo plugin ls");
-  process.exit(1);
-}
-const run = spawnSync(process.execPath, [entry, ...process.argv.slice(2)], { stdio: "inherit" });
-process.exit(run.status === null ? 1 : run.status);
-`;
-}
-const MARKER = `Written by the ${PLUGIN_ID} Paseo plugin`;
-export function defaultLauncherPath(home = homedir()) {
-    return join(home, ".local", "bin", "paseo-progress");
-}
-export async function launcherState(path) {
-    const current = await readFile(path, "utf8").catch(() => null);
-    if (current === null)
-        return "missing";
-    if (current === launcherScript())
-        return "current";
-    return current.includes(MARKER) ? "outdated" : "foreign";
-}
-// Writes the launcher when it is missing or out of date. Never replaces a file
-// something else put there. Returns whether it wrote.
-export async function installLauncher(path) {
-    const state = await launcherState(path);
-    if (state === "current")
-        return false;
-    if (state === "foreign")
-        throw new Error(`${path} already exists and was not written by this plugin. Move it, or pass another path.`);
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, launcherScript());
-    await chmod(path, 0o755);
-    return true;
-}
-// For the panel: whether agents on the daemon host can run `paseo-progress`.
-export async function launcherStatus(path = defaultLauncherPath(), pathEnv = process.env.PATH ?? "") {
-    return {
-        path,
-        state: await launcherState(path),
-        onPath: pathEnv.split(delimiter).some((entry) => entry.replace(/\/+$/, "") === dirname(path)),
-    };
-}
-export async function handleLauncherStatus() {
-    return launcherStatus();
-}
-// Runs only when the user presses Install in the panel.
-export async function handleInstallLauncher() {
-    const path = defaultLauncherPath();
-    await installLauncher(path);
-    return launcherStatus(path);
-}

package/dist/server/lock.js

@@ -1,34 +0,0 @@
-import { mkdir, rm, stat } from "node:fs/promises";
-const RETRY_MS = 25;
-const WAIT_MS = 10_000;
-// A lock older than this was left by a command that crashed.
-const STALE_MS = 30_000;
-// Serializes read-then-append so two commands never hand out the same id or
-// interleave a line. mkdir is atomic, so only one process creates the folder.
-export async function withLock(lockPath, work) {
-    const started = Date.now();
-    while (true) {
-        try {
-            await mkdir(lockPath);
-            break;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            const since = await stat(lockPath).then((info) => Date.now() - info.mtimeMs, () => 0);
-            if (since > STALE_MS) {
-                await rm(lockPath, { recursive: true, force: true });
-                continue;
-            }
-            if (Date.now() - started > WAIT_MS)
-                throw new Error(`Timed out waiting for ${lockPath}. If no other progress command is running, delete it.`);
-            await new Promise((resolve) => setTimeout(resolve, RETRY_MS + Math.random() * RETRY_MS));
-        }
-    }
-    try {
-        return await work();
-    }
-    finally {
-        await rm(lockPath, { recursive: true, force: true });
-    }
-}

package/dist/server/paths.js

@@ -1,22 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-// Whether a path from relative(root, target) leaves the root. "..notes" is a
-// name inside it, not a step out.
-export function outside(inside) {
-    return inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
-}
-// The worktree root is the nearest directory with a `.git` entry (a folder in
-// a checkout, a file in a linked worktree). Outside git, use the directory.
-// The command and the panel both start from here, so a Paseo project set at a
-// subfolder of the repo still reads the file the agent writes.
-export function findRoot(cwd) {
-    let directory = resolve(cwd);
-    while (true) {
-        if (existsSync(join(directory, ".git")))
-            return directory;
-        const parent = dirname(directory);
-        if (parent === directory)
-            return resolve(cwd);
-        directory = parent;
-    }
-}

package/dist/server/progress-file.js

@@ -1,115 +0,0 @@
-// Everything that reads or writes a worktree's progress files: the event log
-// the command appends to and the panel-opened marker. Each function takes the
-// folder that holds them, which `findStore` in store.ts picks. The command and
-// the panel's RPC handlers go through here, so they agree on how they're read.
-import { access, appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { EMPTY_DASHBOARD, latestRun, parseProgress, reduceProgress } from "../shared/dashboard.js";
-import { EVENT_VERSION, eventSchema, PANEL_OPENED_NAME, PROGRESS_FILE_NAME } from "../shared/events.js";
-import { withLock } from "./lock.js";
-const LOCK_NAME = `${PROGRESS_FILE_NAME}.lock`;
-// A draft the event schema rejects. The message names each bad field.
-export class InvalidEvent extends Error {
-}
-// The parsed file per folder, kept until its size or change time moves. The
-// file only grows, and the panel and pills read it every few seconds.
-const parsedFiles = new Map();
-// Replaced file snapshots and their derived data can be collected together.
-const dashboards = new WeakMap();
-// The dashboard at `now`, for the panel, the pills and `show`. Repeated reads
-// reuse the last one until the file changes or a stale or overdue time passes.
-// Stale and overdue checks use the daemon host's clock, the same clock the
-// command stamps events with.
-export async function readProgress(directory, now = new Date()) {
-    const parsed = await readParsed(directory);
-    const panelOpened = await exists(join(directory, PANEL_OPENED_NAME));
-    if (parsed === null)
-        return { configured: false, dashboard: EMPTY_DASHBOARD, panelOpened };
-    let cached = dashboards.get(parsed);
-    // A backwards clock jump must also re-evaluate stale/overdue state.
-    if (!cached || now.getTime() < cached.from || now.getTime() >= cached.until) {
-        const { dashboard, validUntil } = reduceProgress(parsed, now);
-        cached = { dashboard, from: now.getTime(), until: validUntil };
-        dashboards.set(parsed, cached);
-    }
-    return { configured: true, dashboard: cached.dashboard, panelOpened };
-}
-// The events of the latest run, oldest first.
-export async function readLatestRun(directory) {
-    return latestRun((await readParsed(directory))?.events ?? []).map(({ event }) => event);
-}
-// Appends the one event `write` builds from the file as it is now. Commands
-// that run at once take turns, so each sees the others' events and no two hand
-// out the same id. `write` may throw to append nothing.
-export async function appendProgress(directory, now, 
-// `events` is the latest run as it is now, oldest first.
-write, 
-// Runs before the lock is released, with the whole file as it now is.
-after) {
-    await mkdir(directory, { recursive: true });
-    return withLock(join(directory, LOCK_NAME), async () => {
-        const text = (await readText(directory)) ?? "";
-        const parsed = parseProgress(text);
-        const { dashboard, nextIds } = reduceProgress(parsed, now());
-        const { event, result } = write({ dashboard, nextIds, events: latestRun(parsed.events).map((line) => line.event) });
-        const checked = eventSchema.safeParse({ v: EVENT_VERSION, ts: now().toISOString(), ...withoutUndefined(event) });
-        if (!checked.success) {
-            throw new InvalidEvent(checked.error.issues.map((issue) => `${issue.path.join(".") || "value"}: ${issue.message}`).join("; "));
-        }
-        // A line cut short (a killed command, a hand edit) would swallow this event, so start a new line.
-        const lead = text && !text.endsWith("\n") ? "\n" : "";
-        const line = `${lead}${JSON.stringify(checked.data)}\n`;
-        await appendFile(join(directory, PROGRESS_FILE_NAME), line);
-        await after?.(text + line);
-        return result;
-    });
-}
-export async function markPanelOpened(directory) {
-    await mkdir(directory, { recursive: true });
-    await writeFile(join(directory, PANEL_OPENED_NAME), "");
-}
-async function readText(directory) {
-    try {
-        return await readFile(join(directory, PROGRESS_FILE_NAME), "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-async function readParsed(directory) {
-    const info = await stat(join(directory, PROGRESS_FILE_NAME)).catch((error) => {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    });
-    if (!info) {
-        parsedFiles.delete(directory);
-        return null;
-    }
-    const cached = parsedFiles.get(directory);
-    if (cached && cached.size === info.size && cached.mtimeMs === info.mtimeMs && cached.ctimeMs === info.ctimeMs)
-        return cached.parsed;
-    // Stat before reading: if the file grows in between, the next stat won't match and it's read again.
-    const text = await readText(directory);
-    if (text === null) {
-        parsedFiles.delete(directory);
-        return null;
-    }
-    const parsed = parseProgress(text);
-    parsedFiles.set(directory, { size: info.size, mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs, parsed });
-    return parsed;
-}
-async function exists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function withoutUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}

package/dist/server/store.js

@@ -1,205 +0,0 @@
-// Where a worktree's progress files live, and the run history a repo can opt
-// in to saving. The working files never touch the repo: they live outside it,
-// one folder per worktree, so git never sees them and nothing needs hiding.
-// Only runs the user asks to save are written into the repo, one file per run.
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { realpathSync } from "node:fs";
-import { appendFile, mkdir, readdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, join, normalize, resolve } from "node:path";
-import { promisify } from "node:util";
-import { LEGACY_FOLDER, PANEL_OPENED_NAME, PROGRESS_FILE_NAME } from "../shared/events.js";
-import { withLock } from "./lock.js";
-import { outside } from "./paths.js";
-const LOCK_NAME = `${PROGRESS_FILE_NAME}.lock`;
-const SAVE_RUNS_KEY = "paseo-progress.saveRuns";
-// Exactly what 0.1.x wrote into .scratch/.gitignore. Only this is ever removed.
-const LEGACY_GITIGNORE = `# Added by the progress plugin for Paseo so its files stay out of git.
-${PROGRESS_FILE_NAME}
-${LOCK_NAME}/
-${PANEL_OPENED_NAME}
-.gitignore
-`;
-export async function git(cwd, args) {
-    try {
-        const { stdout } = await promisify(execFile)("git", args, { cwd });
-        return { code: 0, stdout };
-    }
-    catch (error) {
-        const failed = error;
-        return { code: typeof failed.code === "number" ? failed.code : -1, stdout: failed.stdout ?? "" };
-    }
-}
-async function exists(path) {
-    return Boolean(await stat(path).catch(() => null));
-}
-// One folder per worktree on this computer, named so a person can tell which
-// worktree it belongs to.
-export function outsideDirectory(root, home = homedir()) {
-    let real = root;
-    try {
-        real = realpathSync(root);
-    }
-    catch { }
-    const hash = createHash("sha1").update(real).digest("hex").slice(0, 8);
-    return join(home, ".local", "state", "paseo-progress", `${basename(real)}-${hash}`);
-}
-// Whether git tracks a 0.1.x progress file, per worktree, until the file changes.
-const trackedLegacy = new Map();
-async function legacyTracked(root, mtimeMs) {
-    const cached = trackedLegacy.get(root);
-    if (cached && cached.mtimeMs === mtimeMs)
-        return cached.tracked;
-    const { code } = await git(root, ["ls-files", "--error-unmatch", "--", `${LEGACY_FOLDER}/${PROGRESS_FILE_NAME}`]);
-    trackedLegacy.set(root, { mtimeMs, tracked: code === 0 });
-    return code === 0;
-}
-// The worktree's working files. A run 0.1.x left in .scratch moves outside the
-// first time anything asks, unless git tracks it: then it stays and is used in
-// place, so nothing changes for a repo that commits it.
-export async function findStore(root, home = homedir()) {
-    const directory = outsideDirectory(root, home);
-    const store = { directory, shown: directory.startsWith(home) ? `~${directory.slice(home.length)}` : directory };
-    const legacy = join(root, LEGACY_FOLDER);
-    const info = await stat(join(legacy, PROGRESS_FILE_NAME)).catch(() => null);
-    if (!info)
-        return store;
-    if (await legacyTracked(root, info.mtimeMs))
-        return { directory: legacy, shown: LEGACY_FOLDER };
-    await moveLegacy(legacy, directory);
-    return store;
-}
-// Appends the old file's lines to the new one rather than replacing it, so a
-// command that wrote to the old place mid-move loses nothing: the next move
-// picks those lines up. Then tidies what 0.1.x left behind.
-async function moveLegacy(legacy, directory) {
-    await mkdir(directory, { recursive: true });
-    await withLock(join(legacy, LOCK_NAME), async () => {
-        const text = await readFile(join(legacy, PROGRESS_FILE_NAME), "utf8").catch(() => null);
-        if (text === null)
-            return;
-        await withLock(join(directory, LOCK_NAME), async () => {
-            const current = await readFile(join(directory, PROGRESS_FILE_NAME), "utf8").catch(() => "");
-            const lead = current && !current.endsWith("\n") ? "\n" : "";
-            await appendFile(join(directory, PROGRESS_FILE_NAME), `${lead}${text}`);
-        });
-        await rm(join(legacy, PROGRESS_FILE_NAME));
-        if (await exists(join(legacy, PANEL_OPENED_NAME))) {
-            await writeFile(join(directory, PANEL_OPENED_NAME), "");
-            await rm(join(legacy, PANEL_OPENED_NAME));
-        }
-    });
-    const ignore = await readFile(join(legacy, ".gitignore"), "utf8").catch(() => null);
-    if (ignore === LEGACY_GITIGNORE)
-        await rm(join(legacy, ".gitignore"));
-    // Only if nothing else is in there; the user's own files keep the folder.
-    await rmdir(legacy).catch(() => { });
-}
-// The repo's saved-history folder, kept in its local git config, which every
-// worktree of the repo shares and nothing commits. Polls cost one stat; git
-// runs again only when the config file changes.
-const configFiles = new Map();
-const savedFolders = new Map();
-async function configFile(root) {
-    if (!configFiles.has(root)) {
-        const { code, stdout } = await git(root, ["rev-parse", "--git-common-dir"]);
-        configFiles.set(root, code === 0 ? join(resolve(root, stdout.trim()), "config") : null);
-    }
-    return configFiles.get(root);
-}
-// Whether the worktree is in a git repo, which saving run history needs.
-export async function inGitRepo(root) {
-    return (await configFile(root)) !== null;
-}
-// The folder runs are saved to, relative to the worktree root, or null.
-export async function historyFolder(root) {
-    const file = await configFile(root);
-    if (file === null)
-        return null;
-    const mtimeMs = (await stat(file).catch(() => null))?.mtimeMs ?? 0;
-    const cached = savedFolders.get(file);
-    if (cached && cached.mtimeMs === mtimeMs)
-        return cached.folder;
-    const { stdout } = await git(root, ["config", "--get", SAVE_RUNS_KEY]);
-    const folder = stdout.trim() || null;
-    savedFolders.set(file, { mtimeMs, folder });
-    return folder;
-}
-// A folder the user picked, as a clean path inside the worktree, or why not.
-export function checkFolder(raw) {
-    const trimmed = raw.trim().replace(/\/+$/, "");
-    if (!trimmed)
-        return { error: "Choose a folder" };
-    const folder = normalize(trimmed);
-    if (outside(folder) || folder === ".")
-        return { error: "Choose a folder inside the repo" };
-    if (folder === ".git" || folder.startsWith(".git/"))
-        return { error: "Choose a folder outside .git" };
-    return { folder };
-}
-// Starts or stops saving runs for the whole repo. Files already saved stay.
-export async function setHistoryFolder(root, raw) {
-    if (raw === null) {
-        const { code } = await git(root, ["config", "--local", "--unset-all", SAVE_RUNS_KEY]);
-        // 5: it wasn't set, which is what was asked for.
-        if (code !== 0 && code !== 5)
-            throw new Error("Could not change this repo's git settings.");
-        return null;
-    }
-    const checked = checkFolder(raw);
-    if ("error" in checked)
-        throw new Error(checked.error);
-    const { code } = await git(root, ["config", "--local", SAVE_RUNS_KEY, checked.folder]);
-    if (code !== 0)
-        throw new Error("Could not save this in the repo's git settings. Is it a git repo?");
-    return checked.folder;
-}
-// "20261001-064512-warn-when-scratch.jsonl": when the run started, then its
-// title as it was at the start, so the name never changes and two runs never
-// share one.
-export function runFileName(startedAt, title) {
-    const stamp = startedAt.replace(/\.\d+Z$/, "").replace(/[-:]/g, "").replace("T", "-");
-    const slug = title.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-    return `${stamp}${slug ? `-${slug}` : ""}.jsonl`;
-}
-// After each change: when the repo saves runs, rewrite the current run's file
-// with every event from its start. Runs before the first start aren't saved.
-export async function saveRunCopy(root, text) {
-    const folder = await historyFolder(root);
-    if (!folder)
-        return;
-    const lines = text.split("\n").filter((line) => line.trim());
-    let start = -1;
-    let event = null;
-    for (let index = lines.length - 1; index >= 0; index--) {
-        try {
-            const parsed = JSON.parse(lines[index]);
-            if (parsed?.type === "run.start") {
-                start = index;
-                event = parsed;
-                break;
-            }
-        }
-        catch { }
-    }
-    if (start < 0 || !event?.ts || !event.title)
-        return;
-    const directory = join(root, folder);
-    await mkdir(directory, { recursive: true });
-    await writeFile(join(directory, runFileName(event.ts, event.title)), `${lines.slice(start).join("\n")}\n`);
-}
-// The folders directly inside one folder of the worktree ("" is the top), for
-// the folder picker. .git is left out; so are links, which could leave the repo.
-export async function listFolders(root, folder) {
-    const checked = folder === "" ? { folder: "" } : checkFolder(folder);
-    if ("error" in checked)
-        throw new Error(checked.error);
-    const entries = await readdir(join(root, checked.folder), { withFileTypes: true }).catch((error) => {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    });
-    const folders = entries.filter((entry) => entry.isDirectory() && !(checked.folder === "" && entry.name === ".git")).map((entry) => entry.name);
-    return { folder: checked.folder, folders: folders.sort((a, b) => a.localeCompare(b)) };
-}

package/dist/shared/attachments.js

@@ -1,92 +0,0 @@
-export function deliverableAttachment(deliverable) {
-    return { ref: deliverable.id, title: deliverable.title, path: deliverable.path, url: deliverable.url, kind: deliverable.kind };
-}
-function fileAttachment(ref, file) {
-    return { ref, title: file.label ?? (file.path ?? file.url ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "", path: file.path, url: file.url };
-}
-export function questionAttachments(question) {
-    return question.files.map((file, index) => fileAttachment(`${question.id}.${index + 1}`, file));
-}
-export function ticketSourceAttachment(ticket) {
-    return ticket.source ? fileAttachment(`${ticket.id}.source`, ticket.source) : null;
-}
-// The attachment a reference names, or null when it names nothing.
-export function findAttachment(dashboard, ref) {
-    const question = ref.match(/^(Q\d+)\./);
-    if (question) {
-        const found = [...dashboard.questions.open, ...dashboard.questions.answered].find((candidate) => candidate.id === question[1]);
-        return (found && questionAttachments(found).find((attachment) => attachment.ref === ref)) ?? null;
-    }
-    const ticket = ref.match(/^(.+)\.source$/);
-    if (ticket) {
-        const found = dashboard.tickets.find((candidate) => candidate.id === ticket[1]);
-        return found ? ticketSourceAttachment(found) : null;
-    }
-    const deliverable = dashboard.deliverables.find((candidate) => candidate.id === ref);
-    return deliverable ? deliverableAttachment(deliverable) : null;
-}
-const IMAGE_TYPES = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".svg": "image/svg+xml",
-};
-// Plain text shown as-is in the preview dialog, and opened in the browser on
-// the host. HTML is left to the browser either way.
-const TEXT_EXTENSIONS = new Set([".md", ".markdown", ".mdx", ".txt", ".log", ".json", ".jsonl", ".yaml", ".yml", ".csv"]);
-function extension(path) {
-    return path.toLowerCase().match(/\.[a-z0-9]+$/)?.[0] ?? null;
-}
-// The image type of a path by its extension, or null when it isn't an image.
-export function imageMimeType(path) {
-    return IMAGE_TYPES[extension(path) ?? ""] ?? null;
-}
-export function previewKind(path) {
-    if (imageMimeType(path))
-        return "image";
-    return TEXT_EXTENSIONS.has(extension(path) ?? "") ? "text" : null;
-}
-// Whether the preview dialog can show it. Only a browser draws SVG: Paseo's
-// desktop app can, the phone apps' image view can't, so there an SVG opens on
-// the host like any other file.
-export function canPreview(attachment, where) {
-    if (!attachment.path)
-        return false;
-    const kind = previewKind(attachment.path);
-    if (kind === "image" && extension(attachment.path) === ".svg")
-        return where.browser;
-    return kind !== null;
-}
-const KIND_ICON = {
-    file: "File",
-    folder: "Folder",
-    report: "FileChartColumn",
-    screenshot: "Image",
-    link: "Globe",
-};
-// One icon per attachment, the same on every screen. What the agent called a
-// deliverable wins; otherwise the file itself decides.
-export function attachmentIcon(attachment) {
-    if (attachment.kind && attachment.kind !== "file")
-        return KIND_ICON[attachment.kind];
-    if (attachment.url)
-        return "Globe";
-    if (!attachment.path)
-        return "File";
-    const kind = previewKind(attachment.path);
-    return kind === "image" ? "Image" : kind === "text" ? "FileText" : /[\/]$/.test(attachment.path) ? "Folder" : "File";
-}
-// The short name people recognize: a file or folder's own name, or a link's site.
-export function shortName(attachment) {
-    if (attachment.url) {
-        try {
-            return new URL(attachment.url).host.replace(/^www\./, "");
-        }
-        catch {
-            return attachment.url;
-        }
-    }
-    return (attachment.path ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
-}