@camerontaylor/paseo-cli 0.8.0-fork.1 → 0.8.0-fork.3

package/dist/commands/agent/stop.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { isSameOrDescendantPath } from "../../utils/paths.js";
 /** Schema for stop command output */
 export const stopSchema = {
@@ -14,7 +14,6 @@ export function addStopOptions(cmd) {
         .option("--cwd <path>", "Stop all agents in directory");
 }
 export async function runStopCommand(id, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments - need either an id, --all, or --cwd
     if (!id && !options.all && !options.cwd) {
         const error = {
@@ -24,19 +23,7 @@ export async function runStopCommand(id, options, _command) {
         };
         throw error;
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-        throw error;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchPayload = await client.fetchAgents({ filter: { includeArchived: true } });
         let agents = fetchPayload.entries.map((entry) => entry.agent);

package/dist/commands/agent/update.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 /** Schema for update command output */
 export const updateSchema = {
     idField: "agentId",
@@ -122,7 +122,6 @@ function parseAgentChanges(options) {
     };
 }
 export async function runUpdateCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!agentIdArg || agentIdArg.trim().length === 0) {
         const error = {
@@ -133,19 +132,7 @@ export async function runUpdateCommand(agentIdArg, options, _command) {
         throw error;
     }
     const changes = parseAgentChanges(options);
-    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;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: agentIdArg });
         if (!fetchResult) {

package/dist/commands/agent/wait.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { fetchAgentTimelineItems, formatAgentActivityTranscript } from "./logs.js";
 import { parseDuration } from "../../utils/duration.js";
 /** Schema for agent wait output */
@@ -44,6 +44,8 @@ function parseWaitTimeout(timeout) {
         };
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         throw {
             code: "INVALID_TIMEOUT",
@@ -94,7 +96,6 @@ export function addWaitOptions(cmd) {
         .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",
@@ -103,19 +104,7 @@ export async function runWaitCommand(agentIdArg, options, _command) {
         };
     }
     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;
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         try {
             const state = await client.waitForFinish(agentIdArg, timeoutMs);

package/dist/commands/clone.js

@@ -1,5 +1,5 @@
 import { isCompleteGitRemote } from "@camerontaylor/paseo-protocol/git-remote";
-import { buildDaemonConnectionCommandError, connectToDaemon } from "../utils/client.js";
+import { connectToDaemon } from "../utils/client.js";
 export const cloneSchema = {
     idField: "projectId",
     columns: [
@@ -20,13 +20,7 @@ export async function runCloneCommand(repo, options, _command) {
     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 });
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     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.");

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

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

package/dist/commands/daemon/config.js

@@ -0,0 +1,102 @@
+import { addLocalDaemonOptions } from "../../utils/command-options.js";
+import { Command } from "commander";
+import { readDaemonInstance, readPersistedConfig, getPersistedConfigValue, editPersistedConfig, } from "@camerontaylor/paseo-server";
+import { connectToDaemon } from "../../utils/client.js";
+import { withOutput } from "../../output/index.js";
+function redact(value) {
+    if (Array.isArray(value))
+        return value.map(redact);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        /password|(?:api|private|access)[_-]?key|token|secret|authorization/i.test(key)
+            ? "[redacted]"
+            : redact(item),
+    ]));
+}
+function result(data) {
+    return {
+        type: "single",
+        data,
+        schema: {
+            idField: () => "configuration",
+            columns: [],
+            renderHuman: () => JSON.stringify(data, null, 2),
+        },
+    };
+}
+function homeOf(options) {
+    if (options.daemonTarget.kind !== "instance")
+        throw new Error("Configuration edits require --home");
+    return options.daemonTarget.home;
+}
+async function applySaved(home, options) {
+    const nextCommand = `paseo daemon start --home ${JSON.stringify(home)}`;
+    const instance = await readDaemonInstance(home);
+    if (!instance?.listen)
+        return result({
+            action: "saved",
+            applied: false,
+            message: "Saved; not applied to a running daemon",
+            nextCommand,
+        });
+    let client;
+    try {
+        client = await connectToDaemon({ target: options.daemonTarget, timeout: 1500 });
+    }
+    catch {
+        return result({
+            action: "saved",
+            applied: false,
+            message: "Saved; not applied to a running daemon",
+            nextCommand: `paseo daemon reload --home ${JSON.stringify(home)}`,
+        });
+    }
+    try {
+        const reload = await client.reloadDaemonConfig();
+        return result({ action: "saved", ...reload });
+    }
+    catch (error) {
+        throw { code: "CONFIG_SAVED_RELOAD_FAILED", message: `Saved; reload failed: ${String(error)}` };
+    }
+    finally {
+        await client.close();
+    }
+}
+export function daemonConfigCommand() {
+    const config = new Command("config").description("Read or edit persistent local configuration (local operation)");
+    addLocalDaemonOptions(config.command("get [path]")).action(withOutput(async (field, options, _command) => {
+        const persisted = readPersistedConfig(homeOf(options));
+        const value = field ? getPersistedConfigValue(persisted, field) : persisted;
+        return result({
+            source: "configured",
+            path: field ?? null,
+            set: value !== undefined,
+            value: field && /password|(?:api|private|access)[_-]?key|token|secret|authorization/i.test(field)
+                ? "[redacted]"
+                : redact(value),
+        });
+    }));
+    addLocalDaemonOptions(config.command("set <path> <value>"))
+        .option("--string", "Interpret value literally as a string")
+        .action(withOutput(async (field, raw, options, _command) => {
+        let value = raw;
+        if (!options.string) {
+            try {
+                value = JSON.parse(raw);
+            }
+            catch {
+                /* Unquoted input is a string. */
+            }
+        }
+        editPersistedConfig(homeOf(options), field, { value });
+        return applySaved(homeOf(options), options);
+    }));
+    addLocalDaemonOptions(config.command("unset <path>")).action(withOutput(async (field, options, _command) => {
+        editPersistedConfig(homeOf(options), field, { unset: true });
+        return applySaved(homeOf(options), options);
+    }));
+    return config;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/daemon/index.js

@@ -1,60 +1,28 @@
-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 { Command } from "commander";
+import { startCommand, daemonRunCommand } from "./start.js";
+import { daemonStatusCommand } from "./status.js";
+import { daemonStopCommand } from "./stop.js";
+import { daemonRestartCommand } from "./restart.js";
 import { runSetPasswordCommand } from "./set-password.js";
 import { pairCommand } from "./pair.js";
-import { runDaemonReloadCommand } from "./reload.js";
+import { daemonReloadCommand } from "./reload.js";
+import { daemonConfigCommand } from "./config.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;
-}
+import { addJsonOption, addLocalDaemonOptions } from "../../utils/command-options.js";
 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));
+    for (const command of [
+        startCommand(),
+        daemonRunCommand(),
+        daemonStatusCommand(),
+        daemonStopCommand(),
+        daemonRestartCommand(),
+        daemonReloadCommand(),
+        pairCommand(),
+        daemonConfigCommand(),
+    ])
+        daemon.addCommand(command);
+    addJsonOption(addLocalDaemonOptions(daemon.command("set-password").description("Save a hashed daemon password (local operation)"))).action(withOutput(runSetPasswordCommand));
     return daemon;
 }
 //# sourceMappingURL=index.js.map

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

@@ -1,78 +1,13 @@
-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 {
+import { Command } from "commander";
+export declare function launchLocalDaemon(options: {
     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>;
+    foreground?: boolean;
+}): Promise<{
+    instance: import("@camerontaylor/paseo-server").DaemonInstance;
+    spawned: boolean;
+    exitCode?: number;
+}>;
+export declare function parseTimeoutMs(raw: unknown, fallback?: number): number;
+export declare function rejectRemovedLaunchFlags(command: Command): Command;
 //# sourceMappingURL=local-daemon.d.ts.map