@otto-code/cli 0.5.0

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

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type ScheduleCommandOptions, type ScheduleRow } from "./shared.js";
+export declare function runLsCommand(options: ScheduleCommandOptions, _command: Command): Promise<ListResult<ScheduleRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/schedule/ls.js

@@ -0,0 +1,23 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runLsCommand(options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleList();
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "list",
+            data: payload.schedules.map(toScheduleRow),
+            schema: scheduleSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_LIST_FAILED", "list schedules", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ScheduleCommandOptions, type ScheduleRow } from "./shared.js";
+export declare function runPauseCommand(id: string, options: ScheduleCommandOptions, _command: Command): Promise<SingleResult<ScheduleRow>>;
+//# sourceMappingURL=pause.d.ts.map

package/dist/commands/schedule/pause.js

@@ -0,0 +1,23 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runPauseCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.schedulePause({ id });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Failed to pause schedule: ${id}`);
+        }
+        return {
+            type: "single",
+            data: toScheduleRow(payload.schedule),
+            schema: scheduleSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_PAUSE_FAILED", "pause schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=pause.js.map

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

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ScheduleCommandOptions, type ScheduleRow } from "./shared.js";
+export declare function runResumeCommand(id: string, options: ScheduleCommandOptions, _command: Command): Promise<SingleResult<ScheduleRow>>;
+//# sourceMappingURL=resume.d.ts.map

package/dist/commands/schedule/resume.js

@@ -0,0 +1,23 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runResumeCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleResume({ id });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Failed to resume schedule: ${id}`);
+        }
+        return {
+            type: "single",
+            data: toScheduleRow(payload.schedule),
+            schema: scheduleSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_RESUME_FAILED", "resume schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=resume.js.map

package/dist/commands/schedule/run-once.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ScheduleCommandOptions, type ScheduleRow } from "./shared.js";
+export declare function runRunOnceCommand(id: string, options: ScheduleCommandOptions, _command: Command): Promise<SingleResult<ScheduleRow>>;
+//# sourceMappingURL=run-once.d.ts.map

package/dist/commands/schedule/run-once.js

@@ -0,0 +1,23 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runRunOnceCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleRunOnce({ id });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Failed to run schedule once: ${id}`);
+        }
+        return {
+            type: "single",
+            data: toScheduleRow(payload.schedule),
+            schema: scheduleSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_RUN_ONCE_FAILED", "run schedule once", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=run-once.js.map

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

@@ -0,0 +1,21 @@
+import type { OutputSchema } from "../../output/index.js";
+import { type ScheduleRow } from "./shared.js";
+import type { ScheduleRecord, ScheduleRunRecord } from "./types.js";
+export declare const scheduleSchema: OutputSchema<ScheduleRow>;
+export interface ScheduleInspectRow {
+    key: string;
+    value: string;
+}
+export declare function createScheduleInspectSchema(record: ScheduleRecord): OutputSchema<ScheduleInspectRow>;
+export interface ScheduleLogRow {
+    id: string;
+    status: string;
+    startedAt: string;
+    agentId: string | null;
+    output: string | null;
+    error: string | null;
+}
+export declare const scheduleLogSchema: OutputSchema<ScheduleLogRow>;
+export declare function toScheduleLogRow(run: ScheduleRunRecord): ScheduleLogRow;
+export declare function createScheduleInspectRows(schedule: ScheduleRecord): ScheduleInspectRow[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/schedule/schema.js

@@ -0,0 +1,67 @@
+import { formatCadence, formatTarget } from "./shared.js";
+export const scheduleSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 10 },
+        { header: "NAME", field: "name", width: 20 },
+        { header: "CADENCE", field: "cadence", width: 20 },
+        { header: "TARGET", field: "target", width: 20 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "NEXT RUN", field: "nextRunAt", width: 24 },
+    ],
+};
+export function createScheduleInspectSchema(record) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key", width: 18 },
+            { header: "VALUE", field: "value", width: 80 },
+        ],
+        serialize: () => record,
+    };
+}
+export const scheduleLogSchema = {
+    idField: "id",
+    columns: [
+        { header: "RUN ID", field: "id", width: 14 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "STARTED", field: "startedAt", width: 24 },
+        { header: "AGENT", field: "agentId", width: 12 },
+        { header: "OUTPUT", field: "output", width: 40 },
+        { header: "ERROR", field: "error", width: 40 },
+    ],
+};
+export function toScheduleLogRow(run) {
+    return {
+        id: run.id,
+        status: run.status,
+        startedAt: run.startedAt,
+        agentId: run.agentId ? run.agentId.slice(0, 7) : null,
+        output: run.output,
+        error: run.error,
+    };
+}
+export function createScheduleInspectRows(schedule) {
+    return [
+        { key: "Id", value: schedule.id },
+        { key: "Name", value: schedule.name ?? "null" },
+        { key: "Prompt", value: schedule.prompt },
+        {
+            key: "Cadence",
+            value: schedule.cadence.type === "cron"
+                ? formatCadence(schedule.cadence)
+                : `every:${schedule.cadence.everyMs}ms`,
+        },
+        { key: "Target", value: formatTarget(schedule.target) },
+        { key: "Status", value: schedule.status },
+        { key: "CreatedAt", value: schedule.createdAt },
+        { key: "UpdatedAt", value: schedule.updatedAt },
+        { key: "NextRunAt", value: schedule.nextRunAt ?? "null" },
+        { key: "LastRunAt", value: schedule.lastRunAt ?? "null" },
+        { key: "PausedAt", value: schedule.pausedAt ?? "null" },
+        { key: "ExpiresAt", value: schedule.expiresAt ?? "null" },
+        { key: "MaxRuns", value: schedule.maxRuns == null ? "null" : `${schedule.maxRuns}` },
+        { key: "RunCount", value: `${schedule.runs.length}` },
+    ];
+}
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,56 @@
+import type { CommandError, CommandOptions } from "../../output/index.js";
+import type { CreateScheduleInput, ScheduleCadence, ScheduleDaemonClient, ScheduleListItem, ScheduleRecord, ScheduleTarget, UpdateScheduleInput } from "./types.js";
+export interface ScheduleCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectScheduleClient(host: string | undefined): Promise<{
+    client: ScheduleDaemonClient;
+    host: string;
+}>;
+export declare function toScheduleCommandError(code: string, action: string, error: unknown): CommandError;
+export declare function formatCadence(cadence: ScheduleCadence): string;
+export declare function formatTarget(target: ScheduleTarget | ScheduleListItem["target"]): string;
+export declare function formatDurationMs(durationMs: number): string;
+export declare function parseScheduleCreateInput(options: {
+    prompt: string;
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    name?: string;
+    target?: string;
+    provider?: string;
+    mode?: string;
+    cwd?: string;
+    host?: string;
+    maxRuns?: string;
+    expiresIn?: string;
+    runNow?: boolean;
+}): CreateScheduleInput;
+export interface ScheduleUpdateOptionsInput {
+    id: string;
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    name?: string;
+    prompt?: string;
+    provider?: string;
+    model?: string;
+    mode?: string;
+    cwd?: string;
+    maxRuns?: string;
+    expiresIn?: string;
+    clearMaxRuns?: boolean;
+    clearExpires?: boolean;
+}
+export declare function parseScheduleUpdateInput(options: ScheduleUpdateOptionsInput): UpdateScheduleInput;
+export interface ScheduleRow {
+    id: string;
+    name: string | null;
+    cadence: string;
+    target: string;
+    status: string;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+}
+export declare function toScheduleRow(schedule: ScheduleListItem | ScheduleRecord): ScheduleRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/schedule/shared.js

@@ -0,0 +1,346 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { parseDuration } from "../../utils/duration.js";
+import { resolveProviderAndModel } from "../../utils/provider-model.js";
+export async function connectScheduleClient(host) {
+    const resolvedHost = getDaemonHost({ host });
+    try {
+        const client = (await connectToDaemon({
+            host,
+        }));
+        return { client, host: resolvedHost };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${resolvedHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+export function toScheduleCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        code,
+        message: `Failed to ${action}: ${message}`,
+    };
+}
+export function formatCadence(cadence) {
+    if (cadence.type === "cron") {
+        const timezoneSuffix = cadence.timezone ? ` (${cadence.timezone})` : "";
+        return `cron:${cadence.expression}${timezoneSuffix}`;
+    }
+    return `every:${formatDurationMs(cadence.everyMs)}`;
+}
+export function formatTarget(target) {
+    if (target.type === "self") {
+        return `self:${target.agentId.slice(0, 7)}`;
+    }
+    if (target.type === "agent") {
+        return `agent:${target.agentId.slice(0, 7)}`;
+    }
+    const modelSuffix = target.config.model ? `/${target.config.model}` : "";
+    return `new-agent:${target.config.provider}${modelSuffix}`;
+}
+export function formatDurationMs(durationMs) {
+    const parts = [];
+    let remainingMs = durationMs;
+    const hours = Math.floor(remainingMs / (60 * 60 * 1000));
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+        remainingMs -= hours * 60 * 60 * 1000;
+    }
+    const minutes = Math.floor(remainingMs / (60 * 1000));
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+        remainingMs -= minutes * 60 * 1000;
+    }
+    const seconds = Math.floor(remainingMs / 1000);
+    if (seconds > 0 || parts.length === 0) {
+        parts.push(`${seconds}s`);
+    }
+    return parts.join("");
+}
+function resolveScheduleTarget(args) {
+    const { targetValue, hasExplicitNewAgentOption, createNewAgentTarget } = args;
+    const currentAgentId = process.env.OTTO_AGENT_ID?.trim();
+    if (!targetValue) {
+        if (currentAgentId && !hasExplicitNewAgentOption) {
+            return { type: "self", agentId: currentAgentId };
+        }
+        return createNewAgentTarget();
+    }
+    if (targetValue === "new-agent") {
+        return createNewAgentTarget();
+    }
+    if (hasExplicitNewAgentOption) {
+        throw {
+            code: "INVALID_TARGET",
+            message: "--provider/--mode can only be used with a new-agent target",
+            details: "Use --target new-agent or omit --target to create a new agent schedule",
+        };
+    }
+    if (targetValue === "self") {
+        if (!currentAgentId) {
+            throw {
+                code: "INVALID_TARGET",
+                message: "--target self requires running inside a Otto agent",
+            };
+        }
+        return { type: "self", agentId: currentAgentId };
+    }
+    return { type: "agent", agentId: targetValue };
+}
+export function parseScheduleCreateInput(options) {
+    const prompt = options.prompt.trim();
+    if (!prompt) {
+        throw {
+            code: "INVALID_PROMPT",
+            message: "Schedule prompt cannot be empty",
+        };
+    }
+    const cadence = parseCadenceFromFlags(options.every, options.cron, options.timezone);
+    if (!cadence) {
+        throw {
+            code: "INVALID_CADENCE",
+            message: "Specify exactly one of --every or --cron",
+        };
+    }
+    const cwdInput = options.cwd?.trim();
+    if (options.host !== undefined && !cwdInput) {
+        throw {
+            code: "MISSING_CWD",
+            message: "--cwd is required when --host is specified (the local working directory will not exist on the remote daemon)",
+        };
+    }
+    const runOnCreate = resolveRunOnCreate(options.runNow, cadence.type);
+    const targetValue = options.target?.trim();
+    const modeId = options.mode?.trim();
+    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined;
+    const createNewAgentTarget = () => {
+        const resolvedProviderModel = resolveProviderAndModel({
+            provider: options.provider,
+        });
+        return {
+            type: "new-agent",
+            config: {
+                provider: resolvedProviderModel.provider,
+                cwd: cwdInput ?? process.cwd(),
+                ...(resolvedProviderModel.model ? { model: resolvedProviderModel.model } : {}),
+                ...(modeId ? { modeId } : {}),
+            },
+        };
+    };
+    const target = resolveScheduleTarget({
+        targetValue,
+        hasExplicitNewAgentOption,
+        createNewAgentTarget,
+    });
+    const maxRuns = options.maxRuns === undefined ? undefined : parsePositiveInt(options.maxRuns, "--max-runs");
+    const expiresAt = options.expiresIn === undefined
+        ? undefined
+        : new Date(Date.now() + parseDuration(options.expiresIn)).toISOString();
+    return {
+        prompt,
+        cadence,
+        target,
+        runOnCreate,
+        ...(options.name?.trim() ? { name: options.name.trim() } : {}),
+        ...(maxRuns !== undefined ? { maxRuns } : {}),
+        ...(expiresAt ? { expiresAt } : {}),
+    };
+}
+function resolveRunOnCreate(runNow, cadenceType) {
+    if (runNow === true && cadenceType === "every") {
+        throw {
+            code: "REDUNDANT_RUN_NOW",
+            message: "--run-now is redundant with --every (interval schedules already fire on creation)",
+            details: "Drop --run-now, or use --no-run-now to wait the full interval before the first run",
+        };
+    }
+    if (runNow === false && cadenceType === "cron") {
+        throw {
+            code: "REDUNDANT_NO_RUN_NOW",
+            message: "--no-run-now is redundant with --cron (cron schedules never fire on creation)",
+            details: "Drop --no-run-now, or use --run-now to fire one immediate run on creation",
+        };
+    }
+    return runNow ?? cadenceType === "every";
+}
+export function parseScheduleUpdateInput(options) {
+    const id = options.id.trim();
+    if (!id) {
+        throw {
+            code: "INVALID_SCHEDULE_ID",
+            message: "Schedule id cannot be empty",
+        };
+    }
+    const cadence = parseCadenceFromFlags(options.every, options.cron, options.timezone);
+    const newAgentConfig = buildNewAgentConfigPatch(options);
+    const maxRuns = parseUpdateMaxRuns(options);
+    const expiresAt = parseUpdateExpiresAt(options);
+    const name = parseUpdateName(options);
+    const prompt = parseUpdatePrompt(options);
+    if (name === undefined &&
+        prompt === undefined &&
+        cadence === undefined &&
+        newAgentConfig === undefined &&
+        maxRuns === undefined &&
+        expiresAt === undefined) {
+        throw {
+            code: "NO_UPDATES",
+            message: "Specify at least one field to update",
+        };
+    }
+    return {
+        id,
+        ...(name !== undefined ? { name } : {}),
+        ...(prompt !== undefined ? { prompt } : {}),
+        ...(cadence !== undefined ? { cadence } : {}),
+        ...(newAgentConfig !== undefined ? { newAgentConfig } : {}),
+        ...(maxRuns !== undefined ? { maxRuns } : {}),
+        ...(expiresAt !== undefined ? { expiresAt } : {}),
+    };
+}
+function parseCadenceFromFlags(every, cron, timezone) {
+    if (every !== undefined && cron !== undefined) {
+        throw {
+            code: "INVALID_CADENCE",
+            message: "Specify at most one of --every or --cron",
+        };
+    }
+    const trimmedTimeZone = parseTimeZoneFlag(timezone);
+    if (trimmedTimeZone !== undefined && cron === undefined) {
+        throw {
+            code: "INVALID_TIME_ZONE",
+            message: "--timezone can only be used with --cron",
+        };
+    }
+    if (every !== undefined) {
+        return { type: "every", everyMs: parseDuration(every) };
+    }
+    if (cron !== undefined) {
+        return {
+            type: "cron",
+            expression: cron.trim(),
+            ...(trimmedTimeZone ? { timezone: trimmedTimeZone } : {}),
+        };
+    }
+    return undefined;
+}
+function parseTimeZoneFlag(timeZone) {
+    if (timeZone === undefined) {
+        return undefined;
+    }
+    const trimmed = timeZone.trim();
+    if (!trimmed) {
+        throw {
+            code: "INVALID_TIME_ZONE",
+            message: "--timezone cannot be empty",
+        };
+    }
+    return trimmed;
+}
+function parseUpdateMaxRuns(options) {
+    if (options.maxRuns !== undefined && options.clearMaxRuns) {
+        throw {
+            code: "CONFLICTING_MAX_RUNS",
+            message: "Use either --max-runs <n> or --no-max-runs, not both",
+        };
+    }
+    if (options.clearMaxRuns) {
+        return null;
+    }
+    if (options.maxRuns !== undefined) {
+        return parsePositiveInt(options.maxRuns, "--max-runs");
+    }
+    return undefined;
+}
+function parseUpdateExpiresAt(options) {
+    if (options.expiresIn !== undefined && options.clearExpires) {
+        throw {
+            code: "CONFLICTING_EXPIRES",
+            message: "Use either --expires-in <duration> or --no-expires-in, not both",
+        };
+    }
+    if (options.clearExpires) {
+        return null;
+    }
+    if (options.expiresIn !== undefined) {
+        return new Date(Date.now() + parseDuration(options.expiresIn)).toISOString();
+    }
+    return undefined;
+}
+function parseUpdateName(options) {
+    if (options.name === undefined) {
+        return undefined;
+    }
+    const trimmed = options.name.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function parseUpdatePrompt(options) {
+    if (options.prompt === undefined) {
+        return undefined;
+    }
+    const trimmed = options.prompt.trim();
+    if (!trimmed) {
+        throw {
+            code: "INVALID_PROMPT",
+            message: "--prompt cannot be empty",
+        };
+    }
+    return trimmed;
+}
+function buildNewAgentConfigPatch(options) {
+    const patch = {};
+    if (options.provider !== undefined || options.model !== undefined) {
+        const resolved = resolveProviderAndModel({
+            provider: options.provider,
+            model: options.model,
+        });
+        patch.provider = resolved.provider;
+        if (resolved.model !== undefined) {
+            patch.model = resolved.model;
+        }
+    }
+    if (options.mode !== undefined) {
+        const trimmed = options.mode.trim();
+        patch.modeId = trimmed.length > 0 ? trimmed : null;
+    }
+    if (options.cwd !== undefined) {
+        const trimmed = options.cwd.trim();
+        if (!trimmed) {
+            throw {
+                code: "INVALID_CWD",
+                message: "--cwd cannot be empty",
+            };
+        }
+        patch.cwd = trimmed;
+    }
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}
+function parsePositiveInt(value, flag) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw {
+            code: "INVALID_INTEGER",
+            message: `${flag} must be a positive integer`,
+        };
+    }
+    return parsed;
+}
+export function toScheduleRow(schedule) {
+    return {
+        id: schedule.id,
+        name: schedule.name,
+        cadence: formatCadence(schedule.cadence),
+        target: formatTarget(schedule.target),
+        status: schedule.status,
+        nextRunAt: schedule.nextRunAt,
+        lastRunAt: schedule.lastRunAt,
+    };
+}
+//# sourceMappingURL=shared.js.map