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

package/dist/commands/hub/daemon-client.d.ts

@@ -1,3 +1,4 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { ProviderSnapshotEntry } from "@camerontaylor/paseo-protocol/agent-types";
 export interface HubStatus {
     state: string;
@@ -33,8 +34,8 @@ export interface HubDaemonClient {
     close(): Promise<void>;
 }
 export interface HubDaemonConnection {
-    connect(host: string | undefined): Promise<HubDaemonClient>;
+    connect(target: DaemonTarget): Promise<HubDaemonClient>;
 }
 export declare const productionHubDaemonConnection: HubDaemonConnection;
-export declare function withHubDaemon<T>(connection: HubDaemonConnection, host: string | undefined, action: (client: HubDaemonClient) => Promise<T>): Promise<T>;
+export declare function withHubDaemon<T>(connection: HubDaemonConnection, target: DaemonTarget, action: (client: HubDaemonClient) => Promise<T>): Promise<T>;
 //# sourceMappingURL=daemon-client.d.ts.map

package/dist/commands/hub/daemon-client.js

@@ -1,9 +1,9 @@
 import { connectToDaemon } from "../../utils/client.js";
 export const productionHubDaemonConnection = {
-    connect: (host) => connectToDaemon({ host }),
+    connect: (target) => connectToDaemon({ target }),
 };
-export async function withHubDaemon(connection, host, action) {
-    const client = await connection.connect(host);
+export async function withHubDaemon(connection, target, action) {
+    const client = await connection.connect(target);
     try {
         return await action(client);
     }

package/dist/commands/hub/disconnect.d.ts

@@ -4,6 +4,7 @@ import { type HubReporter } from "./reporter.js";
 interface HubDisconnectOptions {
     force?: boolean;
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     json?: boolean;
 }
 interface HubDisconnectDependencies {

package/dist/commands/hub/disconnect.js

@@ -4,7 +4,7 @@ import { withHubDaemon } from "./daemon-client.js";
 import { reportHubProgress } from "./reporter.js";
 import { hubStatusResult } from "./status-output.js";
 export function runHubDisconnect(options, dependencies) {
-    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+    return withHubDaemon(dependencies.daemon, options.daemonTarget, async (client) => {
         const current = (await client.getHubStatus()).status;
         if (current.hubOrigin !== null) {
             reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${current.hubOrigin}`);

package/dist/commands/hub/index.js

@@ -40,7 +40,7 @@ export function createHubCommand(overrides = {}) {
         flow: environment.login,
         reporter: environment.reporter,
         isInteractive: environment.isInteractive,
-        continueGuidedSetup: (origin) => continueHubGuidedSetup(origin, environment),
+        continueGuidedSetup: (origin, daemonTarget) => continueHubGuidedSetup(origin, { ...environment, daemonTarget }),
     });
     addHubInitCommand(hub, environment);
     addHubConnectCommand(hub, {
@@ -52,7 +52,7 @@ export function createHubCommand(overrides = {}) {
     });
     addJsonAndDaemonHostOptions(hub.command("status")).action(withOutput(async (...args) => {
         const options = args.at(-2);
-        return withHubDaemon(environment.daemon, options.host, async (client) => hubStatusResult((await client.getHubStatus()).status));
+        return withHubDaemon(environment.daemon, options.daemonTarget, async (client) => hubStatusResult((await client.getHubStatus()).status));
     }));
     addHubDisconnectCommand(hub, {
         daemon: environment.daemon,

package/dist/commands/hub/init.d.ts

@@ -1,3 +1,4 @@
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import { select, text } from "@clack/prompts";
 import type { Command } from "commander";
 import type { HubCredentialStore } from "./credentials.js";
@@ -6,6 +7,7 @@ import type { HubHttpClient } from "./hub-client/index.js";
 import type { CliLoginFlow } from "./login-flow.js";
 import type { HubReporter } from "./reporter.js";
 export interface HubGuidedSetupEnvironment {
+    daemonTarget: DaemonTarget;
     env: Readonly<Record<string, string | undefined>>;
     credentials: HubCredentialStore;
     hub: HubHttpClient;
@@ -26,7 +28,7 @@ interface HubGuidedSetupState {
     daemonId?: string;
     deploy?: boolean;
 }
-export declare function addHubInitCommand(parent: Command, environment: HubGuidedSetupEnvironment): void;
+export declare function addHubInitCommand(parent: Command, environment: Omit<HubGuidedSetupEnvironment, "daemonTarget">): void;
 export declare function runHubInit(environment: HubGuidedSetupEnvironment): Promise<void>;
 export declare function runHubGuidedSetup(environment: HubGuidedSetupEnvironment, state?: HubGuidedSetupState): Promise<void>;
 export declare function continueHubGuidedSetup(origin: string, environment: HubGuidedSetupEnvironment): Promise<void>;

package/dist/commands/hub/init.js

@@ -1,3 +1,4 @@
+import { withGlobalOptions } from "../../utils/command-options.js";
 import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, text, } from "@clack/prompts";
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -28,9 +29,9 @@ export function addHubInitCommand(parent, environment) {
     parent
         .command("init")
         .description("Create and optionally deploy a safe starter Hub trigger")
-        .action(async () => {
+        .action(withGlobalOptions(async (options) => {
         try {
-            await runHubInit(environment);
+            await runHubInit({ ...environment, daemonTarget: options.daemonTarget });
         }
         catch (error) {
             if (error instanceof HubInitCancelledError) {
@@ -40,7 +41,7 @@ export function addHubInitCommand(parent, environment) {
             cancel(initErrorMessage(error));
             process.exitCode = 1;
         }
-    });
+    }));
 }
 export async function runHubInit(environment) {
     await runHubGuidedSetup(environment);
@@ -102,13 +103,13 @@ export async function runHubGuidedSetup(environment, state = {}) {
     outro(deploy ? "Hub is ready" : "Hub trigger is ready");
 }
 export async function continueHubGuidedSetup(origin, environment) {
-    const currentStatus = await withHubDaemon(environment.daemon, undefined, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    const currentStatus = await withHubDaemon(environment.daemon, environment.daemonTarget, async (daemon) => daemon.getHubStatus().then((response) => response.status));
     const current = resolveHubInitConnection(currentStatus, origin);
     if (current.kind === "connected") {
         reportMessage(environment, `This daemon is already connected to ${origin}. Permissions: ${currentStatus.permissions.join(", ") || "None"}.`);
     }
     else if (current.kind === "pending") {
-        await waitForDaemonReady(origin, environment.daemon);
+        await waitForDaemonReady(origin, environment);
     }
     else if (current.kind === "conflict") {
         reportMessage(environment, `This daemon is connected to ${current.origin}. Disconnect it before connecting to ${origin}.`);
@@ -163,7 +164,7 @@ async function ensureLogin(activeOrigin, environment) {
     return normalizedOrigin;
 }
 async function ensureDaemonConnection(origin, environment, confirmed = false, permissions = ["hub.execute"]) {
-    const status = await withHubDaemon(environment.daemon, undefined, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    const status = await withHubDaemon(environment.daemon, environment.daemonTarget, async (daemon) => daemon.getHubStatus().then((response) => response.status));
     const connection = resolveHubInitConnection(status, origin);
     if (connection.kind === "connected") {
         if (permissions.includes("hub.execute") && !status.permissions.includes("hub.execute")) {
@@ -172,7 +173,7 @@ async function ensureDaemonConnection(origin, environment, confirmed = false, pe
         return connection.daemonId;
     }
     if (connection.kind === "pending") {
-        return waitForDaemonReady(origin, environment.daemon);
+        return waitForDaemonReady(origin, environment);
     }
     if (connection.kind === "conflict") {
         throw new HubCommandError("HUB_DAEMON_ALREADY_CONNECTED", `This daemon is connected to ${connection.origin}. Disconnect it before running Hub init for ${origin}.`);
@@ -184,17 +185,17 @@ async function ensureDaemonConnection(origin, environment, confirmed = false, pe
     return connectDaemon(origin, environment, permissions);
 }
 async function connectDaemon(origin, environment, permissions = ["hub.execute"]) {
-    await runHubConnect(origin, { permissions }, {
+    await runHubConnect(origin, { permissions, daemonTarget: environment.daemonTarget }, {
         env: environment.env,
         credentials: environment.credentials,
         hub: environment.hub,
         daemon: environment.daemon,
         reporter: environment.reporter,
     });
-    return waitForDaemonReady(origin, environment.daemon);
+    return waitForDaemonReady(origin, environment);
 }
-async function waitForDaemonReady(origin, connection) {
-    return withSpinner("Waiting for the daemon to connect", async (reporter) => withHubDaemon(connection, undefined, async (daemon) => {
+async function waitForDaemonReady(origin, environment) {
+    return withSpinner("Waiting for the daemon to connect", async (reporter) => withHubDaemon(environment.daemon, environment.daemonTarget, async (daemon) => {
         const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
         while (true) {
             const status = (await daemon.getHubStatus()).status;
@@ -260,7 +261,7 @@ async function chooseStarterAgentRuntime(environment, cwd) {
     return { ...runtime, mode: runtime.mode };
 }
 async function waitForStarterAgentProviders(environment, cwd) {
-    return withSpinner("Discovering agent runtimes", async (reporter) => withHubDaemon(environment.daemon, undefined, async (daemon) => {
+    return withSpinner("Discovering agent runtimes", async (reporter) => withHubDaemon(environment.daemon, environment.daemonTarget, async (daemon) => {
         const deadline = Date.now() + PROVIDER_READY_TIMEOUT_MS;
         while (true) {
             const snapshot = await daemon.getProvidersSnapshot({ cwd });

package/dist/commands/hub/login.d.ts

@@ -1,3 +1,5 @@
+import type { CommandOptions } from "../../output/index.js";
+import type { DaemonTarget } from "../../utils/daemon-target.js";
 import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
 import type { HubCredentialStore } from "./credentials.js";
@@ -13,11 +15,9 @@ interface HubLoginDependencies {
     flow: Pick<CliLoginFlow, "authorize">;
     reporter: HubReporter;
     isInteractive?(): boolean;
-    continueGuidedSetup?(origin: string): Promise<void>;
+    continueGuidedSetup?(origin: string, daemonTarget: DaemonTarget): Promise<void>;
 }
-export declare function runHubLogin(originInput: string | undefined, options: {
-    json?: boolean;
-}, dependencies: HubLoginDependencies): Promise<SingleResult<HubLoginResult>>;
+export declare function runHubLogin(originInput: string | undefined, options: Pick<CommandOptions, "json" | "daemonTarget">, dependencies: HubLoginDependencies): Promise<SingleResult<HubLoginResult>>;
 export declare function addHubLoginCommand(parent: Command, dependencies: HubLoginDependencies): void;
 export {};
 //# sourceMappingURL=login.d.ts.map

package/dist/commands/hub/login.js

@@ -23,7 +23,7 @@ export async function runHubLogin(originInput, options, dependencies) {
     if (!options.json &&
         dependencies.isInteractive?.() &&
         dependencies.continueGuidedSetup !== undefined) {
-        await dependencies.continueGuidedSetup(origin);
+        await dependencies.continueGuidedSetup(origin, options.daemonTarget);
     }
     return { type: "single", data: { origin, status: "logged_in" }, schema };
 }

package/dist/commands/hub/logout.d.ts

@@ -13,6 +13,7 @@ interface HubLogoutOptions {
     disconnectDaemon?: boolean;
     force?: boolean;
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     json?: boolean;
 }
 interface HubLogoutDependencies {

package/dist/commands/hub/logout.js

@@ -22,7 +22,7 @@ export async function runHubLogout(options, dependencies) {
     let daemonStatus = null;
     const shouldInspectDaemon = options.disconnectDaemon === true || mayPrompt;
     if (shouldInspectDaemon) {
-        daemonStatus = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+        daemonStatus = await withHubDaemon(dependencies.daemon, options.daemonTarget, async (daemon) => daemon.getHubStatus().then((response) => response.status));
     }
     const sameHub = daemonStatus?.hubOrigin === active.origin;
     let shouldDisconnect = options.disconnectDaemon === true && sameHub;
@@ -34,7 +34,7 @@ export async function runHubLogout(options, dependencies) {
         return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: false });
     }
     reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${active.origin}`);
-    const disconnect = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+    const disconnect = await withHubDaemon(dependencies.daemon, options.daemonTarget, async (daemon) => {
         return daemon.disconnectHub(options.force ?? false);
     });
     dependencies.credentials.logoutActive();

package/dist/commands/hub/permissions.d.ts

@@ -4,6 +4,7 @@ import type { HubDaemonConnection } from "./daemon-client.js";
 import { type HubReporter } from "./reporter.js";
 interface HubPermissionsOptions {
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     json?: boolean;
 }
 interface HubPermissionsDependencies {

package/dist/commands/hub/permissions.js

@@ -11,7 +11,7 @@ const schema = {
     ],
 };
 export function runHubPermissionsList(options, dependencies) {
-    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+    return withHubDaemon(dependencies.daemon, options.daemonTarget, async (client) => {
         const status = (await client.getHubStatus()).status;
         requireConnectedHub(status);
         return {
@@ -25,7 +25,7 @@ export function runHubPermissionsList(options, dependencies) {
     });
 }
 export function runHubPermissionChange(operation, permission, options, dependencies) {
-    return withHubDaemon(dependencies.daemon, options.host, async (client) => {
+    return withHubDaemon(dependencies.daemon, options.daemonTarget, async (client) => {
         const current = (await client.getHubStatus()).status;
         requireConnectedHub(current);
         const response = await client.updateHubPermissions(operation === "grant" ? { grant: [permission] } : { revoke: [permission] });

package/dist/commands/onboard.d.ts

@@ -1,6 +1,11 @@
 import { Command } from "commander";
-import { type DaemonStartOptions } from "./daemon/local-daemon.js";
-interface OnboardOptions extends DaemonStartOptions {
+import type { CommandOptions } from "../output/index.js";
+interface OnboardOptions extends CommandOptions {
+    port?: string;
+    listen?: string;
+    relay?: boolean;
+    mcp?: boolean;
+    hostnames?: string;
     timeout?: string;
     voice?: "ask" | "enable" | "disable";
 }

package/dist/commands/onboard.js

@@ -1,39 +1,19 @@
-import { cancel, confirm, intro, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { addLocalDaemonOptions } from "../utils/command-options.js";
+import { cancel, confirm, intro, isCancel, log, note, outro } from "@clack/prompts";
 import { Command, Option } from "commander";
-import { writeFileSync } from "node:fs";
 import path from "node:path";
-import { loadPersistedConfig } from "@camerontaylor/paseo-server";
-import { resolveLocalPaseoHome, resolveLocalDaemonState, resolveTcpHostFromListen, startLocalDaemonDetached, tailDaemonLog, } from "./daemon/local-daemon.js";
-import { tryConnectToDaemon } from "../utils/client.js";
+import { readPersistedConfig as loadPersistedConfig, savePersistedConfig, readDaemonInstance, waitForDaemonReady, } from "@camerontaylor/paseo-server";
+import { withGlobalOptions } from "../utils/command-options.js";
+import { launchLocalDaemon, parseTimeoutMs } from "./daemon/local-daemon.js";
+import { connectToDaemon } from "../utils/client.js";
 import { formatPairingInstructions } from "../output/pairing.js";
 import { confirmRelayPairing, printDirectConnectionGuidance, resolveLocalPairingOffer, } from "./daemon/pair.js";
-const DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1000;
-const READY_PROBE_TIMEOUT_MS = 1200;
 class OnboardCancelledError extends Error {
 }
 const plainNoteFormat = (line) => line;
 function renderNote(message, title) {
     note(message, title, { format: plainNoteFormat });
 }
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-function parseTimeoutMs(raw) {
-    if (!raw || raw.trim().length === 0) {
-        return DEFAULT_READY_TIMEOUT_MS;
-    }
-    const seconds = Number(raw);
-    if (!Number.isFinite(seconds) || seconds <= 0) {
-        throw new Error(`Invalid timeout value: ${raw}`);
-    }
-    return Math.ceil(seconds * 1000);
-}
-function savePersistedConfig(paseoHome, config) {
-    const configPath = path.join(paseoHome, "config.json");
-    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
-}
 function applyVoiceSelection(config, enabled) {
     return {
         ...config,
@@ -83,101 +63,6 @@ async function resolveVoiceSelection(mode) {
     }
     return answer;
 }
-function parseDownloadProgress(logTail) {
-    const lines = logTail.split("\n").filter(Boolean);
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        const line = lines[index];
-        if (!line || !line.includes("Downloading model artifact")) {
-            continue;
-        }
-        const pctMatch = line.match(/"pct"\s*:\s*(\d{1,3})|\bpct[=:]\s*(\d{1,3})/);
-        const modelMatch = line.match(/"modelId"\s*:\s*"([^"]+)"|\bmodelId[=:]\s*"?([^\s",}]+)/);
-        return {
-            modelId: modelMatch?.[1] ?? modelMatch?.[2] ?? null,
-            pct: pctMatch ? Number(pctMatch[1] ?? pctMatch[2]) : null,
-        };
-    }
-    return null;
-}
-function renderProgressLine(progress) {
-    const modelSuffix = progress.modelId ? ` (${progress.modelId})` : "";
-    if (progress.pct === null) {
-        return `Downloading speech model${modelSuffix}...`;
-    }
-    return `Downloading speech model${modelSuffix}: ${progress.pct}%`;
-}
-async function probeDaemonReady(home, timeoutMs) {
-    const state = resolveLocalDaemonState({ home });
-    const host = resolveTcpHostFromListen(state.listen);
-    const deadline = Date.now() + timeoutMs;
-    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
-    if (state.running && host) {
-        const client = await tryConnectToDaemon({
-            host,
-            timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
-        });
-        if (client) {
-            try {
-                await client.fetchAgents({
-                    timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
-                });
-                return { kind: "ready", listen: state.listen, host };
-            }
-            catch {
-                // Daemon process is alive but not API-ready yet.
-            }
-            finally {
-                await client.close().catch(() => { });
-            }
-        }
-    }
-    else if (state.running && !host) {
-        return { kind: "ready", listen: state.listen, host: null };
-    }
-    return { kind: "pending" };
-}
-function announceProgress(home, state, onStatus) {
-    const progress = parseDownloadProgress(tailDaemonLog(home, 120) ?? "");
-    const progressLine = progress ? renderProgressLine(progress) : null;
-    const statusMessage = progressLine ?? "Waiting for daemon to become ready...";
-    if (statusMessage !== state.lastStatus) {
-        onStatus?.(statusMessage);
-        return { lastStatus: statusMessage, lastPrintedAt: Date.now() };
-    }
-    if (!onStatus && Date.now() - state.lastPrintedAt >= 3000) {
-        console.log(statusMessage);
-        return { lastStatus: state.lastStatus, lastPrintedAt: Date.now() };
-    }
-    return state;
-}
-async function waitForDaemonReady(args) {
-    const deadline = Date.now() + args.timeoutMs;
-    const createTimeoutError = () => {
-        const recentLogs = tailDaemonLog(args.home, 60);
-        return new Error([
-            `Timed out after ${Math.ceil(args.timeoutMs / 1000)}s waiting for daemon readiness.`,
-            recentLogs ? `Recent daemon logs:\n${recentLogs}` : null,
-        ]
-            .filter(Boolean)
-            .join("\n\n"));
-    };
-    async function poll(state) {
-        if (Date.now() >= deadline) {
-            throw createTimeoutError();
-        }
-        const probe = await probeDaemonReady(args.home, Math.max(1, deadline - Date.now()));
-        if (probe.kind === "ready") {
-            return { listen: probe.listen, host: probe.host };
-        }
-        const nextState = announceProgress(args.home, state, args.onStatus);
-        if (Date.now() >= deadline) {
-            throw createTimeoutError();
-        }
-        await sleep(200);
-        return poll(nextState);
-    }
-    return poll({ lastStatus: "", lastPrintedAt: 0 });
-}
 function printNextSteps(pairingUrl, paseoHome, richUi) {
     const daemonLogPath = path.join(paseoHome, "daemon.log");
     const nextStepsLines = [
@@ -187,13 +72,13 @@ function printNextSteps(pairingUrl, paseoHome, richUi) {
         "2. Web app: https://app.paseo.sh",
         "3. Desktop app: https://github.com/getpaseo/paseo/releases/latest",
         "4. Docs: https://paseo.sh/docs",
-        '5. Example: paseo run --output-schema schema.json "extract fields"',
+        `5. Example: paseo run --home ${JSON.stringify(paseoHome)} --output-schema schema.json "extract fields"`,
     ];
     const quickReferenceLines = [
         "1. paseo --help",
-        "2. paseo ls",
-        '3. paseo run "your prompt"',
-        "4. paseo status",
+        `2. paseo ls --home ${JSON.stringify(paseoHome)}`,
+        `3. paseo run --home ${JSON.stringify(paseoHome)} "your prompt"`,
+        `4. paseo status --home ${JSON.stringify(paseoHome)}`,
         `5. Daemon logs: ${daemonLogPath}`,
     ];
     if (!richUi) {
@@ -213,11 +98,10 @@ function printNextSteps(pairingUrl, paseoHome, richUi) {
     renderNote(quickReferenceLines.join("\n"), "CLI quick reference");
 }
 export function onboardCommand() {
-    return new Command("onboard")
+    return addLocalDaemonOptions(new Command("onboard"))
         .description("Run first-time setup, start daemon, and print pairing instructions")
         .option("--listen <listen>", "Listen target (host:port, port, or unix socket path)")
         .option("--port <port>", "Port to listen on (default: 6767)")
-        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
         .option("--relay", "Enable relay connection without prompting")
         .option("--no-relay", "Disable relay connection")
         .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
@@ -225,12 +109,13 @@ export function onboardCommand() {
         .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
         .option("--timeout <seconds>", "Max time to wait for daemon readiness (default: 600)")
         .option("--voice <mode>", "Voice setup mode: ask, enable, disable", "ask")
-        .action(async (options) => {
+        .action(withGlobalOptions(async (options, command) => {
         await runOnboard({
             ...options,
+            mcp: command.getOptionValueSource("mcp") === "cli" ? options.mcp : undefined,
             hostnames: options.hostnames ?? options.allowedHosts,
         });
-    });
+    }));
 }
 async function resolveAndPersistVoice(paseoHome, options) {
     let persisted = loadPersistedConfig(paseoHome);
@@ -257,72 +142,30 @@ async function resolveAndPersistVoice(paseoHome, options) {
     savePersistedConfig(paseoHome, persisted);
     return voiceEnabled;
 }
-async function ensureDaemonStarted(options, richUi) {
-    const stateBeforeStart = resolveLocalDaemonState({ home: options.home });
-    if (stateBeforeStart.running) {
-        log.message(`Daemon already running (PID ${stateBeforeStart.pidInfo?.pid ?? "unknown"}).`);
-        return;
-    }
-    const startSpinner = richUi ? spinner() : null;
-    try {
-        if (startSpinner) {
-            startSpinner.start("Starting daemon...");
-        }
-        else {
-            log.message("Starting daemon...");
-        }
-        const startup = await startLocalDaemonDetached(options);
-        if (startSpinner) {
-            startSpinner.stop(`Daemon started (PID ${startup.pid ?? "unknown"})`);
-        }
-        else {
-            log.message(`Daemon started (PID ${startup.pid ?? "unknown"})`);
-        }
-        log.message(`Logs: ${startup.logPath}`);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (startSpinner) {
-            startSpinner.error(message);
-        }
-        else {
-            log.error(message);
-        }
-        process.exit(1);
-    }
-}
-async function waitForDaemonReadyWithUi(args) {
-    const readySpinner = args.richUi ? spinner() : null;
-    try {
-        if (readySpinner) {
-            readySpinner.start("Waiting for daemon to become ready...");
-        }
-        else {
-            log.message("Waiting for daemon to become ready...");
-        }
-        const readyState = await waitForDaemonReady({
-            home: args.home,
-            timeoutMs: args.timeoutMs,
-            onStatus: readySpinner ? (message) => readySpinner.message(message) : undefined,
-        });
-        if (readySpinner) {
-            readySpinner.stop(`Daemon ready on ${readyState.listen}`);
-        }
-        else {
-            log.message(`Daemon ready on ${readyState.listen}`);
-        }
-        return readyState;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (readySpinner) {
-            readySpinner.error(message);
-        }
-        else {
-            log.error(message);
-        }
-        return process.exit(1);
+function persistSetupChoices(paseoHome, options) {
+    const persisted = loadPersistedConfig(paseoHome, { defaultsIfMissing: true });
+    if (options.listen || options.port) {
+        persisted.daemon = {
+            ...persisted.daemon,
+            listen: options.listen ?? `127.0.0.1:${options.port}`,
+        };
     }
+    if (options.relay !== undefined)
+        persisted.daemon = {
+            ...persisted.daemon,
+            relay: { ...persisted.daemon?.relay, enabled: options.relay },
+        };
+    if (options.mcp !== undefined)
+        persisted.daemon = {
+            ...persisted.daemon,
+            mcp: { ...persisted.daemon?.mcp, enabled: options.mcp },
+        };
+    if (options.hostnames)
+        persisted.daemon = {
+            ...persisted.daemon,
+            hostnames: options.hostnames === "true" ? true : options.hostnames.split(","),
+        };
+    savePersistedConfig(paseoHome, persisted);
 }
 export async function runOnboard(options) {
     const richUi = process.stdin.isTTY && process.stdout.isTTY;
@@ -333,16 +176,12 @@ export async function runOnboard(options) {
         cancel("Cannot use --listen and --port together");
         process.exit(1);
     }
-    let timeoutMs = DEFAULT_READY_TIMEOUT_MS;
-    try {
-        timeoutMs = parseTimeoutMs(options.timeout);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        cancel(message);
-        process.exit(1);
-    }
-    const paseoHome = resolveLocalPaseoHome(options.home);
+    const timeoutMs = parseTimeoutMs(options.timeout);
+    if (options.daemonTarget.kind !== "instance")
+        throw new Error("Onboarding requires a local home");
+    const paseoHome = options.daemonTarget.home;
+    const alreadyRunning = await readDaemonInstance(paseoHome);
+    persistSetupChoices(paseoHome, options);
     if (richUi) {
         renderNote(paseoHome, "Paseo home");
     }
@@ -350,12 +189,21 @@ export async function runOnboard(options) {
     log.message(voiceEnabled
         ? "Voice features enabled. Local speech models will be downloaded automatically if missing."
         : "Voice features disabled. Local speech models will not be downloaded.");
-    await ensureDaemonStarted(options, richUi);
-    await waitForDaemonReadyWithUi({
-        home: options.home ?? paseoHome,
-        timeoutMs,
-        richUi,
-    });
+    if (alreadyRunning) {
+        log.message(`Daemon already running (PID ${alreadyRunning.pid}); retaining its supervisor.`);
+        const client = await connectToDaemon({ target: options.daemonTarget, timeout: timeoutMs });
+        try {
+            log.message(JSON.stringify(await client.reloadDaemonConfig()));
+        }
+        finally {
+            await client.close();
+        }
+    }
+    else {
+        await launchLocalDaemon({ home: paseoHome, timeoutMs });
+    }
+    const ready = await waitForDaemonReady(paseoHome, { timeoutMs });
+    log.message(`Daemon ready on ${ready.listen}`);
     if (options.relay === false) {
         log.message("Relay pairing skipped because --no-relay was provided.");
         printNextSteps(null, paseoHome, richUi);

package/dist/commands/open.js

@@ -78,6 +78,8 @@ export async function openDesktopWithProject(projectPath) {
         launchDesktop([projectPath]);
     }
     catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(`${message}\n`);
         process.exitCode = 1;