@camerontaylor/paseo-cli 0.8.0-fork.1 → 0.9.0-beta.2.fork.1

package/dist/utils/client.d.ts

@@ -1,14 +1,13 @@
+import { type DaemonInstance } from "@camerontaylor/paseo-server/daemon-control";
+import { type DaemonTarget } from "./daemon-target.js";
+export type { DaemonTarget } from "./daemon-target.js";
 import { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
 export interface ConnectOptions {
-    host?: string;
+    target: DaemonTarget;
     timeout?: number;
+    instance?: DaemonInstance;
 }
-export interface DaemonConnectionCommandError {
-    code: "DAEMON_NOT_RUNNING";
-    message: string;
-    details: string;
-}
-type DaemonTarget = {
+type TransportTarget = {
     type: "tcp";
     url: string;
 } | {
@@ -16,25 +15,22 @@ type DaemonTarget = {
     url: string;
     socketPath: string;
 };
-/**
- * Get the daemon host from environment or options
- */
-export declare function getDaemonHost(options?: ConnectOptions): string;
-export declare function buildDaemonConnectionCommandError(options: {
-    host?: string;
+export declare function getDaemonHost(options: ConnectOptions): string;
+export declare function buildDaemonConnectionCommandError(options: ConnectOptions & {
     error: unknown;
-}): DaemonConnectionCommandError;
+}): {
+    code: string;
+    message: string;
+    details: string;
+};
 export declare function normalizeDaemonHost(raw: string): string | null;
-export declare function resolveDefaultDaemonHost(env?: NodeJS.ProcessEnv): string;
-export declare function resolveDefaultDaemonHosts(env?: NodeJS.ProcessEnv): string[];
-export declare function getExplicitDaemonHost(host: string | undefined, env?: NodeJS.ProcessEnv): string | undefined;
-export declare function resolveDaemonTarget(host: string): DaemonTarget;
+export declare function resolveDaemonTarget(host: string): TransportTarget;
 export declare function resolveDaemonPassword(host: string): string | undefined;
-export declare function connectToDaemon(options?: ConnectOptions): Promise<DaemonClient>;
+export declare function connectToDaemon(options: ConnectOptions): Promise<DaemonClient>;
 /**
  * Try to connect to the daemon, returns null if connection fails
  */
-export declare function tryConnectToDaemon(options?: ConnectOptions): Promise<DaemonClient | null>;
+export declare function tryConnectToDaemon(options: ConnectOptions): Promise<DaemonClient | null>;
 /** Minimal agent type for ID resolution */
 interface AgentLike {
     id: string;
@@ -50,5 +46,4 @@ interface AgentLike {
  * Returns the full agent ID if found, null otherwise.
  */
 export declare function resolveAgentId(idOrName: string, agents: AgentLike[]): string | null;
-export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/utils/client.js

@@ -1,32 +1,39 @@
-import { existsSync, readFileSync } from "node:fs";
-import { loadConfig, resolvePaseoHome } from "@camerontaylor/paseo-server";
+import { waitForDaemonReady, resolvePaseoHome, } from "@camerontaylor/paseo-server/daemon-control";
+import { describeDaemonTarget } from "./daemon-target.js";
 import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@camerontaylor/paseo-protocol/daemon-endpoints";
 import { parseConnectionOfferFromUrl, } from "@camerontaylor/paseo-protocol/connection-offer";
 import { parseSshTransportUri } from "@camerontaylor/paseo-protocol/ssh-transport";
 import { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
-import path from "node:path";
 import { WebSocket } from "ws";
 import { getOrCreateCliClientId } from "./client-id.js";
 import { resolveCliVersion } from "../version.js";
 import { createSshTunnel } from "../ssh/ssh-tunnel.js";
-const DEFAULT_HOST = "localhost:6767";
 const DEFAULT_TIMEOUT = 15000;
-const PID_FILENAME = "paseo.pid";
-/**
- * Get the daemon host from environment or options
- */
 export function getDaemonHost(options) {
-    return resolveDaemonHostCandidates(options)[0] ?? DEFAULT_HOST;
+    return describeDaemonTarget(options.target);
 }
 export function buildDaemonConnectionCommandError(options) {
-    const host = getDaemonHost({ host: options.host });
-    const message = options.error instanceof Error ? options.error.message : String(options.error);
+    const error = options.error;
+    let message = error instanceof Error ? error.message : String(error);
+    if (error && typeof error === "object" && "message" in error)
+        message = String(error.message);
+    if (options.target.kind === "endpoint")
+        message = message.replaceAll(options.target.host, describeDaemonTarget(options.target));
+    if (message.startsWith("Cannot connect to daemon at "))
+        return error;
+    let code = "DAEMON_UNREACHABLE";
+    if (typeof error === "object" && error !== null && "code" in error)
+        code = String(error.code);
+    else if (message === "Password required")
+        code = "AUTH_REQUIRED";
+    else if (message === "Incorrect password")
+        code = "AUTH_FAILED";
     return {
-        code: "DAEMON_NOT_RUNNING",
-        message: `Cannot connect to daemon at ${host}: ${message}`,
-        details: host.trim().startsWith("ssh://")
-            ? "Start the Paseo daemon on the SSH host; SSH transport does not install or start it."
-            : "Start the daemon with: paseo daemon start",
+        code,
+        message: `Cannot connect to daemon at ${describeDaemonTarget(options.target)}: ${message}`,
+        details: options.target.kind === "instance"
+            ? `Start with: paseo daemon start --home ${JSON.stringify(options.target.home)}`
+            : "Check the selected endpoint and credentials. SSH transport does not install or start the daemon.",
     };
 }
 export function normalizeDaemonHost(raw) {
@@ -70,77 +77,6 @@ export function normalizeDaemonHost(raw) {
     }
     return trimmed.includes(":") ? trimmed : null;
 }
-export function resolveDefaultDaemonHost(env = process.env) {
-    return resolveDefaultDaemonHosts(env)[0] ?? DEFAULT_HOST;
-}
-function isIpcDaemonHost(host) {
-    return host !== null && (host.startsWith("unix://") || host.startsWith("pipe://"));
-}
-function isTcpDaemonHost(host) {
-    return host !== null && !isIpcDaemonHost(host);
-}
-function readPidSocketTarget(paseoHome) {
-    const pidPath = path.join(paseoHome, PID_FILENAME);
-    if (!existsSync(pidPath)) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(readFileSync(pidPath, "utf-8"));
-        if (typeof parsed.listen === "string")
-            return parsed.listen;
-        if (typeof parsed.sockPath === "string")
-            return parsed.sockPath;
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function resolveConfiguredIpcDaemonHost(env, paseoHome) {
-    const directEnvHost = normalizeDaemonHost(env.PASEO_LISTEN ?? "");
-    if (isIpcDaemonHost(directEnvHost)) {
-        return directEnvHost;
-    }
-    const pidHost = normalizeDaemonHost(readPidSocketTarget(paseoHome) ?? "");
-    if (isIpcDaemonHost(pidHost)) {
-        return pidHost;
-    }
-    const config = loadConfig(paseoHome, { env });
-    const configuredHost = normalizeDaemonHost(config.listen);
-    return isIpcDaemonHost(configuredHost) ? configuredHost : null;
-}
-function resolveConfiguredTcpDaemonHost(env, paseoHome) {
-    const configuredHost = normalizeDaemonHost(loadConfig(paseoHome, { env }).listen);
-    if (!isTcpDaemonHost(configuredHost)) {
-        return null;
-    }
-    return configuredHost === "127.0.0.1:6767" ? null : configuredHost;
-}
-export function resolveDefaultDaemonHosts(env = process.env) {
-    const paseoHome = resolvePaseoHome(env);
-    const candidates = [];
-    const configuredIpcHost = resolveConfiguredIpcDaemonHost(env, paseoHome);
-    if (configuredIpcHost) {
-        candidates.push(configuredIpcHost);
-    }
-    const configuredTcpHost = resolveConfiguredTcpDaemonHost(env, paseoHome);
-    if (configuredTcpHost) {
-        candidates.push(configuredTcpHost);
-    }
-    candidates.push(DEFAULT_HOST);
-    return Array.from(new Set(candidates));
-}
-function resolveDaemonHostCandidates(options) {
-    const explicitHost = getExplicitDaemonHost(options?.host);
-    if (explicitHost) {
-        return [explicitHost];
-    }
-    return resolveDefaultDaemonHosts();
-}
-export function getExplicitDaemonHost(host, env = process.env) {
-    const explicitHost = host ?? env.PASEO_HOST;
-    return explicitHost?.trim() ? explicitHost : undefined;
-}
 function stripIpcPrefix(trimmed) {
     if (trimmed.startsWith("unix://"))
         return trimmed.slice("unix://".length).trim();
@@ -269,18 +205,34 @@ function parseHostOfferOrNull(host) {
         throw new Error(`Invalid pairing offer URL: ${message}`, { cause: error });
     }
 }
-export async function connectToDaemon(options) {
-    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-    const clientId = await getOrCreateCliClientId();
+async function connectSelectedDaemon(options) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const deadline = Date.now() + timeout;
+    const explicitHost = options.target.kind === "endpoint"
+        ? options.target.host
+        : (await waitForDaemonReady(options.target.home, {
+            timeoutMs: timeout,
+            instance: options.instance,
+        })).listen;
+    const clientId = await getOrCreateCliClientId(resolvePaseoHome({}));
     const nodeWebSocketFactory = createNodeWebSocketFactory();
-    const explicitHost = getExplicitDaemonHost(options?.host);
     if (explicitHost?.trim().startsWith("ssh://")) {
         const target = parseSshTransportUri(explicitHost.trim());
         const tunnel = await createSshTunnel(target);
         const password = resolveDaemonPassword(explicitHost);
-        const result = await tryConnectHost(tunnel.endpoint, password, clientId, timeout, nodeWebSocketFactory);
-        if ("client" in result)
+        const result = await tryConnectHost(tunnel.endpoint, password, clientId, Math.max(1, deadline - Date.now()), nodeWebSocketFactory);
+        if ("client" in result) {
+            const close = result.client.close.bind(result.client);
+            result.client.close = async () => {
+                try {
+                    await close();
+                }
+                finally {
+                    tunnel.close();
+                }
+            };
             return result.client;
+        }
         const failure = tunnel.failureDetail();
         tunnel.close();
         if (failure)
@@ -289,24 +241,20 @@ export async function connectToDaemon(options) {
     }
     const offer = parseHostOfferOrNull(explicitHost);
     if (offer) {
-        return connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory);
+        return connectViaRelayOffer(offer, clientId, Math.max(1, deadline - Date.now()), nodeWebSocketFactory);
     }
-    const hosts = resolveDaemonHostCandidates(options);
-    async function tryNext(index, lastError) {
-        if (index >= hosts.length) {
-            if (lastError instanceof Error)
-                throw lastError;
-            throw new Error(`Unable to connect to Paseo daemon via ${hosts.join(", ")}`);
-        }
-        const host = hosts[index];
-        const password = resolveDaemonPassword(host);
-        const result = await tryConnectHost(host, password, clientId, timeout, nodeWebSocketFactory);
-        if ("client" in result) {
-            return result.client;
-        }
-        return tryNext(index + 1, result.error);
+    const result = await tryConnectHost(explicitHost, resolveDaemonPassword(explicitHost), clientId, Math.max(1, deadline - Date.now()), nodeWebSocketFactory);
+    if ("client" in result)
+        return result.client;
+    throw result.error;
+}
+export async function connectToDaemon(options) {
+    try {
+        return await connectSelectedDaemon(options);
+    }
+    catch (error) {
+        throw buildDaemonConnectionCommandError({ ...options, error });
     }
-    return tryNext(0, null);
 }
 /**
  * Try to connect to the daemon, returns null if connection fails

package/dist/utils/command-options.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from "commander";
+export declare function addLocalDaemonOptions<T extends Command>(command: T): T;
 export declare function collectMultiple(value: string, previous: string[]): string[];
 export declare function addJsonOption<T extends Command>(command: T): T;
 export declare function addDaemonHostOption<T extends Command>(command: T): T;

package/dist/utils/command-options.js

@@ -1,5 +1,12 @@
+import { selectDaemonTarget } from "./daemon-target.js";
 const JSON_OPTION_DESCRIPTION = "Output in JSON format";
-const DAEMON_HOST_OPTION_DESCRIPTION = "Daemon host target: host:port, tcp://host:port, or ssh://user@host (default: local socket/pipe, then localhost:6767)";
+const DAEMON_HOST_OPTION_DESCRIPTION = "Explicit daemon endpoint: host:port, TCP, socket, SSH, or pairing URL (default: local home)";
+const localCommands = new WeakSet();
+export function addLocalDaemonOptions(command) {
+    localCommands.add(command);
+    command.option("--home <path>", "Local daemon home (default: ~/.paseo)");
+    return command;
+}
 export function collectMultiple(value, previous) {
     return previous.concat([value]);
 }
@@ -9,6 +16,8 @@ export function addJsonOption(command) {
 }
 export function addDaemonHostOption(command) {
     command.option("--host <host>", DAEMON_HOST_OPTION_DESCRIPTION);
+    if (!command.options.some((option) => option.long === "--home"))
+        command.option("--home <path>", "Select a local daemon home (default: ~/.paseo)");
     return command;
 }
 export function addJsonAndDaemonHostOptions(command) {
@@ -18,7 +27,22 @@ export function withGlobalOptions(handler) {
     return (...args) => {
         const command = args.at(-1);
         const mergedArgs = [...args];
-        mergedArgs[mergedArgs.length - 2] = command.optsWithGlobals();
+        const options = command.optsWithGlobals();
+        const selectors = { home: new Set(), host: new Set() };
+        for (let current = command; current; current = current.parent) {
+            for (const key of ["home", "host"]) {
+                const value = current.opts()[key];
+                if (typeof value === "string")
+                    selectors[key].add(value);
+            }
+        }
+        for (const key of ["home", "host"]) {
+            if (selectors[key].size > 1)
+                throw { code: "TARGET_AMBIGUOUS", message: `Conflicting duplicate --${key} selectors.` };
+        }
+        const localOnly = localCommands.has(command);
+        options.daemonTarget = selectDaemonTarget(options, process.env, localOnly);
+        mergedArgs[mergedArgs.length - 2] = options;
         return handler(...mergedArgs);
     };
 }

package/dist/utils/daemon-target.d.ts

@@ -0,0 +1,13 @@
+export type DaemonTarget = {
+    kind: "instance";
+    home: string;
+} | {
+    kind: "endpoint";
+    host: string;
+};
+export declare function selectDaemonTarget(options: {
+    home?: string;
+    host?: string;
+}, env?: NodeJS.ProcessEnv, localOnly?: boolean): DaemonTarget;
+export declare function describeDaemonTarget(target: DaemonTarget): string;
+//# sourceMappingURL=daemon-target.d.ts.map

package/dist/utils/daemon-target.js

@@ -0,0 +1,51 @@
+import { resolvePaseoHome } from "@camerontaylor/paseo-server/daemon-control";
+export function selectDaemonTarget(options, env = process.env, localOnly = false) {
+    for (const key of ["home", "host"]) {
+        if (options[key] !== undefined && !options[key].trim())
+            throw { code: "TARGET_INVALID", message: `--${key} requires a non-empty value.` };
+    }
+    if (options.home !== undefined && options.host !== undefined)
+        throw { code: "TARGET_AMBIGUOUS", message: "Choose either --home or --host, not both." };
+    if (localOnly) {
+        if (options.host !== undefined)
+            throw {
+                code: "LOCAL_OPERATION",
+                message: "This is a local operation; use --home. --host is not supported.",
+            };
+        return {
+            kind: "instance",
+            home: resolvePaseoHome({ PASEO_HOME: options.home ?? env.PASEO_HOME }),
+        };
+    }
+    if (options.home !== undefined)
+        return { kind: "instance", home: resolvePaseoHome({ PASEO_HOME: options.home }) };
+    if (options.host !== undefined)
+        return { kind: "endpoint", host: options.host };
+    if (env.PASEO_HOME && env.PASEO_HOST)
+        throw {
+            code: "TARGET_AMBIGUOUS",
+            message: "PASEO_HOME and PASEO_HOST are both set. Choose --home or --host explicitly.",
+        };
+    if (env.PASEO_HOST)
+        return { kind: "endpoint", host: env.PASEO_HOST };
+    return { kind: "instance", home: resolvePaseoHome({ PASEO_HOME: env.PASEO_HOME }) };
+}
+export function describeDaemonTarget(target) {
+    if (target.kind === "instance")
+        return `home ${target.home}`;
+    try {
+        const url = new URL(target.host);
+        if (url.password)
+            url.password = "REDACTED";
+        for (const key of url.searchParams.keys())
+            if (/password|token|secret/i.test(key))
+                url.searchParams.set(key, "REDACTED");
+        if (url.hash)
+            url.hash = "REDACTED";
+        return url.toString();
+    }
+    catch {
+        return target.host.replace(/([?&](?:password|token|secret)=)[^&]*/gi, "$1REDACTED");
+    }
+}
+//# sourceMappingURL=daemon-target.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-cli",
-  "version": "0.8.0-fork.1",
+  "version": "0.9.0-beta.2.fork.1",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@camerontaylor/paseo-client": "0.8.0-fork.1",
-    "@camerontaylor/paseo-protocol": "0.8.0-fork.1",
-    "@camerontaylor/paseo-server": "0.8.0-fork.1",
+    "@camerontaylor/paseo-client": "0.9.0-beta.2.fork.1",
+    "@camerontaylor/paseo-protocol": "0.9.0-beta.2.fork.1",
+    "@camerontaylor/paseo-server": "0.9.0-beta.2.fork.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",
@@ -46,5 +46,9 @@
     "typescript": "^5.2.2",
     "vitest": "^4.1.6",
     "zx": "^8.8.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camerontaylor/paseo"
   }
 }