@otto-code/cli 0.5.0

package/bin/otto

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --disable-warning=DEP0040
+import '../dist/index.js'
+

package/dist/classify.d.ts

@@ -0,0 +1,19 @@
+export type CliInvocation = {
+    kind: "cli";
+    argv: string[];
+} | {
+    kind: "open-project";
+    resolvedPath: string;
+};
+export declare function isPathLikeArg(arg: string): boolean;
+export declare function expandUserPath(inputPath: string): string;
+export declare function isExistingDirectory(input: {
+    pathArg: string;
+    cwd: string;
+}): boolean;
+export declare function classifyInvocation(input: {
+    argv: string[];
+    knownCommands: ReadonlySet<string>;
+    cwd: string;
+}): CliInvocation;
+//# sourceMappingURL=classify.d.ts.map

package/dist/classify.js

@@ -0,0 +1,49 @@
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+export function isPathLikeArg(arg) {
+    return (arg === "." ||
+        arg === ".." ||
+        arg.startsWith("./") ||
+        arg.startsWith("../") ||
+        arg.startsWith("/") ||
+        arg === "~" ||
+        arg.startsWith("~/") ||
+        /^[A-Za-z]:[\\/]/.test(arg));
+}
+export function expandUserPath(inputPath) {
+    if (inputPath === "~") {
+        return homedir();
+    }
+    if (inputPath.startsWith("~/")) {
+        return path.join(homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+export function isExistingDirectory(input) {
+    const resolvedPath = path.resolve(input.cwd, expandUserPath(input.pathArg));
+    if (!existsSync(resolvedPath)) {
+        return false;
+    }
+    return statSync(resolvedPath).isDirectory();
+}
+export function classifyInvocation(input) {
+    const [firstArg] = input.argv;
+    if (!firstArg) {
+        return { kind: "cli", argv: input.argv };
+    }
+    if (firstArg.startsWith("-")) {
+        return { kind: "cli", argv: input.argv };
+    }
+    if (input.knownCommands.has(firstArg)) {
+        return { kind: "cli", argv: input.argv };
+    }
+    if (isExistingDirectory({ pathArg: firstArg, cwd: input.cwd })) {
+        return {
+            kind: "open-project",
+            resolvedPath: path.resolve(input.cwd, expandUserPath(firstArg)),
+        };
+    }
+    return { kind: "cli", argv: input.argv };
+}
+//# sourceMappingURL=classify.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createCli(): Command;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,113 @@
+import { Command, Option } from "commander";
+import { createAgentCommand } from "./commands/agent/index.js";
+import { createDaemonCommand } from "./commands/daemon/index.js";
+import { createChatCommand } from "./commands/chat/index.js";
+import { createLoopCommand } from "./commands/loop/index.js";
+import { createPermitCommand } from "./commands/permit/index.js";
+import { createProviderCommand } from "./commands/provider/index.js";
+import { createScheduleCommand } from "./commands/schedule/index.js";
+import { createSpeechCommand } from "./commands/speech/index.js";
+import { createTerminalCommand } from "./commands/terminal/index.js";
+import { createWorktreeCommand } from "./commands/worktree/index.js";
+import { createHooksCommand } from "./commands/hooks.js";
+import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
+import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
+import { runRestartCommand as runDaemonRestartCommand } from "./commands/daemon/restart.js";
+import { addLsOptions, runLsCommand } from "./commands/agent/ls.js";
+import { addRunOptions, runRunCommand } from "./commands/agent/run.js";
+import { addLogsOptions, runLogsCommand } from "./commands/agent/logs.js";
+import { addDeleteOptions, runDeleteCommand } from "./commands/agent/delete.js";
+import { addStopOptions, runStopCommand } from "./commands/agent/stop.js";
+import { addSendOptions, runSendCommand } from "./commands/agent/send.js";
+import { addInspectOptions, runInspectCommand } from "./commands/agent/inspect.js";
+import { addWaitOptions, runWaitCommand } from "./commands/agent/wait.js";
+import { addArchiveOptions, runArchiveCommand } from "./commands/agent/archive.js";
+import { addAttachOptions, runAttachCommand } from "./commands/agent/attach.js";
+import { addImportOptions, runImportCommand } from "./commands/agent/import.js";
+import { withOutput } from "./output/index.js";
+import { onboardCommand } from "./commands/onboard.js";
+import { addDaemonHostOption, addJsonAndDaemonHostOptions, addJsonOption, } from "./utils/command-options.js";
+import { resolveCliVersion } from "./version.js";
+const VERSION = resolveCliVersion();
+function resolveHostnamesOption(hostnames, allowedHosts) {
+    if (typeof hostnames === "string")
+        return hostnames;
+    if (typeof allowedHosts === "string")
+        return allowedHosts;
+    return undefined;
+}
+export function createCli() {
+    const program = new Command();
+    program
+        .name("otto")
+        .description("Otto CLI - control your AI coding agents from the command line")
+        .version(VERSION, "-v, --version", "output the version number")
+        // Global output options
+        .option("-o, --format <format>", "output format: table, json, yaml", "table")
+        .option("--json", "output in JSON format (alias for --format json)")
+        .option("-q, --quiet", "minimal output (IDs only)")
+        .option("--no-headers", "omit table headers")
+        .option("--no-color", "disable colored output");
+    // Primary agent commands (top-level)
+    addJsonAndDaemonHostOptions(addLsOptions(program.command("ls"))).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(addRunOptions(program.command("run"))).action(withOutput(runRunCommand));
+    addJsonAndDaemonHostOptions(addImportOptions(program.command("import"))).action(withOutput(runImportCommand));
+    addDaemonHostOption(addAttachOptions(program.command("attach"))).action(runAttachCommand);
+    addDaemonHostOption(addLogsOptions(program.command("logs"))).action(runLogsCommand);
+    addJsonAndDaemonHostOptions(addStopOptions(program.command("stop"))).action(withOutput(runStopCommand));
+    addJsonAndDaemonHostOptions(addDeleteOptions(program.command("delete"))).action(withOutput(runDeleteCommand));
+    addJsonAndDaemonHostOptions(addSendOptions(program.command("send"))).action(withOutput(runSendCommand));
+    addJsonAndDaemonHostOptions(addInspectOptions(program.command("inspect"))).action(withOutput(runInspectCommand));
+    addJsonAndDaemonHostOptions(addWaitOptions(program.command("wait"))).action(withOutput(runWaitCommand));
+    addJsonAndDaemonHostOptions(addArchiveOptions(program.command("archive"))).action(withOutput(runArchiveCommand));
+    // Top-level local daemon shortcuts
+    program.addCommand(onboardCommand());
+    program.addCommand(daemonStartCommand());
+    program.addCommand(createHooksCommand());
+    addJsonOption(program
+        .command("status")
+        .description('Show local daemon status (alias for "otto daemon status")'))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .action(withOutput(runDaemonStatusCommand));
+    addJsonOption(program
+        .command("restart")
+        .description('Restart local daemon (alias for "otto daemon restart")'))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--timeout <seconds>", "Wait timeout before force step (default: 15)")
+        .option("--force", "Send SIGKILL if graceful stop times out")
+        .option("--listen <listen>", "Listen target for restarted daemon (host:port, port, or unix socket)")
+        .option("--port <port>", "Port for restarted daemon listen target")
+        .option("--no-relay", "Disable relay on restarted daemon")
+        .option("--no-mcp", "Disable Agent MCP on restarted daemon")
+        .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
+        .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
+        .action(withOutput((...args) => {
+        const [options, command] = args.slice(-2);
+        return runDaemonRestartCommand({
+            ...options,
+            hostnames: resolveHostnamesOption(options.hostnames, options.allowedHosts),
+        }, command);
+    }));
+    // Advanced agent commands (less common operations)
+    program.addCommand(createAgentCommand());
+    // Daemon commands
+    program.addCommand(createDaemonCommand());
+    // Chat commands
+    program.addCommand(createChatCommand());
+    // Terminal commands
+    program.addCommand(createTerminalCommand());
+    // Loop commands
+    program.addCommand(createLoopCommand());
+    // Schedule commands
+    program.addCommand(createScheduleCommand());
+    // Permission commands
+    program.addCommand(createPermitCommand());
+    // Provider commands
+    program.addCommand(createProviderCommand());
+    // Speech model commands
+    program.addCommand(createSpeechCommand());
+    // Worktree commands
+    program.addCommand(createWorktreeCommand());
+    return program;
+}
+//# sourceMappingURL=cli.js.map

package/dist/commands/agent/archive.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for agent archive command */
+export interface AgentArchiveResult {
+    agentId: string;
+    status: "archived";
+    archivedAt: string;
+}
+/** Schema for archive command output */
+export declare const archiveSchema: OutputSchema<AgentArchiveResult>;
+export declare function addArchiveOptions(cmd: Command): Command;
+export interface AgentArchiveOptions extends CommandOptions {
+    force?: boolean;
+    host?: string;
+}
+export type AgentArchiveCommandResult = SingleResult<AgentArchiveResult>;
+export declare function runArchiveCommand(agentIdArg: string, options: AgentArchiveOptions, _command: Command): Promise<AgentArchiveCommandResult>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/commands/agent/archive.js

@@ -0,0 +1,102 @@
+import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+/** Schema for archive command output */
+export const archiveSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "STATUS", field: "status" },
+        { header: "ARCHIVED AT", field: "archivedAt" },
+    ],
+};
+export function addArchiveOptions(cmd) {
+    return cmd
+        .description("Archive an agent (soft-delete)")
+        .argument("<id>", "Agent ID, prefix, or name")
+        .option("--force", "Force archive running agent (interrupts active run first)");
+}
+export async function runArchiveCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: otto agent archive <id-or-name>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agents = agentsPayload.entries.map((entry) => entry.agent);
+        const agentId = resolveAgentId(agentIdArg, agents);
+        if (!agentId) {
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdArg}`,
+                details: 'Use "otto ls" to list available agents',
+            };
+            throw error;
+        }
+        const agent = agents.find((entry) => entry.id === agentId);
+        if (!agent) {
+            throw new Error(`Resolved agent missing from fetched agents: ${agentId}`);
+        }
+        // Check if agent is already archived
+        if (agent.archivedAt) {
+            const error = {
+                code: "AGENT_ALREADY_ARCHIVED",
+                message: `Agent ${agentId.slice(0, 7)} is already archived`,
+                details: `Archived at: ${agent.archivedAt}`,
+            };
+            throw error;
+        }
+        // Check if agent is running and reject unless --force is set
+        if (agent.status === "running" && !options.force) {
+            const error = {
+                code: "AGENT_RUNNING",
+                message: `Agent ${agentId.slice(0, 7)} is currently running`,
+                details: "Use --force to archive a running agent (it will interrupt the active run), or stop it first with: otto agent stop. Use otto agent delete to hard-delete it.",
+            };
+            throw error;
+        }
+        // Archive the agent
+        const result = await client.archiveAgent(agentId);
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                agentId,
+                status: "archived",
+                archivedAt: result.archivedAt,
+            },
+            schema: archiveSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "ARCHIVE_FAILED",
+            message: `Failed to archive agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=archive.js.map

package/dist/commands/agent/attach.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+export declare function addAttachOptions(cmd: Command): Command;
+export interface AgentAttachOptions {
+    host?: string;
+    [key: string]: unknown;
+}
+/**
+ * Attach to a running agent's output stream
+ */
+export declare function runAttachCommand(id: string, options: AgentAttachOptions, _command: Command): Promise<void>;
+//# sourceMappingURL=attach.d.ts.map

package/dist/commands/agent/attach.js

@@ -0,0 +1,159 @@
+export function addAttachOptions(cmd) {
+    return cmd
+        .description("Attach to a running agent's output stream")
+        .argument("<id>", "Agent ID (or prefix)");
+}
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
+/**
+ * Format and print a timeline item to the terminal
+ */
+function printTimelineItem(item) {
+    switch (item.type) {
+        case "assistant_message":
+            // Print assistant text directly
+            process.stdout.write(item.text);
+            break;
+        case "reasoning":
+            // Print reasoning in a muted color if available
+            console.log(`\n[Reasoning] ${item.text}`);
+            break;
+        case "tool_call": {
+            const toolName = item.name;
+            const status = item.status ?? "started";
+            console.log(`\n[Tool: ${toolName}] ${status}`);
+            break;
+        }
+        case "todo": {
+            const completed = item.items.filter((i) => i.completed).length;
+            const total = item.items.length;
+            console.log(`\n[Todo] ${completed}/${total} completed`);
+            break;
+        }
+        case "error":
+            console.error(`\n[Error] ${item.message}`);
+            break;
+        case "user_message":
+            console.log(`\n[User] ${item.text}`);
+            break;
+        default:
+            // Unknown item type, skip
+            break;
+    }
+}
+/**
+ * Format and print a stream event to the terminal
+ */
+function printStreamEvent(event) {
+    switch (event.type) {
+        case "timeline":
+            // Print the timeline item
+            printTimelineItem(event.item);
+            break;
+        case "permission_requested":
+            console.log(`\n[Permission Required] ${event.request.name}`);
+            if (event.request.description) {
+                console.log(`  ${event.request.description}`);
+            }
+            break;
+        case "permission_resolved":
+            console.log(`\n[Permission ${event.resolution.behavior}]`);
+            break;
+        case "turn_failed":
+            console.error(`\n[Turn Failed] ${event.error}`);
+            break;
+        case "attention_required":
+            console.log(`\n[Attention Required: ${event.reason}]`);
+            break;
+        default:
+            // Other event types are internal
+            break;
+    }
+}
+/**
+ * Attach to a running agent's output stream
+ */
+export async function runAttachCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!id) {
+        console.error("Error: Agent ID required");
+        console.error("Usage: otto attach <id>");
+        process.exit(1);
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
+        console.error("Start the daemon with: otto daemon start");
+        process.exit(1);
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: id });
+        if (!fetchResult) {
+            console.error(`Error: No agent found matching: ${id}`);
+            console.error("Use `otto ls` to list available agents");
+            await client.close();
+            process.exit(1);
+        }
+        const resolvedId = fetchResult.agent.id;
+        // Print header
+        console.log(`Attaching to agent ${resolvedId.substring(0, 7)}...`);
+        console.log(`(Press Ctrl+C to detach)\n`);
+        // Print existing output from timeline fetch.
+        try {
+            const timelineItems = await fetchProjectedTimelineItems({
+                client,
+                agentId: resolvedId,
+                timeoutMs: LIVE_HISTORY_FETCH_TIMEOUT_MS,
+            });
+            for (const item of timelineItems) {
+                printTimelineItem(item);
+            }
+        }
+        catch (error) {
+            console.warn("Warning: failed to fetch existing timeline", error);
+        }
+        // Subscribe to new events
+        const unsubscribe = client.on("agent_stream", (msg) => {
+            const message = msg;
+            if (message.type !== "agent_stream")
+                return;
+            if (message.payload.agentId !== resolvedId)
+                return;
+            printStreamEvent(message.payload.event);
+        });
+        // Handle Ctrl+C to detach gracefully
+        let detached = false;
+        const detach = () => {
+            if (detached)
+                return;
+            detached = true;
+            console.log("\n\nDetaching from agent...");
+            unsubscribe();
+            client
+                .close()
+                .then(() => {
+                process.exit(0);
+            })
+                .catch(() => {
+                process.exit(1);
+            });
+        };
+        process.on("SIGINT", detach);
+        process.on("SIGTERM", detach);
+        // Keep the process alive
+        await new Promise(() => {
+            // Wait indefinitely until interrupted
+        });
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: Failed to attach to agent: ${message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=attach.js.map

package/dist/commands/agent/delete.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+export declare function addDeleteOptions(cmd: Command): Command;
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+export interface DeleteResult {
+    deletedCount: number;
+    agentIds: string[];
+}
+export declare const deleteSchema: OutputSchema<DeleteResult>;
+export interface AgentDeleteOptions extends CommandOptions {
+    all?: boolean;
+    cwd?: string;
+}
+export type AgentDeleteResult = SingleResult<DeleteResult>;
+export declare function runDeleteCommand(id: string | undefined, options: AgentDeleteOptions, _command: Command): Promise<AgentDeleteResult>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/agent/delete.js

@@ -0,0 +1,107 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { isSameOrDescendantPath } from "../../utils/paths.js";
+export function addDeleteOptions(cmd) {
+    return cmd
+        .description("Delete an agent (interrupt if running, then hard-delete)")
+        .argument("[id]", "Agent ID (or prefix) - optional if --all or --cwd specified")
+        .option("--all", "Delete all agents")
+        .option("--cwd <path>", "Delete all agents in directory");
+}
+export const deleteSchema = {
+    idField: (item) => item.agentIds.join("\n"),
+    columns: [{ header: "DELETED", field: "deletedCount" }],
+};
+export async function runDeleteCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!id && !options.all && !options.cwd) {
+        const error = {
+            code: "MISSING_ARGUMENT",
+            message: "Agent ID required unless --all or --cwd is specified",
+            details: "Usage: otto agent delete <id> | --all | --cwd <path>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        let agents = fetchPayload.entries.map((entry) => entry.agent);
+        const deletedIds = [];
+        if (options.all) {
+            agents = agents.filter((a) => !a.archivedAt);
+        }
+        else if (options.cwd) {
+            agents = agents.filter((a) => {
+                if (a.archivedAt)
+                    return false;
+                return isSameOrDescendantPath(options.cwd, a.cwd);
+            });
+        }
+        else if (id) {
+            const fetchResult = await client.fetchAgent({ agentId: id });
+            if (!fetchResult) {
+                const error = {
+                    code: "AGENT_NOT_FOUND",
+                    message: `No agent found matching: ${id}`,
+                    details: "Use `otto ls` to list available agents",
+                };
+                throw error;
+            }
+            agents = [fetchResult.agent];
+        }
+        const deleteResults = await Promise.all(agents.map(async (agent) => {
+            try {
+                if (agent.status === "running") {
+                    await client.cancelAgent(agent.id);
+                }
+                await client.deleteAgent(agent.id);
+                return { ok: true, id: agent.id };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { ok: false, id: agent.id, message };
+            }
+        }));
+        for (const result of deleteResults) {
+            if (result.ok) {
+                deletedIds.push(result.id);
+            }
+            else {
+                console.error(`Warning: Failed to delete agent ${result.id.slice(0, 7)}: ${result.message}`);
+            }
+        }
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                deletedCount: deletedIds.length,
+                agentIds: deletedIds,
+            },
+            schema: deleteSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DELETE_AGENT_FAILED",
+            message: `Failed to delete agent(s): ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=delete.js.map

package/dist/commands/agent/import.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+import { type AgentRunResult } from "./run.js";
+export declare function addImportOptions(cmd: Command): Command;
+export interface AgentImportOptions extends CommandOptions {
+    provider?: string;
+    cwd?: string;
+    label?: string[];
+    host?: string;
+}
+export type AgentImportCommandResult = SingleResult<AgentRunResult>;
+export declare function resolveImportCwd(explicitCwd: string | undefined, defaultCwd: string): string;
+export declare function runImportCommand(sessionIdArg: string, options: AgentImportOptions, _command: Command): Promise<AgentImportCommandResult>;
+//# sourceMappingURL=import.d.ts.map