@miosa/cli 1.3.4 → 2.0.0

package/dist/commands/agent.js

@@ -1,737 +0,0 @@
-/**
- * miosa agent - first-class computer control session management.
- *
- * Routes map to: /api/v1/computers/:computer_id/control/sessions[/:session_id/...]
- *
- * Subcommands:
- *   start     POST   /computers/:id/control/sessions
- *   ls        GET    /computers/:id/control/sessions  (all computers when no --computer)
- *   get       GET    /computers/:id/control/sessions/:session_id
- *   task      POST   /computers/:id/control/sessions/:session_id/task
- *   pause     POST   /computers/:id/control/sessions/:session_id/pause
- *   resume    POST   /computers/:id/control/sessions/:session_id/resume
- *   stop      DELETE /computers/:id/control/sessions/:session_id
- *   history   GET    /computers/:id/control/sessions/:session_id/events
- */
-import fs from "node:fs";
-import chalk from "chalk";
-import { MiosaClient } from "../client.js";
-import { loadConfig } from "../config.js";
-import { UserError } from "../errors.js";
-import { renderTable } from "../ui/table.js";
-import { spin } from "../ui/spinner.js";
-import { handleError, isJsonMode, parseEnvPairs } from "./util.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function apiV1(path) {
-    return `/api/v1${path}`;
-}
-function enc(value) {
-    return encodeURIComponent(value);
-}
-function collectOption(value, previous) {
-    previous.push(value);
-    return previous;
-}
-function readJsonValue(value, file, label) {
-    if (value && file) {
-        throw new UserError(`Use either --${label} or --${label}-file, not both.`);
-    }
-    if (file) {
-        return JSON.parse(fs.readFileSync(file, "utf8"));
-    }
-    if (value) {
-        return JSON.parse(value);
-    }
-    return undefined;
-}
-/** Extract a list from the standard {data: [...]} envelope or bare array. */
-function listOf(payload, extraKeys = []) {
-    if (Array.isArray(payload))
-        return payload;
-    if (isRecord(payload)) {
-        if (Array.isArray(payload["data"]))
-            return payload["data"];
-        for (const key of extraKeys) {
-            if (Array.isArray(payload[key]))
-                return payload[key];
-        }
-    }
-    return [];
-}
-/** Extract a single object from {data: {...}} envelope or the payload itself. */
-function dataOf(payload) {
-    if (isRecord(payload) && isRecord(payload["data"])) {
-        return payload["data"];
-    }
-    return payload;
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
- * Resolve a computer by name or ID.
- * Calls GET /api/v1/computers and filters the list.
- */
-async function resolveComputer(c, nameOrId) {
-    const payload = await c.apiGet(apiV1("/computers"));
-    const items = listOf(payload, ["computers"]);
-    const match = items.find((item) => item.id === nameOrId || item.name === nameOrId);
-    if (!match) {
-        throw new UserError(`Computer not found: ${nameOrId}`, "Run `miosa computers list` to see available computers.");
-    }
-    return match;
-}
-/** Relative time string, e.g. "3 minutes ago" */
-function timeAgo(iso) {
-    if (!iso)
-        return chalk.dim("—");
-    const ms = Date.now() - new Date(iso).getTime();
-    if (ms < 0)
-        return "just now";
-    if (ms < 60_000)
-        return `${Math.floor(ms / 1_000)}s ago`;
-    if (ms < 3_600_000)
-        return `${Math.floor(ms / 60_000)} minutes ago`;
-    if (ms < 86_400_000)
-        return `${Math.floor(ms / 3_600_000)} hours ago`;
-    return `${Math.floor(ms / 86_400_000)} days ago`;
-}
-/** "3m 42s" from two ISO timestamps */
-function duration(start, end) {
-    if (!start)
-        return chalk.dim("—");
-    const endMs = end ? new Date(end).getTime() : Date.now();
-    const ms = endMs - new Date(start).getTime();
-    if (ms < 0)
-        return chalk.dim("—");
-    const totalSec = Math.floor(ms / 1_000);
-    const mins = Math.floor(totalSec / 60);
-    const secs = totalSec % 60;
-    return mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-}
-/** Truncate a string to max characters, appending "…" if cut. */
-function truncate(s, max) {
-    return s.length <= max ? s : s.slice(0, max - 1) + "…";
-}
-function str(value) {
-    if (typeof value === "string")
-        return value;
-    if (value == null)
-        return "";
-    return String(value);
-}
-function unwrapData(payload) {
-    if (isRecord(payload) && isRecord(payload["data"])) {
-        return payload["data"];
-    }
-    return isRecord(payload) ? payload : {};
-}
-function colorStatus(status) {
-    switch (status.toLowerCase()) {
-        case "running":
-            return chalk.green(status);
-        case "paused":
-            return chalk.yellow(status);
-        case "completed":
-        case "done":
-        case "succeeded":
-            return chalk.dim(status);
-        case "failed":
-        case "canceled":
-        case "cancelled":
-            return chalk.red(status);
-        default:
-            return chalk.dim(status);
-    }
-}
-function isTerminalStatus(status) {
-    return (typeof status === "string" &&
-        ["succeeded", "failed", "canceled", "cancelled"].includes(status.toLowerCase()));
-}
-function sleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitForRun(c, id, timeoutSec) {
-    const deadline = Date.now() + timeoutSec * 1000;
-    while (true) {
-        const run = unwrapData(await c.apiGet(apiV1(`/runs/${enc(id)}`)));
-        if (isTerminalStatus(run["status"]))
-            return run;
-        if (Date.now() >= deadline) {
-            throw new Error(`Timed out waiting for run ${id}`);
-        }
-        await sleep(Math.min(2000, Math.max(0, deadline - Date.now())));
-    }
-}
-function colorEventType(type) {
-    switch (type.toLowerCase()) {
-        case "thought":
-            return chalk.magenta(type.padEnd(8));
-        case "exec":
-            return chalk.blue(type.padEnd(8));
-        case "click":
-            return chalk.cyan(type.padEnd(8));
-        case "type":
-            return chalk.cyan(type.padEnd(8));
-        case "done":
-            return chalk.green(type.padEnd(8));
-        case "error":
-            return chalk.red(type.padEnd(8));
-        default:
-            return chalk.dim(type.padEnd(8));
-    }
-}
-function formatEventTimestamp(event, baseTime) {
-    const raw = event.timestamp ?? event.inserted_at;
-    if (!raw)
-        return chalk.dim("--:--:--");
-    const d = new Date(raw);
-    // Offset from session start for context
-    const diffMs = d.getTime() - baseTime.getTime();
-    const absTime = d.toLocaleTimeString("en-US", { hour12: false });
-    if (diffMs < 0)
-        return chalk.dim(absTime);
-    return chalk.dim(absTime);
-}
-async function startAgentSession(computerNameOrId, goal, opts) {
-    const config = loadConfig();
-    const c = new MiosaClient(config);
-    const spinner = isJsonMode(opts)
-        ? null
-        : spin(`Resolving computer ${computerNameOrId}...`);
-    const computer = await resolveComputer(c, computerNameOrId);
-    spinner?.succeed(`Starting agent on ${computer.name}`);
-    const body = { goal };
-    if (opts.model)
-        body["model_id"] = opts.model;
-    if (opts.maxTurns != null)
-        body["max_turns"] = parseInt(opts.maxTurns, 10);
-    const payload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions`), body);
-    const session = dataOf(payload);
-    if (isJsonMode(opts)) {
-        console.log(JSON.stringify(session, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Agent session started: ${session.id}`));
-    console.log(chalk.dim(`Watch: miosa agent get ${session.id} --computer ${computer.name}`));
-    console.log(chalk.dim(`Resume: miosa agent resume ${session.id} --computer ${computer.name}`));
-}
-async function resumeAgentSession(computerNameOrId, sessionId, instruction, opts) {
-    const config = loadConfig();
-    const c = new MiosaClient(config);
-    const computer = await resolveComputer(c, computerNameOrId);
-    const payload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/resume`), {});
-    if (instruction) {
-        await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/task`), { instruction });
-    }
-    if (isJsonMode(opts)) {
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Session ${sessionId} resumed.`));
-    if (instruction)
-        console.log(chalk.dim(`Task submitted to ${sessionId}.`));
-}
-async function runInstructionTarget(instruction, opts) {
-    const targets = [opts.sandbox, opts.computer, opts.host].filter(Boolean);
-    if (targets.length !== 1) {
-        throw new UserError("Choose exactly one target.", "Use one of: --sandbox <id>, --computer <name-or-id>, or --host <id>.");
-    }
-    const config = loadConfig();
-    const c = new MiosaClient(config);
-    if (opts.host) {
-        await runOpenComputerHostPrompt(c, opts.host, instruction, opts);
-        return;
-    }
-    const targetKind = opts.sandbox ? "sandbox" : "computer";
-    const targetId = targetKind === "computer"
-        ? (await resolveComputer(c, opts.computer)).id
-        : opts.sandbox;
-    const body = {
-        target_kind: targetKind,
-        target_id: targetId,
-        instruction,
-        runner: opts.runner ?? "claude-code",
-    };
-    if (opts.model)
-        body["model"] = opts.model;
-    if (opts.cwd)
-        body["cwd"] = opts.cwd;
-    if (opts.env && opts.env.length > 0)
-        body["env"] = parseEnvPairs(opts.env);
-    if (opts.timeout)
-        body["timeout"] = Number.parseInt(opts.timeout, 10);
-    if (opts.agentProfile)
-        body["agent_runtime_profile_id"] = opts.agentProfile;
-    if (opts.skipAgentProfile)
-        body["skip_agent_runtime_profile"] = true;
-    if (opts.externalWorkspace)
-        body["external_workspace_id"] = opts.externalWorkspace;
-    if (opts.externalUser)
-        body["external_user_id"] = opts.externalUser;
-    if (opts.externalProject)
-        body["external_project_id"] = opts.externalProject;
-    const executionPacket = readJsonValue(opts.executionPacket, opts.executionPacketFile, "execution-packet");
-    const expectedOutputs = readJsonValue(opts.expectedOutputs, opts.expectedOutputsFile, "expected-outputs");
-    const approvalPolicy = readJsonValue(opts.approvalPolicy, opts.approvalPolicyFile, "approval-policy");
-    if (executionPacket !== undefined)
-        body["execution_packet"] = executionPacket;
-    if (expectedOutputs !== undefined)
-        body["expected_outputs"] = expectedOutputs;
-    if (approvalPolicy !== undefined)
-        body["approval_policy"] = approvalPolicy;
-    if (opts.capability?.length)
-        body["capability_requirements"] = opts.capability;
-    let run = unwrapData(await c.apiPost(apiV1("/runs"), body));
-    const runId = str(run["id"]);
-    if (opts.wait) {
-        if (!runId)
-            throw new Error("Run response did not include an id.");
-        run = await waitForRun(c, runId, Number.parseInt(opts.waitTimeout ?? opts.timeout ?? "900", 10));
-    }
-    if (isJsonMode(opts)) {
-        console.log(JSON.stringify(run, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Run ${str(run["status"] || "created")}: ${str(run["id"])}`));
-    console.log(chalk.dim(`Target: ${targetKind} ${targetId}`));
-    const output = str(run["output"]).trim();
-    const stderr = str(run["stderr"]).trim();
-    if (output) {
-        console.log();
-        console.log(output);
-    }
-    if (stderr) {
-        console.error();
-        console.error(chalk.red(stderr));
-    }
-}
-async function runOpenComputerHostPrompt(c, hostId, instruction, opts) {
-    const body = { task: instruction };
-    if (opts.model)
-        body["model"] = opts.model;
-    if (opts.agentProfile)
-        body["agent_runtime_profile_id"] = opts.agentProfile;
-    if (opts.skipAgentProfile)
-        body["skip_agent_runtime_profile"] = true;
-    if (opts.externalWorkspace)
-        body["external_workspace_id"] = opts.externalWorkspace;
-    if (opts.externalUser)
-        body["external_user_id"] = opts.externalUser;
-    if (opts.externalProject)
-        body["external_project_id"] = opts.externalProject;
-    const executionPacket = readJsonValue(opts.executionPacket, opts.executionPacketFile, "execution-packet");
-    const expectedOutputs = readJsonValue(opts.expectedOutputs, opts.expectedOutputsFile, "expected-outputs");
-    const approvalPolicy = readJsonValue(opts.approvalPolicy, opts.approvalPolicyFile, "approval-policy");
-    if (executionPacket !== undefined)
-        body["execution_packet"] = executionPacket;
-    if (expectedOutputs !== undefined)
-        body["expected_outputs"] = expectedOutputs;
-    if (approvalPolicy !== undefined)
-        body["approval_policy"] = approvalPolicy;
-    if (opts.capability?.length)
-        body["capability_requirements"] = opts.capability;
-    if (opts.timeout) {
-        body["budget"] = { timeout_ms: Number.parseInt(opts.timeout, 10) * 1000 };
-    }
-    const session = unwrapData(await c.apiPost(apiV1(`/opencomputers/hosts/${enc(hostId)}/agent/dispatch`), body));
-    if (isJsonMode(opts)) {
-        console.log(JSON.stringify(session, null, 2));
-        return;
-    }
-    console.log(chalk.green(`OpenComputers agent session started: ${str(session["id"] || session["session_id"])}`));
-    console.log(chalk.dim(`Host: ${hostId}`));
-    if (session["sse_url"]) {
-        console.log(chalk.dim(`Events: ${str(session["sse_url"])}`));
-    }
-}
-// ---------------------------------------------------------------------------
-// Subcommand builders
-// ---------------------------------------------------------------------------
-function buildStart(agent) {
-    agent
-        .command("start")
-        .description("Start an agent session on a computer")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .requiredOption("--goal <goal>", "Goal for the agent to accomplish")
-        .option("--model <model-id>", "Model ID override")
-        .option("--max-turns <n>", "Maximum agent turns (default: server default)")
-        .option("--json", "Output as JSON")
-        .action(async (opts) => {
-        try {
-            await startAgentSession(opts.computer, opts.goal, opts);
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildRun(agent) {
-    agent
-        .command("run <instruction...>")
-        .description("Dispatch one instruction to a Sandbox, Computer, or OpenComputers host")
-        .option("--sandbox <id>", "Sandbox ID target")
-        .option("--computer <name-or-id>", "Computer name or ID target")
-        .option("--host <id>", "OpenComputers host ID target")
-        .option("--runner <name>", "Runner for Sandbox/Computer targets: claude-code (default), codex, claude (alias), hermes, osa, pi, custom")
-        .option("--model <name>", "Provider/model override")
-        .option("--cwd <path>", "Working directory for Sandbox/Computer targets")
-        .option("--env <KEY=VALUE>", "Environment variable for Sandbox/Computer targets. Repeatable.", collectOption, [])
-        .option("--timeout <sec>", "Timeout in seconds")
-        .option("--agent-profile <id>", "Agent runtime profile ID")
-        .option("--skip-agent-profile", "Do not apply default agent runtime profile")
-        .option("--external-workspace <id>", "White-label workspace/customer ID for billing attribution")
-        .option("--external-user <id>", "White-label user ID for billing attribution")
-        .option("--external-project <id>", "White-label project ID for billing attribution")
-        .option("--execution-packet <json>", "Execution packet JSON for product context, plan, and acceptance criteria")
-        .option("--execution-packet-file <file>", "Read execution packet JSON from a file")
-        .option("--expected-outputs <json>", "Expected outputs JSON declaring files/previews/messages")
-        .option("--expected-outputs-file <file>", "Read expected outputs JSON from a file")
-        .option("--approval-policy <json>", "Approval policy JSON for publish/writeback/destructive actions")
-        .option("--approval-policy-file <file>", "Read approval policy JSON from a file")
-        .option("--capability <name>", "Required runtime capability. Repeatable.", collectOption, [])
-        .option("--wait", "Wait for Sandbox/Computer run completion")
-        .option("--wait-timeout <sec>", "Maximum seconds to wait for --wait")
-        .option("--json", "Output as JSON")
-        .action(async (instruction, opts, command) => {
-        try {
-            const resolvedOpts = command.optsWithGlobals();
-            const mergedOpts = { ...opts };
-            for (const [key, value] of Object.entries(resolvedOpts)) {
-                if (mergedOpts[key] == null) {
-                    mergedOpts[key] = value;
-                }
-            }
-            const runInstruction = instruction.join(" ").trim();
-            if (!runInstruction) {
-                throw new UserError("No agent instruction provided.");
-            }
-            await runInstructionTarget(runInstruction, mergedOpts);
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildLs(agent) {
-    agent
-        .command("ls")
-        .description("List active agent sessions (all computers or one with --computer)")
-        .option("--computer <name-or-id>", "Filter to a specific computer")
-        .option("--json", "Output as JSON")
-        .action(async (opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            let sessions;
-            if (opts.computer) {
-                const spinner = spin(`Fetching sessions for ${opts.computer}…`);
-                const computer = await resolveComputer(c, opts.computer);
-                spinner.text = `Loading sessions on ${computer.name}…`;
-                const payload = await c.apiGet(apiV1(`/computers/${enc(computer.id)}/control/sessions`));
-                sessions = listOf(payload, ["sessions"]).map((s) => ({
-                    ...s,
-                    computer_name: computer.name,
-                }));
-                spinner.stop();
-            }
-            else {
-                const spinner = spin("Fetching all computers…");
-                const computersPayload = await c.apiGet(apiV1("/computers"));
-                const computers = listOf(computersPayload, [
-                    "computers",
-                ]);
-                spinner.text = `Fetching sessions across ${computers.length} computer(s)…`;
-                const settled = await Promise.allSettled(computers.map(async (computer) => {
-                    const payload = await c.apiGet(apiV1(`/computers/${enc(computer.id)}/control/sessions`));
-                    return listOf(payload, ["sessions"]).map((s) => ({
-                        ...s,
-                        computer_name: computer.name,
-                    }));
-                }));
-                sessions = settled.flatMap((result) => result.status === "fulfilled" ? result.value : []);
-                spinner.stop();
-            }
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(sessions, null, 2));
-                return;
-            }
-            if (sessions.length === 0) {
-                console.log(chalk.dim("No agent sessions found."));
-                return;
-            }
-            renderTable(sessions, [
-                {
-                    header: "ID",
-                    key: (s) => s.id,
-                    width: 22,
-                },
-                {
-                    header: "COMPUTER",
-                    key: (s) => s.computer_name ?? s.computer_id,
-                    width: 16,
-                },
-                {
-                    header: "STATUS",
-                    key: (s) => s.status,
-                    width: 10,
-                    color: (val) => colorStatus(val.trim()),
-                },
-                {
-                    header: "STARTED",
-                    key: (s) => timeAgo(s.started_at ?? s.inserted_at),
-                    width: 18,
-                },
-                {
-                    header: "GOAL",
-                    key: (s) => truncate(s.goal, 42),
-                },
-            ]);
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildGet(agent) {
-    agent
-        .command("get <session-id>")
-        .description("Get details of an agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const payload = await c.apiGet(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}`));
-            const session = dataOf(payload);
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(session, null, 2));
-                return;
-            }
-            const rows = [
-                ["Session", session.id],
-                ["Computer", session.computer_name ?? computer.name],
-                ["Status", colorStatus(session.status)],
-                ["Started", session.started_at ?? chalk.dim("—")],
-                ["Goal", session.goal],
-            ];
-            if (session.actions_total != null) {
-                const parts = [`${session.actions_total} total`];
-                if (session.actions_exec != null)
-                    parts.push(`${session.actions_exec} exec`);
-                if (session.actions_click != null)
-                    parts.push(`${session.actions_click} click`);
-                if (session.actions_type != null)
-                    parts.push(`${session.actions_type} type`);
-                rows.push(["Actions", parts.join(", ")]);
-            }
-            if (session.screenshots != null) {
-                rows.push(["Screenshots", String(session.screenshots)]);
-            }
-            rows.push([
-                "Duration",
-                duration(session.started_at, session.finished_at),
-            ]);
-            if (session.model_id) {
-                rows.push(["Model", session.model_id]);
-            }
-            for (const [label, value] of rows) {
-                console.log(`${chalk.bold(label.padEnd(14))} ${value}`);
-            }
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildTask(agent) {
-    agent
-        .command("task <session-id> <instruction>")
-        .description("Send a new task to a running agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, instruction, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const payload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/task`), { instruction });
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(payload, null, 2));
-                return;
-            }
-            console.log(chalk.green(`Task submitted to ${sessionId}`));
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildPause(agent) {
-    agent
-        .command("pause <session-id>")
-        .description("Pause a running agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const payload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/pause`), {});
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(payload, null, 2));
-                return;
-            }
-            console.log(chalk.yellow(`Session ${sessionId} paused.`));
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildResume(agent) {
-    agent
-        .command("resume <session-id>")
-        .description("Resume a paused agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const payload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/resume`), {});
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(payload, null, 2));
-                return;
-            }
-            console.log(chalk.green(`Session ${sessionId} resumed.`));
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildStop(agent) {
-    agent
-        .command("stop <session-id>")
-        .description("Stop (cancel) an agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const payload = await c.apiDelete(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}`));
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(payload ?? { stopped: true }, null, 2));
-                return;
-            }
-            console.log(chalk.green("Agent session stopped."));
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-function buildHistory(agent) {
-    agent
-        .command("history <session-id>")
-        .description("View the event history of an agent session")
-        .requiredOption("--computer <name-or-id>", "Computer name or ID")
-        .option("--limit <n>", "Maximum number of events to show")
-        .option("--json", "Output as JSON")
-        .action(async (sessionId, opts) => {
-        try {
-            const config = loadConfig();
-            const c = new MiosaClient(config);
-            const computer = await resolveComputer(c, opts.computer);
-            const ticketPayload = await c.apiPost(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/sse-ticket`), {});
-            const ticket = dataOf(ticketPayload).ticket;
-            if (!ticket) {
-                throw new UserError("Could not create an agent history ticket.");
-            }
-            const search = new URLSearchParams({ ticket });
-            if (opts.limit)
-                search.set("limit", opts.limit);
-            const payload = await c.apiGet(apiV1(`/computers/${enc(computer.id)}/control/sessions/${enc(sessionId)}/events?${search.toString()}`));
-            const events = listOf(payload, ["events"]);
-            if (isJsonMode(opts)) {
-                console.log(JSON.stringify(events, null, 2));
-                return;
-            }
-            if (events.length === 0) {
-                console.log(chalk.dim("No events recorded yet."));
-                return;
-            }
-            // Determine base time for relative display from first event
-            const firstTimestamp = events[0]?.timestamp ?? events[0]?.inserted_at;
-            const baseTime = firstTimestamp
-                ? new Date(firstTimestamp)
-                : new Date();
-            for (const event of events) {
-                const ts = formatEventTimestamp(event, baseTime);
-                const typePart = colorEventType(event.type);
-                const contentPart = event.content
-                    ? truncate(event.content, 100)
-                    : chalk.dim("—");
-                console.log(`${ts} [${typePart}]  ${contentPart}`);
-            }
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-export function register(program) {
-    const agent = program
-        .command("agent")
-        .description("Manage AI computer control sessions on Computers - start, monitor, and control agent runs")
-        .argument("[computer]", "Computer name or ID")
-        .argument("[instruction...]", "Goal/instruction for the agent")
-        .option("--model <model-id>", "Model ID override")
-        .option("--max-turns <n>", "Maximum agent turns")
-        .option("--resume <session-id>", "Resume a paused session, optionally with a new instruction")
-        .option("--json", "Output as JSON")
-        .action(async (computer, instruction, opts, command) => {
-        try {
-            if (!computer) {
-                command.help();
-                return;
-            }
-            const goal = instruction.join(" ").trim();
-            if (opts.resume) {
-                await resumeAgentSession(computer, opts.resume, goal || undefined, opts);
-                return;
-            }
-            if (!goal) {
-                throw new UserError("No agent instruction provided.", 'Use `miosa agent <computer> "run the tests"` or `miosa agent start --computer <computer> --goal "..."`.');
-            }
-            await startAgentSession(computer, goal, opts);
-        }
-        catch (err) {
-            handleError(err);
-        }
-    });
-    buildStart(agent);
-    buildRun(agent);
-    buildLs(agent);
-    buildGet(agent);
-    buildTask(agent);
-    buildPause(agent);
-    buildResume(agent);
-    buildStop(agent);
-    buildHistory(agent);
-}
-//# sourceMappingURL=agent.js.map