@otto-code/cli 0.8.12 → 0.8.14

package/dist/commands/hub/cloud-device-authorization.js

@@ -1,92 +0,0 @@
-import { z } from "zod";
-const START_TIMEOUT_MS = 15000;
-const activationUrlSchema = z.url({ protocol: /^https?$/u });
-const authorizationSchema = z.object({
-    deviceCode: z.string().min(32),
-    userCode: z.string().min(1),
-    verificationUri: activationUrlSchema,
-    verificationUriComplete: activationUrlSchema,
-    expiresAt: z.string().datetime(),
-    interval: z.number().int().min(5),
-});
-const pollSchema = z.discriminatedUnion("status", [
-    z.object({ status: z.literal("pending"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(5) }),
-    z.object({
-        status: z.literal("approved"),
-        interval: z.number().int().min(5),
-        enrollmentToken: z.string().min(32),
-    }),
-    z.object({ status: z.literal("denied"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("expired"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("enrolled"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("retry_later") }),
-]);
-export class CloudDeviceAuthorizationClient {
-    constructor(startTimeoutMilliseconds = START_TIMEOUT_MS) {
-        this.startTimeoutMilliseconds = startTimeoutMilliseconds;
-    }
-    async start(hubUrl, displayName) {
-        const signal = AbortSignal.timeout(this.startTimeoutMilliseconds);
-        try {
-            const response = await fetch(endpoint(hubUrl, "/api/device-authorizations/"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ displayName }),
-                signal,
-            });
-            if (!response.ok)
-                throw new Error(`Cloud registration failed (${response.status})`);
-            return authorizationSchema.parse(await response.json());
-        }
-        catch (error) {
-            if (signal.aborted) {
-                throw new Error("Cloud registration start timed out", { cause: error });
-            }
-            throw error;
-        }
-    }
-    async poll(hubUrl, deviceCode, timeoutMilliseconds) {
-        const signal = AbortSignal.timeout(timeoutMilliseconds);
-        let response;
-        try {
-            response = await fetch(endpoint(hubUrl, "/api/device-authorizations/poll"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ deviceCode }),
-                signal,
-            });
-        }
-        catch {
-            return { status: "retry_later" };
-        }
-        if ([408, 425, 429].includes(response.status) || response.status >= 500) {
-            return { status: "retry_later" };
-        }
-        if (!response.ok)
-            throw new Error(`Cloud registration poll failed (${response.status})`);
-        let body;
-        try {
-            body = await response.json();
-        }
-        catch (error) {
-            if (signal.aborted || error instanceof TypeError)
-                return { status: "retry_later" };
-            throw error;
-        }
-        return pollSchema.parse(body);
-    }
-}
-function endpoint(hubUrl, pathname) {
-    const url = new URL(hubUrl);
-    if (!["http:", "https:"].includes(url.protocol) ||
-        url.username ||
-        url.password ||
-        url.search ||
-        url.hash) {
-        throw new Error("Hub URL must be an HTTP or HTTPS origin without credentials or a query");
-    }
-    url.pathname = `${url.pathname.replace(/\/$/u, "")}${pathname}`;
-    return url.toString();
-}
-//# sourceMappingURL=cloud-device-authorization.js.map

package/dist/commands/hub/device-authorization.js

@@ -1,87 +0,0 @@
-import { spawn } from "node:child_process";
-import { platform } from "node:os";
-import { CloudDeviceAuthorizationClient, } from "./cloud-device-authorization.js";
-export class SystemBrowser {
-    constructor(options = {}) {
-        this.hostPlatform = options.hostPlatform ?? platform();
-        this.launch = options.launch ?? launchDetached;
-    }
-    async open(url) {
-        if (this.hostPlatform === "win32") {
-            await this.launch("rundll32.exe", ["url.dll,FileProtocolHandler", url]);
-            return;
-        }
-        await this.launch(this.hostPlatform === "darwin" ? "open" : "xdg-open", [url]);
-    }
-}
-export class DeviceAuthorizationWorkflow {
-    constructor(options) {
-        this.options = options;
-    }
-    async authorize(hubUrl, displayName) {
-        const authorization = await this.options.cloud.start(hubUrl, displayName);
-        this.options.reporter.instructions(authorization.verificationUri, authorization.userCode);
-        if (this.options.openBrowser !== false) {
-            await this.options.browser.open(authorization.verificationUriComplete).catch(() => undefined);
-        }
-        let interval = authorization.interval;
-        const expiresAt = Date.parse(authorization.expiresAt);
-        while (true) {
-            const remaining = expiresAt - this.options.waiter.now();
-            if (remaining <= 0)
-                throw new Error("Daemon registration expired");
-            await this.options.waiter.wait(Math.min(interval * 1000, remaining));
-            if (this.options.waiter.now() >= expiresAt)
-                throw new Error("Daemon registration expired");
-            const pollLifetime = expiresAt - this.options.waiter.now();
-            if (pollLifetime <= 0)
-                throw new Error("Daemon registration expired");
-            const outcome = await this.options.cloud.poll(hubUrl, authorization.deviceCode, pollLifetime);
-            if (this.options.waiter.now() >= expiresAt)
-                throw new Error("Daemon registration expired");
-            if (outcome.status === "retry_later")
-                continue;
-            interval = outcome.interval;
-            if (outcome.status === "approved")
-                return outcome.enrollmentToken;
-            if (outcome.status === "denied")
-                throw new Error("Daemon registration was denied");
-            if (outcome.status === "expired")
-                throw new Error("Daemon registration expired");
-            if (outcome.status === "enrolled") {
-                throw new Error("Daemon registration was already used");
-            }
-        }
-    }
-}
-export function createDeviceAuthorizationWorkflow() {
-    return new DeviceAuthorizationWorkflow({
-        cloud: new CloudDeviceAuthorizationClient(),
-        waiter: {
-            wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-            now: Date.now,
-        },
-        browser: new SystemBrowser(),
-        reporter: {
-            instructions(verificationUri, userCode) {
-                process.stderr.write(`Open ${verificationUri} and enter code ${userCode}\n`);
-            },
-        },
-        openBrowser: process.stderr.isTTY === true,
-    });
-}
-async function launchDetached(command, args) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            detached: true,
-            shell: false,
-            stdio: "ignore",
-        });
-        child.once("spawn", () => {
-            child.unref();
-            resolve();
-        });
-        child.once("error", reject);
-    });
-}
-//# sourceMappingURL=device-authorization.js.map

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

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

package/dist/commands/loop/index.js

@@ -1,18 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions, addDaemonHostOption } from "../../utils/command-options.js";
-import { addLoopRunOptions, runLoopRunCommand } from "./run.js";
-import { addLoopLsOptions, runLoopLsCommand } from "./ls.js";
-import { addLoopInspectOptions, runLoopInspectCommand } from "./inspect.js";
-import { addLoopLogsOptions, runLoopLogsCommand } from "./logs.js";
-import { addLoopStopOptions, runLoopStopCommand } from "./stop.js";
-export function createLoopCommand() {
-    const loop = new Command("loop").description("Run iterative worker loops");
-    addJsonAndDaemonHostOptions(addLoopRunOptions(loop.command("run"))).action(withOutput(runLoopRunCommand));
-    addJsonAndDaemonHostOptions(addLoopLsOptions(loop.command("ls"))).action(withOutput(runLoopLsCommand));
-    addJsonAndDaemonHostOptions(addLoopInspectOptions(loop.command("inspect"))).action(withOutput(runLoopInspectCommand));
-    addDaemonHostOption(addLoopLogsOptions(loop.command("logs"))).action(runLoopLogsCommand);
-    addJsonAndDaemonHostOptions(addLoopStopOptions(loop.command("stop"))).action(withOutput(runLoopStopCommand));
-    return loop;
-}
-//# sourceMappingURL=index.js.map

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

@@ -1,13 +0,0 @@
-import { Command } from "commander";
-import type { CommandOptions, ListResult } from "../../output/index.js";
-interface InspectRow {
-    key: string;
-    value: string;
-}
-export interface LoopInspectOptions extends CommandOptions {
-}
-export declare function addLoopInspectOptions(command: Command): Command;
-export type LoopInspectResult = ListResult<InspectRow>;
-export declare function runLoopInspectCommand(id: string, options: LoopInspectOptions, _command: Command): Promise<LoopInspectResult>;
-export {};
-//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/loop/inspect.js

@@ -1,100 +0,0 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-export function addLoopInspectOptions(command) {
-    return command.description("Show loop details and iteration history").argument("<id>", "Loop ID");
-}
-function createInspectSchema(loop) {
-    return {
-        idField: "key",
-        columns: [
-            { header: "KEY", field: "key", width: 18 },
-            { header: "VALUE", field: "value", width: 80 },
-        ],
-        serialize: () => loop,
-    };
-}
-function toRows(loop) {
-    return [
-        { key: "Id", value: loop.id },
-        { key: "Name", value: loop.name ?? "null" },
-        { key: "Status", value: loop.status },
-        { key: "Cwd", value: loop.cwd },
-        { key: "Provider", value: loop.provider },
-        { key: "Model", value: loop.model ?? "null" },
-        { key: "WorkerProvider", value: loop.workerProvider ?? "null" },
-        { key: "WorkerModel", value: loop.workerModel ?? "null" },
-        { key: "VerifierProvider", value: loop.verifierProvider ?? "null" },
-        { key: "VerifierModel", value: loop.verifierModel ?? "null" },
-        { key: "Prompt", value: loop.prompt },
-        { key: "VerifyPrompt", value: loop.verifyPrompt ?? "null" },
-        {
-            key: "VerifyChecks",
-            value: loop.verifyChecks.length > 0 ? loop.verifyChecks.join(" | ") : "[]",
-        },
-        { key: "Archive", value: String(loop.archive) },
-        { key: "SleepMs", value: String(loop.sleepMs) },
-        {
-            key: "MaxIterations",
-            value: loop.maxIterations === null ? "null" : String(loop.maxIterations),
-        },
-        { key: "MaxTimeMs", value: loop.maxTimeMs === null ? "null" : String(loop.maxTimeMs) },
-        { key: "CreatedAt", value: loop.createdAt },
-        { key: "UpdatedAt", value: loop.updatedAt },
-        { key: "CompletedAt", value: loop.completedAt ?? "null" },
-        {
-            key: "Iterations",
-            value: loop.iterations.length === 0
-                ? "[]"
-                : loop.iterations
-                    .map((iteration) => {
-                    const summary = [
-                        `#${iteration.index}`,
-                        iteration.status,
-                        iteration.workerAgentId ? `worker=${iteration.workerAgentId}` : null,
-                        iteration.verifierAgentId ? `verifier=${iteration.verifierAgentId}` : null,
-                        iteration.failureReason ? `reason=${iteration.failureReason}` : null,
-                    ]
-                        .filter(Boolean)
-                        .join(" ");
-                    return summary;
-                })
-                    .join(" | "),
-        },
-    ];
-}
-export async function runLoopInspectCommand(id, options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    let client;
-    try {
-        client = (await connectToDaemon({
-            host: options.host,
-        }));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: otto daemon start",
-        };
-    }
-    try {
-        const payload = await client.loopInspect(id);
-        await client.close();
-        if (payload.error || !payload.loop) {
-            throw new Error(payload.error ?? `Loop not found: ${id}`);
-        }
-        return {
-            type: "list",
-            data: toRows(payload.loop),
-            schema: createInspectSchema(payload.loop),
-        };
-    }
-    catch (error) {
-        await client.close().catch(() => { });
-        throw {
-            code: "LOOP_INSPECT_FAILED",
-            message: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-//# sourceMappingURL=inspect.js.map

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

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-import type { CommandOptions } from "../../output/index.js";
-export interface LoopLogsOptions extends CommandOptions {
-    pollInterval?: string;
-}
-export declare function addLoopLogsOptions(command: Command): Command;
-export declare function runLoopLogsCommand(id: string, options: LoopLogsOptions, _command: Command): Promise<void>;
-//# sourceMappingURL=logs.d.ts.map

package/dist/commands/loop/logs.js

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

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

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

package/dist/commands/loop/ls.js

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

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

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

package/dist/commands/loop/run.js

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