@otto-code/cli 0.5.0

package/dist/commands/permit/deny.js

@@ -0,0 +1,105 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { permitResponseSchema } from "./allow.js";
+export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!options.all && !reqId) {
+        const error = {
+            code: "MISSING_ARGUMENT",
+            message: "Request ID is required unless --all is specified",
+            details: "Usage: otto permit deny <agent> <req_id> or otto permit deny <agent> --all",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+        if (!fetchResult) {
+            await client.close();
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdOrPrefix}`,
+                details: 'Use "otto ls" to list available agents',
+            };
+            throw error;
+        }
+        const agent = fetchResult.agent;
+        const resolvedAgentId = agent.id;
+        // Get pending permissions for this agent
+        const pendingPermissions = agent.pendingPermissions || [];
+        if (pendingPermissions.length === 0) {
+            await client.close();
+            const error = {
+                code: "NO_PENDING_PERMISSIONS",
+                message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+            };
+            throw error;
+        }
+        // Determine which permissions to deny
+        let permissionsToDeny;
+        if (options.all) {
+            permissionsToDeny = pendingPermissions;
+        }
+        else {
+            // Find permission by ID prefix
+            const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+            if (!permission) {
+                await client.close();
+                const error = {
+                    code: "PERMISSION_NOT_FOUND",
+                    message: `Permission request not found: ${reqId}`,
+                    details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                };
+                throw error;
+            }
+            permissionsToDeny = [permission];
+        }
+        // Deny permissions
+        const results = await Promise.all(permissionsToDeny.map(async (permission) => {
+            await client.respondToPermission(resolvedAgentId, permission.id, {
+                behavior: "deny",
+                ...(options.message ? { message: options.message } : {}),
+                ...(options.interrupt ? { interrupt: true } : {}),
+            });
+            return {
+                requestId: permission.id.slice(0, 8),
+                agentId: resolvedAgentId,
+                agentShortId: resolvedAgentId.slice(0, 7),
+                name: permission.name,
+                result: "denied",
+            };
+        }));
+        await client.close();
+        return {
+            type: "list",
+            data: results,
+            schema: permitResponseSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandErrors
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DENY_PERMISSION_FAILED",
+            message: `Failed to deny permission: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=deny.js.map

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

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

package/dist/commands/permit/index.js

@@ -0,0 +1,27 @@
+import { Command } from "commander";
+import { runLsCommand } from "./ls.js";
+import { runAllowCommand } from "./allow.js";
+import { runDenyCommand } from "./deny.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+export function createPermitCommand() {
+    const permit = new Command("permit").description("Manage permission requests");
+    addJsonAndDaemonHostOptions(permit.command("ls").description("List all pending permissions")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(permit
+        .command("allow")
+        .description("Allow a permission request")
+        .argument("<agent>", "Agent ID (or prefix)")
+        .argument("[req_id]", "Permission request ID (optional if --all)")
+        .option("--all", "Allow all pending permissions for this agent")
+        .option("--input <json>", "Modified input parameters (JSON)")).action(withOutput(runAllowCommand));
+    addJsonAndDaemonHostOptions(permit
+        .command("deny")
+        .description("Deny a permission request")
+        .argument("<agent>", "Agent ID (or prefix)")
+        .argument("[req_id]", "Permission request ID (optional if --all)")
+        .option("--all", "Deny all pending permissions for this agent")
+        .option("--message <msg>", "Denial reason message")
+        .option("--interrupt", "Stop agent after denial")).action(withOutput(runDenyCommand));
+    return permit;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Permission list item for display */
+export interface PermissionListItem {
+    id: string;
+    agentId: string;
+    agentShortId: string;
+    name: string;
+    description: string;
+}
+/** Schema for permit ls output */
+export declare const permitLsSchema: OutputSchema<PermissionListItem>;
+export type PermitLsResult = ListResult<PermissionListItem>;
+export interface PermitLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: PermitLsOptions, _command: Command): Promise<PermitLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/permit/ls.js

@@ -0,0 +1,66 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for permit ls output */
+export const permitLsSchema = {
+    idField: "id",
+    columns: [
+        { header: "AGENT", field: "agentShortId", width: 12 },
+        { header: "REQ_ID", field: "id", width: 12 },
+        { header: "TOOL", field: "name", width: 20 },
+        { header: "DESCRIPTION", field: "description", width: 50 },
+    ],
+};
+/** Transform agent snapshot + permission to list item */
+function toListItem(agent, permission) {
+    return {
+        id: permission.id.slice(0, 8),
+        agentId: agent.id,
+        agentShortId: agent.id.slice(0, 7),
+        name: permission.name,
+        description: permission.description ?? "-",
+    };
+}
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agents = agentsPayload.entries.map((entry) => entry.agent);
+        await client.close();
+        // Collect all pending permissions from all agents
+        const items = [];
+        for (const agent of agents) {
+            if (agent.pendingPermissions && agent.pendingPermissions.length > 0) {
+                for (const permission of agent.pendingPermissions) {
+                    items.push(toListItem(agent, permission));
+                }
+            }
+        }
+        return {
+            type: "list",
+            data: items,
+            schema: permitLsSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "LIST_PERMISSIONS_FAILED",
+            message: `Failed to list permissions: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=ls.js.map

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

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

package/dist/commands/provider/index.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { runLsCommand } from "./ls.js";
+import { runModelsCommand } from "./models.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+export function createProviderCommand() {
+    const provider = new Command("provider").description("Manage agent providers");
+    addJsonAndDaemonHostOptions(provider.command("ls").description("List available providers and status")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("models")
+        .description("List models for a provider")
+        .argument("<provider>", "Provider name (claude, codex, opencode)")
+        .option("--thinking", "Include thinking option IDs for each model")).action(withOutput(runModelsCommand));
+    return provider;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+import type { ProviderSnapshotEntry } from "@otto-code/protocol/agent-types";
+export interface ProviderListItem {
+    provider: ProviderSnapshotEntry["provider"];
+    label: string;
+    status: string;
+    enabled: "Enabled" | "Disabled";
+    defaultMode: string;
+    modes: string;
+}
+/** Schema for provider ls output */
+export declare const providerLsSchema: OutputSchema<ProviderListItem>;
+export type ProviderLsResult = ListResult<ProviderListItem>;
+export interface ProviderLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: ProviderLsOptions, _command: Command): Promise<ProviderLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/provider/ls.js

@@ -0,0 +1,73 @@
+import { AGENT_PROVIDER_DEFINITIONS } from "@otto-code/protocol/provider-manifest";
+import { tryConnectToDaemon } from "../../utils/client.js";
+/** Derive provider list from the manifest — single source of truth */
+const PROVIDERS = AGENT_PROVIDER_DEFINITIONS.map((def) => ({
+    provider: def.id,
+    label: def.label,
+    status: "available",
+    enabled: def.enabledByDefault === false ? "Disabled" : "Enabled",
+    defaultMode: def.defaultModeId ?? "-",
+    modes: def.modes.length > 0 ? def.modes.map((m) => m.label).join(", ") : "-",
+}));
+function getStaticProviders() {
+    return PROVIDERS;
+}
+/** Schema for provider ls output */
+export const providerLsSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 12 },
+        { header: "LABEL", field: "label", width: 16 },
+        {
+            header: "STATUS",
+            field: "status",
+            width: 12,
+            color: (value) => {
+                if (value === "available")
+                    return "green";
+                if (value === "unavailable")
+                    return "red";
+                return undefined;
+            },
+        },
+        { header: "ENABLED", field: "enabled", width: 10 },
+        { header: "DEFAULT MODE", field: "defaultMode", width: 14 },
+        { header: "MODES", field: "modes", width: 30 },
+    ],
+};
+export async function runLsCommand(options, _command) {
+    const client = await tryConnectToDaemon({ host: options.host });
+    if (!client) {
+        return {
+            type: "list",
+            data: getStaticProviders(),
+            schema: providerLsSchema,
+        };
+    }
+    try {
+        const snapshot = await client.getProvidersSnapshot();
+        return {
+            type: "list",
+            data: snapshot.entries.map((entry) => ({
+                provider: entry.provider,
+                label: entry.label ?? entry.provider,
+                status: entry.status === "ready" ? "available" : entry.status,
+                enabled: !entry.enabled ? "Disabled" : "Enabled",
+                defaultMode: entry.defaultModeId ?? "default",
+                modes: (entry.modes ?? []).map((mode) => mode.label).join(", "),
+            })),
+            schema: providerLsSchema,
+        };
+    }
+    catch {
+        return {
+            type: "list",
+            data: getStaticProviders(),
+            schema: providerLsSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

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

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Model list item for display */
+export interface ModelListItem {
+    model: string;
+    id: string;
+    description: string;
+    thinkingOptionIds: string[];
+    defaultThinkingOptionId: string | null;
+    thinkingOptions: string;
+}
+/** Schema for provider models output */
+export declare const providerModelsSchema: OutputSchema<ModelListItem>;
+export type ProviderModelsResult = ListResult<ModelListItem>;
+export interface ProviderModelsOptions extends CommandOptions {
+    host?: string;
+    thinking?: boolean;
+}
+export declare function runModelsCommand(provider: string, options: ProviderModelsOptions, _command: Command): Promise<ProviderModelsResult>;
+//# sourceMappingURL=models.d.ts.map

package/dist/commands/provider/models.js

@@ -0,0 +1,53 @@
+import { connectToDaemon } from "../../utils/client.js";
+/** Schema for provider models output */
+export const providerModelsSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 30 },
+        { header: "MODEL", field: "model", width: 30 },
+        { header: "DESCRIPTION", field: "description", width: 40 },
+    ],
+};
+const providerModelsWithThinkingSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 30 },
+        { header: "MODEL", field: "model", width: 30 },
+        { header: "THINKING IDS", field: "thinkingOptions", width: 40 },
+        {
+            header: "DEFAULT THINKING",
+            field: (item) => item.defaultThinkingOptionId ?? "auto",
+            width: 18,
+        },
+    ],
+};
+export async function runModelsCommand(provider, options, _command) {
+    const normalizedProvider = provider.toLowerCase();
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.listProviderModels(normalizedProvider);
+        if (result.error) {
+            throw {
+                code: "PROVIDER_ERROR",
+                message: `Failed to fetch models for ${provider}: ${result.error}`,
+            };
+        }
+        const models = (result.models ?? []).map((m) => ({
+            model: m.label,
+            id: m.id,
+            description: m.description ?? "",
+            thinkingOptionIds: (m.thinkingOptions ?? []).map((option) => option.id),
+            defaultThinkingOptionId: m.defaultThinkingOptionId ?? null,
+            thinkingOptions: (m.thinkingOptions ?? []).map((option) => option.id).join(", ") || "none",
+        }));
+        return {
+            type: "list",
+            data: models,
+            schema: options.thinking ? providerModelsWithThinkingSchema : providerModelsSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=models.js.map

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

@@ -0,0 +1,18 @@
+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;
+    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,40 @@
+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,
+        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 } 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>", "Fixed interval cadence (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")
+        .option("--target <self|new-agent|agent-id>", "Run target")
+        .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("--cwd <path>", "Working directory (default: current; required with --host)")
+        .option("--run-now", "Fire one immediate run on creation (only with --cron)")
+        .option("--no-run-now", "Wait the full interval before the first run (only with --every)")
+        .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>", "Switch to fixed interval cadence (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,24 @@
+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}`);
+        }
+        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,23 @@
+import { scheduleLogSchema, toScheduleLogRow } from "./schema.js";
+import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
+export async function runLogsCommand(id, options, _command) {
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        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