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

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { pairCommand } from "./commands/daemon/pair.js";
 import { Command, Option } from "commander";
 import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
@@ -15,9 +16,9 @@ import { createHeartbeatCommand } from "./commands/heartbeat/index.js";
 import { createHubCommand } from "./commands/hub/index.js";
 import { createHooksCommand } from "./commands/hooks.js";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
-import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
-import { runRestartCommand as runDaemonRestartCommand } from "./commands/daemon/restart.js";
-import { runDaemonReloadCommand } from "./commands/daemon/reload.js";
+import { daemonStatusCommand } from "./commands/daemon/status.js";
+import { daemonRestartCommand } from "./commands/daemon/restart.js";
+import { daemonReloadCommand } from "./commands/daemon/reload.js";
 import { addLsOptions, runLsCommand } from "./commands/agent/ls.js";
 import { addRunOptions, runRunCommand } from "./commands/agent/run.js";
 import { addLogsOptions, runLogsCommand } from "./commands/agent/logs.js";
@@ -32,16 +33,9 @@ import { addImportOptions, runImportCommand } from "./commands/agent/import.js";
 import { withOutput } from "./output/index.js";
 import { runCloneCommand } from "./commands/clone.js";
 import { onboardCommand } from "./commands/onboard.js";
-import { addDaemonHostOption, addJsonAndDaemonHostOptions, addJsonOption, withGlobalOptions, } from "./utils/command-options.js";
+import { addDaemonHostOption, addJsonAndDaemonHostOptions, withGlobalOptions, } from "./utils/command-options.js";
 import { resolveCliVersion } from "./version.js";
 const VERSION = resolveCliVersion();
-function resolveHostnamesOption(hostnames, allowedHosts) {
-    if (typeof hostnames === "string")
-        return hostnames;
-    if (typeof allowedHosts === "string")
-        return allowedHosts;
-    return undefined;
-}
 export function createCli() {
     const program = new Command();
     program
@@ -78,32 +72,10 @@ export function createCli() {
     program.addCommand(onboardCommand());
     program.addCommand(daemonStartCommand());
     program.addCommand(createHooksCommand());
-    addJsonOption(program
-        .command("status")
-        .description('Show local daemon status (alias for "paseo daemon status")'))
-        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
-        .action(withOutput(runDaemonStatusCommand));
-    addJsonAndDaemonHostOptions(program.command("reload").description('Reload daemon config (alias for "paseo daemon reload")')).action(withOutput(runDaemonReloadCommand));
-    addJsonOption(program
-        .command("restart")
-        .description('Restart local daemon (alias for "paseo daemon restart")'))
-        .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("--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 runDaemonRestartCommand({
-            ...options,
-            hostnames: resolveHostnamesOption(options.hostnames, options.allowedHosts),
-        }, command);
-    }));
+    program.addCommand(daemonStatusCommand());
+    program.addCommand(daemonRestartCommand());
+    program.addCommand(daemonReloadCommand());
+    program.addCommand(pairCommand());
     // Advanced agent commands (less common operations)
     program.addCommand(createAgentCommand());
     // Daemon commands
@@ -130,6 +102,22 @@ export function createCli() {
     // COMPAT(worktreeCli): legacy command alias added before workspace was the product unit.
     // Added in v0.2.0; remove after 2027-01-17.
     program.addCommand(createWorktreeCommand(), { hidden: true });
+    const enforceSelectorDuplicates = (command) => {
+        for (const option of command.options) {
+            if (option.long !== "--home" && option.long !== "--host")
+                continue;
+            option.argParser((value, previous) => {
+                if (previous !== undefined && previous !== value)
+                    throw {
+                        code: "TARGET_AMBIGUOUS",
+                        message: `Conflicting duplicate ${option.long} selectors.`,
+                    };
+                return value;
+            });
+        }
+        command.commands.forEach(enforceSelectorDuplicates);
+    };
+    enforceSelectorDuplicates(program);
     return program;
 }
 //# sourceMappingURL=cli.js.map

package/dist/commands/agent/archive.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+import { connectToDaemon, resolveAgentId } from "../../utils/client.js";
 /** Schema for archive command output */
 export const archiveSchema = {
     idField: "agentId",
@@ -15,7 +15,6 @@ export function addArchiveOptions(cmd) {
         .option("--force", "Force archive running agent (interrupts active run first)");
 }
 export async function runArchiveCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!agentIdArg || agentIdArg.trim().length === 0) {
         const error = {
@@ -25,19 +24,7 @@ export async function runArchiveCommand(agentIdArg, 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 agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
         const agents = agentsPayload.entries.map((entry) => entry.agent);

package/dist/commands/agent/attach.d.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 export declare function addAttachOptions(cmd: Command): Command;
 export interface AgentAttachOptions {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     [key: string]: unknown;
 }
 /**

package/dist/commands/agent/attach.js

@@ -3,7 +3,7 @@ export function addAttachOptions(cmd) {
         .description("Attach to a running agent's output stream")
         .argument("<id>", "Agent ID (or prefix)");
 }
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
 /**
  * Format and print a timeline item to the terminal
@@ -74,22 +74,12 @@ function printStreamEvent(event) {
  * Attach to a running agent's output stream
  */
 export async function runAttachCommand(id, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     if (!id) {
         console.error("Error: Agent ID required");
         console.error("Usage: paseo attach <id>");
         process.exit(1);
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
-        console.error("Start the daemon with: paseo daemon start");
-        process.exit(1);
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
@@ -121,6 +111,12 @@ export async function runAttachCommand(id, options, _command) {
             if (message.type === "agent.timeline.replacement") {
                 console.log("\n[Timeline replaced; earlier output is no longer current]");
             }
+            else if (message.type === "agent.timeline.subscription_restored") {
+                console.log("\n[Reconnected; live output resumed. Events may have been missed.]");
+            }
+            else if (message.type === "agent.timeline.error") {
+                console.error(`Timeline observation stopped: ${message.payload.error}`);
+            }
             else {
                 printStreamEvent(message.payload.event);
             }

package/dist/commands/agent/delete.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { isSameOrDescendantPath } from "../../utils/paths.js";
 export function addDeleteOptions(cmd) {
     return cmd
@@ -12,7 +12,6 @@ export const deleteSchema = {
     columns: [{ header: "DELETED", field: "deletedCount" }],
 };
 export async function runDeleteCommand(id, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     if (!id && !options.all && !options.cwd) {
         const error = {
             code: "MISSING_ARGUMENT",
@@ -21,19 +20,7 @@ export async function runDeleteCommand(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);
@@ -69,6 +56,8 @@ export async function runDeleteCommand(id, options, _command) {
                 return { ok: true, id: agent.id };
             }
             catch (err) {
+                if (err && typeof err === "object" && "code" in err)
+                    throw err;
                 const message = err instanceof Error ? err.message : String(err);
                 return { ok: false, id: agent.id, message };
             }

package/dist/commands/agent/detach.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+import { connectToDaemon, resolveAgentId } from "../../utils/client.js";
 const detachSchema = {
     idField: "agentId",
     columns: [
@@ -7,18 +7,7 @@ const detachSchema = {
     ],
 };
 export async function runDetachCommand(agentIdArg, 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}`,
-        };
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const payload = await client.fetchAgents({ filter: { includeArchived: true } });
         const agentId = resolveAgentId(agentIdArg, payload.entries.map((entry) => entry.agent));

package/dist/commands/agent/import.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { collectMultiple } from "../../utils/command-options.js";
 import { agentRunSchema } from "./run.js";
 export function addImportOptions(cmd) {
@@ -66,21 +66,7 @@ export function resolveImportCwd(explicitCwd, defaultCwd) {
     }
     return cwd;
 }
-async function connectToDaemonOrThrow(hostOption, host) {
-    try {
-        return await connectToDaemon({ host: hostOption });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-    }
-}
 export async function runImportCommand(sessionIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     const sessionId = sessionIdArg.trim();
     if (!sessionId) {
         throw {
@@ -92,7 +78,7 @@ export async function runImportCommand(sessionIdArg, options, _command) {
     const provider = parseImportProvider(options.provider);
     const cwd = resolveImportCwd(options.cwd, process.cwd());
     const labels = parseImportLabels(options.label);
-    const client = await connectToDaemonOrThrow(options.host, host);
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const agent = await client.importAgent({
             provider,

package/dist/commands/agent/inspect.js

@@ -1,5 +1,5 @@
 import { PARENT_AGENT_ID_LABEL } from "@camerontaylor/paseo-protocol/agent-labels";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 export function addInspectOptions(cmd) {
     return cmd
         .description("Show detailed information about an agent")
@@ -151,7 +151,6 @@ function toInspectRows(agent) {
     return rows;
 }
 export async function runInspectCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!agentIdArg || agentIdArg.trim().length === 0) {
         const error = {
@@ -161,19 +160,7 @@ export async function runInspectCommand(agentIdArg, 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 fetchResult = await client.fetchAgent({ agentId: agentIdArg });
         if (!fetchResult) {

package/dist/commands/agent/logs.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
 import { curateAgentActivity } from "@camerontaylor/paseo-server";
 export function addLogsOptions(cmd) {
@@ -53,22 +53,12 @@ function matchesFilter(item, filter) {
     }
 }
 export async function runLogsCommand(id, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     if (!id) {
         console.error("Error: Agent ID required");
         console.error("Usage: paseo agent logs <id>");
         process.exit(1);
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
-        console.error("Start the daemon with: paseo daemon start");
-        process.exit(1);
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
@@ -111,6 +101,8 @@ export async function runLogsCommand(id, options, _command) {
         console.log(transcript);
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         console.error(`Error: Failed to get logs: ${message}`);
         await client.close().catch(() => { });
@@ -151,6 +143,14 @@ async function runFollowMode(client, agentId, options) {
             console.log("\n[Timeline replaced; earlier output is no longer current]");
             return;
         }
+        if (message.type === "agent.timeline.error") {
+            console.error(`Timeline observation stopped: ${message.payload.error}`);
+            return;
+        }
+        if (message.type === "agent.timeline.subscription_restored") {
+            console.log("\n[Reconnected; live output resumed. Events may have been missed.]");
+            return;
+        }
         if (message.payload.event.type === "timeline") {
             const item = message.payload.event.item;
             // Apply filter

package/dist/commands/agent/ls.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { collectMultiple } from "../../utils/command-options.js";
 import { isSameOrDescendantPath } from "../../utils/paths.js";
 export function addLsOptions(cmd) {
@@ -78,20 +78,6 @@ function toListItem(agent) {
         created: relativeTime(agent.createdAt),
     };
 }
-function daemonConnectionFailure(host, cause) {
-    const reason = cause instanceof Error ? cause.message : String(cause);
-    const isSsh = host.trim().startsWith("ssh://");
-    return {
-        code: "DAEMON_NOT_RUNNING",
-        message: `Cannot reach the daemon at ${host}: ${reason}`,
-        details: isSsh
-            ? "Start the Paseo daemon on the SSH host; SSH transport does not install or start it."
-            : [
-                "Start a local daemon with: paseo daemon start",
-                "To use another daemon, pass --host <host:port> or set PASEO_HOST.",
-            ].join("\n"),
-    };
-}
 function parseLabelFilters(labels) {
     const labelFilters = {};
     for (const labelStr of labels ?? []) {
@@ -134,14 +120,7 @@ export function buildAgentLsFetchOptions(options) {
  * - `paseo agent ls -ag` → global agents, including archived
  */
 export async function runLsCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        throw daemonConnectionFailure(host, err);
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const normalizedThinkingOptionId = options.thinking?.trim();
         if (options.thinking !== undefined && !normalizedThinkingOptionId) {

package/dist/commands/agent/mode.js

@@ -23,14 +23,14 @@ const missingModeError = () => ({
 });
 export async function runModeCommand(id, mode, options, _command) {
     const normalizedMode = mode?.trim();
-    const host = getDaemonHost({ host: options.host });
+    const host = getDaemonHost({ target: options.daemonTarget });
     // Validate arguments
     if (!options.list && !normalizedMode) {
         throw missingModeError();
     }
     let client;
     try {
-        client = await connectToDaemon({ host: options.host });
+        client = await connectToDaemon({ target: options.daemonTarget });
         const fetchResult = await client.fetchAgent({ agentId: id });
         if (!fetchResult) {
             const error = {

package/dist/commands/agent/open.js

@@ -1,4 +1,4 @@
-import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { openDesktopWithAgent } from "../open.js";
 const openAgentSchema = {
     idField: "agentId",
@@ -19,13 +19,7 @@ async function resolveServerId(options) {
     if (explicitServerId) {
         return explicitServerId;
     }
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (error) {
-        throw buildDaemonConnectionCommandError({ host: options.host, error });
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const serverId = client.getLastServerInfoMessage()?.serverId.trim();
         if (!serverId) {

package/dist/commands/agent/reload.js

@@ -1,4 +1,4 @@
-import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+import { connectToDaemon, resolveAgentId } from "../../utils/client.js";
 export const reloadSchema = {
     idField: "agentId",
     columns: [
@@ -13,7 +13,6 @@ export function addReloadOptions(cmd) {
         .argument("<id>", "Agent ID, prefix, or name");
 }
 export async function runReloadCommand(agentIdArg, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     if (!agentIdArg || agentIdArg.trim().length === 0) {
         const error = {
             code: "MISSING_AGENT_ID",
@@ -22,19 +21,7 @@ export async function runReloadCommand(agentIdArg, 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 agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
         const agents = agentsPayload.entries.map((entry) => entry.agent);

package/dist/commands/agent/run.js

@@ -1,6 +1,6 @@
 import { Option } from "commander";
 import { getStructuredAgentResponse, StructuredAgentResponseError } from "@camerontaylor/paseo-server";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { lookup } from "mime-types";
@@ -57,6 +57,7 @@ function resolveNewWorkspaceKind(options) {
 function buildRunWorkspaceSource(options, cwd) {
     const newWorkspace = resolveNewWorkspaceKind(options) ?? "local";
     return buildWorkspaceSource({
+        daemonTarget: options.daemonTarget,
         isolation: newWorkspace,
         path: cwd,
         mode: options.worktreeMode,
@@ -93,6 +94,8 @@ function loadOutputSchema(value) {
             source = readFileSync(resolve(trimmed), "utf8");
         }
         catch (err) {
+            if (err && typeof err === "object" && "code" in err)
+                throw err;
             const message = err instanceof Error ? err.message : String(err);
             const error = {
                 code: "INVALID_OUTPUT_SCHEMA",
@@ -107,6 +110,8 @@ function loadOutputSchema(value) {
         parsed = JSON.parse(source);
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "INVALID_OUTPUT_SCHEMA",
@@ -285,6 +290,8 @@ function parseWaitTimeoutOption(waitTimeout) {
         return ms;
     }
     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",
@@ -310,6 +317,8 @@ function loadRunImages(imagePaths) {
             };
         }
         catch (err) {
+            if (err && typeof err === "object" && "code" in err)
+                throw err;
             const message = err instanceof Error ? err.message : String(err);
             throw new Error(`Failed to read image ${imagePath}: ${message}`, { cause: err });
         }
@@ -349,19 +358,6 @@ function parseKeyValueFlags(flags, options) {
     }
     return labels;
 }
-async function connectToDaemonOrThrow(hostOption, host) {
-    try {
-        return await connectToDaemon({ host: hostOption });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-    }
-}
 export async function resolveExistingRunWorkspace(client, workspaceId) {
     const result = await client.fetchWorkspaces({
         filter: { query: workspaceId },
@@ -416,13 +412,12 @@ async function resolveRunWorkspace(client, options, cwd) {
     return { id: result.workspace.id, cwd: result.workspace.workspaceDirectory ?? cwd };
 }
 export async function runRunCommand(prompt, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     const outputSchema = options.outputSchema ? loadOutputSchema(options.outputSchema) : undefined;
     validateRunOptions(prompt, options, outputSchema);
     const waitTimeoutMs = parseWaitTimeoutOption(options.waitTimeout);
     const resolvedProviderModel = resolveProviderAndModel(options);
     const resolvedTitle = options.title ?? options.name;
-    const client = await connectToDaemonOrThrow(options.host, host);
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         // Resolve working directory
         const cwd = options.cwd ?? process.cwd();

package/dist/commands/agent/send.js

@@ -1,5 +1,5 @@
 import { collectMultiple } from "../../utils/command-options.js";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { readFile } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 /** Schema for agent send output */
@@ -50,6 +50,8 @@ async function readImageFiles(imagePaths) {
             return { data: buffer.toString("base64"), mimeType };
         }
         catch (err) {
+            if (err && typeof err === "object" && "code" in err)
+                throw err;
             const message = err instanceof Error ? err.message : String(err);
             throw {
                 code: "IMAGE_READ_ERROR",
@@ -89,6 +91,8 @@ async function resolvePromptInput(options) {
         return await readFile(resolve(promptFilePath), "utf8");
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "PROMPT_FILE_READ_ERROR",
@@ -116,7 +120,6 @@ function buildSendResult(agentIdArg, state) {
     return { agentId, status: "completed", message: "Agent completed processing the message" };
 }
 export async function runSendCommand(agentIdArg, prompt, options, _command) {
-    const host = getDaemonHost({ host: options.host });
     // Validate arguments
     if (!agentIdArg || agentIdArg.trim().length === 0) {
         const error = {
@@ -131,19 +134,7 @@ export async function runSendCommand(agentIdArg, prompt, options, _command) {
         promptOption: options.prompt,
         promptFile: options.promptFile,
     });
-    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 {
         // Read image files if provided
         const images = options.image && options.image.length > 0 ? await readImageFiles(options.image) : undefined;