@otto-code/cli 0.5.0

package/dist/commands/daemon/restart.js

@@ -0,0 +1,99 @@
+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;
+}
+export async function runRestartCommand(options, _command) {
+    const timeoutMs = parseTimeoutMs(options.timeout);
+    const force = options.force === true;
+    const startOptions = toStartOptions(options);
+    try {
+        let stopResult;
+        try {
+            stopResult = await stopLocalDaemon({
+                home: startOptions.home,
+                timeoutMs,
+                force,
+            });
+        }
+        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,
+                });
+            }
+            else {
+                throw err;
+            }
+        }
+        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;
+    }
+}
+//# sourceMappingURL=restart.js.map

package/dist/commands/daemon/runtime-toolchain.d.ts

@@ -0,0 +1,6 @@
+export interface NodePathFromPidResult {
+    nodePath: string | null;
+    error?: string;
+}
+export declare function resolveNodePathFromPid(pid: number): Promise<NodePathFromPidResult>;
+//# sourceMappingURL=runtime-toolchain.d.ts.map

package/dist/commands/daemon/runtime-toolchain.js

@@ -0,0 +1,87 @@
+import { platform } from "node:os";
+import { execCommand } from "@otto-code/server";
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function resolveNodePathFromPidUnix(pid) {
+    try {
+        const { stdout } = await execCommand("ps", ["-o", "comm=", "-p", String(pid)]);
+        const resolved = stdout.trim();
+        return resolved
+            ? { nodePath: resolved }
+            : { nodePath: null, error: "ps returned an empty command path" };
+    }
+    catch (error) {
+        return { nodePath: null, error: `ps failed: ${normalizeError(error)}` };
+    }
+}
+async function runProcessProbe(command, args, options) {
+    try {
+        const { stdout } = await execCommand(command, args, { shell: options?.shell });
+        const resolved = stdout.trim();
+        return resolved
+            ? { resolved }
+            : { resolved: null, error: `${command} returned no executable path` };
+    }
+    catch (error) {
+        return { resolved: null, error: `${command} failed: ${normalizeError(error)}` };
+    }
+}
+async function resolveNodePathFromPidWindows(pid) {
+    const probes = [
+        {
+            label: "powershell-cim",
+            command: "powershell.exe",
+            args: [
+                "-NoProfile",
+                "-Command",
+                `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").ExecutablePath`,
+            ],
+        },
+        {
+            label: "powershell-process",
+            command: "powershell.exe",
+            args: ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).Path`],
+        },
+        {
+            label: "wmic",
+            command: "wmic",
+            args: ["process", "where", `ProcessId=${pid}`, "get", "ExecutablePath", "/VALUE"],
+            parseValue: (stdout) => {
+                const match = stdout.match(/ExecutablePath=(.+)/);
+                return match?.[1]?.trim() ?? null;
+            },
+        },
+    ];
+    const errors = [];
+    async function tryProbe(index) {
+        if (index >= probes.length) {
+            return {
+                nodePath: null,
+                error: errors.join("; ") || "could not resolve executable path from PID",
+            };
+        }
+        const probe = probes[index];
+        const result = await runProcessProbe(probe.command, probe.args, { shell: false });
+        if (result.resolved) {
+            const resolved = probe.parseValue ? probe.parseValue(result.resolved) : result.resolved;
+            if (resolved)
+                return { nodePath: resolved };
+            errors.push(`${probe.label} returned no executable path`);
+        }
+        else if (result.error) {
+            errors.push(`${probe.label}: ${result.error}`);
+        }
+        return tryProbe(index + 1);
+    }
+    return tryProbe(0);
+}
+export async function resolveNodePathFromPid(pid) {
+    return platform() === "win32"
+        ? await resolveNodePathFromPidWindows(pid)
+        : await resolveNodePathFromPidUnix(pid);
+}
+//# sourceMappingURL=runtime-toolchain.js.map

package/dist/commands/daemon/set-password.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface SetPasswordResult {
+    action: "password_set";
+    configPath: string;
+    restartCommand: string;
+    message: string;
+}
+export type PromptPassword = (message: string) => Promise<string | symbol>;
+export interface SetPasswordOptions {
+    home?: string;
+    promptPassword?: PromptPassword;
+}
+export declare function setDaemonPasswordInConfig(newPassword: string, options?: SetPasswordOptions): Promise<SetPasswordResult>;
+export declare function runSetPasswordCommand(options: CommandOptions, _command: Command): Promise<SingleResult<SetPasswordResult>>;
+export {};
+//# sourceMappingURL=set-password.d.ts.map

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

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { isCancel, password as passwordPrompt } from "@clack/prompts";
+import { hashDaemonPassword, loadPersistedConfig, savePersistedConfig, } from "@otto-code/server";
+import { resolveLocalOttoHome } from "./local-daemon.js";
+const CONFIG_FILENAME = "config.json";
+const setPasswordResultSchema = {
+    idField: "action",
+    columns: [
+        { header: "STATUS", field: "action", color: () => "green" },
+        { header: "CONFIG", field: "configPath" },
+        { header: "RESTART", field: "restartCommand" },
+    ],
+    renderHuman: (result, options) => {
+        const data = result.data;
+        const rows = [
+            `Password written to ${data.configPath}`,
+            "Restart the daemon for the change to take effect.",
+            `Run: ${data.restartCommand}`,
+        ];
+        if (options.format === "table") {
+            return rows.join("\n");
+        }
+        return data.message;
+    },
+};
+function createCommandError(code, message, details) {
+    return { code, message, ...(details ? { details } : {}) };
+}
+async function promptForPassword(promptPassword) {
+    const first = await promptPassword("New daemon password");
+    if (isCancel(first)) {
+        throw createCommandError("PASSWORD_CANCELLED", "Password update cancelled");
+    }
+    if (typeof first !== "string" || first.length === 0) {
+        throw createCommandError("PASSWORD_REQUIRED", "Password cannot be empty");
+    }
+    const second = await promptPassword("Confirm daemon password");
+    if (isCancel(second)) {
+        throw createCommandError("PASSWORD_CANCELLED", "Password update cancelled");
+    }
+    if (first !== second) {
+        throw createCommandError("PASSWORD_MISMATCH", "Passwords do not match");
+    }
+    return first;
+}
+export async function setDaemonPasswordInConfig(newPassword, options = {}) {
+    const ottoHome = resolveLocalOttoHome(options.home);
+    const configPath = path.join(ottoHome, CONFIG_FILENAME);
+    const persisted = loadPersistedConfig(ottoHome);
+    const nextConfig = {
+        ...persisted,
+        daemon: {
+            ...persisted.daemon,
+            auth: {
+                ...persisted.daemon?.auth,
+                password: hashDaemonPassword(newPassword),
+            },
+        },
+    };
+    savePersistedConfig(ottoHome, nextConfig);
+    return {
+        action: "password_set",
+        configPath,
+        restartCommand: "otto daemon restart",
+        message: `Password written to ${configPath}\nRestart the daemon for the change to take effect.\nRun: otto daemon restart`,
+    };
+}
+export async function runSetPasswordCommand(options, _command) {
+    const promptPassword = typeof options.promptPassword === "function"
+        ? options.promptPassword
+        : (message) => passwordPrompt({ message });
+    const newPassword = await promptForPassword(promptPassword);
+    const result = await setDaemonPasswordInConfig(newPassword, {
+        home: typeof options.home === "string" ? options.home : undefined,
+    });
+    return {
+        type: "single",
+        data: result,
+        schema: setPasswordResultSchema,
+    };
+}
+//# sourceMappingURL=set-password.js.map

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

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { type DaemonStartOptions as StartOptions } from "./local-daemon.js";
+export type { DaemonStartOptions as StartOptions } from "./local-daemon.js";
+export declare function startCommand(): Command;
+export declare function runStart(options: StartOptions): Promise<void>;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/daemon/start.js

@@ -0,0 +1,56 @@
+import { Command, Option } from "commander";
+import chalk from "chalk";
+import { startLocalDaemonForeground, startLocalDaemonDetached, } from "./local-daemon.js";
+import { getErrorMessage } from "../../utils/errors.js";
+export function startCommand() {
+    return new Command("start")
+        .description("Start the local Otto daemon")
+        .option("--listen <listen>", "Listen target (host:port, port, or unix socket path)")
+        .option("--port <port>", "Port to listen on (default: 6868)")
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--foreground", "Run in foreground (don't daemonize)")
+        .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 Otto 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,
+        });
+    });
+}
+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}`);
+    }
+}
+function exitWithError(message) {
+    console.error(chalk.red(message));
+    process.exit(1);
+}
+//# sourceMappingURL=start.js.map

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

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+interface StatusRow {
+    key: string;
+    value: string;
+}
+export type StatusResult = ListResult<StatusRow>;
+export declare function runStatusCommand(options: CommandOptions, _command: Command): Promise<StatusResult>;
+export {};
+//# sourceMappingURL=status.d.ts.map