@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agents/cursor/selection.js

@@ -0,0 +1,29 @@
+/** A stored model id that still carries parameters: `id[k=v,k=v]`. */
+const VARIANT = /^([^[\]]+)\[(.+)\]$/;
+/**
+ * Splits an older combined model id into separate knobs when the agent now offers them that way.
+ * A catalog that still lists the combined id is left alone.
+ */
+export function normalizeCursorSelection(selection, controls) {
+    const model = selection.model;
+    if (!model)
+        return selection;
+    const match = VARIANT.exec(model);
+    if (!match)
+        return selection;
+    const base = match[1];
+    const catalog = controls.find((control) => control.id === "model");
+    if (!catalog?.options.some((option) => option.value === base))
+        return selection;
+    const next = { ...selection, model: base };
+    for (const part of match[2].split(",")) {
+        const eq = part.indexOf("=");
+        if (eq < 0)
+            continue;
+        const id = part.slice(0, eq).trim();
+        const value = part.slice(eq + 1).trim();
+        if (id && value && next[id] === undefined)
+            next[id] = value;
+    }
+    return next;
+}

package/packages/server/modules/agents/cursor/task.js

@@ -0,0 +1,32 @@
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+function subagentOf(value) {
+    if (typeof value === "string" && value.trim() && value !== "unspecified")
+        return value;
+    if (value && typeof value === "object" && "custom" in value) {
+        const custom = value.custom;
+        if (typeof custom === "string" && custom.trim())
+            return custom;
+    }
+    return undefined;
+}
+/** `cursor/task`: the subagent finished; the dialect already opened the task on the tool call. */
+export async function reportCursorTask(options, params) {
+    const id = text(params.toolCallId, 200);
+    if (!id)
+        return {};
+    const subagent = subagentOf(params.subagentType);
+    const title = text(params.description, 500) || subagent || "задача";
+    const prompt = text(params.prompt, 2000);
+    const duration = typeof params.durationMs === "number" ? params.durationMs : undefined;
+    options.emit("task", {
+        id,
+        kind: "agent",
+        title,
+        status: "done",
+        background: false,
+        ...(subagent ? { subagent } : {}),
+        ...(prompt ? { prompt } : {}),
+        ...(duration !== undefined ? { durationMs: duration } : {}),
+    });
+    return {};
+}

package/packages/server/modules/agents/cursor/todos.js

@@ -0,0 +1,69 @@
+const STATUSES = new Set(["pending", "in_progress", "completed"]);
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+function statusOf(value) {
+    if (value === "completed" || value === "in_progress")
+        return value;
+    return "pending";
+}
+/** Todos from a plan or an update: phases flatten when the top-level list is empty. */
+export function cursorTodos(params) {
+    const direct = readList(params.todos);
+    if (direct.length)
+        return direct;
+    const phases = Array.isArray(params.phases) ? params.phases : [];
+    return phases.flatMap((phase) => readList(phase?.todos));
+}
+function readList(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const content = text(row.content, 500) || text(row.id, 200);
+        if (!content)
+            return [];
+        return [
+            {
+                ...(text(row.id, 200) ? { id: text(row.id, 200) } : {}),
+                content,
+                status: STATUSES.has(String(row.status)) ? statusOf(row.status) : "pending",
+            },
+        ];
+    });
+}
+const lastByChat = new Map();
+function chatKey(options) {
+    return options.chat || options.sessionId || "";
+}
+export function rememberCursorTodos(options, todos) {
+    lastByChat.set(chatKey(options), todos);
+}
+function mergeTodos(chat, incoming, merge) {
+    if (!merge) {
+        lastByChat.set(chat, incoming);
+        return incoming;
+    }
+    const previous = lastByChat.get(chat) ?? [];
+    const byId = new Map(previous.filter((item) => item.id).map((item) => [item.id, item]));
+    const merged = [...previous];
+    for (const item of incoming) {
+        if (item.id && byId.has(item.id)) {
+            const index = merged.findIndex((row) => row.id === item.id);
+            if (index >= 0)
+                merged[index] = { ...merged[index], ...item };
+        }
+        else
+            merged.push(item);
+    }
+    lastByChat.set(chat, merged);
+    return merged;
+}
+/** `cursor/update_todos`: the island reads the emitted tool; merge keeps the last full list. */
+export async function updateCursorTodos(options, params) {
+    const todos = mergeTodos(chatKey(options), cursorTodos(params), params.merge === true);
+    const id = text(params.toolCallId, 200) || "update_todos";
+    options.emit("tool", { id, name: "update_todos", input: { todos } });
+    options.emit("tool-result", { id, name: "update_todos", output: "" });
+    return {};
+}

package/packages/server/modules/agents/ide-mcp/config.js

@@ -0,0 +1,40 @@
+import { fileURLToPath } from "node:url";
+import { appUrl } from "../../../../core/modules/app-paths/index.js";
+import { ideMcpTokenFile } from "../../ide/index.js";
+/** Name of the built-in server; a project's own `.mcp.json` must not silently replace it. */
+export const IDE_MCP_SERVER = "projector-ide";
+/** The stdio MCP server every external agent can start to reach the live IDE command registry. */
+export function ideMcpServer(projectId) {
+    return {
+        name: IDE_MCP_SERVER,
+        command: process.execPath,
+        args: [fileURLToPath(new URL("./server.js", import.meta.url))],
+        env: {
+            PROJECTOR_MCP_URL: process.env.PROJECTOR_URL || appUrl(),
+            PROJECTOR_MCP_TOKEN_FILE: ideMcpTokenFile(),
+            PROJECTOR_PROJECT_ID: projectId,
+        },
+    };
+}
+/** The Claude Agent SDK takes a server object inline with the same fields. */
+export function claudeIdeMcpServer(projectId) {
+    const server = ideMcpServer(projectId);
+    return {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env: server.env,
+        // Keep the three tools in the prompt instead of deferring them behind tool search.
+        alwaysLoad: true,
+    };
+}
+/** ACP passes environment variables as a list of names and values. */
+export function acpIdeMcpServer(projectId) {
+    const server = ideMcpServer(projectId);
+    return {
+        name: server.name,
+        command: server.command,
+        args: server.args,
+        env: Object.entries(server.env).map(([name, value]) => ({ name, value })),
+    };
+}

package/packages/server/modules/agents/ide-mcp/index.js

@@ -0,0 +1 @@
+export { acpIdeMcpServer, claudeIdeMcpServer, IDE_MCP_SERVER, ideMcpServer, } from "./config.js";

package/packages/server/modules/agents/ide-mcp/server.js

@@ -0,0 +1,154 @@
+// The built-in IDE MCP server: three tools over the live Projector command registry, plus one that
+// shows a secret without returning it. An external agent starts this process; it asks the running
+// server, which asks the open Projector page, so the catalog is always the one the user has.
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { os } from "../../../../core/modules/os/index.js";
+const url = process.env.PROJECTOR_MCP_URL || "http://localhost:4177";
+const tokenFile = process.env.PROJECTOR_MCP_TOKEN_FILE;
+const projectId = process.env.PROJECTOR_PROJECT_ID;
+/** This MCP process keeps one page owner for its whole life, so its tools see one workbench. */
+const session = randomUUID();
+const RESULT_CHARS = 60_000;
+/** Commands described in this MCP session: execution is refused until its pair was described. */
+const described = new Set();
+async function bridge(request) {
+    if (!projectId)
+        throw new Error("MCP-сервер запущен вне чата Projector");
+    if (!tokenFile)
+        throw new Error("MCP-серверу не передан ключ Projector");
+    const token = (await readFile(tokenFile, "utf8")).trim();
+    const response = await fetch(`${url}/api/ide/command-request`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ projectId, session, request }),
+        signal: AbortSignal.timeout(90_000),
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        throw new Error(data.error || "Projector недоступен");
+    return data.output;
+}
+function text(value) {
+    const body = JSON.stringify(value ?? null, null, 2);
+    return {
+        content: [
+            {
+                type: "text",
+                text: body.length > RESULT_CHARS ? `${body.slice(0, RESULT_CHARS)}\n…обрезано` : body,
+            },
+        ],
+    };
+}
+/** Runs one command in the agent's project; only stdout reaches the user's panel. */
+async function scriptOutput(script) {
+    const command = script.trim();
+    if (!command)
+        throw new Error("Укажите скрипт, который вернёт секрет");
+    if (command.length > 8_000)
+        throw new Error("Скрипт слишком длинный");
+    const result = await os.tools.runBash(command, { cwd: process.cwd() });
+    if (result.terminated)
+        throw new Error("Скрипт не завершился вовремя");
+    if (result.exitCode !== 0)
+        throw new Error("Скрипт завершился с ошибкой");
+    const secret = result.stdout.replace(/[\r\n]+$/, "");
+    if (!secret.trim())
+        throw new Error("Скрипт ничего не вернул");
+    if (secret.length > 32 * 1024)
+        throw new Error("Секрет слишком длинный");
+    if (secret.includes("\0"))
+        throw new Error("Секрет содержит недопустимый символ");
+    return secret;
+}
+/** Posts the value to the live page; the response confirms delivery and never repeats it. */
+async function pushSecret(input) {
+    if (!projectId)
+        throw new Error("MCP-сервер запущен вне чата Projector");
+    if (!tokenFile)
+        throw new Error("MCP-серверу не передан ключ Projector");
+    const token = (await readFile(tokenFile, "utf8")).trim();
+    const response = await fetch(`${url}/api/agent/secret-show/push`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({
+            secret: input.secret,
+            ...(input.label ? { label: input.label } : {}),
+            ...(input.comment ? { comment: input.comment } : {}),
+            projectId,
+            session,
+        }),
+        signal: AbortSignal.timeout(10_000),
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || data.shown !== true)
+        throw new Error(data.error || "Не удалось показать секрет пользователю");
+    return {
+        shown: true,
+        delivered: data.delivered === true,
+        label: typeof data.label === "string" ? data.label : null,
+    };
+}
+const server = new McpServer({ name: "projector-ide", version: "1" }, {
+    instructions: "Команды Projector. Сначала list_commands, затем describe_command для пары command и scope, затем execute_command с теми же command и scope. Изменяющие команды спрашивают подтверждение в окне Projector. show_secret показывает пользователю значение скрипта и не возвращает его тебе.",
+});
+server.registerTool("list_commands", {
+    description: "Найти существующие команды Projector и их области (scope). Пустой query возвращает весь каталог текущего проекта.",
+    inputSchema: { query: z.string().optional() },
+}, async ({ query }) => text(await bridge({ operation: "list", ...(query ? { query } : {}) })));
+server.registerTool("describe_command", {
+    description: "Получить описание, аргументы и контекст команды перед вызовом.",
+    inputSchema: { command: z.string(), scope: z.string() },
+}, async ({ command, scope }) => {
+    const result = await bridge({ operation: "describe", command, scope });
+    described.add(`${scope}\n${command}`);
+    return text(result);
+});
+server.registerTool("execute_command", {
+    description: "Вызвать команду Projector в явной области scope. Только после describe_command для этой же пары command и scope: без него вызов отклоняется. Порядок всегда такой: list_commands, describe_command, execute_command.",
+    inputSchema: {
+        command: z.string(),
+        scope: z.string(),
+        args: z.record(z.string(), z.unknown()).optional(),
+    },
+}, async ({ command, scope, args }) => {
+    if (!described.has(`${scope}\n${command}`))
+        throw new Error("Сначала вызовите describe_command для этой пары command и scope");
+    return text(await bridge({ operation: "execute", command, scope, ...(args ? { args } : {}) }));
+});
+server.registerTool("show_secret", {
+    description: "Показать пользователю секрет, который вернёт скрипт, не получая значение в ответ. Запускает shell-команду на машине пользователя, берёт её stdout и открывает панель только в окне Projector; инструмент возвращает лишь факт показа. Используйте, когда просят показать ключ, токен или пароль, а не записать его. script — команда, чей stdout и есть секрет; comment — короткое пояснение пользователю. Значение не печатайте в ответе и не угадывайте.",
+    inputSchema: {
+        script: z
+            .string()
+            .min(1)
+            .max(8_000)
+            .describe("Shell-команда, чей stdout — секрет; выполняется на машине пользователя"),
+        label: z.string().max(200).optional().describe("Название секрета в панели"),
+        comment: z.string().max(1_000).optional().describe("Пояснение агента пользователю"),
+    },
+}, async ({ script, label, comment }) => {
+    try {
+        const secret = await scriptOutput(script);
+        return text(await pushSecret({
+            secret,
+            ...(label?.trim() ? { label: label.trim() } : {}),
+            ...(comment?.trim() ? { comment: comment.trim() } : {}),
+        }));
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : "Скрипт не вернул секрет",
+                },
+            ],
+        };
+    }
+});
+await server.connect(new StdioServerTransport());

package/packages/server/modules/agents/kimi/dialect.js

@@ -0,0 +1,18 @@
+import { extendPlainDialect } from "../acp/index.js";
+import { stripReadLineNumbers } from "../../../../core/modules/agent-read/index.js";
+/** A call that reads a file: its result is a numbered file body, not raw tool text. */
+const readsFile = (update) => update.kind === "read" || (typeof update.title === "string" && /^Reading\b/i.test(update.title));
+/** Kimi Code adds no subagents or background commands, only numbered file reads. */
+export function createKimiDialect() {
+    const reads = new Set();
+    return extendPlainDialect({
+        call(update, id) {
+            if (readsFile(update))
+                reads.add(id);
+            return [];
+        },
+        result(_update, id, output) {
+            return reads.has(id) ? stripReadLineNumbers(output) : output;
+        },
+    });
+}

package/packages/server/modules/agents/kimi/index.js

@@ -0,0 +1,11 @@
+import { createAcpBackend } from "../acp/index.js";
+import { createKimiDialect } from "./dialect.js";
+/** Kimi Code CLI through its ACP mode (`kimi acp`). */
+export const kimiProgram = {
+    id: "kimi",
+    label: "Kimi",
+    command: "kimi",
+    args: ["acp"],
+    dialect: createKimiDialect,
+};
+export const kimiBackend = createAcpBackend(kimiProgram);

package/packages/server/modules/agents/opencode/dialect.js

@@ -0,0 +1,232 @@
+import { extendPlainDialect, inputOf, readCompaction, shorten, } from "../acp/index.js";
+import { cleanReadOutput } from "./read.js";
+/**
+ * OpenCode ids hold `ms * 4096 + counter` cut to 48 bits, so only the low 36 bits of the time
+ * survive (about 2.2 years): the full time is the one closest to `now`.
+ */
+export function opencodeIdTime(id, now = Date.now()) {
+    const hex = typeof id === "string" ? /^msg_([0-9a-f]{12})/.exec(id)?.[1] : undefined;
+    if (!hex)
+        return undefined;
+    const period = 2 ** 36;
+    const low = Math.floor(parseInt(hex, 16) / 4096);
+    return low + Math.round((now - low) / period) * period;
+}
+function childOf(update) {
+    const meta = update._meta?.["opencode/child-session"];
+    const { id, title } = (meta ?? {});
+    if (typeof id !== "string") {
+        // Calls of a child session are also named after it: `<session id>:<call id>`.
+        const session = /^(ses_[^:]+):/.exec(String(update.toolCallId ?? ""))?.[1];
+        return session ? { id: session } : undefined;
+    }
+    return { id, ...(typeof title === "string" ? { title } : {}) };
+}
+/** The provider retry OpenCode reports while it waits: `null` means the wait is over. */
+function retryOf(update) {
+    const meta = update._meta;
+    if (!meta || !("opencode/retry" in meta))
+        return undefined;
+    const raw = meta["opencode/retry"];
+    if (raw === null)
+        return null;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const { attempt, nextRetryAt, error } = raw;
+    if (typeof attempt !== "number" || !Number.isFinite(attempt))
+        return undefined;
+    const at = typeof nextRetryAt === "string" ? Date.parse(nextRetryAt) : NaN;
+    const delay = Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
+    const message = typeof error?.message === "string" ? error.message : undefined;
+    return {
+        // OpenCode counts the attempt it is about to make; the chat names the repeat.
+        attempt: Math.max(1, Math.trunc(attempt) - 1),
+        ...(delay !== undefined ? { delay } : {}),
+        ...(message ? { message } : {}),
+    };
+}
+/**
+ * Older OpenCode builds report compaction in `session_info_update._meta`; newer ones (with the
+ * client's `session.compaction` capability) use the standard `compaction_update` instead.
+ */
+function compactionOf(update) {
+    if (update.sessionUpdate !== "session_info_update")
+        return readCompaction(update);
+    const meta = update._meta;
+    const raw = meta?.["opencode/compaction"];
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const { status, messageId, summary, error } = raw;
+    const id = typeof messageId === "string" ? messageId : undefined;
+    const withId = id ? { id } : {};
+    if (status === "started")
+        return { ...withId, status: "started" };
+    if (status === "completed")
+        return {
+            ...withId,
+            status: "completed",
+            ...(typeof summary === "string" && summary.trim() ? { summary: summary.trim() } : {}),
+        };
+    if (status === "failed") {
+        const text = typeof error === "string"
+            ? error
+            : typeof error?.message === "string"
+                ? error.message
+                : "";
+        return { ...withId, status: "failed", ...(text ? { error: text } : {}) };
+    }
+    return undefined;
+}
+/** The input of the call that starts a subagent; it arrives with a later update, not the first. */
+function subagentOf(update) {
+    const { agent, description, prompt } = inputOf(update);
+    if (typeof agent !== "string")
+        return undefined;
+    return {
+        agent,
+        description: typeof description === "string" ? description : agent,
+        ...(typeof prompt === "string" && prompt ? { prompt } : {}),
+    };
+}
+/** The result of a subagent call wraps the subagent's answer in `<subagent ...>` tags. */
+const unwrap = (text) => text.replace(/<\/?subagent[^>]*>/g, "");
+function backgroundOf(update) {
+    const { background, command } = inputOf(update);
+    return background === true && typeof command === "string" ? command : undefined;
+}
+/** A call that reads a file: its result is a framed file body, not raw tool text. */
+const readsFile = (update) => update.kind === "read" || String(update.title ?? "").toLowerCase() === "read";
+export function createOpencodeDialect() {
+    /** Subagent calls still open, with the description their child session is titled by. */
+    const open = [];
+    const bound = new Map();
+    const started = new Set();
+    const counts = new Map();
+    /** What each subagent has said so far: chunks arrive a few tokens at a time. */
+    const said = new Map();
+    /** File reads whose result is a framed body: only those get the frame removed. */
+    const reads = new Set();
+    /** The call a child session works for; the session is told apart only by its title. */
+    function parentOf(child) {
+        const known = bound.get(child.id);
+        if (known)
+            return known;
+        const taken = new Set(bound.values());
+        const free = open.filter((item) => !taken.has(item.call));
+        // Without a matching title only a lone candidate is certain enough to take.
+        const match = free.find((item) => child.title !== undefined && item.description === child.title) ??
+            (free.length === 1 ? free[0] : undefined);
+        if (match) {
+            bound.set(child.id, match.call);
+            found.push({ id: match.call, session: child.id });
+        }
+        return match?.call;
+    }
+    /** Sessions found for tasks since the last patch; they travel with the next one. */
+    const found = [];
+    const flush = () => found.splice(0);
+    const dialect = extendPlainDialect({
+        time: (update) => opencodeIdTime(update.messageId),
+        retry: retryOf,
+        compaction: compactionOf,
+        tool(update) {
+            const child = childOf(update);
+            const title = String(update.title || update.kind || "tool");
+            // The calls of a child session are titled "<session title>: <tool>".
+            const name = child?.title && title.startsWith(`${child.title}: `)
+                ? title.slice(child.title.length + 2)
+                : title;
+            const parent = child && parentOf(child);
+            return { name, ...(parent ? { parent } : {}) };
+        },
+        inner: (update) => childOf(update) !== undefined,
+        chunk(update, text) {
+            const child = childOf(update);
+            if (!child)
+                return undefined;
+            const parent = parentOf(child);
+            if (!parent)
+                return [];
+            const all = (said.get(parent) ?? "") + text;
+            said.set(parent, all);
+            return [...flush(), ...(all.trim() ? [{ id: parent, summary: shorten(all) }] : [])];
+        },
+        call(update, id) {
+            const patches = [];
+            if (readsFile(update))
+                reads.add(id);
+            const child = childOf(update);
+            const parent = child && parentOf(child);
+            patches.push(...flush());
+            if (parent && update.sessionUpdate === "tool_call") {
+                const count = (counts.get(parent) ?? 0) + 1;
+                counts.set(parent, count);
+                patches.push({ id: parent, tools: count, lastTool: dialect.tool(update).name });
+            }
+            const agent = subagentOf(update);
+            if (agent && !started.has(id)) {
+                started.add(id);
+                open.push({ call: id, description: agent.description });
+                patches.push({
+                    id,
+                    kind: "agent",
+                    title: agent.description,
+                    status: "running",
+                    background: false,
+                    subagent: agent.agent,
+                    ...(agent.prompt ? { prompt: agent.prompt } : {}),
+                    tool: id,
+                });
+            }
+            const command = backgroundOf(update);
+            if (command && !started.has(id)) {
+                started.add(id);
+                patches.push({
+                    id,
+                    kind: "shell",
+                    title: command,
+                    status: "running",
+                    background: true,
+                    untracked: true,
+                    tool: id,
+                });
+            }
+            return patches;
+        },
+        result(_update, id, output) {
+            return reads.has(id) ? cleanReadOutput(output) : output;
+        },
+        end(update, id, output) {
+            const index = open.findIndex((item) => item.call === id);
+            if (index < 0)
+                return [];
+            // A subagent started in the background answers at once with its session and keeps working:
+            // its call stays open so its later calls and messages still find the task.
+            const session = /"sessionID"\s*:\s*"([^"]+)"/.exec(output)?.[1];
+            if (session && /^\{[^]*"status"\s*:\s*"running"/.test(output.trimStart())) {
+                bound.set(session, id);
+                return [
+                    {
+                        id,
+                        status: "running",
+                        background: true,
+                        untracked: true,
+                        session,
+                    },
+                ];
+            }
+            open.splice(index, 1);
+            // Without a spoken answer the output is only metadata (a JSON object), not worth showing.
+            const summary = shorten(unwrap(said.get(id) || (output.trimStart().startsWith("{") ? "" : output)));
+            return [
+                {
+                    id,
+                    status: update.status === "failed" ? "error" : "done",
+                    ...(summary ? { summary } : {}),
+                    tools: counts.get(id) ?? 0,
+                },
+            ];
+        },
+    });
+    return dialect;
+}

package/packages/server/modules/agents/opencode/index.js

@@ -0,0 +1,21 @@
+import { acpSessions, createAcpBackend } from "../acp/index.js";
+import { createOpencodeDialect } from "./dialect.js";
+import { withOpenCodeBranches } from "./sessions.js";
+/** OpenCode through its own ACP mode (`opencode acp`). */
+export const opencodeProgram = {
+    id: "opencode",
+    label: "OpenCode",
+    command: "opencode",
+    args: ["acp"],
+    dialect: createOpencodeDialect,
+    // ACP v2 compaction updates carry the summary; older builds fall back to `_meta` markers.
+    clientCapabilities: { session: { compaction: {} } },
+};
+/**
+ * OpenCode lists a subagent's own session next to real chats, so the list is marked with the
+ * parents it keeps in its database: history shows those as branches instead of separate chats.
+ */
+export const opencodeBackend = {
+    ...createAcpBackend(opencodeProgram),
+    sessions: (cwd) => acpSessions("opencode", cwd, withOpenCodeBranches),
+};

package/packages/server/modules/agents/opencode/read.js

@@ -0,0 +1,46 @@
+/**
+ * OpenCode frames a file read as `Read file <path>, lines <from>-<to>` followed by numbered
+ * lines. The chat shows a tool result as text, so the frame and the numbers are removed here:
+ * the shared client renders the file body without knowing how OpenCode labels it.
+ */
+const HEADER = /^Read file (.+), lines (\d+)-(\d+)\r?\n/;
+const EMPTY = /^Read file .+, 0 lines\r?\n?$/;
+const TRUNCATED = /^\[Output truncated\. Continue reading with offset: \d+\]$/;
+export function cleanReadOutput(text) {
+    if (EMPTY.test(text))
+        return "";
+    const header = HEADER.exec(text);
+    if (!header)
+        return text;
+    const from = Number(header[2]);
+    const lines = text.slice(header[0].length).split(/\r?\n/);
+    // A file that merely begins with this phrase is not a read result: keep it untouched.
+    const first = lines[0] ?? "";
+    if (first !== `${from}:` && !first.startsWith(`${from}: `))
+        return text;
+    const cleaned = [];
+    let number = from;
+    for (const [index, line] of lines.entries()) {
+        // A trailing newline is not a numbered file line.
+        if (index === lines.length - 1 && line === "")
+            break;
+        if (TRUNCATED.test(line)) {
+            cleaned.push(line);
+            continue;
+        }
+        const prefix = `${number}: `;
+        if (line.startsWith(prefix)) {
+            cleaned.push(line.slice(prefix.length));
+            number++;
+            continue;
+        }
+        if (line === `${number}:`) {
+            cleaned.push("");
+            number++;
+            continue;
+        }
+        // An unexpected shape keeps the body, but still without the duplicated header.
+        return lines.join("\n");
+    }
+    return cleaned.join("\n");
+}