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

package/dist/commands/terminal/send-keys.d.ts

@@ -3,5 +3,5 @@ import { type TerminalCommandOptions } from "./shared.js";
 export interface TerminalSendKeysOptions extends TerminalCommandOptions {
     literal?: boolean;
 }
-export declare function runSendKeysCommand(terminalId: string, keys: string[], _options: TerminalSendKeysOptions, command: Command): Promise<void>;
+export declare function runSendKeysCommand(terminalId: string, keys: string[], options: TerminalSendKeysOptions, _command: Command): Promise<void>;
 //# sourceMappingURL=send-keys.d.ts.map

package/dist/commands/terminal/send-keys.js

@@ -1,7 +1,6 @@
 import { renderError, toCommandError } from "../../output/render.js";
 import { connectTerminalClient, resolveTerminalId, toTerminalCommandError, } from "./shared.js";
-export async function runSendKeysCommand(terminalId, keys, _options, command) {
-    const options = command.optsWithGlobals();
+export async function runSendKeysCommand(terminalId, keys, options, _command) {
     try {
         const payload = await executeSendKeysCommand(terminalId, keys, options);
         if (options.json) {
@@ -18,7 +17,7 @@ export async function runSendKeysCommand(terminalId, keys, _options, command) {
     }
 }
 async function executeSendKeysCommand(terminalId, keys, options) {
-    const { client, close } = await connectTerminalClient(options.host);
+    const { client, close } = await connectTerminalClient(options.daemonTarget);
     try {
         const resolvedId = await resolveTerminalId(client, terminalId);
         if (!resolvedId) {

package/dist/commands/terminal/shared.d.ts

@@ -1,8 +1,9 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { CommandError, CommandOptions } from "../../output/index.js";
 export interface TerminalCommandOptions extends CommandOptions {
     host?: string;
 }
-export declare function connectTerminalClient(host?: string): Promise<{
+export declare function connectTerminalClient(target: DaemonTarget): Promise<{
     client: import("@camerontaylor/paseo-client").PaseoApi;
     daemonHost: string;
     close: () => Promise<void>;

package/dist/commands/terminal/shared.js

@@ -1,12 +1,14 @@
 import { createPaseoApi } from "@camerontaylor/paseo-client";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-export async function connectTerminalClient(host) {
-    const daemonHost = getDaemonHost({ host });
+export async function connectTerminalClient(target) {
+    const daemonHost = getDaemonHost({ target });
     try {
-        const client = await connectToDaemon({ host });
+        const client = await connectToDaemon({ target });
         return { client: createPaseoApi(client), daemonHost, close: () => client.close() };
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/workspace/archive.d.ts

@@ -7,6 +7,7 @@ interface WorkspaceArchiveResult {
 }
 export declare function runArchiveCommand(workspaceId: string, options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<SingleResult<WorkspaceArchiveResult>>;
 export {};
 //# sourceMappingURL=archive.d.ts.map

package/dist/commands/workspace/archive.js

@@ -8,8 +8,8 @@ const workspaceArchiveSchema = {
     ],
 };
 export async function runArchiveCommand(workspaceId, options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",
@@ -31,6 +31,8 @@ export async function runArchiveCommand(workspaceId, options, _command) {
         };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "WORKSPACE_ARCHIVE_FAILED", message };
     }

package/dist/commands/workspace/create.js

@@ -85,8 +85,8 @@ export function buildWorkspaceSource(options) {
     throw new Error(`Unsupported workspace isolation: ${String(options.isolation)}`);
 }
 export async function runCreateCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",
@@ -104,6 +104,8 @@ export async function runCreateCommand(options, _command) {
         return { type: "single", data: toWorkspaceRow(payload.workspace), schema: workspaceSchema };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "WORKSPACE_CREATE_FAILED", message };
     }

package/dist/commands/workspace/ls.d.ts

@@ -3,5 +3,6 @@ import type { ListResult } from "../../output/index.js";
 import { type WorkspaceRow } from "./shared.js";
 export declare function runLsCommand(options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<ListResult<WorkspaceRow>>;
 //# sourceMappingURL=ls.d.ts.map

package/dist/commands/workspace/ls.js

@@ -1,8 +1,8 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { toWorkspaceRow, workspaceSchema } from "./shared.js";
 export async function runLsCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/workspace/rename.d.ts

@@ -7,6 +7,7 @@ interface WorkspaceRenameResult {
 }
 export interface WorkspaceRenameOptions {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     reset?: boolean;
 }
 /**

package/dist/commands/workspace/rename.js

@@ -33,8 +33,8 @@ export function resolveWorkspaceTitle(input) {
 }
 export async function runRenameCommand(workspaceId, titleArg, options, _command) {
     const title = resolveWorkspaceTitle({ title: titleArg, reset: options.reset });
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         throw {
             code: "DAEMON_NOT_RUNNING",
@@ -51,6 +51,8 @@ export async function runRenameCommand(workspaceId, titleArg, options, _command)
         };
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         throw { code: "WORKSPACE_RENAME_FAILED", message };
     }

package/dist/commands/workspace/setup.d.ts

@@ -6,6 +6,7 @@ interface WorkspaceSetupResult {
 }
 export declare function runSetupCommand(workspaceId: string, options: {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
 }, _command: Command): Promise<SingleResult<WorkspaceSetupResult>>;
 export {};
 //# sourceMappingURL=setup.d.ts.map

package/dist/commands/workspace/setup.js

@@ -7,8 +7,8 @@ const workspaceSetupSchema = {
     ],
 };
 export async function runSetupCommand(workspaceId, options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+    const host = getDaemonHost({ target: options.daemonTarget });
+    const client = await connectToDaemon({ target: options.daemonTarget }).catch((error) => {
         throw {
             code: "DAEMON_NOT_RUNNING",
             message: `Cannot connect to daemon at ${host}: ${error instanceof Error ? error.message : String(error)}`,

package/dist/commands/worktree/archive.js

@@ -16,7 +16,7 @@ export async function runArchiveCommand(nameArg, options, _command) {
     return runArchiveCommandWithDeps(nameArg, options, { connectToDaemon });
 }
 export async function runArchiveCommandWithDeps(nameArg, options, deps) {
-    const host = getDaemonHost({ host: options.host });
+    const host = getDaemonHost({ target: options.daemonTarget });
     // Validate arguments
     if (!nameArg || nameArg.trim().length === 0) {
         const error = {
@@ -28,9 +28,11 @@ export async function runArchiveCommandWithDeps(nameArg, options, deps) {
     }
     let client;
     try {
-        client = await deps.connectToDaemon({ host: options.host });
+        client = await deps.connectToDaemon({ target: options.daemonTarget });
     }
     catch (err) {
+        if (err && typeof err === "object" && "code" in err)
+            throw err;
         const message = err instanceof Error ? err.message : String(err);
         const error = {
             code: "DAEMON_NOT_RUNNING",

package/dist/commands/worktree/create.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { connectToDaemon } from "../../utils/client.js";
 import { buildCreateWorktreeRequest } from "./create-input.js";
 export const createSchema = {
     idField: "worktreePath",
@@ -15,15 +15,7 @@ function cmdError(code, message, details) {
 export async function runCreateCommand(options, _command) {
     const cwd = options.cwd ?? process.cwd();
     const request = buildCreateWorktreeRequest(options, cwd);
-    const host = getDaemonHost({ host: options.host });
-    let client;
-    try {
-        client = await connectToDaemon({ host: options.host });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw cmdError("DAEMON_NOT_RUNNING", `Cannot connect to daemon at ${host}: ${message}`, "Start the daemon with: paseo daemon start");
-    }
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const response = await client.createPaseoWorktree(request);
         const workspace = response.workspace;

package/dist/commands/worktree/ls.d.ts

@@ -7,8 +7,6 @@ export interface WorktreeListItem {
     cwd: string;
     agent: string;
 }
-export declare function resolvePaseoHomePath(): string;
-export declare function resolvePaseoWorktreesDir(): string;
 /** Schema for worktree ls output */
 export declare const worktreeLsSchema: OutputSchema<WorktreeListItem>;
 export type WorktreeLsResult = ListResult<WorktreeListItem>;

package/dist/commands/worktree/ls.js

@@ -1,6 +1,5 @@
-import { homedir } from "node:os";
-import { basename, join, sep } from "node:path";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { basename } from "node:path";
+import { connectToDaemon } from "../../utils/client.js";
 /** Shorten home directory in path */
 function shortenPath(path) {
     const home = process.env.HOME;
@@ -13,16 +12,6 @@ function shortenPath(path) {
 function extractWorktreeName(path) {
     return basename(path);
 }
-export function resolvePaseoHomePath() {
-    return process.env.PASEO_HOME ?? join(homedir(), ".paseo");
-}
-export function resolvePaseoWorktreesDir() {
-    return join(resolvePaseoHomePath(), "worktrees");
-}
-function isAgentInManagedWorktree(agentCwd) {
-    const worktreesDir = resolvePaseoWorktreesDir();
-    return agentCwd === worktreesDir || agentCwd.startsWith(worktreesDir + sep);
-}
 /** Schema for worktree ls output */
 export const worktreeLsSchema = {
     idField: "name",
@@ -34,20 +23,7 @@ export const worktreeLsSchema = {
     ],
 };
 export async function runLsCommand(options, _command) {
-    const host = getDaemonHost({ host: options.host });
-    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);
@@ -64,9 +40,7 @@ export async function runLsCommand(options, _command) {
         // Build a map of worktree paths to agent IDs
         const worktreeAgentMap = new Map();
         for (const agent of agents) {
-            if (isAgentInManagedWorktree(agent.cwd)) {
-                worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
-            }
+            worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
         }
         const items = response.worktrees.map((wt) => ({
             name: extractWorktreeName(wt.worktreePath),

package/dist/output/with-output.d.ts

@@ -7,6 +7,8 @@ import type { Command } from "commander";
 import type { AnyCommandResult, OutputOptions } from "./types.js";
 /** Options that include output settings from global options */
 export interface CommandOptions extends Partial<OutputOptions> {
+    daemonTarget: import("../utils/daemon-target.js").DaemonTarget;
+    home?: string;
     /** Daemon host target from --host option */
     host?: string;
     /** JSON output flag from --json option */

package/dist/run.js

@@ -1,3 +1,4 @@
+import { renderError, toCommandError, defaultOutputOptions } from "./output/render.js";
 import { createCli } from "./cli.js";
 import { classifyInvocation } from "./classify.js";
 import { openDesktopWithProject } from "./commands/open.js";
@@ -34,7 +35,16 @@ export async function runCli(argv, options = {}) {
         return typeof process.exitCode === "number" ? process.exitCode : 0;
     }
     const program = createCli();
-    await program.parseAsync(parseArgv, { from: "node" });
+    try {
+        await program.parseAsync(parseArgv, { from: "node" });
+    }
+    catch (error) {
+        process.stderr.write(renderError(toCommandError(error), {
+            ...defaultOutputOptions,
+            format: argv.includes("--json") ? "json" : "table",
+        }) + "\n");
+        return 1;
+    }
     return typeof process.exitCode === "number" ? process.exitCode : 0;
 }
 //# sourceMappingURL=run.js.map

package/dist/utils/client-id.d.ts

@@ -1,2 +1,2 @@
-export declare function getOrCreateCliClientId(): Promise<string>;
+export declare function getOrCreateCliClientId(home: string): Promise<string>;
 //# sourceMappingURL=client-id.d.ts.map

package/dist/utils/client-id.js

@@ -1,9 +1,7 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { ensurePrivateDirectory } from "@camerontaylor/paseo-server";
+import { readFile, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-const CLIENT_SESSION_KEY_FILE = join(process.env.PASEO_HOME ?? join(homedir(), ".paseo"), "cli-client-id");
-let cachedClientId = null;
+import { join } from "node:path";
 function normalizeClientId(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
@@ -11,14 +9,11 @@ function normalizeClientId(value) {
 function generateClientId() {
     return `cid_${randomUUID().replace(/-/g, "")}`;
 }
-export async function getOrCreateCliClientId() {
-    if (cachedClientId) {
-        return cachedClientId;
-    }
+export async function getOrCreateCliClientId(home) {
+    const clientSessionKeyFile = join(home, "cli-client-id");
     try {
-        const existing = normalizeClientId(await readFile(CLIENT_SESSION_KEY_FILE, "utf8"));
+        const existing = normalizeClientId(await readFile(clientSessionKeyFile, "utf8"));
         if (existing) {
-            cachedClientId = existing;
             return existing;
         }
     }
@@ -29,9 +24,8 @@ export async function getOrCreateCliClientId() {
         }
     }
     const nextValue = generateClientId();
-    await mkdir(dirname(CLIENT_SESSION_KEY_FILE), { recursive: true });
-    await writeFile(CLIENT_SESSION_KEY_FILE, nextValue, { mode: 0o600 });
-    cachedClientId = nextValue;
+    ensurePrivateDirectory(home);
+    await writeFile(clientSessionKeyFile, nextValue, { mode: 0o600 });
     return nextValue;
 }
 //# sourceMappingURL=client-id.js.map

package/dist/utils/client.d.ts

@@ -1,14 +1,13 @@
+import { type DaemonInstance } from "@camerontaylor/paseo-server";
+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";
+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