@seawork/server 1.0.0

package/dist/server/server/allowed-hosts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowed-hosts.js","sourceRoot":"","sources":["../../../src/server/allowed-hosts.ts"],"names":[],"mappings":"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"}

package/dist/server/server/bootstrap.d.ts

@@ -0,0 +1,74 @@
+import type { Logger } from "pino";
+export type ListenTarget = {
+    type: "tcp";
+    host: string;
+    port: number;
+} | {
+    type: "socket";
+    path: string;
+} | {
+    type: "pipe";
+    path: string;
+};
+export declare function parseListenString(listen: string): ListenTarget;
+import type { OpenAiSpeechProviderConfig } from "./speech/providers/openai/config.js";
+import type { LocalSpeechProviderConfig } from "./speech/providers/local/config.js";
+import type { RequestedSpeechProviders } from "./speech/speech-types.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import { AgentStorage } from "./agent/agent-storage.js";
+import { type TerminalManager } from "../terminal/terminal-manager.js";
+import type { AgentClient, AgentProvider } from "./agent/agent-sdk-types.js";
+import type { AgentProviderRuntimeSettingsMap } from "./agent/provider-launch-config.js";
+import { type AllowedHostsConfig } from "./allowed-hosts.js";
+export type SeaworkOpenAIConfig = OpenAiSpeechProviderConfig;
+export type SeaworkLocalSpeechConfig = LocalSpeechProviderConfig;
+export type SeaworkSpeechConfig = {
+    providers: RequestedSpeechProviders;
+    local?: SeaworkLocalSpeechConfig;
+};
+export type DaemonLifecycleIntent = {
+    type: "shutdown";
+    clientId: string;
+    requestId: string;
+} | {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason?: string;
+};
+export type SeaworkDaemonConfig = {
+    listen: string;
+    seaworkHome: string;
+    corsAllowedOrigins: string[];
+    allowedHosts?: AllowedHostsConfig;
+    mcpEnabled?: boolean;
+    mcpInjectIntoAgents?: boolean;
+    staticDir: string;
+    mcpDebug: boolean;
+    agentClients: Partial<Record<AgentProvider, AgentClient>>;
+    agentStoragePath: string;
+    relayEnabled?: boolean;
+    relayEndpoint?: string;
+    relayPublicEndpoint?: string;
+    appBaseUrl?: string;
+    openai?: SeaworkOpenAIConfig;
+    speech?: SeaworkSpeechConfig;
+    voiceLlmProvider?: AgentProvider | null;
+    voiceLlmProviderExplicit?: boolean;
+    voiceLlmModel?: string | null;
+    dictationFinalTimeoutMs?: number;
+    downloadTokenTtlMs?: number;
+    agentProviderSettings?: AgentProviderRuntimeSettingsMap;
+    onLifecycleIntent?: (intent: DaemonLifecycleIntent) => void;
+};
+export interface SeaworkDaemon {
+    config: SeaworkDaemonConfig;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    terminalManager: TerminalManager;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getListenTarget(): ListenTarget | null;
+}
+export declare function createSeaworkDaemon(config: SeaworkDaemonConfig, rootLogger: Logger): Promise<SeaworkDaemon>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/server/server/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/bootstrap.ts"],"names":[],"mappings":"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"}

package/dist/server/server/bootstrap.js

@@ -0,0 +1,537 @@
+import express from "express";
+import { createServer as createHTTPServer } from "http";
+import { createReadStream, unlinkSync, existsSync } from "fs";
+import { stat } from "fs/promises";
+import { randomUUID } from "node:crypto";
+import { hostname as getHostname } from "node:os";
+import path from "node:path";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+function resolveBoundListenTarget(listenTarget, httpServer) {
+    if (listenTarget.type !== "tcp") {
+        return listenTarget;
+    }
+    const address = httpServer.address();
+    if (!address || typeof address === "string") {
+        throw new Error("HTTP server did not expose a TCP address after listening");
+    }
+    return {
+        type: "tcp",
+        host: listenTarget.host,
+        port: address.port,
+    };
+}
+// Matches a Windows drive-letter path like C:\ or D:\
+const WINDOWS_DRIVE_RE = /^[A-Za-z]:\\/;
+export function parseListenString(listen) {
+    // 1. Windows named pipes: \\.\pipe\... or pipe://...
+    if (listen.startsWith("\\\\.\\pipe\\") || listen.startsWith("pipe://")) {
+        return {
+            type: "pipe",
+            path: listen.startsWith("pipe://") ? listen.slice("pipe://".length) : listen,
+        };
+    }
+    // 2. Explicit unix:// prefix
+    if (listen.startsWith("unix://")) {
+        return { type: "socket", path: listen.slice(7) };
+    }
+    // 3. Reject Windows absolute drive paths — they are not Unix sockets
+    if (WINDOWS_DRIVE_RE.test(listen)) {
+        throw new Error(`Invalid listen string (Windows path is not a valid listen target): ${listen}`);
+    }
+    // 4. POSIX absolute path (/ or ~) — Unix socket
+    if (listen.startsWith("/") || listen.startsWith("~")) {
+        return { type: "socket", path: listen };
+    }
+    // 5. Pure numeric — TCP port on 127.0.0.1
+    const trimmed = listen.trim();
+    if (/^\d+$/.test(trimmed)) {
+        const port = parseInt(trimmed, 10);
+        return { type: "tcp", host: "127.0.0.1", port };
+    }
+    // 6. host:port — TCP
+    if (listen.includes(":")) {
+        const [host, portStr] = listen.split(":");
+        const parsedPort = parseInt(portStr, 10);
+        if (!Number.isFinite(parsedPort)) {
+            throw new Error(`Invalid port in listen string: ${listen}`);
+        }
+        return { type: "tcp", host: host || "127.0.0.1", port: parsedPort };
+    }
+    throw new Error(`Invalid listen string: ${listen}`);
+}
+function formatListenTarget(listenTarget) {
+    if (!listenTarget) {
+        return null;
+    }
+    if (listenTarget.type === "tcp") {
+        return `${listenTarget.host}:${listenTarget.port}`;
+    }
+    return listenTarget.path;
+}
+import { VoiceAssistantWebSocketServer } from "./websocket-server.js";
+import { DownloadTokenStore } from "./file-download/token-store.js";
+import { createSpeechService } from "./speech/speech-runtime.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import { AgentStorage } from "./agent/agent-storage.js";
+import { attachAgentStoragePersistence } from "./persistence-hooks.js";
+import { createAgentMcpServer } from "./agent/mcp-server.js";
+import { buildProviderRegistry, createAllClients, shutdownProviders, } from "./agent/provider-registry.js";
+import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
+import { FileBackedProjectRegistry, FileBackedWorkspaceRegistry } from "./workspace-registry.js";
+import { FileBackedChatService } from "./chat/chat-service.js";
+import { CheckoutDiffManager } from "./checkout-diff-manager.js";
+import { LoopService } from "./loop-service.js";
+import { ScheduleService } from "./schedule/service.js";
+import { DaemonConfigStore } from "./daemon-config-store.js";
+import { createTerminalManager } from "../terminal/terminal-manager.js";
+import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
+import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
+import { startRelayTransport } from "./relay-transport.js";
+import { getOrCreateServerId } from "./server-id.js";
+import { resolveDaemonVersion } from "./daemon-version.js";
+import { isHostAllowed } from "./allowed-hosts.js";
+function formatHostForHttpUrl(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function createAgentMcpBaseUrl(listenTarget) {
+    if (!listenTarget || listenTarget.type !== "tcp") {
+        return null;
+    }
+    return new URL("/mcp/agents", `http://${formatHostForHttpUrl(listenTarget.host)}:${listenTarget.port}`).toString();
+}
+export async function createSeaworkDaemon(config, rootLogger) {
+    const logger = rootLogger.child({ module: "bootstrap" });
+    const bootstrapStart = performance.now();
+    const elapsed = () => `${(performance.now() - bootstrapStart).toFixed(0)}ms`;
+    const daemonVersion = resolveDaemonVersion(import.meta.url);
+    const daemonConfigStore = new DaemonConfigStore(config.seaworkHome, {
+        mcp: { injectIntoAgents: config.mcpInjectIntoAgents ?? true },
+    }, logger);
+    try {
+        const serverId = getOrCreateServerId(config.seaworkHome, { logger });
+        const daemonKeyPair = await loadOrCreateDaemonKeyPair(config.seaworkHome, logger);
+        let relayTransport = null;
+        const staticDir = config.staticDir;
+        const downloadTokenTtlMs = config.downloadTokenTtlMs ?? 60000;
+        const downloadTokenStore = new DownloadTokenStore({ ttlMs: downloadTokenTtlMs });
+        const listenTarget = parseListenString(config.listen);
+        const app = express();
+        let boundListenTarget = null;
+        // Host allowlist / DNS rebinding protection (vite-like semantics).
+        // For non-TCP (unix sockets), skip host validation.
+        if (listenTarget.type === "tcp") {
+            app.use((req, res, next) => {
+                const hostHeader = typeof req.headers.host === "string" ? req.headers.host : undefined;
+                if (!isHostAllowed(hostHeader, config.allowedHosts)) {
+                    res.status(403).json({ error: "Invalid Host header" });
+                    return;
+                }
+                next();
+            });
+        }
+        // CORS - allow same-origin + configured origins
+        const allowedOrigins = new Set([
+            ...config.corsAllowedOrigins,
+            // Packaged desktop renderers use the custom seawork:// protocol scheme.
+            "seawork://app",
+            // For TCP, add localhost variants
+            ...(listenTarget.type === "tcp"
+                ? [
+                    `http://${listenTarget.host}:${listenTarget.port}`,
+                    `http://localhost:${listenTarget.port}`,
+                    `http://127.0.0.1:${listenTarget.port}`,
+                ]
+                : []),
+        ]);
+        app.use((req, res, next) => {
+            const origin = req.headers.origin;
+            if (origin && (allowedOrigins.has("*") || allowedOrigins.has(origin))) {
+                res.setHeader("Access-Control-Allow-Origin", origin);
+                res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+                res.setHeader("Access-Control-Allow-Credentials", "true");
+            }
+            if (req.method === "OPTIONS") {
+                res.status(204).end();
+                return;
+            }
+            next();
+        });
+        // Serve static files from public directory
+        app.use("/public", express.static(staticDir));
+        // Middleware
+        app.use(express.json());
+        // Health check endpoint
+        app.get("/api/health", (_req, res) => {
+            res.json({ status: "ok", timestamp: new Date().toISOString() });
+        });
+        app.get("/api/status", (_req, res) => {
+            res.json({
+                status: "server_info",
+                serverId,
+                hostname: getHostname(),
+                version: daemonVersion,
+                listen: formatListenTarget(boundListenTarget ?? listenTarget),
+            });
+        });
+        app.get("/api/files/download", async (req, res) => {
+            const token = typeof req.query.token === "string" && req.query.token.trim().length > 0
+                ? req.query.token.trim()
+                : null;
+            if (!token) {
+                res.status(400).json({ error: "Missing download token" });
+                return;
+            }
+            const entry = downloadTokenStore.consumeToken(token);
+            if (!entry) {
+                res.status(403).json({ error: "Invalid or expired token" });
+                return;
+            }
+            try {
+                const fileStats = await stat(entry.absolutePath);
+                if (!fileStats.isFile()) {
+                    res.status(404).json({ error: "File not found" });
+                    return;
+                }
+                const safeFileName = entry.fileName.replace(/["\r\n]/g, "_");
+                res.setHeader("Content-Type", entry.mimeType);
+                res.setHeader("Content-Disposition", `attachment; filename="${safeFileName}"`);
+                res.setHeader("Content-Length", entry.size.toString());
+                const stream = createReadStream(entry.absolutePath);
+                stream.on("error", (err) => {
+                    logger.error({ err }, "Failed to stream download");
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: "Failed to read file" });
+                    }
+                    else {
+                        res.end();
+                    }
+                });
+                stream.pipe(res);
+            }
+            catch (err) {
+                logger.error({ err }, "Failed to download file");
+                if (!res.headersSent) {
+                    res.status(404).json({ error: "File not found" });
+                }
+            }
+        });
+        const httpServer = createHTTPServer(app);
+        const agentStorage = new AgentStorage(config.agentStoragePath, logger);
+        const projectRegistry = new FileBackedProjectRegistry(path.join(config.seaworkHome, "projects", "projects.json"), logger);
+        const workspaceRegistry = new FileBackedWorkspaceRegistry(path.join(config.seaworkHome, "projects", "workspaces.json"), logger);
+        const chatService = new FileBackedChatService({
+            seaworkHome: config.seaworkHome,
+            logger,
+        });
+        const agentManager = new AgentManager({
+            clients: {
+                ...createAllClients(logger, {
+                    runtimeSettings: config.agentProviderSettings,
+                }),
+                ...config.agentClients,
+            },
+            registry: agentStorage,
+            logger,
+        });
+        const providerRegistry = buildProviderRegistry(logger, {
+            runtimeSettings: config.agentProviderSettings,
+        });
+        const terminalManager = createTerminalManager();
+        const detachAgentStoragePersistence = attachAgentStoragePersistence(logger, agentManager, agentStorage);
+        await agentStorage.initialize();
+        logger.info({ elapsed: elapsed() }, "Agent storage initialized");
+        await bootstrapWorkspaceRegistries({
+            seaworkHome: config.seaworkHome,
+            agentStorage,
+            projectRegistry,
+            workspaceRegistry,
+            logger,
+        });
+        logger.info({ elapsed: elapsed() }, "Workspace registries bootstrapped");
+        await chatService.initialize();
+        logger.info({ elapsed: elapsed() }, "Chat service initialized");
+        const checkoutDiffManager = new CheckoutDiffManager({
+            logger,
+            seaworkHome: config.seaworkHome,
+        });
+        const loopService = new LoopService({
+            seaworkHome: config.seaworkHome,
+            logger,
+            agentManager,
+        });
+        await loopService.initialize();
+        logger.info({ elapsed: elapsed() }, "Loop service initialized");
+        const scheduleService = new ScheduleService({
+            seaworkHome: config.seaworkHome,
+            logger,
+            agentManager,
+            agentStorage,
+        });
+        await scheduleService.start();
+        logger.info({ elapsed: elapsed() }, "Schedule service initialized");
+        logger.info({ elapsed: elapsed() }, "Loading persisted agent registry");
+        const persistedRecords = await agentStorage.list();
+        logger.info({ elapsed: elapsed() }, `Agent registry loaded (${persistedRecords.length} record${persistedRecords.length === 1 ? "" : "s"}); agents will initialize on demand`);
+        logger.info("Voice mode configured for agent-scoped resume flow (no dedicated voice assistant provider)");
+        logger.info({ elapsed: elapsed() }, "Preparing voice and MCP runtime");
+        let wsServer = null;
+        const mcpEnabled = config.mcpEnabled ?? true;
+        let agentMcpBaseUrl = null;
+        if (mcpEnabled) {
+            const agentMcpRoute = "/mcp/agents";
+            const agentMcpTransports = new Map();
+            const createAgentMcpTransport = async (callerAgentId) => {
+                const agentMcpServer = await createAgentMcpServer({
+                    agentManager,
+                    agentStorage,
+                    terminalManager,
+                    scheduleService,
+                    providerRegistry,
+                    seaworkHome: config.seaworkHome,
+                    callerAgentId,
+                    enableVoiceTools: false,
+                    resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
+                    resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
+                    logger,
+                });
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (sessionId) => {
+                        agentMcpTransports.set(sessionId, transport);
+                        logger.debug({ sessionId }, "Agent MCP session initialized");
+                    },
+                    onsessionclosed: (sessionId) => {
+                        agentMcpTransports.delete(sessionId);
+                        logger.debug({ sessionId }, "Agent MCP session closed");
+                    },
+                    // NOTE: We enforce a Vite-like host allowlist at the app/websocket layer.
+                    // StreamableHTTPServerTransport's built-in check requires exact Host header matches.
+                    enableDnsRebindingProtection: false,
+                });
+                transport.onclose = () => {
+                    if (transport.sessionId) {
+                        agentMcpTransports.delete(transport.sessionId);
+                    }
+                };
+                transport.onerror = (err) => {
+                    logger.error({ err }, "Agent MCP transport error");
+                };
+                await agentMcpServer.connect(transport);
+                return transport;
+            };
+            const handleAgentMcpRequest = async (req, res) => {
+                if (config.mcpDebug) {
+                    logger.debug({
+                        method: req.method,
+                        url: req.originalUrl,
+                        sessionId: req.header("mcp-session-id"),
+                        authorization: req.header("authorization"),
+                        body: req.body,
+                    }, "Agent MCP request");
+                }
+                try {
+                    const sessionId = req.header("mcp-session-id");
+                    let transport = sessionId ? agentMcpTransports.get(sessionId) : undefined;
+                    if (!transport) {
+                        if (req.method !== "POST") {
+                            res.status(400).json({
+                                jsonrpc: "2.0",
+                                error: {
+                                    code: -32000,
+                                    message: "Missing or invalid MCP session",
+                                },
+                                id: null,
+                            });
+                            return;
+                        }
+                        if (!isInitializeRequest(req.body)) {
+                            res.status(400).json({
+                                jsonrpc: "2.0",
+                                error: {
+                                    code: -32000,
+                                    message: "Initialization request expected",
+                                },
+                                id: null,
+                            });
+                            return;
+                        }
+                        const callerAgentIdRaw = req.query.callerAgentId;
+                        const callerAgentId = typeof callerAgentIdRaw === "string"
+                            ? callerAgentIdRaw
+                            : Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string"
+                                ? callerAgentIdRaw[0]
+                                : undefined;
+                        transport = await createAgentMcpTransport(callerAgentId);
+                    }
+                    await transport.handleRequest(req, res, req.body);
+                }
+                catch (err) {
+                    logger.error({ err }, "Failed to handle Agent MCP request");
+                    if (!res.headersSent) {
+                        res.status(500).json({
+                            jsonrpc: "2.0",
+                            error: {
+                                code: -32603,
+                                message: "Internal MCP server error",
+                            },
+                            id: null,
+                        });
+                    }
+                }
+            };
+            app.post(agentMcpRoute, handleAgentMcpRequest);
+            app.get(agentMcpRoute, handleAgentMcpRequest);
+            app.delete(agentMcpRoute, handleAgentMcpRequest);
+            logger.info({ route: agentMcpRoute }, "Agent MCP server mounted on main app");
+        }
+        else {
+            logger.info("Agent MCP HTTP endpoint disabled");
+        }
+        const speechService = createSpeechService({
+            logger,
+            openaiConfig: config.openai,
+            speechConfig: config.speech,
+        });
+        logger.info({ elapsed: elapsed() }, "Speech service created");
+        logger.info({ elapsed: elapsed() }, "Bootstrap complete, ready to start listening");
+        const start = async () => {
+            // Start main HTTP server
+            await new Promise((resolve, reject) => {
+                const onError = (err) => {
+                    httpServer.off("listening", onListening);
+                    reject(err);
+                };
+                const onListening = () => {
+                    httpServer.off("error", onError);
+                    const logAndResolve = async () => {
+                        boundListenTarget = resolveBoundListenTarget(listenTarget, httpServer);
+                        const mcpBaseUrl = mcpEnabled ? createAgentMcpBaseUrl(boundListenTarget) : null;
+                        agentMcpBaseUrl = config.mcpInjectIntoAgents === false ? null : mcpBaseUrl;
+                        agentManager.setMcpBaseUrl(agentMcpBaseUrl);
+                        daemonConfigStore.onFieldChange("mcp.injectIntoAgents", (value) => {
+                            agentManager.setMcpBaseUrl(value ? mcpBaseUrl : null);
+                        });
+                        const relayEnabled = config.relayEnabled ?? true;
+                        const relayEndpoint = config.relayEndpoint ?? "relay.seawork.ai:443";
+                        const relayPublicEndpoint = config.relayPublicEndpoint ?? relayEndpoint;
+                        const appBaseUrl = config.appBaseUrl ?? "https://app.seawork.ai";
+                        if (boundListenTarget.type === "tcp") {
+                            logger.info({
+                                host: boundListenTarget.host,
+                                port: boundListenTarget.port,
+                                elapsed: elapsed(),
+                            }, `Server listening on http://${boundListenTarget.host}:${boundListenTarget.port}`);
+                        }
+                        else {
+                            logger.info({ path: boundListenTarget.path, elapsed: elapsed() }, `Server listening on ${boundListenTarget.path}`);
+                        }
+                        wsServer = new VoiceAssistantWebSocketServer(httpServer, logger, serverId, agentManager, agentStorage, downloadTokenStore, config.seaworkHome, daemonConfigStore, mcpBaseUrl, { allowedOrigins, allowedHosts: config.allowedHosts }, speechService, terminalManager, {
+                            finalTimeoutMs: config.dictationFinalTimeoutMs,
+                        }, config.agentProviderSettings, daemonVersion, (intent) => {
+                            try {
+                                config.onLifecycleIntent?.(intent);
+                            }
+                            catch (error) {
+                                logger.error({ err: error, intent }, "Failed to handle daemon lifecycle intent");
+                            }
+                        }, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager);
+                        if (typeof process.send === "function" && process.env.SEAWORK_SUPERVISED === "1") {
+                            process.send({
+                                type: "seawork:ready",
+                                listen: boundListenTarget.type === "tcp"
+                                    ? `${boundListenTarget.host}:${boundListenTarget.port}`
+                                    : boundListenTarget.path,
+                            });
+                        }
+                        if (relayEnabled) {
+                            const offer = await createConnectionOfferV2({
+                                serverId,
+                                daemonPublicKeyB64: daemonKeyPair.publicKeyB64,
+                                relay: { endpoint: relayPublicEndpoint },
+                            });
+                            const url = encodeOfferToFragmentUrl({ offer, appBaseUrl });
+                            logger.info({ url }, "pairing_offer");
+                            relayTransport?.stop().catch(() => undefined);
+                            relayTransport = startRelayTransport({
+                                logger,
+                                attachSocket: (ws, metadata) => {
+                                    if (!wsServer) {
+                                        throw new Error("WebSocket server not initialized");
+                                    }
+                                    return wsServer.attachExternalSocket(ws, metadata);
+                                },
+                                relayEndpoint,
+                                serverId,
+                                daemonKeyPair: daemonKeyPair.keyPair,
+                            });
+                        }
+                    };
+                    logAndResolve().then(resolve, reject);
+                };
+                httpServer.once("error", onError);
+                httpServer.once("listening", onListening);
+                if (listenTarget.type === "tcp") {
+                    httpServer.listen(listenTarget.port, listenTarget.host);
+                }
+                else {
+                    if (listenTarget.type === "socket" && existsSync(listenTarget.path)) {
+                        unlinkSync(listenTarget.path);
+                    }
+                    httpServer.listen(listenTarget.path);
+                }
+            });
+            // Start speech service after listening so synchronous Sherpa native
+            // model loading doesn't block the server from accepting connections.
+            speechService.start();
+        };
+        const stop = async () => {
+            await closeAllAgents(logger, agentManager);
+            await agentManager.flush().catch(() => undefined);
+            detachAgentStoragePersistence();
+            await agentStorage.flush().catch(() => undefined);
+            await shutdownProviders(logger, {
+                runtimeSettings: config.agentProviderSettings,
+            });
+            terminalManager.killAll();
+            speechService.stop();
+            await scheduleService.stop().catch(() => undefined);
+            await relayTransport?.stop().catch(() => undefined);
+            if (wsServer) {
+                await wsServer.close();
+            }
+            await new Promise((resolve) => {
+                httpServer.close(() => resolve());
+            });
+            // Clean up socket files
+            if (listenTarget.type === "socket" && existsSync(listenTarget.path)) {
+                unlinkSync(listenTarget.path);
+            }
+        };
+        return {
+            config,
+            agentManager,
+            agentStorage,
+            terminalManager,
+            start,
+            stop,
+            getListenTarget: () => boundListenTarget,
+        };
+    }
+    catch (err) {
+        throw err;
+    }
+}
+async function closeAllAgents(logger, agentManager) {
+    const agents = agentManager.listAgents();
+    for (const agent of agents) {
+        try {
+            await agentManager.closeAgent(agent.id);
+        }
+        catch (err) {
+            logger.error({ err, agentId: agent.id }, "Failed to close agent");
+        }
+    }
+}
+//# sourceMappingURL=bootstrap.js.map