@getpaseo/cli 0.3.0 → 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 { HubDeployError } 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 HubDeployError("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 HubDeployError("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 HubDeployError("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 HubDeployError("HUB_CONFIGURATION_NOT_FILE", `Hub configuration at ${displayPath} must be a regular file.`);
-    }
-    if (!hasReadPermission(stats.mode)) {
-        throw new HubDeployError("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 HubDeployError("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 HubDeployError("HUB_INVALID_CONFIGURATION", "Hub configuration is not valid YAML.");
-    }
-    if (!isRecord(configuration)) {
-        throw new HubDeployError("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 HubDeployError("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 HubDeployError("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 HubDeployError("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 HubDeployError("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 HubDeployError("HUB_PARTIAL_PATH_INVALID", "Hub partial include path must be a string.");
-                }
-                const normalizedPath = normalizePromptPartialPath(include);
-                if (seen.has(normalizedPath)) {
-                    throw new HubDeployError("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 HubDeployError("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 HubDeployError("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 HubDeployError("HUB_PARTIAL_MISSING", `Referenced Hub partial ${displayPath} does not exist.`);
-        }
-        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
-    }
-    if (stats.isSymbolicLink()) {
-        throw new HubDeployError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not be a symlink.`);
-    }
-    if (!stats.isFile()) {
-        throw new HubDeployError("HUB_PARTIAL_NOT_FILE", `Referenced Hub partial ${displayPath} must be a regular file.`);
-    }
-    if (!hasReadPermission(stats.mode)) {
-        throw new HubDeployError("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 HubDeployError("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 HubDeployError)
-                throw failure;
-            if (errorCode(failure) === "ENOENT")
-                return;
-            throw error();
-        }
-    }
-}
-function configurationReadError(displayPath, error) {
-    if (errorCode(error) === "ENOENT") {
-        return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Pass an existing YAML file.`);
-    }
-    return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check the file and permissions.`);
-}
-function invalidConfigurationPath() {
-    return new HubDeployError("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 HubDeployError("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/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: 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