@opencomputer/blue 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,790 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_BLUE_API_URL, accessTokenFor, login, logout, readCredentials, } from "../auth/cli-auth.js";
+import { addSlackChannel, findAgentRoot, initializeAgent, prepareAgent, } from "../core/agent.js";
+import { buildAgentArtifact } from "../core/artifact.js";
+import { findDevState, requestDevManager, startDevManager, } from "../dev/manager.js";
+import { startLocalControlPlane } from "../dev/local-control-plane.js";
+import { authenticateOpenRouter, readOpenRouterCredential, } from "../openrouter/auth.js";
+import { BlueClient } from "../sdk/client.js";
+const DEFAULT_EDGE = DEFAULT_BLUE_API_URL;
+function argument(name) {
+    const index = process.argv.indexOf(`--${name}`);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+function positional(afterCommand) {
+    const booleanFlags = new Set([
+        "--keep",
+        "--local",
+        "--local-only",
+        "--remote",
+    ]);
+    return process.argv
+        .slice(afterCommand)
+        .filter((value, index, all) => {
+        if (index > 0 &&
+            all[index - 1]?.startsWith("--") &&
+            !booleanFlags.has(all[index - 1])) {
+            return false;
+        }
+        return !value.startsWith("--");
+    });
+}
+function hasFlag(name) {
+    return process.argv.includes(`--${name}`);
+}
+function runtimePath() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../runtime/local-runtime.js");
+}
+async function clientFor(edge) {
+    const explicit = argument("api-key") ?? process.env.BLUE_API_KEY;
+    return new BlueClient(edge, explicit ?? (await accessTokenFor(edge)));
+}
+function hostedEdge() {
+    return (argument("api-url") ??
+        argument("edge") ??
+        process.env.BLUE_API_URL ??
+        process.env.BLUE_EDGE_URL ??
+        DEFAULT_EDGE);
+}
+function spawnRuntime(edge, sessionId, token, harness, directory) {
+    const usingTypescript = import.meta.url.endsWith(".ts");
+    const blueRuntimeDirectory = resolve(directory, ".blue");
+    mkdirSync(blueRuntimeDirectory, { recursive: true });
+    return spawn(process.execPath, [
+        ...(usingTypescript ? ["--import", "tsx"] : []),
+        runtimePath().replace(/\.js$/, usingTypescript ? ".ts" : ".js"),
+        "--edge",
+        edge,
+        "--session",
+        sessionId,
+        "--token",
+        token,
+        "--harness",
+        harness,
+        "--directory",
+        directory,
+    ], {
+        stdio: ["ignore", "pipe", "inherit"],
+        env: {
+            ...process.env,
+            BLUE_OPENCODE_SESSION_PATH: resolve(blueRuntimeDirectory, "opencode-session.json"),
+            OPENCODE_DB: resolve(blueRuntimeDirectory, "opencode.db"),
+            BLUE_RUNTIME_QUIET: "1",
+        },
+    });
+}
+function waitForEvent(socket, predicate, options = {}) {
+    return new Promise((resolve, reject) => {
+        let sawMessageDelta = false;
+        let sawReasoningDelta = false;
+        let startedAnswer = false;
+        const timeout = options.timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                cleanup();
+                reject(new Error(`Timed out waiting for session event after ${String(options.timeoutMs)}ms`));
+            }, options.timeoutMs);
+        const onMessage = (message) => {
+            let frame;
+            try {
+                frame = JSON.parse(String(message.data));
+            }
+            catch {
+                return;
+            }
+            if (frame.type === "event") {
+                if (options.rejectOnRuntimeDisconnect &&
+                    frame.event.type === "runtime.disconnected") {
+                    cleanup();
+                    const code = Number(frame.event.data.code);
+                    const providedReason = typeof frame.event.data.reason === "string"
+                        ? frame.event.data.reason.trim()
+                        : "";
+                    const reason = providedReason ||
+                        (code === 4003
+                            ? "OpenRouter credential is unavailable. Run `blue login` or `blue auth openrouter`, then restart `blue dev`."
+                            : "unknown reason");
+                    reject(new Error(`Runtime disconnected${Number.isFinite(code) ? ` (${String(code)})` : ""}: ${reason}`));
+                    return;
+                }
+                if (frame.event.type === "reasoning.delta") {
+                    if (!sawReasoningDelta) {
+                        process.stdout.write("thinking: ");
+                        sawReasoningDelta = true;
+                    }
+                    process.stdout.write(String(frame.event.data.text ?? ""));
+                }
+                if (frame.event.type === "message.delta") {
+                    if (!startedAnswer && sawReasoningDelta) {
+                        process.stdout.write("\nanswer: ");
+                    }
+                    startedAnswer = true;
+                    sawMessageDelta = true;
+                    process.stdout.write(String(frame.event.data.text ?? ""));
+                }
+                if (frame.event.type === "tool.started") {
+                    process.stdout.write(`\ntool: ${String(frame.event.data.tool ?? "tool")} (${String(frame.event.data.title ?? "running")})\n`);
+                }
+                if (frame.event.type === "tool.completed") {
+                    process.stdout.write(`tool: ${String(frame.event.data.tool ?? "tool")} completed\n`);
+                }
+                if (frame.event.type === "tool.failed") {
+                    process.stdout.write(`tool: ${String(frame.event.data.tool ?? "tool")} failed\n`);
+                }
+                if (!sawMessageDelta &&
+                    frame.event.type === "message.completed" &&
+                    typeof frame.event.data.text === "string") {
+                    process.stdout.write(frame.event.data.text);
+                }
+                if (predicate(frame.event)) {
+                    cleanup();
+                    resolve(frame.event);
+                }
+            }
+            else if (frame.type === "error") {
+                cleanup();
+                reject(new Error(frame.message));
+            }
+        };
+        const onError = () => {
+            cleanup();
+            reject(new Error("Client WebSocket connection failed"));
+        };
+        const onClose = () => {
+            cleanup();
+            reject(new Error("Client WebSocket closed before the expected event"));
+        };
+        const cleanup = () => {
+            if (timeout)
+                clearTimeout(timeout);
+            socket.removeEventListener("message", onMessage);
+            socket.removeEventListener("error", onError);
+            socket.removeEventListener("close", onClose);
+        };
+        socket.addEventListener("message", onMessage);
+        socket.addEventListener("error", onError);
+        socket.addEventListener("close", onClose);
+    });
+}
+async function runRemoteTurn(edge, prompt) {
+    const agent = argument("agent") ?? (await inferDeployedAgent());
+    if (!agent) {
+        throw new Error("No agent repository was found. Pass --agent <agent>@<alias>.");
+    }
+    await createRemoteSession(edge, agent, prompt);
+}
+async function suspendRemoteSession(client, sessionId) {
+    process.stdout.write("runtime: suspending...\n");
+    const session = await client.suspendSession(sessionId);
+    process.stdout.write(`runtime: ${session.microvmState ?? "suspended"}\n`);
+}
+async function sendRemoteTurn(edge, sessionId, prompt) {
+    const client = await clientFor(edge);
+    const session = await client.getSession(sessionId);
+    if (!session.microvmId) {
+        throw new Error(`Session ${sessionId} has no MicroVM`);
+    }
+    if (session.microvmState !== "suspended" &&
+        session.microvmState !== "running") {
+        throw new Error(`Session ${sessionId} MicroVM is ${session.microvmState ?? "unknown"}, expected running or suspended`);
+    }
+    const existingEvents = await client.listEvents(sessionId);
+    const cursor = existingEvents.at(-1)?.seq ?? 0;
+    const socket = client.connect(sessionId, cursor);
+    try {
+        process.stdout.write(`session: ${sessionId}\n`);
+        if (session.microvmState === "suspended") {
+            const runtimeConnected = waitForEvent(socket, (event) => event.type === "runtime.connected", { timeoutMs: 60_000, rejectOnRuntimeDisconnect: true });
+            process.stdout.write("runtime: resuming...\n");
+            const resumedAt = Date.now();
+            await client.resumeSession(sessionId);
+            await runtimeConnected;
+            process.stdout.write(`runtime: resumed in ${String(Date.now() - resumedAt)}ms\n`);
+        }
+        const completion = waitForEvent(socket, (event) => event.type === "turn.completed" || event.type === "turn.failed", { rejectOnRuntimeDisconnect: true });
+        const turn = await client.createTurn(sessionId, prompt);
+        process.stdout.write("agent: waiting for model...\n");
+        const terminal = await completion;
+        process.stdout.write(`\nturn: ${turn.turnId} completed\n`);
+        if (hasFlag("keep")) {
+            process.stdout.write(`runtime: ${session.microvmId} running\n`);
+        }
+        else {
+            await suspendRemoteSession(client, sessionId);
+        }
+        if (terminal.type === "turn.failed") {
+            throw new Error(String(terminal.data.message ?? "Turn failed"));
+        }
+    }
+    finally {
+        socket.close();
+    }
+}
+async function endRemoteSession(edge, sessionId) {
+    const client = await clientFor(edge);
+    const session = await client.getSession(sessionId);
+    if (session.microvmId && session.microvmState !== "terminated") {
+        await client.terminateSession(sessionId);
+        process.stdout.write(`runtime: ${session.microvmId} terminated\n`);
+    }
+    await client.endSession(sessionId);
+    process.stdout.write(`session: ${sessionId} ended\n`);
+}
+async function runTurn(edge, prompt) {
+    const harness = (argument("harness") ?? "mock");
+    if (harness !== "mock" && harness !== "opencode") {
+        throw new Error("--harness must be mock or opencode");
+    }
+    const prepared = await prepareAgent(argument("agent-dir") ?? process.cwd());
+    const client = new BlueClient(edge, argument("api-key") ?? process.env.BLUE_API_KEY);
+    const created = await client.createSession({
+        agentId: argument("agent") ?? `local/${prepared.name}`,
+        deploymentId: "development",
+    });
+    process.stdout.write(`session: ${created.session.id}\n`);
+    const socket = client.connect(created.session.id);
+    const runtime = spawnRuntime(edge, created.session.id, created.runtimeToken, harness, prepared.runtimeDirectory);
+    runtime.stdout?.on("data", (chunk) => {
+        if (process.env.BLUE_DEBUG)
+            process.stderr.write(chunk);
+    });
+    try {
+        const completion = waitForEvent(socket, (event) => event.type === "turn.completed" || event.type === "turn.failed");
+        const turn = await client.createTurn(created.session.id, prompt);
+        const terminal = await completion;
+        if (terminal.type === "turn.failed") {
+            throw new Error(String(terminal.data.message ?? "Turn failed"));
+        }
+        process.stdout.write(`\nturn: ${turn.turnId} completed\n`);
+    }
+    finally {
+        socket.close();
+        runtime.kill("SIGTERM");
+    }
+}
+async function executePrompt(client, socket, sessionId, prompt) {
+    const completion = waitForEvent(socket, (event) => event.type === "turn.completed" || event.type === "turn.failed", { timeoutMs: 180_000, rejectOnRuntimeDisconnect: true });
+    const turn = await client.createTurn(sessionId, prompt);
+    const terminal = await completion;
+    process.stdout.write(`\nturn: ${turn.turnId} ${terminal.type.slice(5)}\n`);
+    if (terminal.type === "turn.failed") {
+        throw new Error(String(terminal.data.message ?? "Turn failed"));
+    }
+}
+async function runRemoteSessionShell(client, socket, sessionId, exitAction = "leave the session running") {
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    });
+    readline.on("SIGINT", () => readline.close());
+    process.stdout.write(`${terminalStyle(90, `Enter a prompt. Use /exit or Ctrl-C to ${exitAction}.`)}\n\n` +
+        terminalStyle(34, "blue> "));
+    try {
+        for await (const line of readline) {
+            const prompt = line.trim();
+            if (prompt === "/exit" || prompt === "/quit")
+                break;
+            if (prompt) {
+                try {
+                    await executePrompt(client, socket, sessionId, prompt);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (message.startsWith("Runtime disconnected"))
+                        throw error;
+                    process.stderr.write(`${terminalStyle(31, "turn failed")}  ${message}\n`);
+                }
+            }
+            process.stdout.write(terminalStyle(34, "blue> "));
+        }
+    }
+    finally {
+        readline.close();
+    }
+}
+async function sessionTarget() {
+    const explicitEdge = argument("edge");
+    if (explicitEdge)
+        return { edge: explicitEdge, dev: null };
+    if (hasFlag("local")) {
+        const dev = await findDevState();
+        if (!dev)
+            throw new Error("No local `blue dev` process was found");
+        return { edge: dev.edge, dev };
+    }
+    if (hasFlag("remote") || argument("agent")) {
+        return { edge: hostedEdge(), dev: null };
+    }
+    const dev = await findDevState();
+    if (dev)
+        return { edge: dev.edge, dev };
+    return { edge: hostedEdge(), dev: null };
+}
+async function createLocalSession(state, prompt) {
+    const client = new BlueClient(state.edge);
+    const created = await client.createSession({
+        agentId: `local/${state.agentId}`,
+        deploymentId: "development",
+    });
+    const socket = client.connect(created.session.id);
+    try {
+        const connected = waitForEvent(socket, (event) => event.type === "runtime.connected", { timeoutMs: 60_000, rejectOnRuntimeDisconnect: true });
+        await requestDevManager(state, "POST", created.session.id, created.runtimeToken);
+        await connected;
+        process.stdout.write(`session: ${created.session.id}\nagent: local/${state.agentId}\nruntime: ready\n`);
+        if (prompt) {
+            await executePrompt(client, socket, created.session.id, prompt);
+        }
+        else {
+            await runRemoteSessionShell(client, socket, created.session.id, "close the local client");
+        }
+    }
+    finally {
+        socket.close();
+    }
+}
+async function createRemoteSession(edge, agentReference, prompt) {
+    const client = await clientFor(edge);
+    const created = await client.createSession({ agentId: agentReference });
+    const deployment = created.deployment;
+    if (!deployment) {
+        throw new Error(`Blue did not resolve deployment for ${agentReference}`);
+    }
+    process.stdout.write(`session: ${created.session.id}\n` +
+        `agent: ${deployment.agentId}@${deployment.alias}\n` +
+        `deployment: ${deployment.id}\n`);
+    const socket = client.connect(created.session.id);
+    try {
+        const connected = waitForEvent(socket, (event) => event.type === "runtime.connected", { timeoutMs: 60_000, rejectOnRuntimeDisconnect: true });
+        process.stdout.write("runtime: starting...\n");
+        await connected;
+        process.stdout.write("runtime: ready\n");
+        if (prompt) {
+            await executePrompt(client, socket, created.session.id, prompt);
+        }
+        else {
+            await runRemoteSessionShell(client, socket, created.session.id, "suspend the session");
+        }
+        if (hasFlag("keep")) {
+            process.stdout.write("runtime: running\n");
+        }
+        else {
+            await suspendRemoteSession(client, created.session.id);
+        }
+    }
+    finally {
+        socket.close();
+    }
+}
+async function inferDeployedAgent() {
+    const root = await findAgentRoot(argument("agent-dir") ?? process.cwd());
+    if (!root)
+        return undefined;
+    const agentId = basename(root)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return agentId
+        ? `${agentId}@${argument("alias") ?? "production"}`
+        : undefined;
+}
+async function sendLocalTurn(state, sessionId, prompt) {
+    const client = new BlueClient(state.edge);
+    await requestDevManager(state, "POST", sessionId);
+    const session = await client.getSession(sessionId);
+    if (!session.agentId.startsWith("local/")) {
+        throw new Error(`${sessionId} is not a local development session`);
+    }
+    const events = await client.listEvents(sessionId);
+    const socket = client.connect(sessionId, events.at(-1)?.seq ?? 0);
+    try {
+        await executePrompt(client, socket, sessionId, prompt);
+    }
+    finally {
+        socket.close();
+    }
+}
+async function deployAgent(edge) {
+    const built = await buildAgentArtifact(argument("agent-dir") ?? process.cwd());
+    const client = await clientFor(edge);
+    const upload = await client.createDeploymentUpload({
+        agentId: built.agentId,
+        digest: built.digest,
+        size: built.body.byteLength,
+        contentType: "application/vnd.blue.agent+json",
+    });
+    const uploaded = await fetch(upload.uploadUrl, {
+        method: upload.method,
+        headers: upload.headers,
+        body: built.body,
+    });
+    if (!uploaded.ok) {
+        throw new Error(`Agent upload failed with status ${String(uploaded.status)}`);
+    }
+    const alias = argument("alias") ?? "production";
+    const deployment = await client.registerDeployment({
+        agentId: built.agentId,
+        alias,
+        artifact: upload.artifact,
+    });
+    process.stdout.write(`agent: ${deployment.agentId}\n` +
+        `deployment: ${deployment.id}\n` +
+        `alias: ${deployment.alias}\n` +
+        `artifact: s3://${deployment.artifact.bucket}/${deployment.artifact.key}\n` +
+        `ready in: ${String(built.elapsedMs)}ms\n`);
+}
+function printSession(session) {
+    const separator = session.deploymentId.lastIndexOf(":");
+    const deployment = separator >= 0
+        ? session.deploymentId.slice(separator + 1)
+        : session.deploymentId;
+    process.stdout.write(`${session.id}  ${session.status.padEnd(15)}  ` +
+        `${session.agentId}@${deployment.slice(0, 12)}  ` +
+        `${session.microvmState ?? "local"}\n`);
+}
+async function attachSession(edge, sessionId) {
+    const client = await clientFor(edge);
+    const events = await client.listEvents(sessionId);
+    for (const event of events) {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+    }
+    const socket = client.connect(sessionId, events.at(-1)?.seq ?? 0);
+    socket.addEventListener("message", (message) => {
+        const frame = JSON.parse(String(message.data));
+        if (frame.type === "event") {
+            process.stdout.write(`${JSON.stringify(frame.event)}\n`);
+        }
+    });
+    process.stdout.write("attached; press Ctrl-C to exit\n");
+    await new Promise((resolvePromise) => {
+        process.once("SIGINT", () => {
+            socket.close();
+            resolvePromise();
+        });
+        socket.addEventListener("close", () => resolvePromise());
+    });
+}
+function terminalStyle(code, text) {
+    return process.stdout.isTTY ? `\u001b[${String(code)}m${text}\u001b[0m` : text;
+}
+async function dev() {
+    const requestedPort = argument("port");
+    const port = requestedPort
+        ? Number.parseInt(requestedPort, 10)
+        : undefined;
+    if (port !== undefined && (!Number.isFinite(port) || port < 1)) {
+        throw new Error("--port must be a positive integer");
+    }
+    const managerPort = Number.parseInt(argument("manager-port") ?? "0", 10);
+    const harness = (argument("harness") ?? "opencode");
+    if (harness !== "mock" && harness !== "opencode") {
+        throw new Error("--harness must be mock or opencode");
+    }
+    const prepared = await prepareAgent(argument("agent-dir") ?? process.cwd());
+    try {
+        process.loadEnvFile(resolve(prepared.root, ".env"));
+    }
+    catch (error) {
+        if (!(error instanceof Error) ||
+            !("code" in error) ||
+            error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    let useBlueOpenRouterGateway = false;
+    if (harness === "opencode" && !process.env.OPENROUTER_API_KEY) {
+        const credential = await readOpenRouterCredential(prepared.root);
+        if (credential) {
+            process.env.OPENROUTER_API_KEY = credential;
+        }
+        else {
+            await accessTokenFor(hostedEdge());
+            useBlueOpenRouterGateway = true;
+        }
+    }
+    process.env.BLUE_MODEL =
+        argument("model") ??
+            process.env.BLUE_MODEL ??
+            "openrouter/anthropic/claude-sonnet-4.6";
+    const local = await startLocalControlPlane({
+        port,
+        statePath: resolve(prepared.root, ".blue", "dev", "control-plane.json"),
+        openRouterApiKey: process.env.OPENROUTER_API_KEY,
+        model: process.env.BLUE_MODEL,
+    });
+    const edge = local.url;
+    let manager;
+    try {
+        manager = await startDevManager({
+            edge,
+            blueApiUrl: hostedEdge(),
+            port: managerPort,
+            agentRoot: prepared.root,
+            agentId: prepared.name,
+            harness,
+            spawnRuntime: (sessionId, runtimeToken, directory) => spawnRuntime(edge, sessionId, runtimeToken, harness, directory),
+        });
+        if (useBlueOpenRouterGateway) {
+            process.env.OPENROUTER_API_KEY = manager.state.token;
+            process.env.BLUE_OPENROUTER_BASE_URL =
+                `${manager.state.manager}/openrouter/api/v1`;
+        }
+        process.stdout.write(`blue dev: ${prepared.name} ready at ${edge}\n` +
+            `manager: ${manager.state.manager}\n` +
+            `session: blue session\n` +
+            `prompt: blue session "your first message"\n` +
+            (manager.state.channels.slack
+                ? manager.state.channels.slack.mode === "socket"
+                    ? "slack: Socket Mode connected\n"
+                    : `slack: ${manager.state.channels.slack.webhook}\n`
+                : ""));
+        await new Promise((resolvePromise) => {
+            process.once("SIGINT", resolvePromise);
+            process.once("SIGTERM", resolvePromise);
+        });
+    }
+    finally {
+        await manager?.close();
+        await local.close();
+    }
+}
+async function demo() {
+    const requestedPort = argument("port");
+    const local = await startLocalControlPlane({
+        port: requestedPort
+            ? Number.parseInt(requestedPort, 10)
+            : undefined,
+        statePath: resolve(".blue", "dev", "demo-control-plane.json"),
+        openRouterApiKey: process.env.OPENROUTER_API_KEY,
+        model: argument("model") ??
+            process.env.BLUE_MODEL ??
+            "openrouter/anthropic/claude-sonnet-4.6",
+    });
+    try {
+        const prompt = positional(3).join(" ") || "Hello from Blue";
+        await runTurn(local.url, prompt);
+    }
+    finally {
+        await local.close();
+    }
+}
+function usage() {
+    process.stdout.write(`blue - OpenCode agent sessions
+
+Usage:
+  blue login [--api-url URL]
+  blue logout
+  blue whoami
+  blue init <directory>
+  blue dev [--agent-dir path] [--model provider/model] [--port port]
+  blue demo [prompt] [--agent-dir path] [--harness mock|opencode]
+  blue run <prompt> [--agent <agent>@<alias>]
+  blue auth openrouter
+  blue channels add slack [--agent-dir path]
+  blue deploy [--agent-dir path] [--alias production] [--edge URL]
+  blue remote <prompt> [--edge URL] [--api-key key] [--keep]
+  blue agents list
+  blue session [prompt] [--local|--remote]
+  blue session create --local [prompt]
+  blue session create [--agent <agent>@<alias>] [prompt] [--keep]
+  blue session list [--local]
+  blue session inspect <session-id> [--local]
+  blue session attach <session-id> [--local]
+  blue session send <session-id> <prompt> [--local] [--keep]
+  blue session end <session-id> [--local]
+`);
+}
+async function main() {
+    const command = process.argv[2];
+    if (command === "login") {
+        const credentials = await login(hostedEdge());
+        process.stdout.write(`Logged in${credentials.user?.email ? ` as ${credentials.user.email}` : ""}.\n`);
+        return;
+    }
+    if (command === "logout") {
+        process.stdout.write((await logout()) ? "Logged out.\n" : "Not logged in.\n");
+        return;
+    }
+    if (command === "whoami") {
+        const edge = hostedEdge();
+        const identity = await (await clientFor(edge)).whoami();
+        const credentials = await readCredentials();
+        process.stdout.write(`${credentials?.user?.email ?? identity.userId}\n` +
+            `account: ${identity.accountId}\n` +
+            (identity.organizationId
+                ? `organization: ${identity.organizationId}\n`
+                : ""));
+        return;
+    }
+    if (command === "init") {
+        const directory = positional(3)[0];
+        if (!directory)
+            throw new Error("A target directory is required");
+        process.stdout.write(`created: ${await initializeAgent(directory)}\n`);
+        return;
+    }
+    if (command === "dev") {
+        await dev();
+        return;
+    }
+    if (command === "demo") {
+        await demo();
+        return;
+    }
+    if (command === "run") {
+        const prompt = positional(3).join(" ");
+        if (!prompt)
+            throw new Error("A prompt is required");
+        await runRemoteTurn(hostedEdge(), prompt);
+        return;
+    }
+    if (command === "auth") {
+        if (positional(3)[0] !== "openrouter") {
+            throw new Error("Only `blue auth openrouter` is supported");
+        }
+        if (!(await readOpenRouterCredential())) {
+            await authenticateOpenRouter();
+        }
+        process.stdout.write("OpenRouter connected locally.\n");
+        return;
+    }
+    if (command === "channels") {
+        const [action, channel] = positional(3);
+        if (action !== "add" || channel !== "slack") {
+            throw new Error("Use `blue channels add slack`");
+        }
+        process.stdout.write(`created: ${await addSlackChannel(argument("agent-dir") ?? process.cwd())}\n`);
+        return;
+    }
+    if (command === "deploy") {
+        await deployAgent(hostedEdge());
+        return;
+    }
+    if (command === "remote") {
+        const prompt = positional(3).join(" ");
+        if (!prompt)
+            throw new Error("A prompt is required");
+        await runRemoteTurn(hostedEdge(), prompt);
+        return;
+    }
+    if (command === "session") {
+        const sessionArguments = positional(3);
+        const knownActions = new Set([
+            "create",
+            "list",
+            "inspect",
+            "attach",
+            "send",
+            "end",
+        ]);
+        const shorthand = sessionArguments[0];
+        const action = shorthand && knownActions.has(shorthand) ? shorthand : "create";
+        const target = await sessionTarget();
+        if (action === "create") {
+            const prompt = (shorthand === "create"
+                ? sessionArguments.slice(1)
+                : sessionArguments).join(" ") || undefined;
+            if (hasFlag("local") || (target.dev && !argument("agent"))) {
+                if (!target.dev)
+                    throw new Error("Run `blue dev` first");
+                await createLocalSession(target.dev, prompt);
+            }
+            else {
+                const agent = argument("agent") ?? (await inferDeployedAgent());
+                if (!agent) {
+                    throw new Error("No agent repository was found. Pass --agent <agent>@<alias>.");
+                }
+                await createRemoteSession(target.edge, agent, prompt);
+            }
+            return;
+        }
+        if (action === "list") {
+            const sessions = await (await clientFor(target.edge)).listSessions();
+            if (sessions.length === 0) {
+                process.stdout.write("No sessions.\n");
+            }
+            else {
+                sessions.forEach(printSession);
+            }
+            return;
+        }
+        const sessionId = positional(4)[0];
+        if (!sessionId)
+            throw new Error("A session ID is required");
+        if (action === "send") {
+            const prompt = positional(5).join(" ");
+            if (!prompt)
+                throw new Error("A prompt is required");
+            if (target.dev) {
+                await sendLocalTurn(target.dev, sessionId, prompt);
+            }
+            else {
+                await sendRemoteTurn(target.edge, sessionId, prompt);
+            }
+            return;
+        }
+        if (action === "end") {
+            if (target.dev) {
+                await requestDevManager(target.dev, "DELETE", sessionId);
+                await new BlueClient(target.edge).endSession(sessionId);
+                process.stdout.write(`session: ${sessionId} ended\n`);
+            }
+            else {
+                await endRemoteSession(target.edge, sessionId);
+            }
+            return;
+        }
+        if (action === "inspect") {
+            const client = await clientFor(target.edge);
+            process.stdout.write(`${JSON.stringify(await client.getSession(sessionId), null, 2)}\n`);
+            return;
+        }
+        if (action === "attach") {
+            await attachSession(target.edge, sessionId);
+            return;
+        }
+        throw new Error("Use `blue session create`, `list`, `inspect`, `attach`, `send`, or `end`");
+    }
+    if (command === "agents") {
+        if (positional(3)[0] !== "list") {
+            throw new Error("Use `blue agents list`");
+        }
+        const agents = await (await clientFor(hostedEdge())).listAgents();
+        if (agents.length === 0) {
+            process.stdout.write("No deployed agents.\n");
+        }
+        else {
+            for (const agent of agents) {
+                const separator = agent.activeDeploymentId.lastIndexOf(":");
+                const deployment = separator >= 0
+                    ? agent.activeDeploymentId.slice(separator + 1)
+                    : agent.activeDeploymentId;
+                process.stdout.write(`${agent.id}@${agent.activeAlias}  ` +
+                    `${deployment.slice(0, 12)}  ` +
+                    `${String(agent.deploymentCount)} deployment(s)\n`);
+            }
+        }
+        return;
+    }
+    if (command === "inspect") {
+        const sessionId = positional(3)[0];
+        if (!sessionId)
+            throw new Error("A session ID is required");
+        const client = await clientFor(hostedEdge());
+        process.stdout.write(`${JSON.stringify(await client.getSession(sessionId), null, 2)}\n`);
+        return;
+    }
+    usage();
+}
+main().catch((error) => {
+    process.stderr.write(`blue: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map