@opencomputer/cli 0.3.3 → 0.3.5

package/dist/local.js

@@ -1,130 +1,667 @@
+import { createOpencode, } from "@opencode-ai/sdk/v2";
 import { spawn } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { access } from "node:fs/promises";
-import { createServer } from "node:http";
-import { resolve } from "node:path";
-import { findAgentRoot, prepareAgent } from "./project.js";
+import { mkdir, readFile, rm, writeFile, } from "node:fs/promises";
+import { createServer, } from "node:http";
+import { delimiter, dirname, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+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);
     const rightBytes = Buffer.from(right);
     return (leftBytes.length === rightBytes.length &&
         timingSafeEqual(leftBytes, rightBytes));
 }
-async function readBody(request) {
+async function readBody(request, limit = 2 * 1024 * 1024) {
     const chunks = [];
     let size = 0;
     for await (const chunk of request) {
         const buffer = Buffer.from(chunk);
         size += buffer.byteLength;
-        if (size > 2 * 1024 * 1024) {
-            throw new Error("Connection request is too large");
-        }
+        if (size > limit)
+            throw new Error("Request is too large");
         chunks.push(buffer);
     }
     return Buffer.concat(chunks);
 }
-async function startConnectionProxy(config) {
+function authorized(request, token) {
+    const header = request.headers.authorization;
+    return (typeof header === "string" &&
+        header.startsWith("Bearer ") &&
+        sameToken(header.slice(7), token));
+}
+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 testing connected tools.");
+        throw new Error("Not logged in. Run `opencomputer login` before starting dev mode.");
     }
     const token = randomBytes(32).toString("base64url");
     const server = createServer((request, response) => {
         void (async () => {
-            if (request.method !== "POST" || request.url !== "/google/fetch") {
-                response.writeHead(404).end();
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            const header = request.headers.authorization;
+            if (!header?.startsWith("Bearer ") ||
+                !sameToken(header.slice(7), token)) {
+                response.writeHead(401).end();
                 return;
             }
-            const authorization = request.headers.authorization;
-            if (!authorization?.startsWith("Bearer ") ||
-                !sameToken(authorization.slice(7), token)) {
-                response.writeHead(401).end();
+            let target;
+            if (request.method === "POST" && url.pathname === "/google/fetch") {
+                target = `${config.apiUrl}/api/managed-agents/connections/google/fetch`;
+            }
+            else if (url.pathname.startsWith("/openrouter/")) {
+                target =
+                    `${config.apiUrl}/api/managed-agents/openrouter` +
+                        `${url.pathname.slice("/openrouter".length)}${url.search}`;
+            }
+            else {
+                response.writeHead(404).end();
                 return;
             }
-            const upstream = await fetch(`${config.apiUrl}/api/managed-agents/connections/google/fetch`, {
-                method: "POST",
+            const upstream = await fetch(target, {
+                method: request.method,
                 headers: {
-                    "content-type": "application/json",
+                    "content-type": request.headers["content-type"] ?? "application/json",
                     "x-api-key": config.apiKey,
                 },
-                body: await readBody(request),
-                signal: AbortSignal.timeout(30_000),
+                body: request.method === "GET" || request.method === "HEAD"
+                    ? undefined
+                    : await readBody(request),
+                signal: AbortSignal.timeout(60_000),
             });
             response.writeHead(upstream.status, {
                 "content-type": upstream.headers.get("content-type") ?? "application/json",
             });
             response.end(Buffer.from(await upstream.arrayBuffer()));
         })().catch((error) => {
-            response.writeHead(502, { "content-type": "application/json" });
-            response.end(JSON.stringify({
+            sendJSON(response, 502, {
                 error: {
-                    message: error instanceof Error
-                        ? error.message
-                        : "Connection proxy failed",
+                    message: error instanceof Error ? error.message : "Gateway request failed",
                 },
-            }));
+            });
         });
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((done, reject) => {
         server.once("error", reject);
-        server.listen(0, "127.0.0.1", resolve);
+        server.listen(0, "127.0.0.1", done);
     });
     const address = server.address();
     if (!address || typeof address === "string") {
         server.close();
-        throw new Error("Could not start the local connection proxy");
+        throw new Error("Could not start the local OpenComputer gateway");
     }
     return {
         url: `http://127.0.0.1:${String(address.port)}`,
         token,
-        close: () => new Promise((resolve) => server.close(() => resolve())),
+        close: () => {
+            server.closeAllConnections();
+            return new Promise((done) => server.close(() => done()));
+        },
+    };
+}
+function addBundledRuntimeToPath() {
+    const packagePath = fileURLToPath(import.meta.resolve("opencode-ai/package.json"));
+    const bin = resolve(dirname(packagePath), "..", ".bin");
+    const current = process.env.PATH ?? "";
+    if (!current.split(delimiter).includes(bin)) {
+        process.env.PATH = current ? `${bin}${delimiter}${current}` : bin;
+    }
+}
+function modelParts() {
+    const full = process.env.OPENCOMPUTER_MODEL ??
+        "openrouter/anthropic/claude-sonnet-4.6";
+    const separator = full.indexOf("/");
+    return {
+        providerID: separator === -1 ? "openrouter" : full.slice(0, separator),
+        modelID: separator === -1 ? full : full.slice(separator + 1),
+        full,
     };
 }
-export async function runOpenCode(args, config) {
+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 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 emitTool = (part) => {
+        if (!assistantMessages.has(part.messageID))
+            return;
+        const previous = toolStates.get(part.callID);
+        const current = part.state.status;
+        if (previous === current)
+            return;
+        toolStates.set(part.callID, current);
+        if (current === "running") {
+            emit({
+                type: "tool.started",
+                data: { tool: part.tool, input: part.state.input },
+            });
+        }
+        else if (current === "completed") {
+            emit({ type: "tool.completed", data: { tool: part.tool } });
+        }
+        else if (current === "error") {
+            emit({
+                type: "tool.failed",
+                data: { tool: part.tool, message: part.state.error },
+            });
+        }
+    };
+    try {
+        const model = modelParts();
+        const started = await client.session.promptAsync({
+            sessionID,
+            directory,
+            model: { providerID: model.providerID, modelID: model.modelID },
+            parts: [{ type: "text", text: prompt }],
+        });
+        if (started.error)
+            throw new Error(JSON.stringify(started.error));
+        for await (const event of subscription.stream) {
+            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);
+                    }
+                    for (const part of tools.values()) {
+                        if (part.messageID === info.id)
+                            emitTool(part);
+                    }
+                }
+            }
+            else if (event.type === "message.part.updated") {
+                const part = event.properties.part;
+                if (part.sessionID !== sessionID)
+                    continue;
+                if (part.type === "text") {
+                    messageByPart.set(part.id, part.messageID);
+                    textByPart.set(part.id, part.text);
+                    emitText(part.id);
+                }
+                else if (part.type === "tool") {
+                    tools.set(part.callID, part);
+                    emitTool(part);
+                }
+            }
+            else if (event.type === "session.error" &&
+                event.properties.sessionID === sessionID) {
+                throw new Error(JSON.stringify(event.properties.error));
+            }
+            else if (event.type === "session.idle" &&
+                event.properties.sessionID === sessionID) {
+                break;
+            }
+        }
+    }
+    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 text = completedText.join("");
+    emit({ type: "message.completed", data: { text } });
+    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");
+}
+async function readDevState(root) {
+    try {
+        const state = JSON.parse(await readFile(statePath(root), "utf8"));
+        if (state.version !== 1 || !state.url || !state.token)
+            return null;
+        const response = await fetch(`${state.url}/health`, {
+            headers: { authorization: `Bearer ${state.token}` },
+            signal: AbortSignal.timeout(1_000),
+        });
+        return response.ok ? state : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function startDevService(config) {
     const root = await findAgentRoot();
     if (!root) {
         throw new Error("No OpenComputer agent repository found. Run `opencomputer init <template>` first.");
     }
-    const runtime = await prepareAgent(root);
-    const connections = await startConnectionProxy(config);
-    const localExecutable = resolve(root, "node_modules", ".bin", process.platform === "win32" ? "opencode.cmd" : "opencode");
-    const executable = await access(localExecutable)
-        .then(() => localExecutable)
-        .catch(() => process.platform === "win32" ? "opencode.cmd" : "opencode");
-    const openCodeArgs = args[0] === "run"
-        ? [...args, "--dir", runtime]
-        : args.length === 0
-            ? [runtime]
-            : args;
-    try {
-        await new Promise((resolve, reject) => {
-            const child = spawn(executable, openCodeArgs, {
-                cwd: runtime,
-                env: {
-                    ...process.env,
-                    OPENCOMPUTER_CONNECTIONS_URL: connections.url,
-                    OPENCOMPUTER_CONNECTION_TOKEN: connections.token,
-                    OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: process.env.OPENCOMPUTER_MAX_OUTPUT_TOKENS ??
-                        process.env.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX ??
-                        "16384",
+    const existing = await readDevState(root);
+    if (existing) {
+        throw new Error(`OpenComputer dev is already running at ${existing.url}`);
+    }
+    const directory = await prepareAgent(root);
+    const manifest = await readManifest(root);
+    const gateway = await startGateway(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` },
                 },
-                stdio: "inherit",
-            });
-            child.once("error", (error) => {
-                reject(error instanceof Error && "code" in error && error.code === "ENOENT"
-                    ? new Error("OpenCode is not installed. Run `npm install` first.")
-                    : error);
-            });
-            child.once("exit", (code, signal) => {
-                if (code === 0)
-                    resolve();
+            },
+            autoupdate: false,
+            share: "disabled",
+        },
+    });
+    const authenticated = await instance.client.auth.set({
+        providerID: "openrouter",
+        auth: { type: "api", key: gateway.token },
+    });
+    if (authenticated.error || authenticated.data !== true) {
+        throw new Error("The embedded agent runtime rejected its local credential");
+    }
+    const token = randomBytes(32).toString("base64url");
+    const nonce = randomBytes(18).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 === "/") {
+                response.writeHead(200, {
+                    "content-type": "text/html; charset=utf-8",
+                    "cache-control": "no-store",
+                    "content-security-policy": `default-src 'none'; script-src 'nonce-${nonce}'; ` +
+                        "style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; frame-ancestors 'none'",
+                });
+                response.end(renderDevUI(manifest.name, nonce));
+                return;
+            }
+            if (!authorized(request, token)) {
+                sendJSON(response, 401, { message: "Unauthorized" });
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/health") {
+                sendJSON(response, 200, {
+                    ok: true,
+                    agentId: manifest.id,
+                    sessions: sessions.size,
+                });
+                return;
+            }
+            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",
+                });
+                const emit = (event) => {
+                    response.write(`${JSON.stringify(event)}\n`);
+                };
+                if (created) {
+                    emit({ type: "session.created", data: { sessionId: session.id } });
+                }
+                try {
+                    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({
+                        type: "session.failed",
+                        data: {
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                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 {
-                    reject(new Error(`OpenCode exited ${signal ? `with ${signal}` : `with code ${String(code)}`}`));
+                    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" });
+        })().catch((error) => {
+            if (!response.headersSent) {
+                sendJSON(response, 500, {
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            else {
+                response.end();
+            }
         });
+    });
+    await new Promise((done, reject) => {
+        server.once("error", reject);
+        server.listen(Number(process.env.OPENCOMPUTER_DEV_PORT ?? 0), "127.0.0.1", done);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("The OpenComputer dev service did not receive a port");
+    }
+    const state = {
+        version: 1,
+        pid: process.pid,
+        url: `http://127.0.0.1:${String(address.port)}`,
+        token,
+        agentRoot: root,
+        agentId: manifest.id,
+        startedAt: new Date().toISOString(),
+    };
+    await mkdir(dirname(statePath(root)), { recursive: true, mode: 0o700 });
+    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` +
+        `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, state, sessionID) {
+    const endpoint = sessionID
+        ? `${state.url}/sessions/${encodeURIComponent(sessionID)}`
+        : `${state.url}/sessions`;
+    const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${state.token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({ prompt }),
+    });
+    if (!response.ok || !response.body) {
+        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;
+    for await (const chunk of response.body) {
+        buffered += decoder.decode(chunk, { stream: true });
+        const lines = buffered.split("\n");
+        buffered = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const event = JSON.parse(line);
+            if (event.type === "session.created") {
+                resolvedSessionID = String(event.data.sessionId);
+                process.stderr.write(`Session ${resolvedSessionID}\n`);
+            }
+            else if (event.type === "message.delta") {
+                streamedText = true;
+                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");
+            }
+            else if (event.type === "tool.started") {
+                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`);
+            }
+            else if (event.type === "tool.failed") {
+                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);
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    });
+    let sessionID;
+    process.stdout.write("Local agent ready. Enter a prompt; use /exit or Ctrl-C to quit.\n\n");
+    readline.on("SIGINT", () => readline.close());
+    try {
+        for (;;) {
+            let line;
+            try {
+                line = await readline.question("opencomputer> ");
+            }
+            catch {
+                break;
+            }
+            const prompt = line.trim();
+            if (prompt === "/exit" || prompt === "/quit")
+                break;
+            if (!prompt)
+                continue;
+            try {
+                sessionID = await runLocalSession(prompt, target.state, sessionID);
+            }
+            catch (error) {
+                process.stderr.write(`turn failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    }
+    finally {
+        readline.close();
+        await stopOwnedDev(target.owned);
+    }
+}
+async function runOneShotSession(prompt, config) {
+    const target = await ensureDevService(config);
+    try {
+        await runLocalSession(prompt, target.state);
     }
     finally {
-        await connections.close();
+        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 runOneShotSession(prompt, config);
+        return;
+    }
+    if (args[0] === "shell") {
+        if (args.length > 1)
+            throw new Error(`Unexpected local argument: ${args[1]}`);
+        await runSessionShell(config);
+        return;
     }
+    throw new Error(`Unexpected local argument: ${args[0] ?? "none"}`);
 }
 //# sourceMappingURL=local.js.map