@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/agent/wait.js

@@ -0,0 +1,158 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { fetchAgentTimelineItems, formatAgentActivityTranscript } from "./logs.js";
+import { parseDuration } from "../../utils/duration.js";
+/** Schema for agent wait output */
+export const agentWaitSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId", width: 12 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "MESSAGE", field: "message", width: 40 },
+    ],
+};
+const WAIT_ACTIVITY_PREVIEW_COUNT = 5;
+const WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS = 2000;
+function appendRecentActivity(message, transcript) {
+    if (!transcript || transcript.trim().length === 0) {
+        return message;
+    }
+    return `${message}\nLast ${WAIT_ACTIVITY_PREVIEW_COUNT} activity items:\n${transcript}`;
+}
+async function getRecentActivityTranscript(client, agentId) {
+    try {
+        const timelineItems = await fetchAgentTimelineItems(client, agentId, {
+            timeoutMs: WAIT_ACTIVITY_PREVIEW_TIMEOUT_MS,
+        });
+        return formatAgentActivityTranscript(timelineItems, WAIT_ACTIVITY_PREVIEW_COUNT);
+    }
+    catch {
+        return null;
+    }
+}
+function parseWaitTimeout(timeout) {
+    if (!timeout)
+        return { timeoutMs: 0, timeoutLabel: null };
+    try {
+        const ms = parseDuration(timeout);
+        if (ms <= 0) {
+            throw new Error("Timeout must be positive");
+        }
+        const timeoutSeconds = Math.floor(ms / 1000);
+        return {
+            timeoutMs: ms,
+            timeoutLabel: `${timeoutSeconds} second${timeoutSeconds === 1 ? "" : "s"}`,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw {
+            code: "INVALID_TIMEOUT",
+            message: "Invalid timeout value",
+            details: message,
+        };
+    }
+}
+function buildWaitResult(args) {
+    const { state, resolvedAgentId, recentActivity, timeoutLabel } = args;
+    if (state.status === "timeout") {
+        const timeoutMessage = timeoutLabel
+            ? `Agent did not finish within ${timeoutLabel}. Run \`paseo wait ${resolvedAgentId}\` again to keep waiting.`
+            : `Agent wait timed out. Run \`paseo wait ${resolvedAgentId}\` again to keep waiting.`;
+        return {
+            agentId: resolvedAgentId,
+            status: "timeout",
+            message: appendRecentActivity(timeoutMessage, recentActivity),
+        };
+    }
+    if (state.status === "permission") {
+        const permission = state.final?.pendingPermissions?.[0];
+        return {
+            agentId: resolvedAgentId,
+            status: "permission",
+            message: permission
+                ? `Agent is waiting for permission: ${permission.kind}`
+                : "Agent is waiting for permission",
+        };
+    }
+    if (state.status === "error") {
+        return {
+            agentId: resolvedAgentId,
+            status: "error",
+            message: state.error ?? "Agent finished with error",
+        };
+    }
+    return {
+        agentId: resolvedAgentId,
+        status: "idle",
+        message: appendRecentActivity("Agent is idle.", recentActivity),
+    };
+}
+export function addWaitOptions(cmd) {
+    return cmd
+        .description("Wait for an agent to become idle")
+        .argument("<id>", "Agent ID (or prefix)")
+        .option("--timeout <seconds>", "Maximum wait time (default: no limit)");
+}
+export async function runWaitCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        throw {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: paseo agent wait <id>",
+        };
+    }
+    const { timeoutMs, timeoutLabel } = parseWaitTimeout(options.timeout);
+    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: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        try {
+            const state = await client.waitForFinish(agentIdArg, timeoutMs);
+            const resolvedAgentId = state.final?.id ?? agentIdArg;
+            const recentActivity = state.status === "timeout" || state.status === "idle"
+                ? await getRecentActivityTranscript(client, resolvedAgentId)
+                : null;
+            await client.close();
+            return {
+                type: "single",
+                data: buildWaitResult({ state, resolvedAgentId, recentActivity, timeoutLabel }),
+                schema: agentWaitSchema,
+            };
+        }
+        catch (waitErr) {
+            await client.close().catch(() => { });
+            const waitMessage = waitErr instanceof Error ? waitErr.message : String(waitErr);
+            // Other errors
+            const error = {
+                code: "WAIT_FAILED",
+                message: `Failed to wait for agent: ${waitMessage}`,
+            };
+            throw error;
+        }
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WAIT_FAILED",
+            message: `Failed to wait for agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=wait.js.map

package/dist/commands/clone.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import type { OutputSchema, SingleResult } from "../output/index.js";
+import type { CommandOptions } from "../output/with-output.js";
+type CloneProtocol = "https" | "ssh";
+interface CloneCommandOptions extends CommandOptions {
+    protocol?: CloneProtocol;
+}
+export interface CloneResult {
+    repo: string;
+    checkoutPath: string;
+    projectId: string;
+    projectName: string;
+}
+export declare const cloneSchema: OutputSchema<CloneResult>;
+export declare function runCloneCommand(repo: string, options: CloneCommandOptions, _command: Command): Promise<SingleResult<CloneResult>>;
+export {};
+//# sourceMappingURL=clone.d.ts.map

package/dist/commands/clone.js

@@ -0,0 +1,65 @@
+import { isCompleteGitRemote } from "@camerontaylor/paseo-protocol/git-remote";
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../utils/client.js";
+export const cloneSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "REPO", field: "repo", width: 28 },
+        { header: "PROJECT", field: "projectName", width: 28 },
+        { header: "PATH", field: "checkoutPath", width: 56 },
+    ],
+};
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+export async function runCloneCommand(repo, options, _command) {
+    const targetDirectory = typeof options.dir === "string" ? options.dir.trim() : "";
+    if (!targetDirectory) {
+        throw cmdError("INVALID_ARGUMENT", "--dir is required");
+    }
+    const repoIsCompleteRemote = isCompleteGitRemote(repo);
+    if (!repoIsCompleteRemote && !options.protocol) {
+        throw cmdError("INVALID_ARGUMENT", "--protocol is required for owner/repo repository names");
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        throw buildDaemonConnectionCommandError({ host: options.host, error: err });
+    }
+    if (client.getLastServerInfoMessage()?.features?.projectGithubClone !== true) {
+        await client.close().catch(() => { });
+        throw cmdError("UNSUPPORTED_BY_HOST", "This daemon does not support cloning GitHub repos.", "Update the host to a newer Paseo version.");
+    }
+    try {
+        const response = await client.cloneGithubProject({
+            repo,
+            targetDirectory,
+            ...(repoIsCompleteRemote ? {} : { cloneProtocol: options.protocol }),
+        });
+        if (response.error || !response.project || !response.checkoutPath) {
+            throw cmdError("CLONE_FAILED", `Failed to clone GitHub repo: ${response.error ?? "no project returned"}`);
+        }
+        return {
+            type: "single",
+            data: {
+                repo: response.repo,
+                checkoutPath: response.checkoutPath,
+                projectId: response.project.projectId,
+                projectName: response.project.projectDisplayName,
+            },
+            schema: cloneSchema,
+        };
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("CLONE_FAILED", `Failed to clone GitHub repo: ${message}`);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=clone.js.map

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

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

package/dist/commands/daemon/index.js

@@ -0,0 +1,60 @@
+import { Command, Option } from "commander";
+import { startCommand } from "./start.js";
+import { runStatusCommand } from "./status.js";
+import { runStopCommand } from "./stop.js";
+import { runRestartCommand } from "./restart.js";
+import { runSetPasswordCommand } from "./set-password.js";
+import { pairCommand } from "./pair.js";
+import { runDaemonReloadCommand } from "./reload.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
+function resolveHostnamesOption(hostnames, allowedHosts) {
+    if (typeof hostnames === "string")
+        return hostnames;
+    if (typeof allowedHosts === "string")
+        return allowedHosts;
+    return undefined;
+}
+export function createDaemonCommand() {
+    const daemon = new Command("daemon").description("Manage the Paseo daemon");
+    daemon.addCommand(startCommand());
+    daemon.addCommand(pairCommand());
+    addJsonAndDaemonHostOptions(daemon.command("reload").description("Reload config.json without restarting the daemon")).action(withOutput(runDaemonReloadCommand));
+    addJsonOption(daemon.command("status").description("Show local daemon status"))
+        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+        .action(withOutput(runStatusCommand));
+    addJsonOption(daemon.command("stop").description("Stop the local daemon"))
+        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+        .option("--timeout <seconds>", "Wait timeout before failing (default: 15)")
+        .option("--force", "Send SIGKILL if graceful stop times out")
+        .option("--kill-timeout <seconds>", "Wait after SIGKILL before failing (default: 3)")
+        .action(withOutput(runStopCommand));
+    addJsonOption(daemon.command("restart").description("Restart the local daemon"))
+        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+        .option("--timeout <seconds>", "Wait timeout before force step (default: 15)")
+        .option("--force", "Send SIGKILL if graceful stop times out")
+        .option("--listen <listen>", "Listen target for restarted daemon (host:port, port, or unix socket)")
+        .option("--port <port>", "Port for restarted daemon listen target")
+        .option("--relay", "Enable relay on restarted daemon")
+        .option("--no-relay", "Disable relay on restarted daemon")
+        .option("--no-mcp", "Disable Agent MCP on restarted daemon")
+        .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
+        .option("--web-ui", "Enable the bundled daemon web UI on restarted daemon")
+        .option("--no-web-ui", "Disable the bundled daemon web UI on restarted daemon")
+        .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
+        .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
+        .action(withOutput((...args) => {
+        const [options, command] = args.slice(-2);
+        return runRestartCommand({
+            ...options,
+            hostnames: resolveHostnamesOption(options.hostnames, options.allowedHosts),
+        }, command);
+    }));
+    addJsonOption(daemon
+        .command("set-password")
+        .description("Prompt for and save a hashed daemon password to config.json"))
+        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+        .action(withOutput(runSetPasswordCommand));
+    return daemon;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/daemon/local-daemon.d.ts

@@ -0,0 +1,78 @@
+import { spawnSync, type ChildProcess } from "node:child_process";
+import { spawnProcess } from "@camerontaylor/paseo-server";
+export interface DaemonStartOptions {
+    port?: string;
+    listen?: string;
+    home?: string;
+    foreground?: boolean;
+    relay?: boolean;
+    relayUseTls?: boolean;
+    mcp?: boolean;
+    injectMcp?: boolean;
+    webUi?: boolean;
+    hostnames?: string;
+}
+export interface LocalDaemonPidInfo {
+    pid: number;
+    startedAt?: string;
+    hostname?: string;
+    uid?: number;
+    listen?: string;
+    desktopManaged?: boolean;
+}
+export interface LocalDaemonState {
+    home: string;
+    listen: string;
+    relayEnabled: boolean;
+    relayEndpoint: string;
+    relayUseTls: boolean;
+    relayPublicUseTls: boolean;
+    logPath: string;
+    pidPath: string;
+    pidInfo: LocalDaemonPidInfo | null;
+    running: boolean;
+    stalePidFile: boolean;
+}
+export interface DetachedStartResult {
+    pid: number | null;
+    logPath: string;
+}
+export interface StopLocalDaemonOptions {
+    home?: string;
+    timeoutMs?: number;
+    killTimeoutMs?: number;
+    force?: boolean;
+}
+export interface StopLocalDaemonResult {
+    action: "stopped" | "not_running";
+    home: string;
+    pid: number | null;
+    forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
+    message: string;
+}
+export interface DetachedDaemonProcess extends Pick<ChildProcess, "once" | "pid" | "unref"> {
+}
+export interface ForegroundDaemonProcessResult {
+    status: number | null;
+    error?: Error;
+}
+export interface DaemonLaunchRuntime {
+    resolveRunnerEntry(): string;
+    resolveHome(env: NodeJS.ProcessEnv): string;
+    spawnDetached(command: string, args: string[], options: Parameters<typeof spawnProcess>[2]): DetachedDaemonProcess;
+    spawnForeground(command: string, args: string[], options: Parameters<typeof spawnSync>[2]): ForegroundDaemonProcessResult;
+}
+export declare const DEFAULT_STOP_TIMEOUT_MS = 15000;
+export declare const DEFAULT_KILL_TIMEOUT_MS = 3000;
+export declare function resolveLocalPaseoHome(home?: string): string;
+export declare function resolveTcpHostFromListen(listen: string): string | null;
+export declare function resolveLocalDaemonState(options?: {
+    home?: string;
+}): LocalDaemonState;
+export declare function tailDaemonLog(home?: string, lines?: number): string | null;
+export declare function startLocalDaemonDetached(options: DaemonStartOptions, runtime?: DaemonLaunchRuntime): Promise<DetachedStartResult>;
+export declare function startLocalDaemonForeground(options: DaemonStartOptions, runtime?: DaemonLaunchRuntime): number;
+export declare function stopLocalDaemon(options?: StopLocalDaemonOptions): Promise<StopLocalDaemonResult>;
+//# sourceMappingURL=local-daemon.d.ts.map