@otto-code/cli 0.5.0

package/dist/commands/daemon/local-daemon.js

@@ -0,0 +1,544 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { loadConfig, resolveOttoHome, spawnProcess } from "@otto-code/server";
+import treeKill from "tree-kill";
+import { tryConnectToDaemon } from "../../utils/client.js";
+const DETACHED_STARTUP_GRACE_MS = 1200;
+const PID_POLL_INTERVAL_MS = 100;
+const DAEMON_LOG_FILENAME = "daemon.log";
+const DAEMON_PID_FILENAME = "otto.pid";
+export const DEFAULT_STOP_TIMEOUT_MS = 15000;
+export const DEFAULT_KILL_TIMEOUT_MS = 3000;
+const require = createRequire(import.meta.url);
+const defaultDaemonLaunchRuntime = {
+    resolveRunnerEntry: resolveDaemonRunnerEntry,
+    resolveHome: resolveOttoHome,
+    spawnDetached: spawnProcess,
+    spawnForeground: spawnSync,
+};
+const startupReady = () => ({ exitedEarly: false });
+const startupExited = (details) => ({
+    exitedEarly: true,
+    ...details,
+});
+function envWithHome(home) {
+    if (!home) {
+        return process.env;
+    }
+    return { ...process.env, OTTO_HOME: home };
+}
+function buildRunnerArgs(options) {
+    const args = [];
+    if (options.relay === false) {
+        args.push("--no-relay");
+    }
+    if (options.relayUseTls === true) {
+        args.push("--relay-use-tls");
+    }
+    if (options.mcp === false) {
+        args.push("--no-mcp");
+    }
+    if (options.injectMcp === false) {
+        args.push("--no-inject-mcp");
+    }
+    if (options.webUi === true) {
+        args.push("--web-ui");
+    }
+    if (options.webUi === false) {
+        args.push("--no-web-ui");
+    }
+    return args;
+}
+function buildChildEnv(options) {
+    const childEnv = { ...process.env };
+    if (options.home) {
+        childEnv.OTTO_HOME = options.home;
+    }
+    if (options.listen) {
+        childEnv.OTTO_LISTEN = options.listen;
+    }
+    else if (options.port) {
+        childEnv.OTTO_LISTEN = `127.0.0.1:${options.port}`;
+    }
+    if (options.hostnames) {
+        childEnv.OTTO_HOSTNAMES = options.hostnames;
+    }
+    if (options.relayUseTls === true) {
+        childEnv.OTTO_RELAY_USE_TLS = "true";
+    }
+    if (options.webUi === true) {
+        childEnv.OTTO_WEB_UI_ENABLED = "true";
+    }
+    if (options.webUi === false) {
+        childEnv.OTTO_WEB_UI_ENABLED = "false";
+    }
+    return childEnv;
+}
+function resolveServerRunnerFromDir(currentDir) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (!existsSync(packageJsonPath))
+        return null;
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.name !== "@otto-code/server")
+            return null;
+        const distRunner = path.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
+        if (existsSync(distRunner)) {
+            return distRunner;
+        }
+        return path.join(currentDir, "scripts", "supervisor-entrypoint.ts");
+    }
+    catch {
+        return null;
+    }
+}
+function resolveDaemonRunnerEntry() {
+    const serverExportPath = require.resolve("@otto-code/server");
+    let currentDir = path.dirname(serverExportPath);
+    while (true) {
+        const entry = resolveServerRunnerFromDir(currentDir);
+        if (entry) {
+            return entry;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new Error("Unable to resolve @otto-code/server package root for daemon runner");
+}
+function pidFilePath(ottoHome) {
+    return path.join(ottoHome, DAEMON_PID_FILENAME);
+}
+function resolveListenField(listen, sockPath) {
+    if (typeof listen === "string")
+        return listen;
+    if (typeof sockPath === "string")
+        return sockPath;
+    return undefined;
+}
+function resolveStopMessage(forced, lifecycleRequested, fallbackMessage) {
+    if (forced)
+        return "Daemon owner process was force-stopped";
+    if (lifecycleRequested)
+        return "Daemon stopped gracefully";
+    return fallbackMessage ?? "Daemon stopped via owner PID signal";
+}
+function resolveStopReason(forced, lifecycleRequested) {
+    if (forced)
+        return "owner_pid_sigkill";
+    if (lifecycleRequested)
+        return "lifecycle_shutdown_rpc";
+    return "owner_pid_signal";
+}
+function readPidFile(pidPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(pidPath, "utf-8"));
+        const pidValue = parsed.pid;
+        if (typeof pidValue !== "number" || !Number.isInteger(pidValue) || pidValue <= 0) {
+            return null;
+        }
+        return {
+            pid: pidValue,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+            hostname: typeof parsed.hostname === "string" ? parsed.hostname : undefined,
+            uid: typeof parsed.uid === "number" ? parsed.uid : undefined,
+            listen: resolveListenField(parsed.listen, parsed.sockPath),
+            desktopManaged: parsed.desktopManaged === true ? true : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function tailFile(filePath, lines = 30) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        return content.split("\n").filter(Boolean).slice(-lines).join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function readNodeErrnoCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error)) {
+        return undefined;
+    }
+    return typeof error.code === "string" ? error.code : undefined;
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = readNodeErrnoCode(err);
+        if (code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+function signalProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch (err) {
+        const code = readNodeErrnoCode(err);
+        if (code === "ESRCH") {
+            return false;
+        }
+        throw err;
+    }
+}
+function signalProcessSafely(pid, signal) {
+    if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) {
+        return false;
+    }
+    try {
+        return signalProcess(pid, signal);
+    }
+    catch (err) {
+        const code = readNodeErrnoCode(err);
+        if (code === "EPERM") {
+            return true;
+        }
+        throw err;
+    }
+}
+async function signalProcessTreeSafely(pid, signal) {
+    if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) {
+        return false;
+    }
+    return new Promise((resolve, reject) => {
+        treeKill(pid, signal, (err) => {
+            if (!err) {
+                resolve(true);
+                return;
+            }
+            const code = readNodeErrnoCode(err);
+            if (code === "ESRCH") {
+                resolve(false);
+                return;
+            }
+            if (code === "EPERM") {
+                resolve(true);
+                return;
+            }
+            reject(err);
+        });
+    });
+}
+async function signalProcessTreeOrOwnerSafely(pid, signal) {
+    try {
+        return await signalProcessTreeSafely(pid, signal);
+    }
+    catch {
+        return signalProcessSafely(pid, signal);
+    }
+}
+async function waitForPidExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    async function poll() {
+        if (!isProcessRunning(pid))
+            return true;
+        if (Date.now() >= deadline)
+            return !isProcessRunning(pid);
+        await sleep(PID_POLL_INTERVAL_MS);
+        return poll();
+    }
+    return poll();
+}
+async function waitForDaemonUnreachable(state, timeoutMs) {
+    const host = resolveTcpHostFromListen(state.listen);
+    if (!host) {
+        return true;
+    }
+    const reachableHost = host;
+    const deadline = Date.now() + timeoutMs;
+    async function poll() {
+        const client = await tryConnectToDaemon({ host: reachableHost, timeout: 500 });
+        if (!client) {
+            return true;
+        }
+        await client.close().catch(() => undefined);
+        if (Date.now() >= deadline) {
+            const finalClient = await tryConnectToDaemon({
+                host: reachableHost,
+                timeout: PID_POLL_INTERVAL_MS,
+            });
+            if (!finalClient) {
+                return true;
+            }
+            await finalClient.close().catch(() => undefined);
+            return false;
+        }
+        await sleep(PID_POLL_INTERVAL_MS);
+        return poll();
+    }
+    return poll();
+}
+function removeStalePidFile(state) {
+    if (!state.stalePidFile) {
+        return;
+    }
+    try {
+        unlinkSync(state.pidPath);
+    }
+    catch {
+        // Best-effort cleanup only. The successful lifecycle stop is authoritative.
+    }
+}
+function createNotRunningStopResult(state, pid, message) {
+    return {
+        action: "not_running",
+        home: state.home,
+        pid,
+        forced: false,
+        usedLifecycleRpc: false,
+        reason: "not_running",
+        message,
+    };
+}
+function createStopTimeoutError(state, pid, timeoutMs) {
+    if (!state.running) {
+        const host = resolveTcpHostFromListen(state.listen);
+        return new Error(`Timed out waiting for daemon${host ? ` at ${host}` : ""} to stop after ${Math.ceil(timeoutMs / 1000)}s`);
+    }
+    return new Error(`Timed out waiting for daemon PID ${pid} to stop after ${Math.ceil(timeoutMs / 1000)}s`);
+}
+async function signalDaemonOwnerForStop(state, pid) {
+    if (pid === null) {
+        return createNotRunningStopResult(state, null, "Daemon is not running");
+    }
+    const signaled = await signalProcessTreeOrOwnerSafely(pid, "SIGTERM");
+    if (signaled) {
+        return null;
+    }
+    return createNotRunningStopResult(state, pid, "Daemon process was already stopped");
+}
+async function waitForStopAfterRequest(args) {
+    const { state, pid, timeoutMs, killTimeoutMs, force } = args;
+    let stopped = state.running && pid !== null
+        ? await waitForPidExit(pid, timeoutMs)
+        : await waitForDaemonUnreachable(state, timeoutMs);
+    if (!stopped && force && state.running && pid !== null) {
+        await signalProcessTreeOrOwnerSafely(pid, "SIGKILL");
+        stopped = await waitForPidExit(pid, killTimeoutMs);
+        return { stopped, forced: true };
+    }
+    return { stopped, forced: false };
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function resolveLocalOttoHome(home) {
+    return resolveOttoHome(envWithHome(home));
+}
+export function resolveTcpHostFromListen(listen) {
+    const normalized = listen.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.startsWith("/") ||
+        normalized.startsWith("unix://") ||
+        normalized.startsWith("pipe://") ||
+        normalized.startsWith("\\\\.\\pipe\\") ||
+        /^[A-Za-z]:[/\\]/.test(normalized)) {
+        return null;
+    }
+    if (/^\d+$/.test(normalized)) {
+        return `127.0.0.1:${normalized}`;
+    }
+    if (normalized.includes(":")) {
+        return normalized;
+    }
+    return null;
+}
+export function resolveLocalDaemonState(options = {}) {
+    const env = {
+        ...envWithHome(options.home),
+        // Status should reflect local persisted config + pid file, not inherited daemon env overrides.
+        // This is CLI-side defensive scrubbing; the daemon RPC is authoritative when available.
+        OTTO_LISTEN: undefined,
+        OTTO_HOSTNAMES: undefined,
+        OTTO_ALLOWED_HOSTS: undefined,
+        OTTO_RELAY_ENABLED: undefined,
+        OTTO_RELAY_ENDPOINT: undefined,
+        OTTO_RELAY_PUBLIC_ENDPOINT: undefined,
+        OTTO_RELAY_USE_TLS: undefined,
+        OTTO_RELAY_PUBLIC_USE_TLS: undefined,
+    };
+    const home = resolveOttoHome(env);
+    const config = loadConfig(home, { env });
+    const pidPath = pidFilePath(home);
+    const logPath = path.join(home, DAEMON_LOG_FILENAME);
+    const pidInfo = existsSync(pidPath) ? readPidFile(pidPath) : null;
+    const running = pidInfo ? isProcessRunning(pidInfo.pid) : false;
+    const listen = pidInfo?.listen ?? config.listen;
+    return {
+        home,
+        listen,
+        relayEnabled: config.relayEnabled ?? true,
+        relayEndpoint: config.relayPublicEndpoint ?? config.relayEndpoint ?? "relay.otto-code.me:443",
+        relayUseTls: config.relayUseTls ?? false,
+        relayPublicUseTls: config.relayPublicUseTls ?? config.relayUseTls ?? false,
+        logPath,
+        pidPath,
+        pidInfo,
+        running,
+        stalePidFile: Boolean(pidInfo) && !running,
+    };
+}
+export function tailDaemonLog(home, lines = 30) {
+    const logPath = path.join(resolveLocalOttoHome(home), DAEMON_LOG_FILENAME);
+    return tailFile(logPath, lines);
+}
+export async function startLocalDaemonDetached(options, runtime = defaultDaemonLaunchRuntime) {
+    if (options.listen && options.port) {
+        throw new Error("Cannot use --listen and --port together");
+    }
+    const daemonRunnerEntry = runtime.resolveRunnerEntry();
+    const childEnv = buildChildEnv(options);
+    const ottoHome = runtime.resolveHome(childEnv);
+    const logPath = path.join(ottoHome, DAEMON_LOG_FILENAME);
+    const child = runtime.spawnDetached(process.execPath, [...process.execArgv, daemonRunnerEntry, ...buildRunnerArgs(options)], {
+        detached: true,
+        envMode: "internal",
+        env: childEnv,
+        stdio: ["ignore", "ignore", "ignore"],
+    });
+    child.unref();
+    const startup = await new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(startupReady()), DETACHED_STARTUP_GRACE_MS);
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            finish(startupExited({ code: null, signal: null, error }));
+        });
+        child.once("exit", (code, signal) => {
+            clearTimeout(timer);
+            finish(startupExited({ code, signal }));
+        });
+    });
+    if (startup.exitedEarly) {
+        const reason = startup.error
+            ? startup.error.message
+            : `exit code ${startup.code ?? "unknown"}${startup.signal ? ` (${startup.signal})` : ""}`;
+        const recentLogs = tailFile(logPath);
+        throw new Error([
+            `Daemon failed to start in background (${reason}).`,
+            recentLogs ? `Recent daemon logs:\n${recentLogs}` : null,
+        ]
+            .filter(Boolean)
+            .join("\n\n"));
+    }
+    return {
+        pid: child.pid ?? null,
+        logPath,
+    };
+}
+export function startLocalDaemonForeground(options, runtime = defaultDaemonLaunchRuntime) {
+    if (options.listen && options.port) {
+        throw new Error("Cannot use --listen and --port together");
+    }
+    const daemonRunnerEntry = runtime.resolveRunnerEntry();
+    const childEnv = buildChildEnv(options);
+    const result = runtime.spawnForeground(process.execPath, [...process.execArgv, daemonRunnerEntry, ...buildRunnerArgs(options)], {
+        env: childEnv,
+        stdio: "inherit",
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    return result.status ?? 1;
+}
+async function requestLifecycleShutdown(state, timeoutMs) {
+    const host = resolveTcpHostFromListen(state.listen);
+    if (!host) {
+        return {
+            requested: false,
+            reason: "daemon listen target is not TCP, falling back to owner PID signal",
+        };
+    }
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
+    const client = await tryConnectToDaemon({ host, timeout: Math.min(remainingTimeoutMs(), 5000) });
+    if (!client) {
+        return {
+            requested: false,
+            reason: `daemon websocket at ${host} is not reachable, falling back to owner PID signal`,
+        };
+    }
+    try {
+        await client.shutdownServer({ timeout: Math.min(remainingTimeoutMs(), 5000) });
+        return { requested: true };
+    }
+    catch (error) {
+        return {
+            requested: false,
+            reason: `daemon lifecycle shutdown request failed (${getErrorMessage(error)}), falling back to owner PID signal`,
+        };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export async function stopLocalDaemon(options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
+    const killTimeoutMs = options.killTimeoutMs ?? DEFAULT_KILL_TIMEOUT_MS;
+    const state = resolveLocalDaemonState({ home: options.home });
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
+    const shutdownAttempt = await requestLifecycleShutdown(state, remainingTimeoutMs());
+    const lifecycleRequested = shutdownAttempt.requested;
+    if (!state.pidInfo || (!state.running && !lifecycleRequested)) {
+        const staleSuffix = state.stalePidFile && state.pidInfo ? ` (stale PID file for ${state.pidInfo.pid})` : "";
+        return createNotRunningStopResult(state, state.pidInfo?.pid ?? null, `Daemon is not running${staleSuffix}`);
+    }
+    const pid = state.pidInfo?.pid ?? null;
+    const fallbackMessage = shutdownAttempt.requested ? null : shutdownAttempt.reason;
+    if (!lifecycleRequested) {
+        const notRunningResult = await signalDaemonOwnerForStop(state, pid);
+        if (notRunningResult)
+            return notRunningResult;
+    }
+    const { stopped, forced } = await waitForStopAfterRequest({
+        state,
+        pid,
+        timeoutMs: remainingTimeoutMs(),
+        killTimeoutMs,
+        force: options.force,
+    });
+    if (!stopped) {
+        throw createStopTimeoutError(state, pid, timeoutMs);
+    }
+    if (lifecycleRequested) {
+        removeStalePidFile(state);
+    }
+    return {
+        action: "stopped",
+        home: state.home,
+        pid,
+        forced,
+        usedLifecycleRpc: lifecycleRequested,
+        reason: resolveStopReason(forced, lifecycleRequested),
+        message: resolveStopMessage(forced, lifecycleRequested, fallbackMessage),
+    };
+}
+//# sourceMappingURL=local-daemon.js.map

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

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+interface PairOptions {
+    home?: string;
+    json?: boolean;
+}
+export declare function pairCommand(): Command;
+export declare function runPairCommand(options: PairOptions): Promise<void>;
+export {};
+//# sourceMappingURL=pair.d.ts.map

package/dist/commands/daemon/pair.js

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { generateLocalPairingOffer, loadConfig, resolveOttoHome } from "@otto-code/server";
+import { tryConnectToDaemon } from "../../utils/client.js";
+import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
+import { addJsonOption } from "../../utils/command-options.js";
+const PAIRING_DAEMON_RPC_TIMEOUT_MS = 1500;
+export function pairCommand() {
+    return addJsonOption(new Command("pair").description("Print the daemon pairing QR code and link"))
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .action(async (_options, command) => {
+        await runPairCommand(command.optsWithGlobals());
+    });
+}
+export async function runPairCommand(options) {
+    if (options.home) {
+        process.env.OTTO_HOME = options.home;
+    }
+    const ottoHome = resolveOttoHome();
+    const state = resolveLocalDaemonState({ home: ottoHome });
+    const host = resolveTcpHostFromListen(state.listen);
+    // Try to get the pairing offer from the running daemon first.
+    if (host) {
+        const client = await tryConnectToDaemon({ host, timeout: 1500 });
+        if (client) {
+            const supportsDaemonStatusRpc = client.getLastServerInfoMessage()?.features?.daemonStatusRpc === true;
+            if (supportsDaemonStatusRpc) {
+                try {
+                    const offer = await client.getDaemonPairingOffer({
+                        timeout: PAIRING_DAEMON_RPC_TIMEOUT_MS,
+                    });
+                    await client.close().catch(() => { });
+                    outputPairingResult({ relayEnabled: offer.relayEnabled, url: offer.url, qr: offer.qr ?? null }, options);
+                    return;
+                }
+                catch {
+                    // COMPAT(daemon-rpc-rollout): fall back to CLI-side pairing generation while
+                    // old daemons lack daemonStatusRpc. Remove once the daemon floor is past
+                    // v0.1.76; pairing should come from daemon.get_pairing_offer.
+                }
+            }
+            await client.close().catch(() => { });
+        }
+    }
+    // Fall back to local pairing offer generation.
+    const config = loadConfig(ottoHome);
+    const pairing = await generateLocalPairingOffer({
+        ottoHome,
+        relayEnabled: config.relayEnabled,
+        relayEndpoint: config.relayEndpoint,
+        relayPublicEndpoint: config.relayPublicEndpoint,
+        relayUseTls: config.relayUseTls,
+        relayPublicUseTls: config.relayPublicUseTls,
+        appBaseUrl: config.appBaseUrl,
+        includeQr: true,
+    });
+    outputPairingResult(pairing, options);
+}
+function outputPairingResult(pairing, options) {
+    if (!pairing.relayEnabled || !pairing.url) {
+        console.error(chalk.red("Relay pairing is disabled for this daemon config."));
+        console.error(chalk.yellow("Enable relay and run this command again."));
+        process.exit(1);
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            relayEnabled: pairing.relayEnabled,
+            url: pairing.url,
+            qr: pairing.qr,
+        }, null, 2)}\n`);
+        return;
+    }
+    const qrBlock = pairing.qr ? `${pairing.qr}\n` : "";
+    process.stdout.write(`\nScan to pair:\n${qrBlock}${pairing.url}\n`);
+}
+//# sourceMappingURL=pair.js.map

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

@@ -0,0 +1,12 @@
+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 {};
+//# sourceMappingURL=restart.d.ts.map