@otto-code/cli 0.5.0

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

@@ -0,0 +1,168 @@
+export type ScheduleStatus = "active" | "paused" | "completed";
+export type ScheduleCadence = {
+    type: "every";
+    everyMs: number;
+} | {
+    type: "cron";
+    expression: string;
+    timezone?: string;
+};
+export type ScheduleTarget = {
+    type: "self";
+    agentId: string;
+} | {
+    type: "agent";
+    agentId: string;
+} | {
+    type: "new-agent";
+    config: {
+        provider: string;
+        cwd: string;
+        modeId?: string;
+        model?: string;
+        thinkingOptionId?: string;
+        title?: string | null;
+        approvalPolicy?: string;
+        sandboxMode?: string;
+        networkAccess?: boolean;
+        webSearch?: boolean;
+    };
+};
+export interface ScheduleRunRecord {
+    id: string;
+    scheduledFor: string;
+    startedAt: string;
+    endedAt: string | null;
+    status: "running" | "succeeded" | "failed";
+    agentId: string | null;
+    output: string | null;
+    error: string | null;
+}
+export interface ScheduleRecord {
+    id: string;
+    name: string | null;
+    prompt: string;
+    cadence: ScheduleCadence;
+    target: Exclude<ScheduleTarget, {
+        type: "self";
+    }>;
+    status: ScheduleStatus;
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    pausedAt: string | null;
+    expiresAt: string | null;
+    maxRuns: number | null;
+    runs: ScheduleRunRecord[];
+}
+export interface ScheduleListItem {
+    id: string;
+    name: string | null;
+    cadence: ScheduleCadence;
+    target: Exclude<ScheduleTarget, {
+        type: "self";
+    }>;
+    status: ScheduleStatus;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    pausedAt: string | null;
+    expiresAt: string | null;
+    maxRuns: number | null;
+}
+export interface CreateScheduleInput {
+    prompt: string;
+    name?: string;
+    cadence: ScheduleCadence;
+    target: ScheduleTarget;
+    maxRuns?: number;
+    expiresAt?: string;
+    runOnCreate?: boolean;
+}
+export interface ScheduleCreatePayload {
+    requestId: string;
+    schedule: ScheduleListItem | null;
+    error: string | null;
+}
+export interface ScheduleListPayload {
+    requestId: string;
+    schedules: ScheduleListItem[];
+    error: string | null;
+}
+export interface ScheduleInspectPayload {
+    requestId: string;
+    schedule: ScheduleRecord | null;
+    error: string | null;
+}
+export interface ScheduleLogsPayload {
+    requestId: string;
+    runs: ScheduleRunRecord[];
+    error: string | null;
+}
+export interface SchedulePausePayload {
+    requestId: string;
+    schedule: ScheduleListItem | null;
+    error: string | null;
+}
+export interface ScheduleResumePayload {
+    requestId: string;
+    schedule: ScheduleListItem | null;
+    error: string | null;
+}
+export interface ScheduleDeletePayload {
+    requestId: string;
+    scheduleId: string;
+    error: string | null;
+}
+export interface ScheduleRunOncePayload {
+    requestId: string;
+    schedule: ScheduleRecord | null;
+    error: string | null;
+}
+export interface UpdateScheduleNewAgentConfig {
+    provider?: string;
+    model?: string | null;
+    modeId?: string | null;
+    cwd?: string;
+}
+export interface UpdateScheduleInput {
+    id: string;
+    name?: string | null;
+    prompt?: string;
+    cadence?: ScheduleCadence;
+    newAgentConfig?: UpdateScheduleNewAgentConfig;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+}
+export interface ScheduleUpdatePayload {
+    requestId: string;
+    schedule: ScheduleRecord | null;
+    error: string | null;
+}
+export interface ScheduleDaemonClient {
+    scheduleCreate(input: CreateScheduleInput): Promise<ScheduleCreatePayload>;
+    scheduleList(): Promise<ScheduleListPayload>;
+    scheduleInspect(input: {
+        id: string;
+    }): Promise<ScheduleInspectPayload>;
+    scheduleLogs(input: {
+        id: string;
+    }): Promise<ScheduleLogsPayload>;
+    schedulePause(input: {
+        id: string;
+    }): Promise<SchedulePausePayload>;
+    scheduleResume(input: {
+        id: string;
+    }): Promise<ScheduleResumePayload>;
+    scheduleDelete(input: {
+        id: string;
+    }): Promise<ScheduleDeletePayload>;
+    scheduleRunOnce(input: {
+        id: string;
+    }): Promise<ScheduleRunOncePayload>;
+    scheduleUpdate(input: UpdateScheduleInput): Promise<ScheduleUpdatePayload>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/schedule/types.js

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

package/dist/commands/schedule/update.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type ScheduleInspectRow } from "./schema.js";
+import { type ScheduleCommandOptions } from "./shared.js";
+export interface ScheduleUpdateOptions extends ScheduleCommandOptions {
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    name?: string;
+    prompt?: string;
+    provider?: string;
+    model?: string;
+    mode?: string;
+    cwd?: string;
+    maxRuns?: string;
+    noMaxRuns?: boolean;
+    expiresIn?: string;
+    noExpiresIn?: boolean;
+}
+export declare function runUpdateCommand(id: string, options: ScheduleUpdateOptions, _command: Command): Promise<ListResult<ScheduleInspectRow>>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/schedule/update.js

@@ -0,0 +1,39 @@
+import { createScheduleInspectRows, createScheduleInspectSchema, } from "./schema.js";
+import { connectScheduleClient, parseScheduleUpdateInput, toScheduleCommandError, } from "./shared.js";
+export async function runUpdateCommand(id, options, _command) {
+    const input = parseScheduleUpdateInput({
+        id,
+        every: options.every,
+        cron: options.cron,
+        timezone: options.timezone,
+        name: options.name,
+        prompt: options.prompt,
+        provider: options.provider,
+        model: options.model,
+        mode: options.mode,
+        cwd: options.cwd,
+        maxRuns: options.maxRuns,
+        expiresIn: options.expiresIn,
+        clearMaxRuns: options.noMaxRuns,
+        clearExpires: options.noExpiresIn,
+    });
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleUpdate(input);
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Failed to update schedule: ${id}`);
+        }
+        return {
+            type: "list",
+            data: createScheduleInspectRows(payload.schedule),
+            schema: createScheduleInspectSchema(payload.schedule),
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_UPDATE_FAILED", "update schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/commands/speech/index.d.ts

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

package/dist/commands/speech/index.js

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export function createSpeechCommand() {
+    return new Command("speech").description("Speech commands");
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/terminal/capture.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import { type TerminalCommandOptions } from "./shared.js";
+export interface TerminalCaptureOptions extends TerminalCommandOptions {
+    start?: string;
+    end?: string;
+    scrollback?: boolean;
+    ansi?: boolean;
+}
+export declare function runCaptureCommand(terminalId: string, _options: TerminalCaptureOptions, command: Command): Promise<void>;
+//# sourceMappingURL=capture.d.ts.map

package/dist/commands/terminal/capture.js

@@ -0,0 +1,68 @@
+import { renderError, toCommandError } from "../../output/render.js";
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+export async function runCaptureCommand(terminalId, _options, command) {
+    const options = command.optsWithGlobals();
+    try {
+        const payload = await executeCaptureCommand(terminalId, options);
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                terminalId: payload.terminalId,
+                lines: payload.lines,
+                totalLines: payload.totalLines,
+            }, null, 2) + "\n");
+            return;
+        }
+        if (payload.lines.length > 0) {
+            process.stdout.write(payload.lines.join("\n") + "\n");
+        }
+    }
+    catch (err) {
+        const output = renderError(toCommandError(err), {
+            format: options.json ? "json" : "table",
+            noColor: options.color === false,
+        });
+        process.stderr.write(output + "\n");
+        process.exit(1);
+    }
+}
+async function executeCaptureCommand(terminalId, options) {
+    const { client } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await resolveTerminalId(client, terminalId);
+        if (!resolvedId) {
+            throw {
+                code: "TERMINAL_NOT_FOUND",
+                message: `No terminal found matching: ${terminalId}`,
+                details: "Use `otto terminal ls --all` to list available terminals.",
+            };
+        }
+        const start = options.scrollback ? 0 : parseLineNumber("--start", options.start);
+        const end = parseLineNumber("--end", options.end);
+        return await client.captureTerminal(resolvedId, {
+            ...(start === undefined ? {} : { start }),
+            ...(end === undefined ? {} : { end }),
+            stripAnsi: !options.ansi,
+        });
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_CAPTURE_FAILED", "capture terminal output", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function parseLineNumber(flag, value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed)) {
+        throw {
+            code: "INVALID_LINE_NUMBER",
+            message: `Invalid ${flag} value: ${value}`,
+            details: "Use an integer line number.",
+        };
+    }
+    return parsed;
+}
+//# sourceMappingURL=capture.js.map

package/dist/commands/terminal/create.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalRow } from "./schema.js";
+export interface TerminalCreateOptions extends TerminalCommandOptions {
+    cwd?: string;
+    name?: string;
+}
+export declare function runCreateCommand(options: TerminalCreateOptions, _command: Command): Promise<SingleResult<TerminalRow>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/terminal/create.js

@@ -0,0 +1,38 @@
+import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
+import { terminalSchema, toTerminalRow } from "./schema.js";
+export async function runCreateCommand(options, _command) {
+    const { client } = await connectTerminalClient(options.host);
+    const cwd = options.cwd ?? process.cwd();
+    try {
+        const opened = await client.openProject(cwd);
+        if (!opened.workspace) {
+            const error = {
+                code: "WORKSPACE_OPEN_FAILED",
+                message: opened.error ?? "Failed to open workspace",
+            };
+            throw error;
+        }
+        const payload = await client.createTerminal(cwd, options.name, undefined, {
+            workspaceId: opened.workspace.id,
+        });
+        if (!payload.terminal) {
+            const error = {
+                code: "TERMINAL_CREATE_FAILED",
+                message: payload.error ?? "Failed to create terminal",
+            };
+            throw error;
+        }
+        return {
+            type: "single",
+            data: toTerminalRow(payload.terminal),
+            schema: terminalSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_CREATE_FAILED", "create terminal", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/terminal/index.d.ts

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

package/dist/commands/terminal/index.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addDaemonHostOption, addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runCaptureCommand } from "./capture.js";
+import { runCreateCommand } from "./create.js";
+import { runKillCommand } from "./kill.js";
+import { runLsCommand } from "./ls.js";
+import { runSendKeysCommand } from "./send-keys.js";
+export function createTerminalCommand() {
+    const terminal = new Command("terminal").description("Manage workspace terminals");
+    addJsonAndDaemonHostOptions(terminal
+        .command("ls")
+        .description("List terminals")
+        .option("--all", "List terminals across all workspaces")
+        .option("--cwd <path>", "Workspace directory")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(terminal
+        .command("create")
+        .description("Create a terminal")
+        .option("--cwd <path>", "Workspace directory")
+        .option("--name <name>", "Terminal name")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(terminal
+        .command("kill")
+        .description("Kill a terminal")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")).action(withOutput(runKillCommand));
+    addDaemonHostOption(terminal
+        .command("capture")
+        .description("Capture terminal output")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")
+        .option("--start <n>", "Capture start line")
+        .option("--end <n>", "Capture end line")
+        .option("-S, --scrollback", "Capture from the beginning of scrollback")
+        .option("--ansi", "Preserve ANSI escape codes")
+        .option("--json", "Output in JSON format")).action(runCaptureCommand);
+    addDaemonHostOption(terminal
+        .command("send-keys")
+        .description("Send keys to a terminal")
+        .argument("<terminal-id>", "Terminal ID, ID prefix, or name")
+        .argument("<keys...>", "Keys to send")
+        .option("-l, --literal", "Send raw keys without interpreting special tokens")
+        .option("--json", "Output in JSON format")).action(runSendKeysCommand);
+    return terminal;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/terminal/kill.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalKillRow } from "./schema.js";
+export declare function runKillCommand(terminalId: string, options: TerminalCommandOptions, _command: Command): Promise<SingleResult<TerminalKillRow>>;
+//# sourceMappingURL=kill.d.ts.map

package/dist/commands/terminal/kill.js

@@ -0,0 +1,36 @@
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+import { terminalKillSchema } from "./schema.js";
+export async function runKillCommand(terminalId, options, _command) {
+    const { client } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await requireTerminalId(client, terminalId);
+        const payload = await client.killTerminal(resolvedId);
+        return {
+            type: "single",
+            data: {
+                terminalId: payload.terminalId,
+                success: payload.success,
+            },
+            schema: terminalKillSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_KILL_FAILED", "kill terminal", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+async function requireTerminalId(client, terminalId) {
+    const resolvedId = await resolveTerminalId(client, terminalId);
+    if (resolvedId) {
+        return resolvedId;
+    }
+    const error = {
+        code: "TERMINAL_NOT_FOUND",
+        message: `No terminal found matching: ${terminalId}`,
+        details: "Use `otto terminal ls --all` to list available terminals.",
+    };
+    throw error;
+}
+//# sourceMappingURL=kill.js.map

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

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type TerminalCommandOptions } from "./shared.js";
+import { type TerminalRow } from "./schema.js";
+export interface TerminalLsOptions extends TerminalCommandOptions {
+    all?: boolean;
+    cwd?: string;
+}
+export declare function runLsCommand(options: TerminalLsOptions, _command: Command): Promise<ListResult<TerminalRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/terminal/ls.js

@@ -0,0 +1,21 @@
+import { connectTerminalClient, toTerminalCommandError, } from "./shared.js";
+import { terminalSchema, toTerminalRow } from "./schema.js";
+export async function runLsCommand(options, _command) {
+    const { client } = await connectTerminalClient(options.host);
+    const cwd = options.all ? undefined : (options.cwd ?? process.cwd());
+    try {
+        const payload = cwd === undefined ? await client.listTerminals() : await client.listTerminals(cwd);
+        return {
+            type: "list",
+            data: payload.terminals.map((terminal) => toTerminalRow(terminal, payload.cwd ?? cwd)),
+            schema: terminalSchema,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_LIST_FAILED", "list terminals", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/terminal/schema.d.ts

@@ -0,0 +1,18 @@
+import type { OutputSchema } from "../../output/index.js";
+export interface TerminalRow {
+    id: string;
+    name: string;
+    cwd: string;
+}
+export interface TerminalKillRow {
+    terminalId: string;
+    success: boolean;
+}
+export declare const terminalSchema: OutputSchema<TerminalRow>;
+export declare const terminalKillSchema: OutputSchema<TerminalKillRow>;
+export declare function toTerminalRow(terminal: {
+    id: string;
+    name: string;
+    cwd?: string;
+}, cwd?: string): TerminalRow;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/terminal/schema.js

@@ -0,0 +1,23 @@
+export const terminalSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: (row) => row.id.slice(0, 8), width: 8 },
+        { header: "NAME", field: "name", width: 24 },
+        { header: "CWD", field: "cwd", width: 48 },
+    ],
+};
+export const terminalKillSchema = {
+    idField: "terminalId",
+    columns: [
+        { header: "ID", field: (row) => row.terminalId.slice(0, 8), width: 8 },
+        { header: "SUCCESS", field: "success", width: 8 },
+    ],
+};
+export function toTerminalRow(terminal, cwd) {
+    return {
+        id: terminal.id,
+        name: terminal.name,
+        cwd: terminal.cwd ?? cwd ?? "-",
+    };
+}
+//# sourceMappingURL=schema.js.map

package/dist/commands/terminal/send-keys.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import { type TerminalCommandOptions } from "./shared.js";
+export interface TerminalSendKeysOptions extends TerminalCommandOptions {
+    literal?: boolean;
+}
+export declare function runSendKeysCommand(terminalId: string, keys: string[], _options: TerminalSendKeysOptions, command: Command): Promise<void>;
+//# sourceMappingURL=send-keys.d.ts.map

package/dist/commands/terminal/send-keys.js

@@ -0,0 +1,76 @@
+import { renderError, toCommandError } from "../../output/render.js";
+import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
+export async function runSendKeysCommand(terminalId, keys, _options, command) {
+    const options = command.optsWithGlobals();
+    try {
+        const payload = await executeSendKeysCommand(terminalId, keys, options);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+        }
+    }
+    catch (err) {
+        const output = renderError(toCommandError(err), {
+            format: options.json ? "json" : "table",
+            noColor: options.color === false,
+        });
+        process.stderr.write(output + "\n");
+        process.exit(1);
+    }
+}
+async function executeSendKeysCommand(terminalId, keys, options) {
+    const { client } = await connectTerminalClient(options.host);
+    try {
+        const resolvedId = await resolveTerminalId(client, terminalId);
+        if (!resolvedId) {
+            throw {
+                code: "TERMINAL_NOT_FOUND",
+                message: `No terminal found matching: ${terminalId}`,
+                details: "Use `otto terminal ls --all` to list available terminals.",
+            };
+        }
+        const data = keys.map((key) => resolveKeyToken(key, options.literal === true)).join("");
+        client.sendTerminalInput(resolvedId, { type: "input", data });
+        return {
+            terminalId: resolvedId,
+            keysSent: data.length,
+        };
+    }
+    catch (err) {
+        throw toTerminalCommandError("TERMINAL_SEND_KEYS_FAILED", "send terminal keys", err);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function resolveKeyToken(key, literal) {
+    if (literal) {
+        return key;
+    }
+    switch (key) {
+        case "Enter":
+            return "\r";
+        case "Tab":
+            return "\t";
+        case "Escape":
+            return "\u001b";
+        case "Space":
+            return " ";
+        case "BSpace":
+            return "\u007f";
+        case "C-c":
+            return "\u0003";
+        case "C-d":
+            return "\u0004";
+        case "C-z":
+            return "\u001a";
+        case "C-l":
+            return "\u000c";
+        case "C-a":
+            return "\u0001";
+        case "C-e":
+            return "\u0005";
+        default:
+            return key;
+    }
+}
+//# sourceMappingURL=send-keys.js.map

package/dist/commands/terminal/shared.d.ts

@@ -0,0 +1,12 @@
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandError, CommandOptions } from "../../output/index.js";
+export interface TerminalCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectTerminalClient(host?: string): Promise<{
+    client: import("@otto-code/client/internal/daemon-client").DaemonClient;
+    daemonHost: string;
+}>;
+export declare function toTerminalCommandError(code: string, action: string, err: unknown): CommandError;
+export declare function resolveTerminalId(client: Awaited<ReturnType<typeof connectToDaemon>>, idOrName: string): Promise<string | null>;
+//# sourceMappingURL=shared.d.ts.map