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

package/dist/commands/daemon/pair.js

@@ -1,10 +1,9 @@
 import { confirm, isCancel, log } from "@clack/prompts";
 import { Command } from "commander";
 import chalk from "chalk";
-import { generateLocalPairingOffer, getOrCreateServerId, loadConfig, resolvePaseoHome, } from "@camerontaylor/paseo-server";
-import { tryConnectToDaemon } from "../../utils/client.js";
-import { resolveLocalDaemonState } from "./local-daemon.js";
-import { addJsonOption } from "../../utils/command-options.js";
+import { generateLocalPairingOffer, readDaemonInstance, readPersistedConfig, editPersistedConfig, resolveConfigFromPersisted, } from "@camerontaylor/paseo-server";
+import { connectToDaemon } from "../../utils/client.js";
+import { addJsonAndDaemonHostOptions, withGlobalOptions } from "../../utils/command-options.js";
 import { formatPairingInstructions } from "../../output/pairing.js";
 const PAIRING_DAEMON_RPC_TIMEOUT_MS = 1500;
 const RELAY_DOCS_URL = "https://paseo.sh/docs/security";
@@ -26,26 +25,17 @@ function createProcessOutput() {
     };
 }
 export function pairCommand() {
-    return addJsonOption(new Command("pair").description("Print the daemon pairing QR code and link"))
-        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+    return addJsonAndDaemonHostOptions(new Command("pair").description("Print the daemon pairing QR code and link"))
         .option("--relay", "Enable relay without prompting")
-        .action(async (_options, command) => {
-        await runPairCommand(command.optsWithGlobals());
-    });
+        .action(withGlobalOptions((options, _command) => runPairCommand(options)));
 }
 export async function resolveLocalPairingOffer(options) {
-    const state = resolveLocalDaemonState({ home: options.paseoHome });
-    const serverId = getOrCreateServerId(state.home);
-    const daemonOffer = await resolveDaemonPairingOffer(state.listen, serverId, options.enableRelay);
-    if (daemonOffer)
-        return daemonOffer;
-    if (state.running) {
-        throw new Error("The running daemon did not provide a pairing offer. Check daemon connectivity or update the daemon.");
-    }
-    const config = loadConfig(options.paseoHome);
-    if (options.enableRelay && !config.relayEnabled) {
-        throw new Error("Start the daemon before enabling relay for pairing.");
-    }
+    const instance = await readDaemonInstance(options.paseoHome);
+    if (instance)
+        return resolveDaemonPairingOffer({ kind: "instance", home: options.paseoHome }, options.enableRelay);
+    if (options.enableRelay)
+        editPersistedConfig(options.paseoHome, "daemon.relay.enabled", { value: true });
+    const config = resolveConfigFromPersisted(options.paseoHome, readPersistedConfig(options.paseoHome, { defaultsIfMissing: true }), { env: {} });
     return generateLocalPairingOffer({
         paseoHome: options.paseoHome,
         relayEnabled: config.relayEnabled,
@@ -57,18 +47,13 @@ export async function resolveLocalPairingOffer(options) {
         includeQr: true,
     });
 }
-async function resolveDaemonPairingOffer(listen, expectedServerId, enableRelay) {
-    const client = await tryConnectToDaemon({
-        host: listen,
+async function resolveDaemonPairingOffer(target, enableRelay) {
+    const client = await connectToDaemon({
+        target,
         timeout: PAIRING_DAEMON_RPC_TIMEOUT_MS,
     });
-    if (!client)
-        return null;
     try {
         const serverInfo = client.getLastServerInfoMessage();
-        if (serverInfo?.serverId.trim() !== expectedServerId) {
-            throw new Error("The reachable daemon belongs to a different Paseo home. Check --home or the daemon listen configuration.");
-        }
         if (serverInfo?.features?.daemonStatusRpc !== true) {
             throw new Error("Update the Paseo daemon before pairing from this command.");
         }
@@ -80,9 +65,12 @@ async function resolveDaemonPairingOffer(listen, expectedServerId, enableRelay)
                 throw new Error("Update the Paseo daemon before enabling relay from this command.");
             }
             await client.patchDaemonConfig({ relay: { enabled: true } });
-            offer = await client.getDaemonPairingOffer({
-                timeout: PAIRING_DAEMON_RPC_TIMEOUT_MS,
-            });
+            try {
+                offer = await client.getDaemonPairingOffer({ timeout: PAIRING_DAEMON_RPC_TIMEOUT_MS });
+            }
+            catch (error) {
+                throw new Error(`Relay configuration was saved, but fetching the pairing offer failed: ${String(error)}`, { cause: error });
+            }
         }
         return {
             relayEnabled: offer.relayEnabled,
@@ -108,35 +96,17 @@ export function printDirectConnectionGuidance() {
     console.log("To connect another device directly, use the daemon's TCP address over your LAN, Tailscale, or another VPN.");
     console.log(`Learn more: ${RELAY_DOCS_URL}#direct-connections`);
 }
-export async function runPairCommand(options, dependencyOverrides = {}) {
-    if (options.home)
-        process.env.PASEO_HOME = options.home;
-    const dependencies = {
-        resolveOffer: resolveLocalPairingOffer,
-        confirmRelay: confirmRelayPairing,
-        printDirectGuidance: printDirectConnectionGuidance,
-        isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
-        output: createProcessOutput(),
-        ...dependencyOverrides,
-    };
-    const paseoHome = resolvePaseoHome();
-    let pairing = await dependencies.resolveOffer({
-        paseoHome,
-        enableRelay: options.relay === true,
-    });
-    const canPrompt = dependencies.isInteractive() && options.json !== true;
-    if (!pairing.relayEnabled && canPrompt) {
-        const shouldEnable = await dependencies.confirmRelay();
-        if (!shouldEnable) {
-            dependencies.printDirectGuidance();
-            dependencies.output.writeStderr(`${chalk.yellow("No pairing QR was created.")}\n`);
-            dependencies.output.setExitCode(1);
-            return;
-        }
-        pairing = await dependencies.resolveOffer({ paseoHome, enableRelay: true });
-        dependencies.output.success("Relay enabled");
-    }
-    outputPairingResult(pairing, options, dependencies.output);
+export async function runPairCommand(options) {
+    const output = createProcessOutput();
+    const target = options.daemonTarget;
+    const resolveOffer = (enableRelay) => target.kind === "instance"
+        ? resolveLocalPairingOffer({ paseoHome: target.home, enableRelay })
+        : resolveDaemonPairingOffer(target, enableRelay);
+    const offline = target.kind === "instance" && !(await readDaemonInstance(target.home));
+    const pairing = await resolveOffer(options.relay === true);
+    if (offline)
+        output.writeStderr(`Offline pairing offer. Start with: paseo daemon start --home ${JSON.stringify(target.kind === "instance" ? target.home : "")}\n`);
+    outputPairingResult(pairing, options, output);
 }
 function outputPairingResult(pairing, options, output) {
     if (!pairing.relayEnabled || !pairing.url) {

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

@@ -1,10 +1,12 @@
-import type { Command } from "commander";
+import { Command } from "commander";
 import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
 export interface DaemonReloadResult {
+    restartCommand: string;
     appliedPaths: string[];
     restartRequiredPaths: string[];
     overrideControlledPaths: string[];
 }
 export declare const daemonReloadSchema: OutputSchema<DaemonReloadResult>;
 export declare function runDaemonReloadCommand(options: CommandOptions, _command: Command): Promise<SingleResult<DaemonReloadResult>>;
+export declare function daemonReloadCommand(): Command;
 //# sourceMappingURL=reload.d.ts.map

package/dist/commands/daemon/reload.js

@@ -1,3 +1,7 @@
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { withOutput } from "../../output/index.js";
+import { Command } from "commander";
+import { describeDaemonTarget } from "../../utils/daemon-target.js";
 import { connectToDaemon } from "../../utils/client.js";
 export const daemonReloadSchema = {
     idField: () => "daemon-config",
@@ -7,7 +11,7 @@ export const daemonReloadSchema = {
             return "";
         const lines = ["Configuration reloaded."];
         if (result.data.restartRequiredPaths.length > 0) {
-            lines.push("", "Warning: These changes require a daemon restart:", ...result.data.restartRequiredPaths.map((path) => `  ${path}`), "", "Run: paseo daemon restart");
+            lines.push("", "Warning: These changes require a daemon restart:", ...result.data.restartRequiredPaths.map((path) => `  ${path}`), "", `Run: ${result.data.restartCommand}`);
         }
         if (result.data.overrideControlledPaths.length > 0) {
             lines.push("", "Warning: These settings are controlled by daemon launch overrides:", ...result.data.overrideControlledPaths.map((path) => `  ${path}`));
@@ -16,12 +20,13 @@ export const daemonReloadSchema = {
     },
 };
 export async function runDaemonReloadCommand(options, _command) {
-    const client = await connectToDaemon({ host: options.host });
+    const client = await connectToDaemon({ target: options.daemonTarget });
     try {
         const payload = await client.reloadDaemonConfig();
         return {
             type: "single",
             data: {
+                restartCommand: `paseo daemon restart ${options.daemonTarget.kind === "instance" ? `--home ${JSON.stringify(options.daemonTarget.home)}` : `--host ${JSON.stringify(describeDaemonTarget(options.daemonTarget))}`}`,
                 appliedPaths: payload.appliedPaths,
                 restartRequiredPaths: payload.restartRequiredPaths,
                 overrideControlledPaths: payload.overrideControlledPaths,
@@ -33,4 +38,7 @@ export async function runDaemonReloadCommand(options, _command) {
         await client.close();
     }
 }
+export function daemonReloadCommand() {
+    return addJsonAndDaemonHostOptions(new Command("reload").description("Reload config.json without restarting")).action(withOutput(runDaemonReloadCommand));
+}
 //# sourceMappingURL=reload.js.map

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

@@ -1,12 +1,20 @@
-import type { Command } from "commander";
-import type { CommandOptions, SingleResult } from "../../output/index.js";
-interface RestartResult {
-    action: "restarted";
-    home: string;
-    pid: string;
-    message: string;
-}
-export type RestartCommandResult = SingleResult<RestartResult>;
-export declare function runRestartCommand(options: CommandOptions, _command: Command): Promise<RestartCommandResult>;
-export {};
+import { Command } from "commander";
+import { type CommandOptions } from "../../output/index.js";
+export declare function daemonRestartCommand(): Command;
+export declare function runRestartCommand(options: CommandOptions, _command: Command): Promise<{
+    type: "single";
+    data: {
+        action: string;
+        target: string;
+        supervisorPid: number | null;
+        previousWorkerPid: number;
+        workerPid: number;
+        acknowledged: boolean;
+    };
+    schema: {
+        idField: "action";
+        columns: never[];
+        renderHuman: () => string;
+    };
+}>;
 //# sourceMappingURL=restart.d.ts.map

package/dist/commands/daemon/restart.js

@@ -1,99 +1,113 @@
-import { startLocalDaemonDetached, stopLocalDaemon, DEFAULT_STOP_TIMEOUT_MS, } from "./local-daemon.js";
-const restartResultSchema = {
-    idField: "action",
-    columns: [
-        {
-            header: "STATUS",
-            field: "action",
-            color: () => "green",
-        },
-        { header: "HOME", field: "home" },
-        { header: "PID", field: "pid" },
-        { header: "MESSAGE", field: "message" },
-    ],
-};
-function parseTimeoutMs(raw) {
-    if (typeof raw !== "string" || raw.trim().length === 0) {
-        return DEFAULT_STOP_TIMEOUT_MS;
-    }
-    const seconds = Number(raw);
-    if (!Number.isFinite(seconds) || seconds <= 0) {
-        const error = {
-            code: "INVALID_TIMEOUT",
-            message: `Invalid timeout value: ${raw}`,
-            details: "Timeout must be a positive number of seconds",
-        };
-        throw error;
-    }
-    return Math.ceil(seconds * 1000);
-}
-function toStartOptions(options) {
-    const startOptions = {
-        home: typeof options.home === "string" ? options.home : undefined,
-        listen: typeof options.listen === "string" ? options.listen : undefined,
-        port: typeof options.port === "string" ? options.port : undefined,
-        relay: typeof options.relay === "boolean" ? options.relay : undefined,
-        mcp: typeof options.mcp === "boolean" ? options.mcp : undefined,
-        injectMcp: typeof options.injectMcp === "boolean" ? options.injectMcp : undefined,
-        webUi: typeof options.webUi === "boolean" ? options.webUi : undefined,
-        hostnames: typeof options.hostnames === "string" ? options.hostnames : undefined,
-    };
-    if (startOptions.listen && startOptions.port) {
-        const error = {
-            code: "INVALID_OPTIONS",
-            message: "Cannot use --listen and --port together",
-        };
-        throw error;
-    }
-    return startOptions;
+import { Command } from "commander";
+import { readDaemonInstance, isSameDaemonInstance, DaemonInstanceError } from "@camerontaylor/paseo-server";
+import { setTimeout as delay } from "node:timers/promises";
+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, rejectRemovedLaunchFlags } from "./local-daemon.js";
+export function daemonRestartCommand() {
+    return rejectRemovedLaunchFlags(addJsonAndDaemonHostOptions(new Command("restart").description("Restart the selected daemon worker, retaining its supervisor launch")))
+        .option("--timeout <seconds>", "Replacement readiness deadline (default: 600)")
+        .action(withOutput(runRestartCommand));
 }
 export async function runRestartCommand(options, _command) {
-    const timeoutMs = parseTimeoutMs(options.timeout);
-    const force = options.force === true;
-    const startOptions = toStartOptions(options);
+    const target = options.daemonTarget;
+    const deadline = Date.now() + parseTimeoutMs(options.timeout);
+    const remaining = () => Math.max(1, deadline - Date.now());
+    const instance = target.kind === "instance" ? await readDaemonInstance(target.home) : null;
+    async function checkSupervisor() {
+        if (target.kind !== "instance")
+            return;
+        const current = await readDaemonInstance(target.home);
+        if (!current || !instance || !isSameDaemonInstance(instance, current))
+            throw new DaemonInstanceError("DAEMON_REPLACED", `Supervisor exited or was replaced for ${target.home}.`);
+    }
+    if (target.kind === "instance" && !instance)
+        throw new DaemonInstanceError("DAEMON_NOT_RUNNING", `Daemon is not running for ${target.home}.`);
+    const client = await connectToDaemon({
+        target,
+        instance: instance ?? undefined,
+        timeout: remaining(),
+    });
+    let workerPid;
+    const serverId = client.getLastServerInfoMessage()?.serverId;
+    let acknowledged = false;
     try {
-        let stopResult;
+        workerPid = (await client.getDaemonStatus({ timeout: remaining() })).pid;
+        await checkSupervisor();
         try {
-            stopResult = await stopLocalDaemon({
-                home: startOptions.home,
-                timeoutMs,
-                force,
-            });
+            await client.restartServer("cli_restart", undefined, { timeout: remaining() });
+            acknowledged = true;
+        }
+        catch (error) {
+            if (!isReconnectFailure(error))
+                throw error;
         }
-        catch (err) {
-            const isTimeout = err instanceof Error && err.message.includes("Timed out waiting for daemon PID");
-            if (!force && isTimeout) {
-                stopResult = await stopLocalDaemon({
-                    home: startOptions.home,
-                    timeoutMs,
-                    force: true,
-                });
+    }
+    finally {
+        await client.close();
+    }
+    let lastError = "No replacement worker observed";
+    while (Date.now() < deadline) {
+        try {
+            const replacement = await connectToDaemon({
+                target,
+                instance: instance ?? undefined,
+                timeout: Math.min(1000, remaining()),
+            });
+            try {
+                if (replacement.getLastServerInfoMessage()?.serverId !== serverId)
+                    throw new Error("Connected peer identity changed");
+                const status = await replacement.getDaemonStatus({ timeout: Math.min(1000, remaining()) });
+                if (status.pid !== workerPid) {
+                    await checkSupervisor();
+                    return {
+                        type: "single",
+                        data: {
+                            action: "restarted",
+                            target: describeDaemonTarget(target),
+                            supervisorPid: instance?.pid ?? null,
+                            previousWorkerPid: workerPid,
+                            workerPid: status.pid,
+                            acknowledged,
+                        },
+                        schema: {
+                            idField: "action",
+                            columns: [],
+                            renderHuman: () => `Restarted worker ${workerPid} → ${status.pid} at ${describeDaemonTarget(target)}. Supervisor launch retained.`,
+                        },
+                    };
+                }
             }
-            else {
-                throw err;
+            finally {
+                await replacement.close();
             }
         }
-        const startup = await startLocalDaemonDetached(startOptions);
-        const before = stopResult.pid === null ? "not running" : `PID ${stopResult.pid}`;
-        const after = startup.pid === null ? "unknown PID" : `PID ${startup.pid}`;
-        return {
-            type: "single",
-            data: {
-                action: "restarted",
-                home: stopResult.home,
-                pid: startup.pid === null ? "-" : String(startup.pid),
-                message: `Local daemon restarted (${before} -> ${after})`,
-            },
-            schema: restartResultSchema,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "RESTART_FAILED",
-            message: `Failed to restart local daemon: ${message}`,
-        };
-        throw error;
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            if (code === "DAEMON_REPLACED" || code === "DAEMON_NOT_RUNNING")
+                break;
+            if (!isReconnectFailure(error))
+                throw error;
+        }
+        await delay(Math.min(100, remaining()));
     }
+    throw {
+        code: "RESTART_NOT_CONFIRMED",
+        message: `Replacement was not confirmed for ${describeDaemonTarget(target)}. Restart acknowledged: ${acknowledged}. Last observation: ${String(lastError)}`,
+    };
+}
+function isReconnectFailure(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        [
+            "DAEMON_CONNECTION_LOST",
+            "DAEMON_REQUEST_TIMEOUT",
+            "DAEMON_UNREACHABLE",
+            "DAEMON_NOT_READY",
+        ].includes(String(error.code)));
 }
 //# sourceMappingURL=restart.js.map

package/dist/commands/daemon/set-password.js

@@ -1,7 +1,6 @@
 import path from "node:path";
 import { isCancel, password as passwordPrompt } from "@clack/prompts";
-import { hashDaemonPassword, loadPersistedConfig, savePersistedConfig, } from "@camerontaylor/paseo-server";
-import { resolveLocalPaseoHome } from "./local-daemon.js";
+import { hashDaemonPassword, readPersistedConfig, resolvePaseoHome, savePersistedConfig, } from "@camerontaylor/paseo-server";
 const CONFIG_FILENAME = "config.json";
 const setPasswordResultSchema = {
     idField: "action",
@@ -44,9 +43,9 @@ async function promptForPassword(promptPassword) {
     return first;
 }
 export async function setDaemonPasswordInConfig(newPassword, options = {}) {
-    const paseoHome = resolveLocalPaseoHome(options.home);
+    const paseoHome = resolvePaseoHome({ PASEO_HOME: options.home });
     const configPath = path.join(paseoHome, CONFIG_FILENAME);
-    const persisted = loadPersistedConfig(paseoHome);
+    const persisted = readPersistedConfig(paseoHome);
     const nextConfig = {
         ...persisted,
         daemon: {
@@ -61,8 +60,8 @@ export async function setDaemonPasswordInConfig(newPassword, options = {}) {
     return {
         action: "password_set",
         configPath,
-        restartCommand: "paseo daemon restart",
-        message: `Password written to ${configPath}\nRestart the daemon for the change to take effect.\nRun: paseo daemon restart`,
+        restartCommand: `paseo daemon restart --home ${JSON.stringify(paseoHome)}`,
+        message: `Password written to ${configPath}\nRestart the daemon for the change to take effect.\nRun: paseo daemon restart --home ${JSON.stringify(paseoHome)}`,
     };
 }
 export async function runSetPasswordCommand(options, _command) {
@@ -71,7 +70,7 @@ export async function runSetPasswordCommand(options, _command) {
         : (message) => passwordPrompt({ message });
     const newPassword = await promptForPassword(promptPassword);
     const result = await setDaemonPasswordInConfig(newPassword, {
-        home: typeof options.home === "string" ? options.home : undefined,
+        home: options.daemonTarget.kind === "instance" ? options.daemonTarget.home : undefined,
     });
     return {
         type: "single",

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

@@ -1,6 +1,20 @@
 import { Command } from "commander";
-import { type DaemonStartOptions as StartOptions } from "./local-daemon.js";
-export type { DaemonStartOptions as StartOptions } from "./local-daemon.js";
+import { type CommandOptions } from "../../output/index.js";
 export declare function startCommand(): Command;
-export declare function runStart(options: StartOptions): Promise<void>;
+export declare function runStart(options: CommandOptions, _command: Command): Promise<{
+    type: "single";
+    data: {
+        action: string;
+        home: string;
+        pid: number;
+        listen: string | null;
+        logPath: string;
+    };
+    schema: {
+        idField: "pid";
+        columns: never[];
+        renderHuman: () => string;
+    };
+}>;
+export declare function daemonRunCommand(): Command;
 //# sourceMappingURL=start.d.ts.map

package/dist/commands/daemon/start.js

@@ -1,57 +1,52 @@
-import { Command, Option } from "commander";
-import chalk from "chalk";
-import { startLocalDaemonForeground, startLocalDaemonDetached, } from "./local-daemon.js";
-import { getErrorMessage } from "../../utils/errors.js";
+import { addLocalDaemonOptions } from "../../utils/command-options.js";
+import { Command } from "commander";
+import { daemonLogPath } from "@camerontaylor/paseo-server";
+import { launchLocalDaemon, parseTimeoutMs, rejectRemovedLaunchFlags } from "./local-daemon.js";
+import { withOutput } from "../../output/index.js";
 export function startCommand() {
-    return new Command("start")
-        .description("Start the local Paseo daemon")
-        .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("--foreground", "Run in foreground (don't daemonize)")
-        .option("--relay", "Enable relay connection")
-        .option("--no-relay", "Disable relay connection")
-        .option("--relay-use-tls", "Use wss:// for the relay connection and pairing offers")
-        .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
-        .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
-        .option("--web-ui", "Enable the bundled daemon web UI")
-        .option("--no-web-ui", "Disable the bundled daemon web UI")
-        .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
-        .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
-        .action(async (options) => {
-        await runStart({
-            ...options,
-            hostnames: options.hostnames ?? options.allowedHosts,
-        });
-    });
+    return rejectRemovedLaunchFlags(addLocalDaemonOptions(new Command("start")))
+        .description("Start the local daemon from persistent configuration (local operation)")
+        .option("--timeout <seconds>", "Readiness deadline (default: 600)")
+        .action(withOutput(runStart));
 }
-export async function runStart(options) {
-    if (options.listen && options.port) {
-        console.error(chalk.red("Cannot use --listen and --port together"));
-        process.exit(1);
-    }
-    if (!options.foreground) {
-        try {
-            const startup = await startLocalDaemonDetached(options);
-            console.log(chalk.green(`Daemon starting in background (PID ${startup.pid ?? "unknown"}).`));
-            console.log(chalk.dim(`Logs: ${startup.logPath}`));
-        }
-        catch (err) {
-            exitWithError(getErrorMessage(err));
-        }
-        return;
-    }
-    try {
-        const status = startLocalDaemonForeground(options);
-        process.exit(status);
-    }
-    catch (err) {
-        const message = getErrorMessage(err);
-        exitWithError(`Failed to start daemon: ${message}`);
-    }
+export async function runStart(options, _command) {
+    if (options.daemonTarget.kind !== "instance")
+        throw new Error("Start requires a local home");
+    const home = options.daemonTarget.home;
+    const result = await launchLocalDaemon({ home, timeoutMs: parseTimeoutMs(options.timeout) });
+    const data = {
+        action: result.spawned ? "started" : "already_running",
+        home,
+        pid: result.instance.pid,
+        listen: result.instance.listen,
+        logPath: daemonLogPath(home),
+    };
+    return {
+        type: "single",
+        data,
+        schema: {
+            idField: "pid",
+            columns: [],
+            renderHuman: () => `${result.spawned ? "Started" : "Already running"}: PID ${data.pid}${data.listen ? `, listening on ${data.listen}` : ", not ready"}\nLogs: ${data.logPath}`,
+        },
+    };
 }
-function exitWithError(message) {
-    console.error(chalk.red(message));
-    process.exit(1);
+export function daemonRunCommand() {
+    return rejectRemovedLaunchFlags(addLocalDaemonOptions(new Command("run")))
+        .description("Run a local daemon in the foreground with deployment environment overrides")
+        .action(withOutput(async (options, _command) => {
+        if (options.daemonTarget.kind !== "instance")
+            throw new Error("Run requires a local home");
+        const result = await launchLocalDaemon({
+            home: options.daemonTarget.home,
+            foreground: true,
+        });
+        process.exitCode = result.exitCode ?? 0;
+        return {
+            type: "single",
+            data: { pid: result.instance.pid, action: result.spawned ? "exited" : "already_running" },
+            schema: { idField: "pid", columns: [] },
+        };
+    }));
 }
 //# sourceMappingURL=start.js.map

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

@@ -1,21 +1,13 @@
-import type { Command } from "commander";
-import type { CommandOptions, ListResult } from "../../output/index.js";
-interface StatusRow {
-    key: string;
-    value: string;
-}
-interface RelayStatusConfig {
-    enabled: boolean;
-    endpoint: string;
-    publicEndpoint: string;
-    useTls: boolean;
-    publicUseTls: boolean;
-}
-export declare function selectRelayStatus(input: {
-    persisted: RelayStatusConfig;
-    live?: RelayStatusConfig;
-}): string;
-export type StatusResult = ListResult<StatusRow>;
-export declare function runStatusCommand(options: CommandOptions, _command: Command): Promise<StatusResult>;
-export {};
+import { Command } from "commander";
+import { type CommandOptions } from "../../output/index.js";
+export declare function daemonStatusCommand(): Command;
+export declare function runStatusCommand(options: CommandOptions, _command: Command): Promise<{
+    type: "single";
+    data: Record<string, unknown>;
+    schema: {
+        idField: () => string;
+        columns: never[];
+        renderHuman: () => string;
+    };
+}>;
 //# sourceMappingURL=status.d.ts.map