@getpaseo/cli 0.3.1 → 0.4.0-beta.1

package/dist/commands/hub/deploy-input.js

@@ -1,264 +0,0 @@
-import { lstat, readFile } from "node:fs/promises";
-import path from "node:path";
-import YAML from "yaml";
-import { HubCommandError } from "./error.js";
-const DEFAULT_CONFIGURATION_PATH = ".paseo/hub.yml";
-const PROMPT_PARTIAL_ROOT = ".paseo/partials";
-const PROMPT_PARTIAL_ROOT_PREFIX = `${PROMPT_PARTIAL_ROOT}/`;
-const PROJECT_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-const MAX_CONFIGURATION_LENGTH = 1000000;
-const MAX_PROMPT_PARTIAL_COUNT = 100;
-const MAX_PROMPT_PARTIAL_PATH_LENGTH = 512;
-const MAX_PROMPT_PARTIAL_CONTENT_BYTES = 1000000;
-const MAX_PROMPT_PARTIAL_BUNDLE_BYTES = 5000000;
-export async function resolveHubDeployInput(input) {
-    const file = input.file ?? DEFAULT_CONFIGURATION_PATH;
-    const projectRoot = path.resolve(input.cwd);
-    const configurationPath = resolveConfigurationPath(projectRoot, file);
-    const yaml = await readConfiguration(projectRoot, configurationPath, file);
-    const configuration = parseConfiguration(yaml);
-    const projectSlug = input.project ?? projectFromConfiguration(configuration);
-    if (projectSlug === undefined) {
-        throw new HubCommandError("HUB_PROJECT_REQUIRED", "Project is required. Pass --project <slug> or add top-level project to the YAML.");
-    }
-    if (!PROJECT_SLUG_PATTERN.test(projectSlug)) {
-        throw new HubCommandError("HUB_INVALID_PROJECT", "Project must be a bare slug such as my-project.");
-    }
-    const partials = await resolvePromptPartials(projectRoot, configuration);
-    return {
-        projectSlug,
-        yaml,
-        ...(partials.length === 0 ? {} : { partials }),
-    };
-}
-function resolveConfigurationPath(cwd, file) {
-    if (file.length === 0 || file.includes("\0")) {
-        throw invalidConfigurationPath();
-    }
-    const segments = file.replaceAll("\\", "/").split("/");
-    if (segments.some((segment) => segment === "..")) {
-        throw invalidConfigurationPath();
-    }
-    const resolved = path.resolve(cwd, file);
-    const relative = path.relative(cwd, resolved);
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw invalidConfigurationPath();
-    }
-    return resolved;
-}
-async function readConfiguration(projectRoot, configurationPath, displayPath) {
-    const unsafePath = () => new HubCommandError("HUB_CONFIGURATION_UNSAFE_PATH", `Hub configuration at ${displayPath} must not use a symlink.`);
-    await rejectSymlinkComponents(projectRoot, configurationPath, unsafePath);
-    let stats;
-    try {
-        stats = await lstat(configurationPath);
-    }
-    catch (error) {
-        throw configurationReadError(displayPath, error);
-    }
-    if (stats.isSymbolicLink()) {
-        throw unsafePath();
-    }
-    if (!stats.isFile()) {
-        throw new HubCommandError("HUB_CONFIGURATION_NOT_FILE", `Hub configuration at ${displayPath} must be a regular file.`);
-    }
-    if (!hasReadPermission(stats.mode)) {
-        throw new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check file permissions.`);
-    }
-    let bytes;
-    try {
-        bytes = await readFile(configurationPath);
-    }
-    catch (error) {
-        throw configurationReadError(displayPath, error);
-    }
-    const yaml = bytes.toString("utf8");
-    if (yaml.length > MAX_CONFIGURATION_LENGTH) {
-        throw new HubCommandError("HUB_CONFIGURATION_TOO_LARGE", `Hub configuration at ${displayPath} exceeds the ${MAX_CONFIGURATION_LENGTH}-character limit.`);
-    }
-    return yaml;
-}
-function parseConfiguration(yaml) {
-    let configuration;
-    try {
-        configuration = YAML.parse(yaml);
-    }
-    catch {
-        throw new HubCommandError("HUB_INVALID_CONFIGURATION", "Hub configuration is not valid YAML.");
-    }
-    if (!isRecord(configuration)) {
-        throw new HubCommandError("HUB_INVALID_CONFIGURATION", "Hub configuration must be a YAML mapping.");
-    }
-    return configuration;
-}
-function projectFromConfiguration(configuration) {
-    const project = configuration["project"];
-    if (project === undefined)
-        return undefined;
-    if (typeof project !== "string") {
-        throw new HubCommandError("HUB_INVALID_PROJECT", "Top-level project must be a bare project slug.");
-    }
-    return project;
-}
-async function resolvePromptPartials(projectRoot, configuration) {
-    const references = collectPromptPartialReferences(configuration);
-    if (references.length > MAX_PROMPT_PARTIAL_COUNT) {
-        throw new HubCommandError("HUB_PARTIAL_LIMIT_EXCEEDED", `Hub configuration references ${references.length} partials; the limit is ${MAX_PROMPT_PARTIAL_COUNT}.`);
-    }
-    const partials = [];
-    let bundleBytes = 0;
-    for (const reference of references) {
-        const partialPath = path.resolve(projectRoot, PROMPT_PARTIAL_ROOT, ...reference.path.split("/"));
-        const content = await readPartial(projectRoot, partialPath, reference.path);
-        const contentBytes = Buffer.byteLength(content, "utf8");
-        if (contentBytes > MAX_PROMPT_PARTIAL_CONTENT_BYTES) {
-            throw new HubCommandError("HUB_PARTIAL_TOO_LARGE", `Referenced Hub partial ${reference.path} exceeds the ${MAX_PROMPT_PARTIAL_CONTENT_BYTES}-byte limit.`);
-        }
-        bundleBytes += contentBytes;
-        if (bundleBytes > MAX_PROMPT_PARTIAL_BUNDLE_BYTES) {
-            throw new HubCommandError("HUB_PARTIAL_BUNDLE_TOO_LARGE", `Referenced Hub partials exceed the ${MAX_PROMPT_PARTIAL_BUNDLE_BYTES}-byte combined limit.`);
-        }
-        partials.push({ path: reference.path, content });
-    }
-    return partials;
-}
-function collectPromptPartialReferences(configuration) {
-    const references = [];
-    const seen = new Set();
-    const triggers = configuration["triggers"];
-    if (!Array.isArray(triggers))
-        return references;
-    for (const trigger of triggers) {
-        if (!isRecord(trigger) || !Array.isArray(trigger["steps"]))
-            continue;
-        for (const step of trigger["steps"]) {
-            if (!isRecord(step) || !Array.isArray(step["prompt"]))
-                continue;
-            for (const block of step["prompt"]) {
-                if (!isRecord(block) || !Object.hasOwn(block, "include"))
-                    continue;
-                const include = block["include"];
-                if (typeof include !== "string") {
-                    throw new HubCommandError("HUB_PARTIAL_PATH_INVALID", "Hub partial include path must be a string.");
-                }
-                const normalizedPath = normalizePromptPartialPath(include);
-                if (seen.has(normalizedPath)) {
-                    throw new HubCommandError("HUB_PARTIAL_DUPLICATE", `Hub partial ${normalizedPath} is referenced more than once. Remove the duplicate include.`);
-                }
-                seen.add(normalizedPath);
-                references.push({ path: normalizedPath });
-            }
-        }
-    }
-    return references;
-}
-function normalizePromptPartialPath(value) {
-    const decoded = decodePromptPartialPath(value);
-    if (decoded.length === 0)
-        throw invalidPromptPartialPath(value);
-    if (/^(?:[a-zA-Z]:[\\/]|[\\/]{1,2})/u.test(decoded)) {
-        throw invalidPromptPartialPath(value);
-    }
-    const segments = decoded.replaceAll("\\", "/").split("/");
-    if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-        throw invalidPromptPartialPath(value);
-    }
-    const canonical = `${PROMPT_PARTIAL_ROOT}/${segments.join("/")}`;
-    if (!canonical.startsWith(PROMPT_PARTIAL_ROOT_PREFIX)) {
-        throw invalidPromptPartialPath(value);
-    }
-    if (canonical.length > MAX_PROMPT_PARTIAL_PATH_LENGTH) {
-        throw new HubCommandError("HUB_PARTIAL_PATH_TOO_LONG", `Hub partial path ${value} exceeds the ${MAX_PROMPT_PARTIAL_PATH_LENGTH}-character limit.`);
-    }
-    return canonical.slice(PROMPT_PARTIAL_ROOT_PREFIX.length);
-}
-function decodePromptPartialPath(value) {
-    let decoded = value;
-    for (let attempt = 0; attempt < 8; attempt += 1) {
-        let next;
-        try {
-            next = decodeURIComponent(decoded);
-        }
-        catch {
-            throw invalidPromptPartialPath(value);
-        }
-        if (next === decoded)
-            break;
-        decoded = next;
-    }
-    if (decoded.includes("\0") || /%[0-9a-f]{2}/iu.test(decoded)) {
-        throw invalidPromptPartialPath(value);
-    }
-    return decoded;
-}
-async function readPartial(projectRoot, partialPath, displayPath) {
-    await rejectSymlinkComponents(projectRoot, partialPath, () => new HubCommandError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not use a symlink.`));
-    let stats;
-    try {
-        stats = await lstat(partialPath);
-    }
-    catch (error) {
-        if (errorCode(error) === "ENOENT") {
-            throw new HubCommandError("HUB_PARTIAL_MISSING", `Referenced Hub partial ${displayPath} does not exist.`);
-        }
-        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
-    }
-    if (stats.isSymbolicLink()) {
-        throw new HubCommandError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not be a symlink.`);
-    }
-    if (!stats.isFile()) {
-        throw new HubCommandError("HUB_PARTIAL_NOT_FILE", `Referenced Hub partial ${displayPath} must be a regular file.`);
-    }
-    if (!hasReadPermission(stats.mode)) {
-        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
-    }
-    try {
-        return (await readFile(partialPath)).toString("utf8");
-    }
-    catch {
-        throw new HubCommandError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
-    }
-}
-async function rejectSymlinkComponents(root, target, error) {
-    const relative = path.relative(root, target);
-    let current = root;
-    for (const segment of relative.split(path.sep).filter(Boolean)) {
-        current = path.join(current, segment);
-        try {
-            if ((await lstat(current)).isSymbolicLink())
-                throw error();
-        }
-        catch (failure) {
-            if (failure instanceof HubCommandError)
-                throw failure;
-            if (errorCode(failure) === "ENOENT")
-                return;
-            throw error();
-        }
-    }
-}
-function configurationReadError(displayPath, error) {
-    if (errorCode(error) === "ENOENT") {
-        return new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Pass an existing YAML file.`);
-    }
-    return new HubCommandError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check the file and permissions.`);
-}
-function invalidConfigurationPath() {
-    return new HubCommandError("HUB_CONFIGURATION_PATH_INVALID", "Hub configuration path must stay within the current project root; parent-directory paths are not allowed.");
-}
-function invalidPromptPartialPath(value) {
-    return new HubCommandError("HUB_PARTIAL_PATH_INVALID", `Hub partial path must be a safe relative path under .paseo/partials/: ${value}`);
-}
-function hasReadPermission(mode) {
-    return (mode & 0o444) !== 0;
-}
-function errorCode(error) {
-    if (typeof error !== "object" || error === null)
-        return undefined;
-    const code = Reflect.get(error, "code");
-    return typeof code === "string" ? code : undefined;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//# sourceMappingURL=deploy-input.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: paseo 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: paseo 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: paseo 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