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

package/dist/commands/daemon/status.js

@@ -1,363 +1,111 @@
-import { createRequire } from "node:module";
-import { getOrCreateServerId, findExecutable, execCommand } from "@camerontaylor/paseo-server";
-import { connectToDaemon } from "../../utils/client.js";
-import { resolveLocalDaemonState } from "./local-daemon.js";
-import { resolveNodePathFromPid } from "./runtime-toolchain.js";
-const DAEMON_STATUS_PROBE_TIMEOUT_MS = 1500;
-const require = createRequire(import.meta.url);
-function normalizeError(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-function shortenMessage(message, max = 120) {
-    const normalized = message.replace(/\s+/g, " ").trim();
-    if (normalized.length <= max) {
-        return normalized;
-    }
-    return `${normalized.slice(0, max - 3)}...`;
-}
-function appendNote(current, next) {
-    if (!next)
-        return current;
-    if (!current)
-        return next;
-    return `${current}; ${next}`;
-}
-function resolveCliVersion() {
-    try {
-        const packageJson = require("../../../package.json");
-        if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
-            return packageJson.version.trim();
-        }
-    }
-    catch {
-        // Fall through.
-    }
-    return "unknown";
+import { Command } from "commander";
+import { DaemonConnectionError } from "@camerontaylor/paseo-client/internal/daemon-client";
+import { readDaemonInstance, readPersistedConfig, resolveConfigFromPersisted, daemonLogPath, isSameDaemonInstance, DaemonInstanceError, } from "@camerontaylor/paseo-server";
+import { connectToDaemon, buildDaemonConnectionCommandError } from "../../utils/client.js";
+import { withOutput, toCommandError } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { describeDaemonTarget } from "../../utils/daemon-target.js";
+export function daemonStatusCommand() {
+    return addJsonAndDaemonHostOptions(new Command("status").description("Observe the selected daemon and its published endpoint")).action(withOutput(runStatusCommand));
 }
-function createStatusSchema(status) {
+export async function runStatusCommand(options, _command) {
+    const target = options.daemonTarget;
+    const instance = target.kind === "instance" ? await readDaemonInstance(target.home) : null;
+    const local = target.kind === "instance"
+        ? localStatus(target.home, instance)
+        : { host: describeDaemonTarget(target) };
+    const observed = target.kind === "endpoint" || instance?.listen
+        ? await probeDaemonStatus(target, instance, local)
+        : { connectedDaemon: "not_probed" };
+    const data = { ...local, ...observed };
     return {
-        idField: "key",
-        columns: [
-            { header: "KEY", field: "key" },
-            {
-                header: "VALUE",
-                field: "value",
-                color: (_, item) => {
-                    if (item.key === "Local Daemon") {
-                        if (item.value === "running")
-                            return "green";
-                        if (item.value === "unresponsive")
-                            return "yellow";
-                        return "red";
-                    }
-                    if (item.key === "Connected Daemon") {
-                        if (item.value === "reachable")
-                            return "green";
-                        if (item.value === "not_probed" || item.value === "auth_required")
-                            return "yellow";
-                        return "red";
-                    }
-                    if (item.key.startsWith("  ")) {
-                        if (item.value === "not found" || item.value === "not found (daemon)")
-                            return "red";
-                        if (item.value.endsWith("(--version failed)"))
-                            return "yellow";
-                        return "green";
-                    }
-                    return undefined;
-                },
-            },
-        ],
-        serialize: () => status,
+        type: "single",
+        data,
+        schema: {
+            idField: () => "daemon",
+            columns: [],
+            renderHuman: () => Object.entries(data)
+                .filter(([, value]) => value !== undefined)
+                .map(([key, value]) => `${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`)
+                .join("\n"),
+        },
     };
 }
-function toStatusRows(status) {
-    const rows = [
-        { key: "Server ID", value: status.serverId ?? "-" },
-        { key: "Local Daemon", value: status.localDaemon },
-        { key: "Connected Daemon", value: status.connectedDaemon },
-        { key: "Home", value: status.home },
-        { key: "Listen", value: status.listen },
-        { key: "Relay", value: status.relay },
-        { key: "Hostname", value: status.hostname ?? "-" },
-        { key: "PID", value: status.pid === null ? "-" : String(status.pid) },
-        { key: "Started", value: status.startedAt ?? "-" },
-        { key: "Owner", value: status.owner ?? "-" },
-        { key: "Logs", value: status.logPath },
-        { key: "Daemon Node", value: status.daemonNode },
-        { key: "CLI Node", value: status.cliNode },
-        { key: "CLI", value: status.cliVersion },
-        { key: "Daemon Version", value: status.daemonVersion ?? "-" },
-    ];
-    if (status.note) {
-        rows.push({ key: "Note", value: status.note });
-    }
-    rows.push({ key: "", value: "" });
-    rows.push({ key: "Providers", value: "" });
-    for (const provider of status.providers) {
-        if (provider.source === "daemon") {
-            if (!provider.path) {
-                rows.push({ key: `  ${provider.label}`, value: "not found (daemon)" });
-            }
-            else {
-                rows.push({ key: `  ${provider.label}`, value: `${provider.path} (daemon)` });
-            }
-        }
-        else if (!provider.path) {
-            rows.push({ key: `  ${provider.label}`, value: "not found" });
-        }
-        else if (!provider.version) {
-            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (--version failed)` });
-        }
-        else {
-            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (${provider.version})` });
-        }
-    }
-    return rows;
-}
-const PROVIDER_BINARIES = [
-    { label: "Claude", binary: "claude" },
-    { label: "Codex", binary: "codex" },
-    { label: "OpenCode", binary: "opencode" },
-];
-async function checkProviderBinary(binary) {
-    const binaryPath = await findExecutable(binary);
-    if (!binaryPath) {
-        return { path: null, version: null };
-    }
-    try {
-        const { stdout } = await execCommand(binaryPath, ["--version"], {
-            timeout: 5000,
-        });
-        return { path: binaryPath, version: stdout.trim() || null };
-    }
-    catch {
-        return { path: binaryPath, version: null };
-    }
-}
-async function checkProviderBinaries() {
-    const results = await Promise.all(PROVIDER_BINARIES.map(async ({ label, binary }) => {
-        const result = await checkProviderBinary(binary);
-        return Object.assign({ label }, result);
-    }));
-    return results;
-}
-function resolveOwnerLabel(uid, hostname) {
-    if (uid === undefined && !hostname) {
-        return null;
-    }
-    const uidPart = uid === undefined ? "?" : String(uid);
-    const hostPart = hostname ?? "unknown-host";
-    return `${uidPart}@${hostPart}`;
-}
-function classifyDaemonAuthProbeFailure(error) {
-    if (!(error instanceof Error))
-        return null;
-    if (error.message === "Password required")
-        return "auth_required";
-    if (error.message === "Incorrect password")
-        return "auth_failed";
-    return null;
-}
-function describeDaemonAuthProbeFailure(host, failure) {
-    if (failure === "auth_required") {
-        return `Daemon is reachable at ${host} but requires a password. Set PASEO_PASSWORD and retry.`;
-    }
-    return `Daemon is reachable at ${host} but the supplied password was rejected. Check PASEO_PASSWORD and retry.`;
-}
-async function probeDaemonOverWebsocket(args) {
-    const { host, state } = args;
+async function probeDaemonStatus(target, instance, local) {
+    let connectedDaemon = "unreachable";
+    let note;
+    let live = {};
     let client;
     try {
-        client = await connectToDaemon({ host, timeout: 1500 });
+        client = await connectToDaemon({ target, instance: instance ?? undefined, timeout: 1500 });
     }
     catch (error) {
-        const authFailure = classifyDaemonAuthProbeFailure(error);
-        if (authFailure) {
-            return {
-                connectedDaemon: authFailure,
-                note: describeDaemonAuthProbeFailure(host, authFailure),
-            };
-        }
-        if (state.running) {
-            return {
-                connectedDaemon: "unreachable",
-                localDaemonOverride: "unresponsive",
-                note: `Local daemon PID is running but websocket at ${host} is not reachable`,
-            };
-        }
-        return { connectedDaemon: "unreachable" };
-    }
-    const daemonVersion = client.getLastServerInfoMessage()?.version ?? null;
+        const failure = buildDaemonConnectionCommandError({ target, error });
+        if (target.kind === "endpoint")
+            throw failure;
+        connectedDaemon = "unreachable";
+        if (failure.code === "AUTH_REQUIRED")
+            connectedDaemon = "auth_required";
+        if (failure.code === "AUTH_FAILED")
+            connectedDaemon = "auth_failed";
+        note = failure.message;
+    }
+    if (!client)
+        return { connectedDaemon, note };
     try {
-        const statusPayload = await client.getDaemonStatus({
-            timeout: DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        let requestError;
+        const status = await client.getDaemonStatus({ timeout: 1500 }).catch((error) => {
+            requestError = error;
+            return null;
         });
-        const labelMap = new Map(PROVIDER_BINARIES.map((p) => [p.binary, p.label]));
-        const daemonProviders = statusPayload.providers.map((p) => ({
-            label: labelMap.get(p.provider) ?? p.provider,
-            path: p.available ? "available" : null,
-            version: p.available ? null : (p.error ?? null),
-            source: "daemon",
-        }));
-        const relayStatus = statusPayload.relay == null
-            ? undefined
-            : selectRelayStatus({
-                persisted: relayConfigFromLocalState(state),
-                live: statusPayload.relay,
-            });
-        if (!state.running) {
-            return {
-                connectedDaemon: "reachable",
-                daemonVersion: statusPayload.version ?? daemonVersion,
-                daemonNodeOverride: statusPayload.nodePath,
-                daemonProviders,
-                relayStatus,
-                note: state.pidInfo
-                    ? `Connected daemon is reachable at ${host} even though local daemon PID ${state.pidInfo.pid} is stale`
-                    : `Connected daemon is reachable at ${host} but no local daemon PID file was found`,
+        // Recheck even when the RPC times out before combining local and live observations.
+        const current = target.kind === "instance" ? await readDaemonInstance(target.home) : null;
+        if (instance && (!current || !isSameDaemonInstance(instance, current)))
+            throw new DaemonInstanceError("DAEMON_REPLACED", "Supervisor exited or was replaced during status observation.");
+        const info = client.getLastServerInfoMessage();
+        live = { serverId: info?.serverId, daemonVersion: info?.version };
+        connectedDaemon = client.isConnected ? "reachable" : "unreachable";
+        if (!status) {
+            const failure = toCommandError(requestError);
+            note = `Status details unavailable (${failure.code}): ${failure.message}`;
+            if (target.kind === "endpoint" ||
+                !client.isConnected ||
+                !(requestError instanceof DaemonConnectionError) ||
+                requestError.code !== "DAEMON_REQUEST_TIMEOUT") {
+                throw { ...failure, message: note, details: { ...local, ...live, connectedDaemon } };
+            }
+        }
+        else {
+            live = {
+                ...live,
+                daemonVersion: status.version,
+                workerPid: status.pid,
+                daemonNode: status.nodePath,
+                providers: status.providers,
+                relay: status.relay,
             };
         }
-        return {
-            connectedDaemon: "reachable",
-            daemonVersion: statusPayload.version ?? daemonVersion,
-            daemonNodeOverride: statusPayload.nodePath,
-            daemonProviders,
-            relayStatus,
-        };
-    }
-    catch {
-        return {
-            connectedDaemon: "reachable",
-            daemonVersion,
-            note: state.running
-                ? `Local daemon PID is running but daemon detail request to ${host} failed`
-                : `Connected daemon websocket is reachable at ${host} but daemon status request failed`,
-        };
     }
     finally {
-        await client.close().catch(() => { });
-    }
-}
-function applyProbeToStatus(input) {
-    const { probe } = input;
-    return {
-        connectedDaemon: probe.connectedDaemon,
-        localDaemon: probe.localDaemonOverride ?? input.localDaemon,
-        daemonNode: probe.daemonNodeOverride ?? input.daemonNode,
-        daemonVersion: probe.daemonVersion !== undefined ? probe.daemonVersion : input.daemonVersion,
-        daemonProviders: probe.daemonProviders ?? input.daemonProviders,
-        relayStatus: probe.relayStatus ?? input.relayStatus,
-        note: probe.note ? appendNote(input.note, probe.note) : input.note,
-    };
-}
-function resolveServerIdSafely(home) {
-    try {
-        return { serverId: getOrCreateServerId(home), error: null };
-    }
-    catch (error) {
-        return {
-            serverId: null,
-            error: `serverId unavailable: ${shortenMessage(normalizeError(error))}`,
-        };
+        await client.close();
     }
+    return { ...live, connectedDaemon, note };
 }
-async function resolveDaemonNodeLabel(state) {
-    if (!state.running)
-        return "-";
-    if (!state.pidInfo?.pid)
-        return "unknown (no PID available)";
-    const fromPid = await resolveNodePathFromPid(state.pidInfo.pid);
-    return fromPid.nodePath ?? `unknown (${fromPid.error ?? "could not resolve from PID"})`;
-}
-function relayConfigFromLocalState(state) {
+function localStatus(home, instance) {
+    const config = resolveConfigFromPersisted(home, readPersistedConfig(home, { defaultsIfMissing: true }), { env: {} });
+    let localDaemon = "stopped";
+    if (instance)
+        localDaemon = instance.listen ? "running" : "not_ready";
     return {
-        enabled: state.relayEnabled,
-        endpoint: state.relayEndpoint,
-        publicEndpoint: state.relayEndpoint,
-        useTls: state.relayUseTls,
-        publicUseTls: state.relayPublicUseTls,
-    };
-}
-export function selectRelayStatus(input) {
-    const relay = input.live ?? input.persisted;
-    if (!relay.enabled)
-        return "disabled";
-    const scheme = relay.publicUseTls ? "wss" : "ws";
-    return `${scheme}://${relay.publicEndpoint}`;
-}
-export async function runStatusCommand(options, _command) {
-    const home = typeof options.home === "string" ? options.home : undefined;
-    const state = resolveLocalDaemonState({ home });
-    const daemonTarget = state.listen.trim();
-    const owner = resolveOwnerLabel(state.pidInfo?.uid, state.pidInfo?.hostname);
-    let daemonNode = await resolveDaemonNodeLabel(state);
-    const cliNode = process.execPath;
-    let localDaemon = state.running ? "running" : "stopped";
-    let connectedDaemon = "not_probed";
-    let daemonVersion = null;
-    let daemonProviders;
-    let relayStatus = selectRelayStatus({ persisted: relayConfigFromLocalState(state) });
-    let note;
-    if (!state.running && state.stalePidFile && state.pidInfo) {
-        localDaemon = "stale_pid";
-        note = `Stale PID file found for PID ${state.pidInfo.pid}`;
-    }
-    if (daemonTarget) {
-        const probe = await probeDaemonOverWebsocket({ host: daemonTarget, state });
-        ({
-            connectedDaemon,
-            localDaemon,
-            daemonNode,
-            daemonVersion,
-            daemonProviders,
-            relayStatus,
-            note,
-        } = applyProbeToStatus({
-            probe,
-            connectedDaemon,
-            localDaemon,
-            daemonNode,
-            daemonVersion,
-            daemonProviders,
-            relayStatus,
-            note,
-        }));
-    }
-    const cliVersion = resolveCliVersion();
-    const serverIdResult = resolveServerIdSafely(state.home);
-    const serverId = serverIdResult.serverId;
-    if (serverIdResult.error) {
-        note = appendNote(note, serverIdResult.error);
-    }
-    const providers = daemonProviders ?? (await checkProviderBinaries());
-    const daemonStatus = {
-        serverId,
+        home,
+        pid: instance?.pid ?? null,
+        startedAt: instance?.startedAt ?? null,
+        listen: instance?.listen ?? null,
+        hostname: instance?.hostname ?? null,
+        configuredListen: config.listen,
         localDaemon,
-        connectedDaemon,
-        home: state.home,
-        listen: state.listen,
-        relay: relayStatus,
-        hostname: state.pidInfo?.hostname ?? null,
-        pid: state.pidInfo?.pid ?? null,
-        startedAt: state.pidInfo?.startedAt ?? null,
-        owner,
-        logPath: state.logPath,
-        daemonNode,
-        cliNode,
-        cliVersion,
-        daemonVersion,
-        desktopManaged: state.pidInfo?.desktopManaged === true,
-        providers,
-        note,
-    };
-    return {
-        type: "list",
-        data: toStatusRows(daemonStatus),
-        schema: createStatusSchema(daemonStatus),
+        desktopManaged: instance?.desktopManaged === true,
+        logPath: daemonLogPath(home),
     };
 }
 //# sourceMappingURL=status.js.map

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

@@ -1,15 +1,20 @@
-import type { Command } from "commander";
-import type { CommandOptions, SingleResult } from "../../output/index.js";
-interface StopResult {
-    action: "stopped" | "not_running";
-    home: string;
-    pid: string;
-    forced: boolean;
-    usedLifecycleRpc: boolean;
-    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
-    message: string;
-}
-export type StopCommandResult = SingleResult<StopResult>;
-export declare function runStopCommand(options: CommandOptions, _command: Command): Promise<StopCommandResult>;
-export {};
+import { Command } from "commander";
+import { type CommandOptions } from "../../output/index.js";
+export declare function daemonStopCommand(): Command;
+export declare function runStopCommand(options: CommandOptions, _command: Command): Promise<{
+    type: "single";
+    data: {
+        action: string;
+        home?: string;
+        host?: string;
+        pid?: number | null;
+        forced?: boolean;
+        usedLifecycleRpc?: boolean;
+    };
+    schema: {
+        idField: "action";
+        columns: never[];
+        renderHuman: () => string;
+    };
+}>;
 //# sourceMappingURL=stop.d.ts.map

package/dist/commands/daemon/stop.js

@@ -1,60 +1,58 @@
-import { stopLocalDaemon, DEFAULT_STOP_TIMEOUT_MS, DEFAULT_KILL_TIMEOUT_MS, } from "./local-daemon.js";
-const stopResultSchema = {
-    idField: "action",
-    columns: [
-        {
-            header: "STATUS",
-            field: "action",
-            color: (value) => (value === "stopped" ? "green" : "yellow"),
-        },
-        { header: "HOME", field: "home" },
-        { header: "PID", field: "pid" },
-        { header: "MESSAGE", field: "message" },
-    ],
-};
-function parseSecondsOption(raw, fallbackMs, label) {
-    if (typeof raw !== "string" || raw.trim().length === 0) {
-        return fallbackMs;
-    }
-    const seconds = Number(raw);
-    if (!Number.isFinite(seconds) || seconds <= 0) {
-        const error = {
-            code: "INVALID_TIMEOUT",
-            message: `Invalid ${label} value: ${raw}`,
-            details: `${label} must be a positive number of seconds`,
-        };
-        throw error;
-    }
-    return Math.ceil(seconds * 1000);
+import { Command } from "commander";
+import { stopDaemonInstance } from "@camerontaylor/paseo-server";
+import { connectToDaemon } from "../../utils/client.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { describeDaemonTarget } from "../../utils/daemon-target.js";
+import { parseTimeoutMs } from "./local-daemon.js";
+export function daemonStopCommand() {
+    return addJsonAndDaemonHostOptions(new Command("stop").description("Stop the selected daemon"))
+        .option("--timeout <seconds>", "Graceful exit deadline (default: 15)")
+        .option("--force", "Permit forced local process cleanup")
+        .option("--kill-timeout <seconds>", "Forced exit deadline (default: 3)")
+        .action(withOutput(runStopCommand));
 }
 export async function runStopCommand(options, _command) {
-    const home = typeof options.home === "string" ? options.home : undefined;
-    const force = options.force === true;
-    const timeoutMs = parseSecondsOption(options.timeout, DEFAULT_STOP_TIMEOUT_MS, "timeout");
-    const killTimeoutMs = parseSecondsOption(options.killTimeout, DEFAULT_KILL_TIMEOUT_MS, "kill-timeout");
-    try {
-        const result = await stopLocalDaemon({ home, force, timeoutMs, killTimeoutMs });
-        return {
-            type: "single",
-            data: {
-                action: result.action,
-                home: result.home,
-                pid: result.pid === null ? "-" : String(result.pid),
-                forced: result.forced,
-                usedLifecycleRpc: result.usedLifecycleRpc,
-                reason: result.reason,
-                message: result.message,
-            },
-            schema: stopResultSchema,
+    const target = options.daemonTarget;
+    const timeoutMs = parseTimeoutMs(options.timeout, 15000);
+    const deadline = Date.now() + timeoutMs;
+    const remaining = () => Math.max(1, deadline - Date.now());
+    const requestShutdown = async (instance) => {
+        const client = await connectToDaemon({ target, timeout: remaining(), instance });
+        try {
+            await client.shutdownServer({ timeout: remaining() });
+        }
+        finally {
+            await client.close();
+        }
+    };
+    if (target.kind === "endpoint" && options.force)
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--force requires a local --home; an endpoint gives no remote process authority.",
         };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "STOP_FAILED",
-            message: `Failed to stop local daemon: ${message}`,
-        };
-        throw error;
-    }
+    const result = target.kind === "instance"
+        ? {
+            ...(await stopDaemonInstance(target.home, {
+                force: options.force === true,
+                timeoutMs,
+                killTimeoutMs: parseTimeoutMs(options.killTimeout, 3000),
+                requestShutdown,
+            })),
+            home: target.home,
+        }
+        : (await requestShutdown(),
+            { action: "shutdown_requested", host: describeDaemonTarget(target) });
+    return {
+        type: "single",
+        data: result,
+        schema: {
+            idField: "action",
+            columns: [],
+            renderHuman: () => target.kind === "endpoint"
+                ? "Shutdown requested; remote process exit was not verified."
+                : `${result.action.replaceAll("_", " ")}: ${target.home}`,
+        },
+    };
 }
 //# sourceMappingURL=stop.js.map

package/dist/commands/heartbeat/index.js

@@ -33,7 +33,7 @@ async function runCreateHeartbeat(prompt, options, _command) {
     if (!cron) {
         throw new Error("--cron is required");
     }
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         const maxRuns = options.maxRuns ? Number.parseInt(options.maxRuns, 10) : undefined;
         if (maxRuns !== undefined && (!Number.isSafeInteger(maxRuns) || maxRuns <= 0)) {
@@ -71,7 +71,7 @@ async function runUpdateHeartbeat(id, options, _command) {
     if (!cron) {
         throw new Error("--cron is required");
     }
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireOwnedHeartbeat(client, id, agentId);
         const payload = await client.scheduleUpdate({
@@ -96,7 +96,7 @@ async function runUpdateHeartbeat(id, options, _command) {
 }
 async function runDeleteHeartbeat(id, options, _command) {
     const agentId = requireCallerAgentId();
-    const { client } = await connectScheduleClient(options.host);
+    const { client } = await connectScheduleClient(options.daemonTarget);
     try {
         await requireOwnedHeartbeat(client, id, agentId);
         const payload = await client.scheduleDelete({ id });

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

@@ -6,6 +6,7 @@ import { type HubReporter } from "./reporter.js";
 interface HubConnectOptions {
     apiKey?: string;
     host?: string;
+    daemonTarget: import("../../utils/daemon-target.js").DaemonTarget;
     json?: boolean;
     permission?: readonly string[];
     permissions?: readonly string[];

package/dist/commands/hub/connect.js

@@ -16,7 +16,7 @@ export async function runHubConnect(originInput, options, dependencies) {
     const credential = resolveHubCredential({ ...resolution, origin });
     const token = await dependencies.hub.issueEnrollmentToken(origin, credential);
     const permissions = options.permissions ?? options.permission ?? [];
-    return withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+    return withHubDaemon(dependencies.daemon, options.daemonTarget, async (daemon) => {
         const response = await daemon.connectHub(origin, token, permissions);
         if (response.status.hubOrigin !== null &&
             !samePermissions(response.status.permissions, permissions)) {