@otto-code/server 0.5.0

package/.env.example

@@ -0,0 +1,31 @@
+# OpenAI API Key (for GPT-4, Whisper STT, and TTS)
+OPENAI_API_KEY=
+
+# Optional: point speech-to-text and text-to-speech at different OpenAI-compatible
+# endpoints. Each falls back to OPENAI_API_KEY / OPENAI_BASE_URL when unset.
+# STT covers composer dictation + voice mode STT; TTS covers voice mode TTS.
+OPENAI_STT_API_KEY=
+OPENAI_STT_BASE_URL=
+OPENAI_TTS_API_KEY=
+OPENAI_TTS_BASE_URL=
+
+# TTS Configuration (optional - defaults shown)
+TTS_VOICE=alloy
+# Available voices: alloy, echo, fable, onyx, nova, shimmer
+TTS_MODEL=tts-1
+# Available models: tts-1 (faster), tts-1-hd (higher quality)
+
+# Server Configuration
+# Location for runtime state (agents.json, etc.). Defaults to ~/.otto
+OTTO_HOME=~/.otto
+
+# Listen address. Defaults to 127.0.0.1:6868
+# Can be host:port, /path/to/socket, or unix:///path/to/socket
+OTTO_LISTEN=127.0.0.1:6868
+
+# Debug recordings (dictation + STT input + TTS output)
+# When enabled, recordings are saved under `${cwd}/.debug/recordings/`
+OTTO_DICTATION_DEBUG=1
+
+# Enable verbose Claude SDK stream logging (trace-level per-token logs)
+OTTO_CLAUDE_DEBUG=1

package/README.md

@@ -0,0 +1,111 @@
+# Voice Assistant
+
+A voice-controlled terminal assistant that runs as a single local service.
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Copy environment variables
+cp .env.example .env
+# Edit .env and add your API keys (OpenAI, Deepgram)
+
+# Run development servers
+npm run dev
+
+# Open browser to http://localhost:5173
+```
+
+## Architecture
+
+- **Express Server** (port 3000) - Serves API and built UI in production
+- **Vite Dev Server** (port 5173) - Hot-reload React UI in development
+- **WebSocket** (`/ws`) - Real-time bidirectional communication
+- **Agent** - STT → LLM → TTS pipeline with terminal control
+- **Daemon** - tmux-based terminal management (in-process)
+
+## Development
+
+```bash
+# Run both servers (recommended)
+npm run dev
+
+# Or run separately:
+npm run dev:server  # Express on port 3000
+npm run dev:ui      # Vite on port 5173
+
+# Type checking
+npm run typecheck
+
+# Build for production
+npm run build
+
+# Start production server
+npm start
+```
+
+## Project Status
+
+**✅ Completed** (Phases 1-2):
+
+- Package setup and configuration
+- Express server with WebSocket
+- React UI with Vite
+- WebSocket client with ping/pong testing
+
+**⏳ In Progress** (Phase 3):
+
+- Terminal control (tmux integration)
+
+**📋 Planned** (Phases 4-9):
+
+- LLM integration (OpenAI GPT-4)
+- Agent orchestrator
+- Speech-to-Text (Deepgram)
+- Text-to-Speech (OpenAI)
+- Audio streaming
+- UI polish
+
+See [IMPLEMENTATION_PLAN.md](./IMPLEMENTATION_PLAN.md) for complete details.
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=your-openai-key-here      # GPT-4 and TTS
+DEEPGRAM_API_KEY=your-deepgram-key-here  # Streaming STT
+STT_MODEL=whisper-1        # Optional: override to gpt-4o-transcribe, etc.
+STT_CONFIDENCE_THRESHOLD=-3.0  # Optional: reject low-confidence clips
+STT_DEBUG_AUDIO_DIR=.stt-debug # Optional: persist raw dictation audio for debugging
+OTTO_HOME=~/.otto        # Runtime state directory (agents/, etc.)
+OTTO_LISTEN=127.0.0.1:6868  # Listen address (host:port or /path/to/socket)
+```
+
+`OTTO_HOME` defaults to `~/.otto` and isolates runtime artifacts like `agents/`. `OTTO_LISTEN` controls the daemon listen address. For blue/green testing you can run a parallel server without touching production state:
+
+```bash
+OTTO_HOME=~/.otto-blue OTTO_LISTEN=127.0.0.1:7777 npm run dev
+```
+
+## Tech Stack
+
+- **Server**: Express, TypeScript, ws (WebSocket)
+- **Client**: React 18, Vite, TypeScript
+- **Terminal**: tmux (via child_process)
+- **AI**: OpenAI (LLM + TTS), Deepgram (STT)
+
+## Testing
+
+Currently manual testing via:
+
+1. Start servers: `npm run dev`
+2. Open http://localhost:5173
+3. Test WebSocket connection (green status indicator)
+4. Click "Send Ping" button to test communication
+
+More testing guidance as features are implemented.
+
+## License
+
+MIT

package/dist/scripts/dev-runner.js

@@ -0,0 +1,37 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "url";
+import dotenv from "dotenv";
+dotenv.config({
+    path: fileURLToPath(new URL("../.env", import.meta.url)),
+    quiet: true,
+});
+const daemonRunnerEntry = fileURLToPath(new URL("./supervisor-entrypoint.ts", import.meta.url));
+const supervisorArgs = [...process.execArgv, daemonRunnerEntry, "--dev", ...process.argv.slice(2)];
+const supervisor = spawn(process.execPath, supervisorArgs, {
+    stdio: "inherit",
+    env: {
+        ...process.env,
+        OTTO_LOG_FORMAT: process.env.OTTO_LOG_FORMAT ?? "pretty",
+    },
+});
+function exitCodeForSignal(signal) {
+    return signal === "SIGINT" ? 130 : 1;
+}
+function forwardSignal(signal) {
+    if (supervisor.exitCode !== null || supervisor.signalCode !== null || supervisor.killed) {
+        return;
+    }
+    supervisor.kill(signal);
+}
+// The supervisor handles SIGINT/SIGTERM itself and needs time to drain the
+// worker gracefully. Keep this wrapper alive until the supervisor exits so npm
+// does not release the shell while the daemon is still logging final shutdown.
+process.on("SIGINT", () => forwardSignal("SIGINT"));
+process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+supervisor.on("error", (error) => {
+    throw error;
+});
+supervisor.on("exit", (code, signal) => {
+    process.exit(code ?? (signal ? exitCodeForSignal(signal) : 1));
+});
+//# sourceMappingURL=dev-runner.js.map

package/dist/scripts/mcp-stdio-socket-bridge-cli.mjs

@@ -0,0 +1,62 @@
+import net from "node:net";
+
+function parseArgs(argv) {
+  let socketPath = null;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--socket") {
+      socketPath = argv[index + 1] ?? null;
+      index += 1;
+    }
+  }
+
+  if (!socketPath || !socketPath.trim()) {
+    throw new Error("Missing required --socket <path>");
+  }
+
+  return { socketPath: socketPath.trim() };
+}
+
+async function main() {
+  const { socketPath } = parseArgs(process.argv.slice(2));
+  const socket = net.createConnection(socketPath);
+
+  socket.on("error", (error) => {
+    process.stderr.write(`MCP stdio-socket bridge error: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+
+  process.stdin.on("error", (error) => {
+    process.stderr.write(`MCP stdio-socket bridge stdin error: ${error.message}\n`);
+    socket.destroy();
+    process.exitCode = 1;
+  });
+
+  process.stdout.on("error", (error) => {
+    process.stderr.write(`MCP stdio-socket bridge stdout error: ${error.message}\n`);
+    socket.destroy();
+    process.exitCode = 1;
+  });
+
+  await new Promise((resolve, reject) => {
+    socket.once("connect", resolve);
+    socket.once("error", reject);
+  });
+
+  process.stdin.pipe(socket);
+  socket.pipe(process.stdout);
+
+  await new Promise((resolve) => {
+    socket.once("close", resolve);
+    process.stdin.once("end", () => {
+      socket.end();
+      resolve();
+    });
+  });
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});

package/dist/scripts/supervisor-entrypoint.js

@@ -0,0 +1,141 @@
+import { fileURLToPath } from "url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { acquirePidLock, PidLockError, releasePidLock, updatePidLock, } from "../src/server/pid-lock.js";
+import { resolveOttoHome } from "../src/server/otto-home.js";
+import { loadPersistedConfig } from "../src/server/persisted-config.js";
+import { runSupervisor } from "./supervisor.js";
+import { resolveSupervisorLogFile } from "./supervisor-log-config.js";
+import { applySherpaLoaderEnv } from "../src/server/speech/providers/local/sherpa/sherpa-runtime-env.js";
+process.title = "Otto Supervisor";
+function parseConfig(argv) {
+    let devMode = false;
+    const workerArgs = [];
+    for (const arg of argv) {
+        if (arg === "--dev") {
+            devMode = true;
+            continue;
+        }
+        workerArgs.push(arg);
+    }
+    return { devMode, workerArgs };
+}
+function resolveWorkerEntry() {
+    const candidates = [
+        fileURLToPath(new URL("../server/server/daemon-worker.js", import.meta.url)),
+        fileURLToPath(new URL("../dist/server/server/daemon-worker.js", import.meta.url)),
+        fileURLToPath(new URL("../src/server/daemon-worker.ts", import.meta.url)),
+        fileURLToPath(new URL("../../src/server/daemon-worker.ts", import.meta.url)),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function resolveDevWorkerEntry() {
+    const candidate = fileURLToPath(new URL("../src/server/daemon-worker.ts", import.meta.url));
+    if (!existsSync(candidate)) {
+        throw new Error(`Dev worker entry not found: ${candidate}`);
+    }
+    return candidate;
+}
+function resolveWorkerExecArgv(workerEntry, devMode) {
+    const execArgv = workerEntry.endsWith(".ts") ? ["--import", "tsx"] : [];
+    if (!devMode) {
+        return execArgv;
+    }
+    const devArgs = [
+        "--heapsnapshot-near-heap-limit=3",
+        "--max-old-space-size=3072",
+        "--report-on-fatalerror",
+        "--report-directory=/tmp/otto-reports",
+    ];
+    const inspectArg = process.env.OTTO_NODE_INSPECT ?? "--inspect";
+    if (inspectArg !== "0" && inspectArg !== "false" && inspectArg !== "off") {
+        devArgs.push(inspectArg);
+    }
+    return [...devArgs, ...execArgv];
+}
+function resolvePackagedNodeEntrypointRunnerPath(currentScriptPath) {
+    const packageMarker = `${path.sep}node_modules${path.sep}@otto-code${path.sep}server${path.sep}`;
+    const markerIndex = currentScriptPath.lastIndexOf(packageMarker);
+    if (markerIndex === -1) {
+        return null;
+    }
+    const appRoot = currentScriptPath.slice(0, markerIndex);
+    const runnerPath = path.join(appRoot, "dist", "daemon", "node-entrypoint-runner.js");
+    return existsSync(runnerPath) ? runnerPath : null;
+}
+async function main() {
+    const config = parseConfig(process.argv.slice(2));
+    const workerEntry = config.devMode ? resolveDevWorkerEntry() : resolveWorkerEntry();
+    const workerExecArgv = resolveWorkerExecArgv(workerEntry, config.devMode);
+    const workerEnv = { ...process.env };
+    const packagedNodeEntrypointRunner = process.env.ELECTRON_RUN_AS_NODE === "1"
+        ? resolvePackagedNodeEntrypointRunnerPath(fileURLToPath(import.meta.url))
+        : null;
+    applySherpaLoaderEnv(workerEnv);
+    const ottoHome = resolveOttoHome(workerEnv);
+    const persistedConfig = loadPersistedConfig(ottoHome);
+    const supervisorLogFile = resolveSupervisorLogFile(ottoHome, persistedConfig, workerEnv);
+    try {
+        await acquirePidLock(ottoHome, null, {
+            ownerPid: process.pid,
+        });
+    }
+    catch (error) {
+        if (error instanceof PidLockError) {
+            process.stderr.write(`${error.message}\n`);
+            process.exit(1);
+            return;
+        }
+        throw error;
+    }
+    let lockReleased = false;
+    const releaseLock = async () => {
+        if (lockReleased) {
+            return;
+        }
+        lockReleased = true;
+        await releasePidLock(ottoHome, {
+            ownerPid: process.pid,
+        });
+    };
+    runSupervisor({
+        name: "DaemonRunner",
+        startupMessage: "Starting daemon worker (IPC restart and crash restart enabled)",
+        resolveWorkerEntry: () => workerEntry,
+        workerArgs: config.workerArgs,
+        workerEnv,
+        workerExecArgv,
+        resolveWorkerSpawnSpec: packagedNodeEntrypointRunner
+            ? (resolvedWorkerEntry) => ({
+                command: process.execPath,
+                args: [
+                    packagedNodeEntrypointRunner,
+                    "node-script",
+                    resolvedWorkerEntry,
+                    ...config.workerArgs,
+                ],
+                env: {
+                    ...workerEnv,
+                    ELECTRON_RUN_AS_NODE: "1",
+                },
+            })
+            : undefined,
+        restartOnCrash: true,
+        logFile: supervisorLogFile,
+        onWorkerReady: async ({ listen }) => {
+            await updatePidLock(ottoHome, { listen }, { ownerPid: process.pid });
+        },
+        onSupervisorExit: releaseLock,
+    });
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=supervisor-entrypoint.js.map

package/dist/scripts/supervisor-log-config.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+const DEFAULT_DAEMON_LOG_FILENAME = "daemon.log";
+const DEFAULT_LOG_ROTATE_SIZE = "10m";
+const DEFAULT_LOG_ROTATE_MAX_FILES = 3;
+export function resolveSupervisorLogFile(ottoHome, persistedConfig, env = process.env) {
+    const configuredFile = persistedConfig.log?.file;
+    const configuredPath = configuredFile?.path;
+    const envRotateSize = env.OTTO_LOG_ROTATE_SIZE?.trim();
+    const envRotateMaxFiles = parseOptionalPositiveInteger(env.OTTO_LOG_ROTATE_COUNT);
+    let logPath = path.join(ottoHome, DEFAULT_DAEMON_LOG_FILENAME);
+    if (configuredPath) {
+        logPath = path.isAbsolute(configuredPath)
+            ? configuredPath
+            : path.resolve(ottoHome, configuredPath);
+    }
+    return {
+        path: logPath,
+        rotate: {
+            maxSize: configuredFile?.rotate?.maxSize ?? envRotateSize ?? DEFAULT_LOG_ROTATE_SIZE,
+            maxFiles: configuredFile?.rotate?.maxFiles ?? envRotateMaxFiles ?? DEFAULT_LOG_ROTATE_MAX_FILES,
+        },
+    };
+}
+function parseOptionalPositiveInteger(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value.trim(), 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+//# sourceMappingURL=supervisor-log-config.js.map

package/dist/scripts/supervisor.js

@@ -0,0 +1,252 @@
+import { fork, spawn } from "child_process";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { createStream as createRotatingFileStream } from "rotating-file-stream";
+function describeExit(code, signal) {
+    return signal ?? (typeof code === "number" ? `code ${code}` : "unknown");
+}
+function parseLifecycleMessage(msg) {
+    if (typeof msg !== "object" || msg === null || !("type" in msg)) {
+        return null;
+    }
+    const type = msg.type;
+    if (type === "otto:shutdown") {
+        const reason = msg.reason;
+        return {
+            type: "otto:shutdown",
+            ...(typeof reason === "string" && reason.trim().length > 0 ? { reason } : {}),
+        };
+    }
+    if (type === "otto:ready") {
+        const listen = msg.listen;
+        if (typeof listen !== "string" || listen.trim().length === 0) {
+            return null;
+        }
+        return { type: "otto:ready", listen };
+    }
+    if (type === "otto:restart") {
+        const reason = msg.reason;
+        return {
+            type: "otto:restart",
+            ...(typeof reason === "string" && reason.trim().length > 0 ? { reason } : {}),
+        };
+    }
+    return null;
+}
+function toRotatingFileStreamSize(size) {
+    const trimmed = size.trim();
+    const match = trimmed.match(/^(\d+)\s*([bBkKmMgG])?$/);
+    if (!match) {
+        return trimmed;
+    }
+    const value = match[1];
+    const unit = (match[2] ?? "M").toUpperCase();
+    return `${value}${unit}`;
+}
+function createSupervisorLogStream(options) {
+    if (!options) {
+        return null;
+    }
+    mkdirSync(path.dirname(options.path), { recursive: true });
+    return createRotatingFileStream(path.basename(options.path), {
+        path: path.dirname(options.path),
+        size: toRotatingFileStreamSize(options.rotate.maxSize),
+        maxFiles: options.rotate.maxFiles,
+    });
+}
+export function runSupervisor(options) {
+    const restartOnCrash = options.restartOnCrash ?? false;
+    const workerArgs = options.workerArgs ?? process.argv.slice(2);
+    const workerEnv = options.workerEnv ?? process.env;
+    const workerExecArgv = options.workerExecArgv ?? ["--import", "tsx"];
+    const resolveWorkerSpawnSpec = options.resolveWorkerSpawnSpec;
+    let child = null;
+    let restarting = false;
+    let shuttingDown = false;
+    let exiting = false;
+    const logStream = createSupervisorLogStream(options.logFile);
+    const writeDurableChunk = (chunk) => {
+        logStream?.write(chunk);
+    };
+    const writeLifecycleLog = (message, fields = {}) => {
+        writeDurableChunk(`${JSON.stringify({
+            level: "info",
+            time: new Date().toISOString(),
+            pid: process.pid,
+            name: options.name,
+            msg: message,
+            ...fields,
+        })}\n`);
+    };
+    const log = (message) => {
+        process.stderr.write(`[${options.name}] ${message}\n`);
+        writeLifecycleLog(message);
+    };
+    const closeLogStream = () => new Promise((resolve) => {
+        if (!logStream) {
+            resolve();
+            return;
+        }
+        logStream.end(resolve);
+    });
+    const exitSupervisor = (code) => {
+        if (exiting) {
+            return;
+        }
+        exiting = true;
+        Promise.resolve(options.onSupervisorExit?.())
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            log(`Supervisor exit cleanup failed: ${message}`);
+        })
+            .then(closeLogStream)
+            .finally(() => {
+            process.exit(code);
+        });
+    };
+    const spawnWorker = () => {
+        let workerEntry;
+        try {
+            // Resolve at spawn time so restarts pick up current filesystem state.
+            workerEntry = options.resolveWorkerEntry();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log(`Failed to resolve worker entry: ${message}`);
+            exitSupervisor(1);
+            return;
+        }
+        const spawnSpec = resolveWorkerSpawnSpec?.(workerEntry) ?? null;
+        writeLifecycleLog("Spawning worker", { workerEntry });
+        if (spawnSpec) {
+            child = spawn(spawnSpec.command, spawnSpec.args, {
+                stdio: ["inherit", "pipe", "pipe", "ipc"],
+                env: spawnSpec.env ?? workerEnv,
+            });
+        }
+        else {
+            child = fork(workerEntry, workerArgs, {
+                stdio: ["inherit", "pipe", "pipe", "ipc"],
+                env: workerEnv,
+                execArgv: workerExecArgv,
+            });
+        }
+        const currentChild = child;
+        const heartbeat = setInterval(() => {
+            const message = { type: "otto:supervisor-heartbeat" };
+            if (currentChild.connected) {
+                currentChild.send?.(message, (error) => {
+                    if (error) {
+                        writeLifecycleLog("Worker heartbeat IPC send failed", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                });
+            }
+            else {
+                writeLifecycleLog("Worker heartbeat skipped because IPC channel is disconnected");
+            }
+        }, 1000);
+        heartbeat.unref();
+        child.on("disconnect", () => {
+            writeLifecycleLog("Worker IPC channel disconnected");
+        });
+        child.stdout?.on("data", (chunk) => {
+            process.stdout.write(chunk);
+            writeDurableChunk(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            process.stderr.write(chunk);
+            writeDurableChunk(chunk);
+        });
+        child.on("message", (msg) => {
+            const lifecycleMessage = parseLifecycleMessage(msg);
+            if (!lifecycleMessage) {
+                return;
+            }
+            if (lifecycleMessage.type === "otto:ready") {
+                writeLifecycleLog("Worker ready", { listen: lifecycleMessage.listen });
+                Promise.resolve(options.onWorkerReady?.({ listen: lifecycleMessage.listen })).catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    log(`Worker ready callback failed: ${message}`);
+                });
+                return;
+            }
+            if (lifecycleMessage.type === "otto:shutdown") {
+                const reason = lifecycleMessage.reason ?? "worker_requested_shutdown";
+                writeLifecycleLog("Worker requested shutdown", { reason });
+                requestShutdown(reason);
+                return;
+            }
+            const reason = lifecycleMessage.reason ?? "worker_requested_restart";
+            writeLifecycleLog("Worker requested restart", { reason });
+            requestRestart(reason);
+        });
+        child.on("close", (code, signal) => {
+            clearInterval(heartbeat);
+            const exitDescriptor = describeExit(code, signal);
+            writeLifecycleLog("Worker exited", { code, signal, exit: exitDescriptor });
+            if (shuttingDown) {
+                log(`Worker exited (${exitDescriptor}). Supervisor shutting down.`);
+                exitSupervisor(0);
+                return;
+            }
+            const crashed = restartOnCrash &&
+                ((code !== 0 && code !== null) || (signal !== null && signal !== "SIGTERM"));
+            if (restarting || crashed) {
+                restarting = false;
+                log(crashed
+                    ? `Worker crashed (${exitDescriptor}). Restarting worker...`
+                    : `Worker exited (${exitDescriptor}). Restarting worker...`);
+                spawnWorker();
+                return;
+            }
+            log(`Worker exited (${exitDescriptor}). Supervisor exiting.`);
+            exitSupervisor(typeof code === "number" ? code : 1);
+        });
+    };
+    const signalWorker = (signal, reason) => {
+        if (!child) {
+            return;
+        }
+        writeLifecycleLog("Supervisor sending signal to worker", {
+            reason,
+            signal,
+            supervisorPid: process.pid,
+            workerPid: child.pid ?? null,
+        });
+        child.kill(signal);
+    };
+    const requestRestart = (reason) => {
+        if (!child || restarting || shuttingDown) {
+            return;
+        }
+        restarting = true;
+        writeLifecycleLog("Restart requested", { reason });
+        log(`${reason}. Stopping worker for restart...`);
+        signalWorker("SIGTERM", reason);
+    };
+    const requestShutdown = (reason) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        restarting = false;
+        writeLifecycleLog("Supervisor shutdown requested", { reason });
+        log(`${reason}. Stopping worker...`);
+        if (!child) {
+            exitSupervisor(0);
+            return;
+        }
+        signalWorker("SIGTERM", reason);
+    };
+    const forwardSignal = (signal) => {
+        requestShutdown(`supervisor_received_${signal}`);
+    };
+    process.on("SIGINT", () => forwardSignal("SIGINT"));
+    process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+    process.stdout.write(`[${options.name}] ${options.startupMessage}\n`);
+    writeLifecycleLog(options.startupMessage);
+    spawnWorker();
+}
+//# sourceMappingURL=supervisor.js.map

package/dist/server/executable-resolution/executable-resolution.d.ts

@@ -0,0 +1,10 @@
+import { existsSync } from "node:fs";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
+export declare function probeExecutable(executablePath: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Check a literal executable path. PATH search is handled by findExecutable().
+ */
+export declare function executableExists(executablePath: string, exists?: typeof existsSync): string | null;
+export declare function findExecutable(name: string, probeTimeoutMs?: number): Promise<string | null>;
+export declare function isCommandAvailable(command: string): Promise<boolean>;
+//# sourceMappingURL=executable-resolution.d.ts.map