@opencomputer/cli 0.3.4 → 0.3.7

package/dist/local.js

@@ -1,9 +1,11 @@
 import { createOpencode, } from "@opencode-ai/sdk/v2";
+import { spawn } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { mkdir, readFile, rm, writeFile, } from "node:fs/promises";
 import { createServer, } from "node:http";
 import { delimiter, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { renderDevUI } from "./dev-ui.js";
 import { findAgentRoot, prepareAgent, readManifest } from "./project.js";
 function sameToken(left, right) {
     const leftBytes = Buffer.from(left);
@@ -33,6 +35,21 @@ function sendJSON(response, status, body) {
     response.writeHead(status, { "content-type": "application/json" });
     response.end(JSON.stringify(body));
 }
+function openBrowser(url) {
+    if (process.env.OPENCOMPUTER_NO_OPEN === "1")
+        return;
+    const command = process.platform === "darwin"
+        ? { file: "open", args: [url] }
+        : process.platform === "win32"
+            ? { file: "cmd", args: ["/c", "start", "", url] }
+            : { file: "xdg-open", args: [url] };
+    const child = spawn(command.file, command.args, {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.on("error", () => undefined);
+    child.unref();
+}
 async function startGateway(config) {
     if (!config.apiKey) {
         throw new Error("Not logged in. Run `opencomputer login` before starting dev mode.");
@@ -95,7 +112,10 @@ async function startGateway(config) {
     return {
         url: `http://127.0.0.1:${String(address.port)}`,
         token,
-        close: () => new Promise((done) => server.close(() => done())),
+        close: () => {
+            server.closeAllConnections();
+            return new Promise((done) => server.close(() => done()));
+        },
     };
 }
 function addBundledRuntimeToPath() {
@@ -116,29 +136,50 @@ function modelParts() {
         full,
     };
 }
-async function streamTurn(client, directory, prompt, emit) {
-    const created = await client.session.create({ directory });
-    if (!created.data)
-        throw new Error("The local agent session did not start");
-    const sessionID = created.data.id;
-    emit({ type: "session.created", data: { sessionId: sessionID } });
+async function streamTurn(client, directory, sessionID, prompt, emit) {
     const subscription = await client.event.subscribe({ directory });
-    const assistantMessages = new Set();
-    const textByPart = new Map();
-    const messageByPart = new Map();
-    const emittedLengths = new Map();
+    const textParts = new Map();
+    const reasoningParts = new Map();
+    const partTypes = new Map();
+    const pendingDeltas = new Map();
     const tools = new Map();
     const toolStates = new Map();
-    const completedText = [];
-    const emitText = (partID) => {
-        const messageID = messageByPart.get(partID);
-        if (!messageID || !assistantMessages.has(messageID))
-            return;
-        const text = textByPart.get(partID) ?? "";
-        const offset = emittedLengths.get(partID) ?? 0;
-        if (text.length > offset) {
-            emit({ type: "message.delta", data: { text: text.slice(offset) } });
-            emittedLengths.set(partID, text.length);
+    const assistantMessages = new Set();
+    const streamedTextParts = new Set();
+    const consumePendingDeltas = (partID, messageID) => {
+        for (const [candidatePartID, deltas] of pendingDeltas) {
+            if (partID && candidatePartID !== partID)
+                continue;
+            const partType = partTypes.get(candidatePartID);
+            if (!partType)
+                continue;
+            const remaining = [];
+            for (const pending of deltas) {
+                if ((messageID && pending.messageID !== messageID) ||
+                    !assistantMessages.has(pending.messageID)) {
+                    remaining.push(pending);
+                    continue;
+                }
+                const parts = partType === "text" ? textParts : reasoningParts;
+                parts.set(candidatePartID, `${parts.get(candidatePartID) ?? ""}${pending.delta}`);
+                if (partType === "text" && !streamedTextParts.has(candidatePartID)) {
+                    if (streamedTextParts.size > 0) {
+                        emit({
+                            type: "message.delta",
+                            data: { text: "\n\n", partId: candidatePartID },
+                        });
+                    }
+                    streamedTextParts.add(candidatePartID);
+                }
+                emit({
+                    type: partType === "text" ? "message.delta" : "reasoning.delta",
+                    data: { text: pending.delta, partId: candidatePartID },
+                });
+            }
+            if (remaining.length)
+                pendingDeltas.set(candidatePartID, remaining);
+            else
+                pendingDeltas.delete(candidatePartID);
         }
     };
     const emitTool = (part) => {
@@ -152,20 +193,38 @@ async function streamTurn(client, directory, prompt, emit) {
         if (current === "running") {
             emit({
                 type: "tool.started",
-                data: { tool: part.tool, input: part.state.input },
+                data: {
+                    callId: part.callID,
+                    tool: part.tool,
+                    title: part.state.title,
+                    input: part.state.input,
+                },
             });
         }
         else if (current === "completed") {
-            emit({ type: "tool.completed", data: { tool: part.tool } });
+            emit({
+                type: "tool.completed",
+                data: { callId: part.callID, tool: part.tool, title: part.state.title },
+            });
         }
         else if (current === "error") {
             emit({
                 type: "tool.failed",
-                data: { tool: part.tool, message: part.state.error },
+                data: {
+                    callId: part.callID,
+                    tool: part.tool,
+                    title: "title" in part.state ? part.state.title : undefined,
+                    message: part.state.error,
+                },
             });
         }
     };
     try {
+        const firstEvent = subscription.stream.next();
+        await Promise.race([
+            firstEvent.then(() => undefined),
+            new Promise((done) => setTimeout(done, 100)),
+        ]);
         const model = modelParts();
         const started = await client.session.promptAsync({
             sessionID,
@@ -175,15 +234,28 @@ async function streamTurn(client, directory, prompt, emit) {
         });
         if (started.error)
             throw new Error(JSON.stringify(started.error));
-        for await (const event of subscription.stream) {
+        async function* events() {
+            const first = await firstEvent;
+            if (!first.done)
+                yield first.value;
+            yield* subscription.stream;
+        }
+        for await (const event of events()) {
+            if (event.type === "message.part.delta") {
+                const { sessionID: eventSessionID, messageID, partID, field, delta } = event.properties;
+                if (eventSessionID !== sessionID || field !== "text" || !delta)
+                    continue;
+                const pending = pendingDeltas.get(partID) ?? [];
+                pending.push({ messageID, delta });
+                pendingDeltas.set(partID, pending);
+                consumePendingDeltas(partID, messageID);
+                continue;
+            }
             if (event.type === "message.updated") {
                 const info = event.properties.info;
                 if (info.sessionID === sessionID && info.role === "assistant") {
                     assistantMessages.add(info.id);
-                    for (const [partID, messageID] of messageByPart) {
-                        if (messageID === info.id)
-                            emitText(partID);
-                    }
+                    consumePendingDeltas(undefined, info.id);
                     for (const part of tools.values()) {
                         if (part.messageID === info.id)
                             emitTool(part);
@@ -195,9 +267,20 @@ async function streamTurn(client, directory, prompt, emit) {
                 if (part.sessionID !== sessionID)
                     continue;
                 if (part.type === "text") {
-                    messageByPart.set(part.id, part.messageID);
-                    textByPart.set(part.id, part.text);
-                    emitText(part.id);
+                    partTypes.set(part.id, "text");
+                    if (assistantMessages.has(part.messageID) &&
+                        part.text.length >= (textParts.get(part.id)?.length ?? 0)) {
+                        textParts.set(part.id, part.text);
+                    }
+                    consumePendingDeltas(part.id, part.messageID);
+                }
+                else if (part.type === "reasoning") {
+                    partTypes.set(part.id, "reasoning");
+                    if (assistantMessages.has(part.messageID) &&
+                        part.text.length >= (reasoningParts.get(part.id)?.length ?? 0)) {
+                        reasoningParts.set(part.id, part.text);
+                    }
+                    consumePendingDeltas(part.id, part.messageID);
                 }
                 else if (part.type === "tool") {
                     tools.set(part.callID, part);
@@ -217,14 +300,22 @@ async function streamTurn(client, directory, prompt, emit) {
     finally {
         await subscription.stream.return(undefined);
     }
-    for (const [partID, text] of textByPart) {
-        const messageID = messageByPart.get(partID);
-        if (messageID && assistantMessages.has(messageID))
-            completedText.push(text);
+    const reasoning = [...reasoningParts.values()].join("");
+    if (reasoning) {
+        emit({ type: "reasoning.completed", data: { text: reasoning } });
     }
-    const text = completedText.join("");
+    const text = [...textParts.values()]
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join("\n\n");
     emit({ type: "message.completed", data: { text } });
-    return sessionID;
+    return text;
+}
+async function createRuntimeSession(client, directory) {
+    const created = await client.session.create({ directory });
+    if (!created.data)
+        throw new Error("The local agent session did not start");
+    return created.data.id;
 }
 function statePath(root) {
     return resolve(root, ".opencomputer", "dev.json");
@@ -259,22 +350,43 @@ async function startDevService(config) {
     addBundledRuntimeToPath();
     const abortController = new AbortController();
     const model = modelParts();
-    const instance = await createOpencode({
-        signal: abortController.signal,
-        port: 0,
-        timeout: 45_000,
-        config: {
-            model: model.full,
-            enabled_providers: ["openrouter"],
-            provider: {
-                openrouter: {
-                    options: { baseURL: `${gateway.url}/openrouter/api/v1` },
+    const previousConnectionsURL = process.env.OPENCOMPUTER_CONNECTIONS_URL;
+    const previousConnectionToken = process.env.OPENCOMPUTER_CONNECTION_TOKEN;
+    process.env.OPENCOMPUTER_CONNECTIONS_URL = gateway.url;
+    process.env.OPENCOMPUTER_CONNECTION_TOKEN = gateway.token;
+    let instance;
+    try {
+        instance = await createOpencode({
+            signal: abortController.signal,
+            port: 0,
+            timeout: 45_000,
+            config: {
+                model: model.full,
+                enabled_providers: ["openrouter"],
+                provider: {
+                    openrouter: {
+                        options: { baseURL: `${gateway.url}/openrouter/api/v1` },
+                    },
                 },
+                autoupdate: false,
+                share: "disabled",
             },
-            autoupdate: false,
-            share: "disabled",
-        },
-    });
+        });
+    }
+    finally {
+        if (previousConnectionsURL === undefined) {
+            delete process.env.OPENCOMPUTER_CONNECTIONS_URL;
+        }
+        else {
+            process.env.OPENCOMPUTER_CONNECTIONS_URL = previousConnectionsURL;
+        }
+        if (previousConnectionToken === undefined) {
+            delete process.env.OPENCOMPUTER_CONNECTION_TOKEN;
+        }
+        else {
+            process.env.OPENCOMPUTER_CONNECTION_TOKEN = previousConnectionToken;
+        }
+    }
     const authenticated = await instance.client.auth.set({
         providerID: "openrouter",
         auth: { type: "api", key: gateway.token },
@@ -283,15 +395,32 @@ async function startDevService(config) {
         throw new Error("The embedded agent runtime rejected its local credential");
     }
     const token = randomBytes(32).toString("base64url");
+    const sessions = new Map();
+    const running = new Set();
     const server = createServer((request, response) => {
         void (async () => {
             const url = new URL(request.url ?? "/", "http://127.0.0.1");
             if (request.method === "GET" && url.pathname === "/") {
-                sendJSON(response, 200, {
-                    service: "OpenComputer local agent",
-                    agentId: manifest.id,
-                    endpoints: ["GET /health", "POST /sessions"],
+                response.writeHead(200, {
+                    "content-type": "text/html; charset=utf-8",
+                    "cache-control": "no-store",
+                    "content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self'; " +
+                        "connect-src 'self'; img-src 'self' data:; base-uri 'none'; frame-ancestors 'none'",
                 });
+                response.end(renderDevUI(manifest.name));
+                return;
+            }
+            const assetMatch = url.pathname.match(/^\/assets\/([A-Za-z0-9_.-]+\.(?:js|css))$/);
+            if (request.method === "GET" && assetMatch?.[1]) {
+                const filename = assetMatch[1];
+                const asset = await readFile(fileURLToPath(new URL(`./ui/${filename}`, import.meta.url)));
+                response.writeHead(200, {
+                    "content-type": filename.endsWith(".css")
+                        ? "text/css; charset=utf-8"
+                        : "text/javascript; charset=utf-8",
+                    "cache-control": "no-store",
+                });
+                response.end(asset);
                 return;
             }
             if (!authorized(request, token)) {
@@ -299,15 +428,23 @@ async function startDevService(config) {
                 return;
             }
             if (request.method === "GET" && url.pathname === "/health") {
-                sendJSON(response, 200, { ok: true, agentId: manifest.id });
+                sendJSON(response, 200, {
+                    ok: true,
+                    agentId: manifest.id,
+                    sessions: sessions.size,
+                });
                 return;
             }
-            if (request.method === "POST" && url.pathname === "/sessions") {
-                const body = JSON.parse((await readBody(request)).toString("utf8"));
-                if (typeof body.prompt !== "string" || !body.prompt.trim()) {
-                    sendJSON(response, 400, { message: "A prompt is required" });
+            const streamSession = async (session, prompt, created = false) => {
+                if (running.has(session.id)) {
+                    sendJSON(response, 409, { message: "This session is already running" });
                     return;
                 }
+                running.add(session.id);
+                session.messages.push({ role: "user", text: prompt });
+                if (!session.title)
+                    session.title = prompt.slice(0, 60);
+                session.updatedAt = new Date().toISOString();
                 response.writeHead(200, {
                     "content-type": "application/x-ndjson",
                     "cache-control": "no-store",
@@ -315,8 +452,13 @@ async function startDevService(config) {
                 const emit = (event) => {
                     response.write(`${JSON.stringify(event)}\n`);
                 };
+                if (created) {
+                    emit({ type: "session.created", data: { sessionId: session.id } });
+                }
                 try {
-                    await streamTurn(instance.client, directory, body.prompt.trim(), emit);
+                    const text = await streamTurn(instance.client, directory, session.id, prompt, emit);
+                    session.messages.push({ role: "assistant", text });
+                    session.updatedAt = new Date().toISOString();
                 }
                 catch (error) {
                     emit({
@@ -326,7 +468,75 @@ async function startDevService(config) {
                         },
                     });
                 }
+                finally {
+                    running.delete(session.id);
+                }
                 response.end();
+            };
+            if (request.method === "GET" && url.pathname === "/sessions") {
+                sendJSON(response, 200, {
+                    sessions: [...sessions.values()]
+                        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+                        .map(({ id, title, createdAt, updatedAt, messages }) => ({
+                        id,
+                        title,
+                        createdAt,
+                        updatedAt,
+                        messageCount: messages.length,
+                    })),
+                });
+                return;
+            }
+            if (request.method === "POST" && url.pathname === "/sessions") {
+                const raw = (await readBody(request)).toString("utf8");
+                const body = (raw ? JSON.parse(raw) : {});
+                const id = await createRuntimeSession(instance.client, directory);
+                const now = new Date().toISOString();
+                const session = {
+                    id,
+                    title: "",
+                    createdAt: now,
+                    updatedAt: now,
+                    messages: [],
+                };
+                sessions.set(id, session);
+                if (typeof body.prompt === "string" && body.prompt.trim()) {
+                    response.setHeader("x-opencomputer-session-id", id);
+                    await streamSession(session, body.prompt.trim(), true);
+                }
+                else {
+                    sendJSON(response, 201, session);
+                }
+                return;
+            }
+            const sessionMatch = url.pathname.match(/^\/sessions\/([^/]+)$/);
+            if (sessionMatch?.[1]) {
+                const id = decodeURIComponent(sessionMatch[1]);
+                const session = sessions.get(id);
+                if (!session) {
+                    sendJSON(response, 404, { message: "Session not found" });
+                    return;
+                }
+                if (request.method === "GET") {
+                    sendJSON(response, 200, session);
+                    return;
+                }
+                if (request.method === "POST") {
+                    const body = JSON.parse((await readBody(request)).toString("utf8"));
+                    if (typeof body.prompt !== "string" || !body.prompt.trim()) {
+                        sendJSON(response, 400, { message: "A prompt is required" });
+                        return;
+                    }
+                    await streamSession(session, body.prompt.trim());
+                    return;
+                }
+            }
+            if (request.method === "GET" && url.pathname === "/api") {
+                sendJSON(response, 200, {
+                    service: "OpenComputer local agent",
+                    agentId: manifest.id,
+                    endpoints: ["GET /sessions", "POST /sessions", "POST /sessions/:id"],
+                });
                 return;
             }
             sendJSON(response, 404, { message: "Route not found" });
@@ -362,30 +572,29 @@ async function startDevService(config) {
     await writeFile(statePath(root), `${JSON.stringify(state, null, 2)}\n`, {
         mode: 0o600,
     });
+    const webUrl = `${state.url}/#token=${encodeURIComponent(token)}`;
     process.stdout.write(`OpenComputer dev service ready\n` +
         `Agent: ${manifest.name} (${manifest.id})\n` +
-        `Local API: ${state.url}\n\n` +
-        `Start a session in another terminal:\n` +
-        `  opencomputer session create "Your prompt"\n`);
+        `Web: ${webUrl}\n` +
+        `Local API: ${state.url}\n` +
+        `Session: opencomputer session\n`);
+    openBrowser(webUrl);
     await new Promise((done) => {
         process.once("SIGINT", done);
         process.once("SIGTERM", done);
     });
     await rm(statePath(root), { force: true });
+    server.closeAllConnections();
     await new Promise((done) => server.close(() => done()));
     abortController.abort();
     instance.server.close();
     await gateway.close();
 }
-async function runLocalSession(prompt) {
-    const root = await findAgentRoot();
-    if (!root)
-        throw new Error("No OpenComputer agent repository found.");
-    const state = await readDevState(root);
-    if (!state) {
-        throw new Error("OpenComputer dev is not running. Start `opencomputer dev` in another terminal.");
-    }
-    const response = await fetch(`${state.url}/sessions`, {
+async function runLocalSession(prompt, state, sessionID, onEvent) {
+    const endpoint = sessionID
+        ? `${state.url}/sessions/${encodeURIComponent(sessionID)}`
+        : `${state.url}/sessions`;
+    const response = await fetch(endpoint, {
         method: "POST",
         headers: {
             authorization: `Bearer ${state.token}`,
@@ -394,8 +603,11 @@ async function runLocalSession(prompt) {
         body: JSON.stringify({ prompt }),
     });
     if (!response.ok || !response.body) {
-        throw new Error(`The local agent service returned ${String(response.status)}`);
+        const detail = await response.text().catch(() => "");
+        throw new Error(`The local agent service returned ${String(response.status)}` +
+            (detail ? `: ${detail}` : ""));
     }
+    let resolvedSessionID = sessionID ?? response.headers.get("x-opencomputer-session-id") ?? undefined;
     const decoder = new TextDecoder();
     let buffered = "";
     let streamedText = false;
@@ -407,43 +619,139 @@ async function runLocalSession(prompt) {
             if (!line.trim())
                 continue;
             const event = JSON.parse(line);
+            onEvent?.(event);
             if (event.type === "session.created") {
-                process.stderr.write(`Session ${String(event.data.sessionId)}\n`);
+                resolvedSessionID = String(event.data.sessionId);
+                if (!onEvent)
+                    process.stderr.write(`Session ${resolvedSessionID}\n`);
             }
             else if (event.type === "message.delta") {
                 streamedText = true;
-                process.stdout.write(String(event.data.text ?? ""));
+                if (!onEvent)
+                    process.stdout.write(String(event.data.text ?? ""));
             }
             else if (event.type === "message.completed") {
-                if (!streamedText)
-                    process.stdout.write(String(event.data.text ?? ""));
-                process.stdout.write("\n");
+                if (!onEvent) {
+                    if (!streamedText)
+                        process.stdout.write(String(event.data.text ?? ""));
+                    process.stdout.write("\n");
+                }
             }
             else if (event.type === "tool.started") {
-                process.stderr.write(`⚙ ${String(event.data.tool ?? "tool")} ${JSON.stringify(event.data.input ?? {})}\n`);
+                if (!onEvent) {
+                    process.stderr.write(`⚙ ${String(event.data.tool ?? "tool")} ${JSON.stringify(event.data.input ?? {})}\n`);
+                }
             }
             else if (event.type === "tool.completed") {
-                process.stderr.write(`✓ ${String(event.data.tool ?? "tool")}\n`);
+                if (!onEvent) {
+                    process.stderr.write(`✓ ${String(event.data.tool ?? "tool")}\n`);
+                }
             }
             else if (event.type === "tool.failed") {
-                process.stderr.write(`✗ ${String(event.data.tool ?? "tool")}: ${String(event.data.message ?? "failed")}\n`);
+                if (!onEvent) {
+                    process.stderr.write(`✗ ${String(event.data.tool ?? "tool")}: ${String(event.data.message ?? "failed")}\n`);
+                }
             }
             else if (event.type === "session.failed") {
                 throw new Error(String(event.data.message ?? "Local session failed"));
             }
         }
     }
+    if (!resolvedSessionID)
+        throw new Error("The local session did not return an ID");
+    return resolvedSessionID;
+}
+async function stopOwnedDev(child) {
+    if (!child || child.exitCode !== null)
+        return;
+    child.kill("SIGTERM");
+    await Promise.race([
+        new Promise((done) => child.once("exit", () => done())),
+        new Promise((done) => setTimeout(done, 3_000)),
+    ]);
+    if (child.exitCode === null)
+        child.kill("SIGKILL");
+}
+async function ensureDevService(config) {
+    const root = await findAgentRoot();
+    if (!root) {
+        throw new Error("No OpenComputer agent repository found. Run `opencomputer init <template>` first.");
+    }
+    const existing = await readDevState(root);
+    if (existing)
+        return { state: existing };
+    const environment = {
+        ...process.env,
+        OPENCOMPUTER_API_URL: config.apiUrl,
+        OPENCOMPUTER_NO_OPEN: "1",
+    };
+    if (config.apiKey)
+        environment.OPENCOMPUTER_API_KEY = config.apiKey;
+    const child = spawn(process.execPath, [process.argv[1], "dev"], {
+        cwd: root,
+        env: environment,
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    let errors = "";
+    child.stderr?.on("data", (chunk) => {
+        errors = `${errors}${chunk.toString("utf8")}`.slice(-8_000);
+    });
+    const deadline = Date.now() + 60_000;
+    while (Date.now() < deadline) {
+        const state = await readDevState(root);
+        if (state)
+            return { state, owned: child };
+        if (child.exitCode !== null) {
+            throw new Error(errors.trim() || "The local development service exited");
+        }
+        await new Promise((done) => setTimeout(done, 100));
+    }
+    await stopOwnedDev(child);
+    throw new Error("Timed out starting the local development service");
+}
+async function runSessionShell(config) {
+    const target = await ensureDevService(config);
+    try {
+        const manifest = await readManifest(target.state.agentRoot);
+        const { runSessionTUI } = await import("./tui.js");
+        await runSessionTUI({
+            agentName: manifest.name,
+            send: (prompt, sessionId, emit) => runLocalSession(prompt, target.state, sessionId, emit),
+        });
+    }
+    finally {
+        await stopOwnedDev(target.owned);
+    }
+}
+async function runOneShotSession(prompt, config) {
+    const target = await ensureDevService(config);
+    try {
+        await runLocalSession(prompt, target.state);
+    }
+    finally {
+        await stopOwnedDev(target.owned);
+    }
 }
 export async function runLocalAgent(args, config) {
+    if (args[0] === "dev") {
+        if (args.length > 1)
+            throw new Error(`Unexpected local argument: ${args[1]}`);
+        await startDevService(config);
+        return;
+    }
     if (args[0] === "run") {
         const prompt = args.slice(1).join(" ").trim();
         if (!prompt)
             throw new Error("A prompt is required");
-        await runLocalSession(prompt);
+        await runOneShotSession(prompt, config);
+        return;
+    }
+    if (args[0] === "shell") {
+        if (args.length > 1)
+            throw new Error(`Unexpected local argument: ${args[1]}`);
+        await runSessionShell(config);
         return;
     }
-    if (args.length)
-        throw new Error(`Unexpected local argument: ${args[0]}`);
-    await startDevService(config);
+    throw new Error(`Unexpected local argument: ${args[0] ?? "none"}`);
 }
 //# sourceMappingURL=local.js.map