@otto-code/cli 0.5.0

package/dist/commands/agent/ls.js

@@ -0,0 +1,204 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { collectMultiple } from "../../utils/command-options.js";
+import { isSameOrDescendantPath } from "../../utils/paths.js";
+export function addLsOptions(cmd) {
+    return cmd
+        .description("List agents. By default excludes archived agents.")
+        .option("-a, --all", "Include archived agents")
+        .option("-g, --global", "List agents across all directories")
+        .option("--label <key=value>", "Filter by label (can be used multiple times)", collectMultiple, [])
+        .option("--thinking <id>", "Filter by thinking option ID");
+}
+/** Helper to get relative time string */
+function relativeTime(date) {
+    const now = Date.now();
+    const then = new Date(date).getTime();
+    const seconds = Math.floor((now - then) / 1000);
+    if (seconds < 60)
+        return "just now";
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)} minutes ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)} hours ago`;
+    return `${Math.floor(seconds / 86400)} days ago`;
+}
+/** Shorten home directory in path */
+function shortenPath(path) {
+    const home = process.env.HOME;
+    if (home && path.startsWith(home)) {
+        return "~" + path.slice(home.length);
+    }
+    return path;
+}
+function normalizeModelId(modelId) {
+    if (typeof modelId !== "string")
+        return null;
+    const normalized = modelId.trim();
+    if (!normalized || normalized.toLowerCase() === "default")
+        return null;
+    return normalized;
+}
+/** Schema for agent ls output */
+export const agentLsSchema = {
+    idField: "shortId",
+    columns: [
+        { header: "AGENT ID", field: "shortId", width: 12 },
+        { header: "NAME", field: "name", width: 20 },
+        { header: "PROVIDER", field: "provider", width: 15 },
+        { header: "THINKING", field: "thinking", width: 12 },
+        {
+            header: "STATUS",
+            field: "status",
+            width: 10,
+            color: (value) => {
+                if (value === "running")
+                    return "green";
+                if (value === "idle")
+                    return "yellow";
+                if (value === "error")
+                    return "red";
+                return undefined;
+            },
+        },
+        { header: "CWD", field: "cwd", width: 30 },
+        { header: "CREATED", field: "created", width: 15 },
+    ],
+};
+/** Transform agent snapshot to AgentListItem */
+function toListItem(agent) {
+    const model = normalizeModelId(agent.runtimeInfo?.model) ?? normalizeModelId(agent.model);
+    return {
+        id: agent.id,
+        shortId: agent.id.slice(0, 7),
+        name: agent.title ?? "-",
+        provider: model ? `${agent.provider}/${model}` : agent.provider,
+        thinking: agent.effectiveThinkingOptionId ?? "auto",
+        status: agent.status,
+        cwd: shortenPath(agent.cwd),
+        created: relativeTime(agent.createdAt),
+    };
+}
+function parseLabelFilters(labels) {
+    const labelFilters = {};
+    for (const labelStr of labels ?? []) {
+        const eqIndex = labelStr.indexOf("=");
+        if (eqIndex !== -1) {
+            const key = labelStr.slice(0, eqIndex);
+            const value = labelStr.slice(eqIndex + 1);
+            labelFilters[key] = value;
+        }
+    }
+    return labelFilters;
+}
+export function buildAgentLsFetchOptions(options) {
+    const labelFilters = parseLabelFilters(options.label);
+    const normalizedThinkingOptionId = options.thinking?.trim();
+    const daemonFilter = {};
+    if (options.all) {
+        daemonFilter.includeArchived = true;
+    }
+    if (Object.keys(labelFilters).length > 0) {
+        daemonFilter.labels = labelFilters;
+    }
+    if (normalizedThinkingOptionId) {
+        daemonFilter.thinkingOptionId = normalizedThinkingOptionId;
+    }
+    const fetchOptions = {};
+    if (!options.global) {
+        fetchOptions.scope = "active";
+    }
+    if (Object.keys(daemonFilter).length > 0) {
+        fetchOptions.filter = daemonFilter;
+    }
+    return fetchOptions;
+}
+/**
+ * Agent ls command semantics:
+ * - `otto agent ls`    → active non-archived agents
+ * - `otto agent ls -g` → global non-archived agents
+ * - `otto agent ls -a` → active agents, including archived
+ * - `otto agent ls -ag` → global agents, including archived
+ */
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    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\nFor a remote daemon, pass --host <host:port> or set OTTO_HOST.",
+        };
+        throw error;
+    }
+    try {
+        const normalizedThinkingOptionId = options.thinking?.trim();
+        if (options.thinking !== undefined && !normalizedThinkingOptionId) {
+            const error = {
+                code: "INVALID_THINKING_OPTION",
+                message: "--thinking cannot be empty",
+            };
+            throw error;
+        }
+        const labelFilters = parseLabelFilters(options.label);
+        const fetchPayload = await client.fetchAgents(buildAgentLsFetchOptions(options));
+        let agents = fetchPayload.entries.map((entry) => entry.agent);
+        // By default, exclude archived agents. `-a` includes them.
+        if (!options.all) {
+            agents = agents.filter((a) => !a.archivedAt);
+        }
+        // If explicit status filter is provided, apply it.
+        if (options.status) {
+            agents = agents.filter((a) => a.status === options.status);
+        }
+        // Optional cwd filter.
+        if (options.cwd) {
+            agents = agents.filter((a) => isSameOrDescendantPath(options.cwd, a.cwd));
+        }
+        // Apply label filtering only when explicitly requested.
+        if (Object.keys(labelFilters).length > 0) {
+            agents = agents.filter((a) => {
+                const agentLabels = a.labels;
+                for (const [key, value] of Object.entries(labelFilters)) {
+                    if (agentLabels[key] !== value) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        await client.close();
+        // Sort agents: running first, then idle, then others; within each group, most recent first
+        const statusOrder = { running: 0, idle: 1 };
+        agents.sort((a, b) => {
+            // Primary sort: by status
+            const aOrder = statusOrder[a.status] ?? 999;
+            const bOrder = statusOrder[b.status] ?? 999;
+            if (aOrder !== bOrder)
+                return aOrder - bOrder;
+            // Secondary sort: by creation time (most recent first)
+            const aTime = new Date(a.createdAt).getTime();
+            const bTime = new Date(b.createdAt).getTime();
+            return bTime - aTime;
+        });
+        const items = agents.map(toListItem);
+        return {
+            type: "list",
+            data: items,
+            schema: agentLsSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "LIST_AGENTS_FAILED",
+            message: `Failed to list agents: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, AnyCommandResult } from "../../output/index.js";
+import type { AgentMode } from "@otto-code/protocol/agent-types";
+/** Result for setting mode */
+export interface SetModeResult {
+    agentId: string;
+    mode: string;
+}
+/** Schema for mode list output */
+export declare const modeListSchema: OutputSchema<AgentMode>;
+/** Schema for set mode output */
+export declare const setModeSchema: OutputSchema<SetModeResult>;
+export interface AgentModeOptions extends CommandOptions {
+    list?: boolean;
+}
+export type AgentModeResult = AnyCommandResult<any>;
+export declare function runModeCommand(id: string, mode: string | undefined, options: AgentModeOptions, _command: Command): Promise<AgentModeResult>;
+//# sourceMappingURL=mode.d.ts.map

package/dist/commands/agent/mode.js

@@ -0,0 +1,100 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for mode list output */
+export const modeListSchema = {
+    idField: "id",
+    columns: [
+        { header: "MODE", field: "id", width: 15 },
+        { header: "LABEL", field: "label", width: 25 },
+        { header: "DESCRIPTION", field: "description", width: 40 },
+    ],
+};
+/** Schema for set mode output */
+export const setModeSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId", width: 12 },
+        { header: "MODE", field: "mode", width: 20 },
+    ],
+};
+const missingModeError = () => ({
+    code: "MISSING_ARGUMENT",
+    message: "Mode argument required unless --list is specified",
+    details: "Usage: otto agent mode <id> <mode> | otto agent mode --list <id>",
+});
+export async function runModeCommand(id, mode, options, _command) {
+    const normalizedMode = mode?.trim();
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!options.list && !normalizedMode) {
+        throw missingModeError();
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+        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;
+        }
+        const agent = fetchResult.agent;
+        const resolvedId = agent.id;
+        if (options.list) {
+            // List available modes for this agent
+            const availableModes = agent.availableModes ?? [];
+            const items = availableModes.map((m) => ({
+                id: m.id,
+                label: m.label,
+                description: m.description,
+            }));
+            return {
+                type: "list",
+                data: items,
+                schema: modeListSchema,
+            };
+        }
+        if (!normalizedMode) {
+            throw missingModeError();
+        }
+        // Set the agent mode
+        await client.setAgentMode(resolvedId, normalizedMode);
+        return {
+            type: "single",
+            data: {
+                agentId: resolvedId.slice(0, 7),
+                mode: normalizedMode,
+            },
+            schema: setModeSchema,
+        };
+    }
+    catch (err) {
+        // Re-throw if it's already a CommandError
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        if (!client) {
+            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;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "MODE_OPERATION_FAILED",
+            message: `Failed to ${options.list ? "list modes" : "set mode"}: ${message}`,
+        };
+        throw error;
+    }
+    finally {
+        if (client) {
+            await client.close().catch(() => { });
+        }
+    }
+}
+//# sourceMappingURL=mode.js.map

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

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+export interface AgentReloadResult {
+    agentId: string;
+    status: "reloaded";
+    timelineSize: number;
+}
+export declare const reloadSchema: OutputSchema<AgentReloadResult>;
+export declare function addReloadOptions(cmd: Command): Command;
+export interface AgentReloadOptions extends CommandOptions {
+    host?: string;
+}
+export type AgentReloadCommandResult = SingleResult<AgentReloadResult>;
+export declare function runReloadCommand(agentIdArg: string, options: AgentReloadOptions, _command: Command): Promise<AgentReloadCommandResult>;
+//# sourceMappingURL=reload.d.ts.map

package/dist/commands/agent/reload.js

@@ -0,0 +1,75 @@
+import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+export const reloadSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "STATUS", field: "status" },
+        { header: "TIMELINE", field: "timelineSize" },
+    ],
+};
+export function addReloadOptions(cmd) {
+    return cmd
+        .description("Reload an agent (restarts the underlying process)")
+        .argument("<id>", "Agent ID, prefix, or name");
+}
+export async function runReloadCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: otto agent reload <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 result = await client.refreshAgent(agentId);
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                agentId: result.agentId,
+                status: "reloaded",
+                timelineSize: result.timelineSize ?? 0,
+            },
+            schema: reloadSchema,
+        };
+    }
+    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: "RELOAD_FAILED",
+            message: `Failed to reload agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=reload.js.map

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

@@ -0,0 +1,44 @@
+import { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+export { resolveProviderAndModel } from "../../utils/provider-model.js";
+export declare function addRunOptions(cmd: Command): Command;
+/** Result type for agent run command */
+export interface AgentRunResult {
+    agentId: string;
+    status: "created" | "running" | "completed" | "timeout" | "permission" | "error";
+    provider: string;
+    cwd: string;
+    title: string | null;
+}
+/** Schema for agent run output */
+export declare const agentRunSchema: OutputSchema<AgentRunResult>;
+export interface AgentRunOptions extends CommandOptions {
+    detach?: boolean;
+    title?: string;
+    name?: string;
+    provider?: string;
+    model?: string;
+    thinking?: string;
+    mode?: string;
+    worktree?: string;
+    base?: string;
+    workspace?: string;
+    image?: string[];
+    cwd?: string;
+    env?: string[];
+    label?: string[];
+    waitTimeout?: string;
+    outputSchema?: string;
+}
+type ConnectedDaemonClient = Awaited<ReturnType<typeof connectToDaemon>>;
+export interface StructuredResponseTimelineClient {
+    fetchAgentTimeline: ConnectedDaemonClient["fetchAgentTimeline"];
+}
+export declare function resolveStructuredResponseMessage(options: {
+    client: StructuredResponseTimelineClient;
+    agentId: string;
+    lastMessage: string | null;
+}): Promise<string | null>;
+export declare function runRunCommand(prompt: string, options: AgentRunOptions, _command: Command): Promise<SingleResult<AgentRunResult>>;
+//# sourceMappingURL=run.d.ts.map