@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/provider/rm.js

@@ -0,0 +1,45 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { isBuiltinProviderId } from "./shared.js";
+export const providerRmSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 16 },
+        { header: "REMOVED", field: "removed", width: 10 },
+    ],
+};
+export async function runRmCommand(id, options, _command) {
+    if (isBuiltinProviderId(id)) {
+        throw {
+            code: "INVALID_PROVIDER_CONFIG",
+            message: `"${id}" is a built-in provider and cannot be removed.`,
+        };
+    }
+    const host = getDaemonHost({ host: options.host });
+    const 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}`,
+        };
+    });
+    try {
+        const { config } = await client.getDaemonConfig();
+        if (!(id in (config.providers ?? {}))) {
+            throw new Error(`No custom provider "${id}" is configured.`);
+        }
+        await client.patchDaemonConfig({ removeProviders: [id] });
+        return {
+            type: "single",
+            data: { provider: id, removed: "yes" },
+            schema: providerRmSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROVIDER_RM_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=rm.js.map

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

@@ -0,0 +1,7 @@
+/** Mirrors the id pattern enforced by ProviderOverridesSchema in the protocol. */
+export declare const PROVIDER_ID_PATTERN: RegExp;
+export declare const BUILTIN_PROVIDER_ID_SET: Set<string>;
+/** Built-in providers plus the generic ACP base. */
+export declare const VALID_EXTENDS_VALUES: string[];
+export declare function isBuiltinProviderId(id: string): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/provider/shared.js

@@ -0,0 +1,10 @@
+import { BUILTIN_PROVIDER_IDS } from "@camerontaylor/paseo-protocol/provider-manifest";
+/** Mirrors the id pattern enforced by ProviderOverridesSchema in the protocol. */
+export const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+export const BUILTIN_PROVIDER_ID_SET = new Set(BUILTIN_PROVIDER_IDS);
+/** Built-in providers plus the generic ACP base. */
+export const VALID_EXTENDS_VALUES = [...BUILTIN_PROVIDER_IDS, "acp"];
+export function isBuiltinProviderId(id) {
+    return BUILTIN_PROVIDER_ID_SET.has(id);
+}
+//# sourceMappingURL=shared.js.map

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

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ScheduleCommandOptions, type ScheduleRow } from "./shared.js";
+export interface ScheduleCreateOptions extends ScheduleCommandOptions {
+    every?: string;
+    cron?: string;
+    timezone?: string;
+    name?: string;
+    target?: string;
+    provider?: string;
+    mode?: string;
+    thinking?: string;
+    cwd?: string;
+    maxRuns?: string;
+    expiresIn?: string;
+    runNow?: boolean;
+}
+export declare function runCreateCommand(prompt: string, options: ScheduleCreateOptions, command: Command): Promise<SingleResult<ScheduleRow>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/schedule/create.js

@@ -0,0 +1,41 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, parseScheduleCreateInput, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runCreateCommand(prompt, options, command) {
+    const runNowSource = command.getOptionValueSource("runNow");
+    const runNow = runNowSource === "cli" ? Boolean(options.runNow) : undefined;
+    const input = parseScheduleCreateInput({
+        prompt,
+        every: options.every,
+        cron: options.cron,
+        timezone: options.timezone,
+        name: options.name,
+        target: options.target,
+        provider: options.provider,
+        mode: options.mode,
+        thinking: options.thinking,
+        cwd: options.cwd,
+        host: options.host,
+        maxRuns: options.maxRuns,
+        expiresIn: options.expiresIn,
+        runNow,
+    });
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleCreate(input);
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? "Schedule creation failed");
+        }
+        return {
+            type: "single",
+            data: toScheduleRow(payload.schedule),
+            schema: scheduleSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_CREATE_FAILED", "create schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

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

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

package/dist/commands/schedule/delete.js

@@ -0,0 +1,32 @@
+import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
+const scheduleDeleteSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 10 },
+        { header: "STATUS", field: "status", width: 12 },
+    ],
+};
+export async function runDeleteCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleDelete({ id });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "single",
+            data: {
+                id: payload.scheduleId,
+                status: "deleted",
+            },
+            schema: scheduleDeleteSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_DELETE_FAILED", "delete schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=delete.js.map

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

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

package/dist/commands/schedule/index.js

@@ -0,0 +1,66 @@
+import { Command, Option } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runCreateCommand } from "./create.js";
+import { runLsCommand } from "./ls.js";
+import { runInspectCommand } from "./inspect.js";
+import { runLogsCommand } from "./logs.js";
+import { runPauseCommand } from "./pause.js";
+import { runResumeCommand } from "./resume.js";
+import { runDeleteCommand } from "./delete.js";
+import { runRunOnceCommand } from "./run-once.js";
+import { runUpdateCommand } from "./update.js";
+export function createScheduleCommand() {
+    const schedule = new Command("schedule").description("Manage recurring schedules");
+    addJsonAndDaemonHostOptions(schedule
+        .command("create")
+        .description("Create a schedule")
+        .argument("<prompt>", "Prompt to run on the schedule")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
+        .option("--cron <expr>", "Cron cadence expression")
+        .option("--timezone <iana>", "IANA time zone for cron cadence (default: UTC)")
+        .option("--name <name>", "Optional schedule name")
+        .addOption(new Option("--target <target>", "Legacy schedule target").hideHelp())
+        .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
+        .option("--mode <mode>", "Provider-specific mode (e.g. claude bypassPermissions, opencode build)")
+        .option("--thinking <id>", "Thinking option ID for new-agent runs")
+        .option("--cwd <path>", "Working directory (default: current; required with --host)")
+        .option("--run-now", "Fire one immediate run on creation")
+        .option("--max-runs <n>", "Maximum number of runs")
+        .option("--expires-in <duration>", "Time to live for the schedule")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(schedule.command("ls").description("List schedules")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(schedule.command("inspect").description("Inspect a schedule").argument("<id>", "Schedule ID")).action(withOutput(runInspectCommand));
+    addJsonAndDaemonHostOptions(schedule
+        .command("logs")
+        .description("Show recent schedule run logs")
+        .argument("<id>", "Schedule ID")).action(withOutput(runLogsCommand));
+    addJsonAndDaemonHostOptions(schedule.command("pause").description("Pause a schedule").argument("<id>", "Schedule ID")).action(withOutput(runPauseCommand));
+    addJsonAndDaemonHostOptions(schedule
+        .command("resume")
+        .description("Resume a paused schedule")
+        .argument("<id>", "Schedule ID")).action(withOutput(runResumeCommand));
+    addJsonAndDaemonHostOptions(schedule.command("delete").description("Delete a schedule").argument("<id>", "Schedule ID")).action(withOutput(runDeleteCommand));
+    addJsonAndDaemonHostOptions(schedule
+        .command("run-once")
+        .description("Manually trigger a single run of a schedule without affecting cadence")
+        .argument("<id>", "Schedule ID")).action(withOutput(runRunOnceCommand));
+    addJsonAndDaemonHostOptions(schedule
+        .command("update")
+        .description("Update an existing schedule in place")
+        .argument("<id>", "Schedule ID")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
+        .option("--cron <expr>", "Switch to cron cadence expression")
+        .option("--timezone <iana>", "IANA time zone for cron cadence (requires --cron)")
+        .option("--name <name>", "Rename the schedule (empty string clears the name)")
+        .option("--prompt <text>", "Replace the schedule prompt")
+        .option("--provider <provider>", "New agent provider, or provider/model (only for new-agent target)")
+        .option("--model <model>", "New agent model (only for new-agent target)")
+        .option("--mode <mode>", "New agent provider mode (only for new-agent target)")
+        .option("--cwd <path>", "New working directory (only for new-agent target)")
+        .option("--max-runs <n>", "Set or change maximum number of runs")
+        .option("--no-max-runs", "Clear the max-runs limit")
+        .option("--expires-in <duration>", "Set or change time to live for the schedule")
+        .option("--no-expires-in", "Clear the expiration")).action(withOutput(runUpdateCommand));
+    return schedule;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+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 declare function runInspectCommand(id: string, options: ScheduleCommandOptions, _command: Command): Promise<ListResult<ScheduleInspectRow>>;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/schedule/inspect.js

@@ -0,0 +1,27 @@
+import { createScheduleInspectRows, createScheduleInspectSchema, } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
+export async function runInspectCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const payload = await client.scheduleInspect({ id });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Schedule not found: ${id}`);
+        }
+        if (payload.schedule.target.type !== "new-agent") {
+            throw new Error(`Schedule not found: ${id}`);
+        }
+        const rows = createScheduleInspectRows(payload.schedule);
+        return {
+            type: "list",
+            data: rows,
+            schema: createScheduleInspectSchema(payload.schedule),
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_INSPECT_FAILED", "inspect schedule", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=inspect.js.map

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

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type ScheduleLogRow } from "./schema.js";
+import { type ScheduleCommandOptions } from "./shared.js";
+export declare function runLogsCommand(id: string, options: ScheduleCommandOptions, _command: Command): Promise<ListResult<ScheduleLogRow>>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/schedule/logs.js

@@ -0,0 +1,24 @@
+import { scheduleLogSchema, toScheduleLogRow } from "./schema.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, } from "./shared.js";
+export async function runLogsCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireNewAgentSchedule(client, id);
+        const payload = await client.scheduleLogs({ id });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "list",
+            data: payload.runs.map(toScheduleLogRow),
+            schema: scheduleLogSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("SCHEDULE_LOGS_FAILED", "read schedule logs", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=logs.js.map

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,25 @@
+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
+                .filter((schedule) => schedule.target.type === "new-agent")
+                .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,24 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runPauseCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireNewAgentSchedule(client, id);
+        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,24 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runResumeCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireNewAgentSchedule(client, id);
+        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,24 @@
+import { scheduleSchema } from "./schema.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+export async function runRunOnceCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireNewAgentSchedule(client, id);
+        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,59 @@
+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 requireNewAgentSchedule(client: ScheduleDaemonClient, id: string): Promise<void>;
+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;
+    thinking?: 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 declare function compileEveryPresetToCron(value: string): string;
+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