@otto-code/cli 0.5.0

package/dist/commands/loop/logs.js

@@ -0,0 +1,69 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export function addLoopLogsOptions(command) {
+    return command
+        .description("Stream loop logs")
+        .argument("<id>", "Loop ID")
+        .option("--poll-interval <ms>", "Polling interval in milliseconds", "1000");
+}
+function parsePollInterval(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw {
+            code: "INVALID_POLL_INTERVAL",
+            message: "--poll-interval must be a positive integer",
+        };
+    }
+    return parsed;
+}
+function renderLogEntry(entry) {
+    const prefix = [
+        entry.timestamp,
+        entry.source,
+        entry.iteration === null ? null : `iteration=${entry.iteration}`,
+        entry.level === "error" ? "ERROR" : null,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return `${prefix}\n${entry.text}`;
+}
+export async function runLoopLogsCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const pollInterval = parsePollInterval(options.pollInterval ?? "1000");
+    let client;
+    try {
+        client = (await connectToDaemon({
+            host: options.host,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
+        console.error("Start the daemon with: otto daemon start");
+        process.exit(1);
+    }
+    async function streamLogs(cursor) {
+        const payload = await client.loopLogs(id, cursor);
+        if (payload.error || !payload.loop) {
+            throw new Error(payload.error ?? `Loop not found: ${id}`);
+        }
+        for (const entry of payload.entries) {
+            console.log(renderLogEntry(entry));
+        }
+        if (payload.loop.status !== "running") {
+            await client.close();
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        return streamLogs(payload.nextCursor);
+    }
+    try {
+        await streamLogs(0);
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: Failed to stream loop logs: ${message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=logs.js.map

package/dist/commands/loop/ls.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import type { CommandOptions, OutputSchema, ListResult } from "../../output/index.js";
+interface LoopListRow {
+    id: string;
+    name: string | null;
+    status: string;
+    cwd: string;
+    updated: string;
+    activeIteration: string;
+}
+export interface LoopLsOptions extends CommandOptions {
+}
+export declare const loopLsSchema: OutputSchema<LoopListRow>;
+export declare function addLoopLsOptions(command: Command): Command;
+export type LoopLsResult = ListResult<LoopListRow>;
+export declare function runLoopLsCommand(options: LoopLsOptions, _command: Command): Promise<LoopLsResult>;
+export {};
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/loop/ls.js

@@ -0,0 +1,62 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export const loopLsSchema = {
+    idField: "id",
+    columns: [
+        { header: "LOOP ID", field: "id", width: 10 },
+        { header: "NAME", field: "name", width: 20 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "ITER", field: "activeIteration", width: 8 },
+        { header: "CWD", field: "cwd", width: 40 },
+        { header: "UPDATED", field: "updated", width: 24 },
+    ],
+};
+export function addLoopLsOptions(command) {
+    return command.description("List loops");
+}
+function toRow(loop) {
+    return {
+        id: loop.id,
+        name: loop.name,
+        status: loop.status,
+        cwd: loop.cwd,
+        updated: loop.updatedAt,
+        activeIteration: loop.activeIteration === null ? "-" : String(loop.activeIteration),
+    };
+}
+export async function runLoopLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = (await connectToDaemon({
+            host: options.host,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+    try {
+        const payload = await client.loopList();
+        await client.close();
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "list",
+            data: payload.loops.map(toRow),
+            schema: loopLsSchema,
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "LOOP_LIST_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+import type { LoopRunInput } from "./types.js";
+export interface LoopRunRow {
+    id: string;
+    status: string;
+    name: string | null;
+    cwd: string;
+}
+export interface LoopRunOptions extends CommandOptions {
+    provider?: string;
+    model?: string;
+    mode?: string;
+    verifyProvider?: string;
+    verifyModel?: string;
+    verifyMode?: string;
+    verify?: string;
+    verifyCheck?: string[];
+    archive?: boolean;
+    name?: string;
+    sleep?: string;
+    maxIterations?: string;
+    maxTime?: string;
+}
+export declare const loopRunSchema: OutputSchema<LoopRunRow>;
+export declare function addLoopRunOptions(command: Command): Command;
+export declare function buildLoopRunInput(prompt: string, options: LoopRunOptions): LoopRunInput;
+export type LoopRunResult = SingleResult<LoopRunRow>;
+export declare function runLoopRunCommand(prompt: string, options: LoopRunOptions, _command: Command): Promise<LoopRunResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/loop/run.js

@@ -0,0 +1,162 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { collectMultiple } from "../../utils/command-options.js";
+import { parseDuration } from "../../utils/duration.js";
+import { resolveProviderAndModel } from "../../utils/provider-model.js";
+export const loopRunSchema = {
+    idField: "id",
+    columns: [
+        { header: "LOOP ID", field: "id", width: 10 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "NAME", field: "name", width: 20 },
+        { header: "CWD", field: "cwd", width: 40 },
+    ],
+};
+export function addLoopRunOptions(command) {
+    return command
+        .description("Start a loop")
+        .argument("<prompt>", "Prompt for each fresh worker iteration")
+        .option("--provider <provider>", "Default provider for worker and verifier agents")
+        .option("--model <model>", "Default model for worker and verifier agents")
+        .option("--mode <mode>", "Provider-specific mode for the worker agent (e.g. claude bypassPermissions, opencode build)")
+        .option("--verify-provider <provider>", "Provider for the verifier agent")
+        .option("--verify-model <model>", "Model for the verifier agent")
+        .option("--verify-mode <mode>", "Provider-specific mode for the verifier agent")
+        .option("--verify <prompt>", "Verifier agent prompt")
+        .option("--verify-check <command>", "Shell command that must exit 0 (repeatable)", collectMultiple, [])
+        .option("--archive", "Archive worker and verifier agents after each iteration")
+        .option("--name <name>", "Optional loop name")
+        .option("--sleep <duration>", "Delay between iterations (for example: 30s, 5m)")
+        .option("--max-iterations <n>", "Maximum number of iterations")
+        .option("--max-time <duration>", "Maximum total runtime (for example: 1h, 30m)");
+}
+function toRow(loop) {
+    return {
+        id: loop.id,
+        status: loop.status,
+        name: loop.name,
+        cwd: loop.cwd,
+    };
+}
+function parseMaxIterations(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw {
+            code: "INVALID_MAX_ITERATIONS",
+            message: "--max-iterations must be a positive integer",
+        };
+    }
+    return parsed;
+}
+// oxlint-disable complexity
+export function buildLoopRunInput(prompt, options) {
+    const verifyPrompt = options.verify?.trim();
+    if (options.verify !== undefined && !verifyPrompt) {
+        throw {
+            code: "INVALID_VERIFY_PROMPT",
+            message: "--verify cannot be empty",
+        };
+    }
+    const result = {
+        prompt,
+        cwd: process.cwd(),
+    };
+    // Resolve provider/model
+    if (options.provider) {
+        const { provider, model } = resolveProviderAndModel({ provider: options.provider });
+        if (provider)
+            result.provider = provider;
+        // Explicit --model takes precedence over parsed model
+        if (options.model?.trim()) {
+            result.model = options.model.trim();
+        }
+        else if (model) {
+            result.model = model;
+        }
+    }
+    else if (options.model?.trim()) {
+        result.model = options.model.trim();
+    }
+    if (options.mode?.trim()) {
+        result.modeId = options.mode.trim();
+    }
+    // Resolve verifier provider/model
+    if (options.verifyProvider) {
+        const { provider, model } = resolveProviderAndModel({ provider: options.verifyProvider });
+        if (provider)
+            result.verifierProvider = provider;
+        // Explicit --verify-model takes precedence over parsed model
+        if (options.verifyModel?.trim()) {
+            result.verifierModel = options.verifyModel.trim();
+        }
+        else if (model) {
+            result.verifierModel = model;
+        }
+    }
+    else if (options.verifyModel?.trim()) {
+        result.verifierModel = options.verifyModel.trim();
+    }
+    if (options.verifyMode?.trim()) {
+        result.verifierModeId = options.verifyMode.trim();
+    }
+    if (verifyPrompt)
+        result.verifyPrompt = verifyPrompt;
+    if (options.verifyCheck && options.verifyCheck.length > 0) {
+        result.verifyChecks = options.verifyCheck;
+    }
+    if (options.archive)
+        result.archive = true;
+    if (options.name?.trim())
+        result.name = options.name.trim();
+    if (options.sleep)
+        result.sleepMs = parseDuration(options.sleep);
+    if (options.maxIterations) {
+        result.maxIterations = parseMaxIterations(options.maxIterations);
+    }
+    if (options.maxTime)
+        result.maxTimeMs = parseDuration(options.maxTime);
+    return result;
+}
+export async function runLoopRunCommand(prompt, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const input = buildLoopRunInput(prompt, options);
+    let client;
+    try {
+        client = (await connectToDaemon({
+            host: options.host,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+    try {
+        const payload = await client.loopRun(input);
+        await client.close();
+        if (payload.error || !payload.loop) {
+            throw new Error(payload.error ?? "Loop creation failed");
+        }
+        return {
+            type: "single",
+            data: toRow(payload.loop),
+            schema: loopRunSchema,
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        if (error && typeof error === "object" && "code" in error) {
+            throw error;
+        }
+        throw {
+            code: "LOOP_RUN_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/commands/loop/stop.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+interface LoopStopRow {
+    id: string;
+    status: string;
+    activeIteration: string;
+}
+export interface LoopStopOptions extends CommandOptions {
+}
+export declare const loopStopSchema: OutputSchema<LoopStopRow>;
+export declare function addLoopStopOptions(command: Command): Command;
+export type LoopStopResult = SingleResult<LoopStopRow>;
+export declare function runLoopStopCommand(id: string, options: LoopStopOptions, _command: Command): Promise<LoopStopResult>;
+export {};
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/loop/stop.js

@@ -0,0 +1,56 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export const loopStopSchema = {
+    idField: "id",
+    columns: [
+        { header: "LOOP ID", field: "id", width: 10 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "ITER", field: "activeIteration", width: 8 },
+    ],
+};
+export function addLoopStopOptions(command) {
+    return command.description("Stop a running loop").argument("<id>", "Loop ID");
+}
+function toRow(loop) {
+    return {
+        id: loop.id,
+        status: loop.status,
+        activeIteration: loop.activeIteration === null ? "-" : String(loop.activeIteration),
+    };
+}
+export async function runLoopStopCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = (await connectToDaemon({
+            host: options.host,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+    try {
+        const payload = await client.loopStop(id);
+        await client.close();
+        if (payload.error || !payload.loop) {
+            throw new Error(payload.error ?? `Loop not found: ${id}`);
+        }
+        return {
+            type: "single",
+            data: toRow(payload.loop),
+            schema: loopStopSchema,
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "LOOP_STOP_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/loop/types.d.ts

@@ -0,0 +1,138 @@
+export type LoopStatus = "running" | "succeeded" | "failed" | "stopped";
+export interface LoopLogEntry {
+    seq: number;
+    timestamp: string;
+    iteration: number | null;
+    source: "loop" | "worker" | "verifier" | "verify-check";
+    level: "info" | "error";
+    text: string;
+}
+export interface LoopVerifyCheckResult {
+    command: string;
+    exitCode: number;
+    passed: boolean;
+    stdout: string;
+    stderr: string;
+    startedAt: string;
+    completedAt: string;
+}
+export interface LoopVerifyPromptResult {
+    passed: boolean;
+    reason: string;
+    verifierAgentId: string | null;
+    startedAt: string;
+    completedAt: string;
+}
+export interface LoopIterationRecord {
+    index: number;
+    workerAgentId: string | null;
+    workerStartedAt: string;
+    workerCompletedAt: string | null;
+    verifierAgentId: string | null;
+    status: "running" | "succeeded" | "failed" | "stopped";
+    workerOutcome: "completed" | "failed" | "canceled" | null;
+    failureReason: string | null;
+    verifyChecks: LoopVerifyCheckResult[];
+    verifyPrompt: LoopVerifyPromptResult | null;
+}
+export interface LoopRecord {
+    id: string;
+    name: string | null;
+    prompt: string;
+    cwd: string;
+    provider: string;
+    model: string | null;
+    modeId: string | null;
+    workerProvider: string | null;
+    workerModel: string | null;
+    verifierProvider: string | null;
+    verifierModel: string | null;
+    verifierModeId: string | null;
+    verifyPrompt: string | null;
+    verifyChecks: string[];
+    archive: boolean;
+    sleepMs: number;
+    maxIterations: number | null;
+    maxTimeMs: number | null;
+    status: LoopStatus;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string;
+    completedAt: string | null;
+    stopRequestedAt: string | null;
+    iterations: LoopIterationRecord[];
+    logs: LoopLogEntry[];
+    nextLogSeq: number;
+    activeIteration: number | null;
+    activeWorkerAgentId: string | null;
+    activeVerifierAgentId: string | null;
+}
+export interface LoopListItem {
+    id: string;
+    name: string | null;
+    status: LoopStatus;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    activeIteration: number | null;
+}
+export interface LoopLogsResult {
+    loop: LoopRecord;
+    entries: LoopLogEntry[];
+    nextCursor: number;
+}
+export interface LoopRunPayload {
+    requestId: string;
+    loop: LoopRecord | null;
+    error: string | null;
+}
+export interface LoopListPayload {
+    requestId: string;
+    loops: LoopListItem[];
+    error: string | null;
+}
+export interface LoopInspectPayload {
+    requestId: string;
+    loop: LoopRecord | null;
+    error: string | null;
+}
+export interface LoopLogsPayload {
+    requestId: string;
+    loop: LoopRecord | null;
+    entries: LoopLogEntry[];
+    nextCursor: number;
+    error: string | null;
+}
+export interface LoopStopPayload {
+    requestId: string;
+    loop: LoopRecord | null;
+    error: string | null;
+}
+export interface LoopRunInput {
+    prompt: string;
+    cwd: string;
+    provider?: string;
+    model?: string;
+    modeId?: string;
+    workerProvider?: string;
+    workerModel?: string;
+    verifierProvider?: string;
+    verifierModel?: string;
+    verifierModeId?: string;
+    verifyPrompt?: string;
+    verifyChecks?: string[];
+    archive?: boolean;
+    name?: string;
+    sleepMs?: number;
+    maxIterations?: number;
+    maxTimeMs?: number;
+}
+export interface LoopDaemonClient {
+    loopRun(input: LoopRunInput): Promise<LoopRunPayload>;
+    loopList(): Promise<LoopListPayload>;
+    loopInspect(id: string): Promise<LoopInspectPayload>;
+    loopLogs(id: string, afterSeq?: number): Promise<LoopLogsPayload>;
+    loopStop(id: string): Promise<LoopStopPayload>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/loop/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/commands/onboard.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { type DaemonStartOptions } from "./daemon/local-daemon.js";
+interface OnboardOptions extends DaemonStartOptions {
+    timeout?: string;
+    voice?: "ask" | "enable" | "disable";
+}
+export declare function onboardCommand(): Command;
+export declare function runOnboard(options: OnboardOptions): Promise<void>;
+export {};
+//# sourceMappingURL=onboard.d.ts.map