loudmouth-ai 0.1.0

package/dist/gateway/server-node-subscriptions.js

@@ -0,0 +1,93 @@
+export function createNodeSubscriptionManager() {
+    const nodeSubscriptions = new Map();
+    const sessionSubscribers = new Map();
+    const toPayloadJSON = (payload) => (payload ? JSON.stringify(payload) : null);
+    const subscribe = (nodeId, sessionKey) => {
+        const normalizedNodeId = nodeId.trim();
+        const normalizedSessionKey = sessionKey.trim();
+        if (!normalizedNodeId || !normalizedSessionKey)
+            return;
+        let nodeSet = nodeSubscriptions.get(normalizedNodeId);
+        if (!nodeSet) {
+            nodeSet = new Set();
+            nodeSubscriptions.set(normalizedNodeId, nodeSet);
+        }
+        if (nodeSet.has(normalizedSessionKey))
+            return;
+        nodeSet.add(normalizedSessionKey);
+        let sessionSet = sessionSubscribers.get(normalizedSessionKey);
+        if (!sessionSet) {
+            sessionSet = new Set();
+            sessionSubscribers.set(normalizedSessionKey, sessionSet);
+        }
+        sessionSet.add(normalizedNodeId);
+    };
+    const unsubscribe = (nodeId, sessionKey) => {
+        const normalizedNodeId = nodeId.trim();
+        const normalizedSessionKey = sessionKey.trim();
+        if (!normalizedNodeId || !normalizedSessionKey)
+            return;
+        const nodeSet = nodeSubscriptions.get(normalizedNodeId);
+        nodeSet?.delete(normalizedSessionKey);
+        if (nodeSet?.size === 0)
+            nodeSubscriptions.delete(normalizedNodeId);
+        const sessionSet = sessionSubscribers.get(normalizedSessionKey);
+        sessionSet?.delete(normalizedNodeId);
+        if (sessionSet?.size === 0)
+            sessionSubscribers.delete(normalizedSessionKey);
+    };
+    const unsubscribeAll = (nodeId) => {
+        const normalizedNodeId = nodeId.trim();
+        const nodeSet = nodeSubscriptions.get(normalizedNodeId);
+        if (!nodeSet)
+            return;
+        for (const sessionKey of nodeSet) {
+            const sessionSet = sessionSubscribers.get(sessionKey);
+            sessionSet?.delete(normalizedNodeId);
+            if (sessionSet?.size === 0)
+                sessionSubscribers.delete(sessionKey);
+        }
+        nodeSubscriptions.delete(normalizedNodeId);
+    };
+    const sendToSession = (sessionKey, event, payload, sendEvent) => {
+        const normalizedSessionKey = sessionKey.trim();
+        if (!normalizedSessionKey || !sendEvent)
+            return;
+        const subs = sessionSubscribers.get(normalizedSessionKey);
+        if (!subs || subs.size === 0)
+            return;
+        const payloadJSON = toPayloadJSON(payload);
+        for (const nodeId of subs) {
+            sendEvent({ nodeId, event, payloadJSON });
+        }
+    };
+    const sendToAllSubscribed = (event, payload, sendEvent) => {
+        if (!sendEvent)
+            return;
+        const payloadJSON = toPayloadJSON(payload);
+        for (const nodeId of nodeSubscriptions.keys()) {
+            sendEvent({ nodeId, event, payloadJSON });
+        }
+    };
+    const sendToAllConnected = (event, payload, listConnected, sendEvent) => {
+        if (!sendEvent || !listConnected)
+            return;
+        const payloadJSON = toPayloadJSON(payload);
+        for (const node of listConnected()) {
+            sendEvent({ nodeId: node.nodeId, event, payloadJSON });
+        }
+    };
+    const clear = () => {
+        nodeSubscriptions.clear();
+        sessionSubscribers.clear();
+    };
+    return {
+        subscribe,
+        unsubscribe,
+        unsubscribeAll,
+        sendToSession,
+        sendToAllSubscribed,
+        sendToAllConnected,
+        clear,
+    };
+}

package/dist/gateway/server-plugins.js

@@ -0,0 +1,36 @@
+import { loadClawdbotPlugins } from "../plugins/loader.js";
+export function loadGatewayPlugins(params) {
+    const pluginRegistry = loadClawdbotPlugins({
+        config: params.cfg,
+        workspaceDir: params.workspaceDir,
+        logger: {
+            info: (msg) => params.log.info(msg),
+            warn: (msg) => params.log.warn(msg),
+            error: (msg) => params.log.error(msg),
+            debug: (msg) => params.log.debug(msg),
+        },
+        coreGatewayHandlers: params.coreGatewayHandlers,
+    });
+    const pluginMethods = Object.keys(pluginRegistry.gatewayHandlers);
+    const gatewayMethods = Array.from(new Set([...params.baseMethods, ...pluginMethods]));
+    if (pluginRegistry.diagnostics.length > 0) {
+        for (const diag of pluginRegistry.diagnostics) {
+            const details = [
+                diag.pluginId ? `plugin=${diag.pluginId}` : null,
+                diag.source ? `source=${diag.source}` : null,
+            ]
+                .filter((entry) => Boolean(entry))
+                .join(", ");
+            const message = details
+                ? `[plugins] ${diag.message} (${details})`
+                : `[plugins] ${diag.message}`;
+            if (diag.level === "error") {
+                params.log.error(message);
+            }
+            else {
+                params.log.info(message);
+            }
+        }
+    }
+    return { pluginRegistry, gatewayMethods };
+}

package/dist/gateway/server-reload-handlers.js

@@ -0,0 +1,112 @@
+import { startGmailWatcher, stopGmailWatcher } from "../hooks/gmail-watcher.js";
+import { resetDirectoryCache } from "../infra/outbound/target-resolver.js";
+import { authorizeGatewaySigusr1Restart, setGatewaySigusr1RestartPolicy, } from "../infra/restart.js";
+import { setCommandLaneConcurrency } from "../process/command-queue.js";
+import { resolveAgentMaxConcurrent, resolveSubagentMaxConcurrent } from "../config/agent-limits.js";
+import { isTruthyEnvValue } from "../infra/env.js";
+import { resolveHooksConfig } from "./hooks.js";
+import { startBrowserControlServerIfEnabled } from "./server-browser.js";
+import { buildGatewayCronService } from "./server-cron.js";
+export function createGatewayReloadHandlers(params) {
+    const applyHotReload = async (plan, nextConfig) => {
+        setGatewaySigusr1RestartPolicy({ allowExternal: nextConfig.commands?.restart === true });
+        const state = params.getState();
+        const nextState = { ...state };
+        if (plan.reloadHooks) {
+            try {
+                nextState.hooksConfig = resolveHooksConfig(nextConfig);
+            }
+            catch (err) {
+                params.logHooks.warn(`hooks config reload failed: ${String(err)}`);
+            }
+        }
+        if (plan.restartHeartbeat) {
+            nextState.heartbeatRunner.updateConfig(nextConfig);
+        }
+        resetDirectoryCache();
+        if (plan.restartCron) {
+            state.cronState.cron.stop();
+            nextState.cronState = buildGatewayCronService({
+                cfg: nextConfig,
+                deps: params.deps,
+                broadcast: params.broadcast,
+            });
+            void nextState.cronState.cron
+                .start()
+                .catch((err) => params.logCron.error(`failed to start: ${String(err)}`));
+        }
+        if (plan.restartBrowserControl) {
+            if (state.browserControl) {
+                await state.browserControl.stop().catch(() => { });
+            }
+            try {
+                nextState.browserControl = await startBrowserControlServerIfEnabled();
+            }
+            catch (err) {
+                params.logBrowser.error(`server failed to start: ${String(err)}`);
+            }
+        }
+        if (plan.restartGmailWatcher) {
+            await stopGmailWatcher().catch(() => { });
+            if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
+                try {
+                    const gmailResult = await startGmailWatcher(nextConfig);
+                    if (gmailResult.started) {
+                        params.logHooks.info("gmail watcher started");
+                    }
+                    else if (gmailResult.reason &&
+                        gmailResult.reason !== "hooks not enabled" &&
+                        gmailResult.reason !== "no gmail account configured") {
+                        params.logHooks.warn(`gmail watcher not started: ${gmailResult.reason}`);
+                    }
+                }
+                catch (err) {
+                    params.logHooks.error(`gmail watcher failed to start: ${String(err)}`);
+                }
+            }
+            else {
+                params.logHooks.info("skipping gmail watcher restart (CLAWDBOT_SKIP_GMAIL_WATCHER=1)");
+            }
+        }
+        if (plan.restartChannels.size > 0) {
+            if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+                isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS)) {
+                params.logChannels.info("skipping channel reload (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
+            }
+            else {
+                const restartChannel = async (name) => {
+                    params.logChannels.info(`restarting ${name} channel`);
+                    await params.stopChannel(name);
+                    await params.startChannel(name);
+                };
+                for (const channel of plan.restartChannels) {
+                    await restartChannel(channel);
+                }
+            }
+        }
+        setCommandLaneConcurrency("cron" /* CommandLane.Cron */, nextConfig.cron?.maxConcurrentRuns ?? 1);
+        setCommandLaneConcurrency("main" /* CommandLane.Main */, resolveAgentMaxConcurrent(nextConfig));
+        setCommandLaneConcurrency("subagent" /* CommandLane.Subagent */, resolveSubagentMaxConcurrent(nextConfig));
+        if (plan.hotReasons.length > 0) {
+            params.logReload.info(`config hot reload applied (${plan.hotReasons.join(", ")})`);
+        }
+        else if (plan.noopPaths.length > 0) {
+            params.logReload.info(`config change applied (dynamic reads: ${plan.noopPaths.join(", ")})`);
+        }
+        params.setState(nextState);
+    };
+    const requestGatewayRestart = (plan, nextConfig) => {
+        setGatewaySigusr1RestartPolicy({ allowExternal: nextConfig.commands?.restart === true });
+        const reasons = plan.restartReasons.length
+            ? plan.restartReasons.join(", ")
+            : plan.changedPaths.join(", ");
+        params.logReload.warn(`config change requires gateway restart (${reasons})`);
+        if (process.listenerCount("SIGUSR1") === 0) {
+            params.logReload.warn("no SIGUSR1 listener found; restart skipped");
+            return;
+        }
+        authorizeGatewaySigusr1Restart();
+        process.emit("SIGUSR1");
+    };
+    return { applyHotReload, requestGatewayRestart };
+}

package/dist/gateway/server-restart-sentinel.js

@@ -0,0 +1,84 @@
+import { resolveAnnounceTargetFromKey } from "../agents/tools/sessions-send-helpers.js";
+import { normalizeChannelId } from "../channels/plugins/index.js";
+import { agentCommand } from "../commands/agent.js";
+import { resolveMainSessionKeyFromConfig } from "../config/sessions.js";
+import { resolveOutboundTarget } from "../infra/outbound/targets.js";
+import { consumeRestartSentinel, formatRestartSentinelMessage, summarizeRestartSentinel, } from "../infra/restart-sentinel.js";
+import { enqueueSystemEvent } from "../infra/system-events.js";
+import { defaultRuntime } from "../runtime.js";
+import { deliveryContextFromSession, mergeDeliveryContext } from "../utils/delivery-context.js";
+import { loadSessionEntry } from "./session-utils.js";
+export async function scheduleRestartSentinelWake(params) {
+    const sentinel = await consumeRestartSentinel();
+    if (!sentinel)
+        return;
+    const payload = sentinel.payload;
+    const sessionKey = payload.sessionKey?.trim();
+    const message = formatRestartSentinelMessage(payload);
+    const summary = summarizeRestartSentinel(payload);
+    if (!sessionKey) {
+        const mainSessionKey = resolveMainSessionKeyFromConfig();
+        enqueueSystemEvent(message, { sessionKey: mainSessionKey });
+        return;
+    }
+    // Extract topic/thread ID from sessionKey (supports both :topic: and :thread:)
+    // Telegram uses :topic:, other platforms use :thread:
+    const topicIndex = sessionKey.lastIndexOf(":topic:");
+    const threadIndex = sessionKey.lastIndexOf(":thread:");
+    const markerIndex = Math.max(topicIndex, threadIndex);
+    const marker = topicIndex > threadIndex ? ":topic:" : ":thread:";
+    const baseSessionKey = markerIndex === -1 ? sessionKey : sessionKey.slice(0, markerIndex);
+    const threadIdRaw = markerIndex === -1 ? undefined : sessionKey.slice(markerIndex + marker.length);
+    const sessionThreadId = threadIdRaw?.trim() || undefined;
+    const { cfg, entry } = loadSessionEntry(sessionKey);
+    const parsedTarget = resolveAnnounceTargetFromKey(baseSessionKey);
+    // Prefer delivery context from sentinel (captured at restart) over session store
+    // Handles race condition where store wasn't flushed before restart
+    const sentinelContext = payload.deliveryContext;
+    let sessionDeliveryContext = deliveryContextFromSession(entry);
+    if (!sessionDeliveryContext && markerIndex !== -1 && baseSessionKey) {
+        const { entry: baseEntry } = loadSessionEntry(baseSessionKey);
+        sessionDeliveryContext = deliveryContextFromSession(baseEntry);
+    }
+    const origin = mergeDeliveryContext(sentinelContext, mergeDeliveryContext(sessionDeliveryContext, parsedTarget ?? undefined));
+    const channelRaw = origin?.channel;
+    const channel = channelRaw ? normalizeChannelId(channelRaw) : null;
+    const to = origin?.to;
+    if (!channel || !to) {
+        enqueueSystemEvent(message, { sessionKey });
+        return;
+    }
+    const resolved = resolveOutboundTarget({
+        channel,
+        to,
+        cfg,
+        accountId: origin?.accountId,
+        mode: "implicit",
+    });
+    if (!resolved.ok) {
+        enqueueSystemEvent(message, { sessionKey });
+        return;
+    }
+    const threadId = payload.threadId ??
+        parsedTarget?.threadId ?? // From resolveAnnounceTargetFromKey (extracts :topic:N)
+        sessionThreadId ??
+        (origin?.threadId != null ? String(origin.threadId) : undefined);
+    try {
+        await agentCommand({
+            message,
+            sessionKey,
+            to: resolved.to,
+            channel,
+            deliver: true,
+            bestEffortDeliver: true,
+            messageChannel: channel,
+            threadId,
+        }, defaultRuntime, params.deps);
+    }
+    catch (err) {
+        enqueueSystemEvent(`${summary}\n${String(err)}`, { sessionKey });
+    }
+}
+export function shouldWakeFromRestartSentinel() {
+    return !process.env.VITEST && process.env.NODE_ENV !== "test";
+}

package/dist/gateway/server-runtime-config.js

@@ -0,0 +1,66 @@
+import { assertGatewayAuthConfigured, resolveGatewayAuth, } from "./auth.js";
+import { normalizeControlUiBasePath } from "./control-ui-shared.js";
+import { resolveHooksConfig } from "./hooks.js";
+import { isLoopbackHost, resolveGatewayBindHost } from "./net.js";
+export async function resolveGatewayRuntimeConfig(params) {
+    const bindMode = params.bind ?? params.cfg.gateway?.bind ?? "loopback";
+    const customBindHost = params.cfg.gateway?.customBindHost;
+    const bindHost = params.host ?? (await resolveGatewayBindHost(bindMode, customBindHost));
+    const controlUiEnabled = params.controlUiEnabled ?? params.cfg.gateway?.controlUi?.enabled ?? true;
+    const openAiChatCompletionsEnabled = params.openAiChatCompletionsEnabled ??
+        params.cfg.gateway?.http?.endpoints?.chatCompletions?.enabled ??
+        false;
+    const openResponsesConfig = params.cfg.gateway?.http?.endpoints?.responses;
+    const openResponsesEnabled = params.openResponsesEnabled ?? openResponsesConfig?.enabled ?? false;
+    const controlUiBasePath = normalizeControlUiBasePath(params.cfg.gateway?.controlUi?.basePath);
+    const authBase = params.cfg.gateway?.auth ?? {};
+    const authOverrides = params.auth ?? {};
+    const authConfig = {
+        ...authBase,
+        ...authOverrides,
+    };
+    const tailscaleBase = params.cfg.gateway?.tailscale ?? {};
+    const tailscaleOverrides = params.tailscale ?? {};
+    const tailscaleConfig = {
+        ...tailscaleBase,
+        ...tailscaleOverrides,
+    };
+    const tailscaleMode = tailscaleConfig.mode ?? "off";
+    const resolvedAuth = resolveGatewayAuth({
+        authConfig,
+        env: process.env,
+        tailscaleMode,
+    });
+    const authMode = resolvedAuth.mode;
+    const hasToken = typeof resolvedAuth.token === "string" && resolvedAuth.token.trim().length > 0;
+    const hasPassword = typeof resolvedAuth.password === "string" && resolvedAuth.password.trim().length > 0;
+    const hasSharedSecret = (authMode === "token" && hasToken) || (authMode === "password" && hasPassword);
+    const hooksConfig = resolveHooksConfig(params.cfg);
+    const canvasHostEnabled = process.env.CLAWDBOT_SKIP_CANVAS_HOST !== "1" && params.cfg.canvasHost?.enabled !== false;
+    assertGatewayAuthConfigured(resolvedAuth);
+    if (tailscaleMode === "funnel" && authMode !== "password") {
+        throw new Error("tailscale funnel requires gateway auth mode=password (set gateway.auth.password or CLAWDBOT_GATEWAY_PASSWORD)");
+    }
+    if (tailscaleMode !== "off" && !isLoopbackHost(bindHost)) {
+        throw new Error("tailscale serve/funnel requires gateway bind=loopback (127.0.0.1)");
+    }
+    if (!isLoopbackHost(bindHost) && !hasSharedSecret) {
+        throw new Error(`refusing to bind gateway to ${bindHost}:${params.port} without auth (set gateway.auth.token/password, or set CLAWDBOT_GATEWAY_TOKEN/CLAWDBOT_GATEWAY_PASSWORD)`);
+    }
+    return {
+        bindHost,
+        controlUiEnabled,
+        openAiChatCompletionsEnabled,
+        openResponsesEnabled,
+        openResponsesConfig: openResponsesConfig
+            ? { ...openResponsesConfig, enabled: openResponsesEnabled }
+            : undefined,
+        controlUiBasePath,
+        resolvedAuth,
+        authMode,
+        tailscaleConfig,
+        tailscaleMode,
+        hooksConfig,
+        canvasHostEnabled,
+    };
+}

package/dist/gateway/server-runtime-state.js

@@ -0,0 +1,113 @@
+import { WebSocketServer } from "ws";
+import { CANVAS_HOST_PATH } from "../canvas-host/a2ui.js";
+import { createCanvasHostHandler } from "../canvas-host/server.js";
+import { createGatewayHooksRequestHandler } from "./server/hooks.js";
+import { listenGatewayHttpServer } from "./server/http-listen.js";
+import { resolveGatewayListenHosts } from "./net.js";
+import { createGatewayPluginRequestHandler } from "./server/plugins-http.js";
+import { createGatewayBroadcaster } from "./server-broadcast.js";
+import { createChatRunState } from "./server-chat.js";
+import { MAX_PAYLOAD_BYTES } from "./server-constants.js";
+import { attachGatewayUpgradeHandler, createGatewayHttpServer } from "./server-http.js";
+export async function createGatewayRuntimeState(params) {
+    let canvasHost = null;
+    if (params.canvasHostEnabled) {
+        try {
+            const handler = await createCanvasHostHandler({
+                runtime: params.canvasRuntime,
+                rootDir: params.cfg.canvasHost?.root,
+                basePath: CANVAS_HOST_PATH,
+                allowInTests: params.allowCanvasHostInTests,
+                liveReload: params.cfg.canvasHost?.liveReload,
+            });
+            if (handler.rootDir) {
+                canvasHost = handler;
+                params.logCanvas.info(`canvas host mounted at http://${params.bindHost}:${params.port}${CANVAS_HOST_PATH}/ (root ${handler.rootDir})`);
+            }
+        }
+        catch (err) {
+            params.logCanvas.warn(`canvas host failed to start: ${String(err)}`);
+        }
+    }
+    const handleHooksRequest = createGatewayHooksRequestHandler({
+        deps: params.deps,
+        getHooksConfig: params.hooksConfig,
+        bindHost: params.bindHost,
+        port: params.port,
+        logHooks: params.logHooks,
+    });
+    const handlePluginRequest = createGatewayPluginRequestHandler({
+        registry: params.pluginRegistry,
+        log: params.logPlugins,
+    });
+    const bindHosts = await resolveGatewayListenHosts(params.bindHost);
+    const httpServers = [];
+    const httpBindHosts = [];
+    for (const host of bindHosts) {
+        const httpServer = createGatewayHttpServer({
+            canvasHost,
+            controlUiEnabled: params.controlUiEnabled,
+            controlUiBasePath: params.controlUiBasePath,
+            openAiChatCompletionsEnabled: params.openAiChatCompletionsEnabled,
+            openResponsesEnabled: params.openResponsesEnabled,
+            openResponsesConfig: params.openResponsesConfig,
+            handleHooksRequest,
+            handlePluginRequest,
+            resolvedAuth: params.resolvedAuth,
+            tlsOptions: params.gatewayTls?.enabled ? params.gatewayTls.tlsOptions : undefined,
+        });
+        try {
+            await listenGatewayHttpServer({
+                httpServer,
+                bindHost: host,
+                port: params.port,
+            });
+            httpServers.push(httpServer);
+            httpBindHosts.push(host);
+        }
+        catch (err) {
+            if (host === bindHosts[0])
+                throw err;
+            params.log.warn(`gateway: failed to bind loopback alias ${host}:${params.port} (${String(err)})`);
+        }
+    }
+    const httpServer = httpServers[0];
+    if (!httpServer) {
+        throw new Error("Gateway HTTP server failed to start");
+    }
+    const wss = new WebSocketServer({
+        noServer: true,
+        maxPayload: MAX_PAYLOAD_BYTES,
+    });
+    for (const server of httpServers) {
+        attachGatewayUpgradeHandler({ httpServer: server, wss, canvasHost });
+    }
+    const clients = new Set();
+    const { broadcast } = createGatewayBroadcaster({ clients });
+    const agentRunSeq = new Map();
+    const dedupe = new Map();
+    const chatRunState = createChatRunState();
+    const chatRunRegistry = chatRunState.registry;
+    const chatRunBuffers = chatRunState.buffers;
+    const chatDeltaSentAt = chatRunState.deltaSentAt;
+    const addChatRun = chatRunRegistry.add;
+    const removeChatRun = chatRunRegistry.remove;
+    const chatAbortControllers = new Map();
+    return {
+        canvasHost,
+        httpServer,
+        httpServers,
+        httpBindHosts,
+        wss,
+        clients,
+        broadcast,
+        agentRunSeq,
+        dedupe,
+        chatRunState,
+        chatRunBuffers,
+        chatDeltaSentAt,
+        addChatRun,
+        removeChatRun,
+        chatAbortControllers,
+    };
+}

package/dist/gateway/server-session-key.js

@@ -0,0 +1,20 @@
+import { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
+import { getAgentRunContext, registerAgentRunContext } from "../infra/agent-events.js";
+import { toAgentRequestSessionKey } from "../routing/session-key.js";
+export function resolveSessionKeyForRun(runId) {
+    const cached = getAgentRunContext(runId)?.sessionKey;
+    if (cached)
+        return cached;
+    const cfg = loadConfig();
+    const storePath = resolveStorePath(cfg.session?.store);
+    const store = loadSessionStore(storePath);
+    const found = Object.entries(store).find(([, entry]) => entry?.sessionId === runId);
+    const storeKey = found?.[0];
+    if (storeKey) {
+        const sessionKey = toAgentRequestSessionKey(storeKey) ?? storeKey;
+        registerAgentRunContext(runId, { sessionKey });
+        return sessionKey;
+    }
+    return undefined;
+}

package/dist/gateway/server-shared.js

@@ -0,0 +1 @@
+export {};

package/dist/gateway/server-startup-log.js

@@ -0,0 +1,27 @@
+import chalk from "chalk";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { getResolvedLoggerSettings } from "../logging.js";
+export function logGatewayStartup(params) {
+    const { provider: agentProvider, model: agentModel } = resolveConfiguredModelRef({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const modelRef = `${agentProvider}/${agentModel}`;
+    params.log.info(`agent model: ${modelRef}`, {
+        consoleMessage: `agent model: ${chalk.whiteBright(modelRef)}`,
+    });
+    const scheme = params.tlsEnabled ? "wss" : "ws";
+    const formatHost = (host) => (host.includes(":") ? `[${host}]` : host);
+    const hosts = params.bindHosts && params.bindHosts.length > 0 ? params.bindHosts : [params.bindHost];
+    const primaryHost = hosts[0] ?? params.bindHost;
+    params.log.info(`listening on ${scheme}://${formatHost(primaryHost)}:${params.port} (PID ${process.pid})`);
+    for (const host of hosts.slice(1)) {
+        params.log.info(`listening on ${scheme}://${formatHost(host)}:${params.port}`);
+    }
+    params.log.info(`log file: ${getResolvedLoggerSettings().file}`);
+    if (params.isNixMode) {
+        params.log.info("gateway: running in Nix mode (config managed externally)");
+    }
+}

package/dist/gateway/server-startup.js

@@ -0,0 +1,119 @@
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { loadModelCatalog } from "../agents/model-catalog.js";
+import { getModelRefStatus, resolveConfiguredModelRef, resolveHooksGmailModel, } from "../agents/model-selection.js";
+import { isTruthyEnvValue } from "../infra/env.js";
+import { startGmailWatcher } from "../hooks/gmail-watcher.js";
+import { clearInternalHooks, createInternalHookEvent, triggerInternalHook, } from "../hooks/internal-hooks.js";
+import { loadInternalHooks } from "../hooks/loader.js";
+import { startPluginServices } from "../plugins/services.js";
+import { startBrowserControlServerIfEnabled } from "./server-browser.js";
+import { scheduleRestartSentinelWake, shouldWakeFromRestartSentinel, } from "./server-restart-sentinel.js";
+export async function startGatewaySidecars(params) {
+    // Start clawd browser control server (unless disabled via config).
+    let browserControl = null;
+    try {
+        browserControl = await startBrowserControlServerIfEnabled();
+    }
+    catch (err) {
+        params.logBrowser.error(`server failed to start: ${String(err)}`);
+    }
+    // Start Gmail watcher if configured (hooks.gmail.account).
+    if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
+        try {
+            const gmailResult = await startGmailWatcher(params.cfg);
+            if (gmailResult.started) {
+                params.logHooks.info("gmail watcher started");
+            }
+            else if (gmailResult.reason &&
+                gmailResult.reason !== "hooks not enabled" &&
+                gmailResult.reason !== "no gmail account configured") {
+                params.logHooks.warn(`gmail watcher not started: ${gmailResult.reason}`);
+            }
+        }
+        catch (err) {
+            params.logHooks.error(`gmail watcher failed to start: ${String(err)}`);
+        }
+    }
+    // Validate hooks.gmail.model if configured.
+    if (params.cfg.hooks?.gmail?.model) {
+        const hooksModelRef = resolveHooksGmailModel({
+            cfg: params.cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+        });
+        if (hooksModelRef) {
+            const { provider: defaultProvider, model: defaultModel } = resolveConfiguredModelRef({
+                cfg: params.cfg,
+                defaultProvider: DEFAULT_PROVIDER,
+                defaultModel: DEFAULT_MODEL,
+            });
+            const catalog = await loadModelCatalog({ config: params.cfg });
+            const status = getModelRefStatus({
+                cfg: params.cfg,
+                catalog,
+                ref: hooksModelRef,
+                defaultProvider,
+                defaultModel,
+            });
+            if (!status.allowed) {
+                params.logHooks.warn(`hooks.gmail.model "${status.key}" not in agents.defaults.models allowlist (will use primary instead)`);
+            }
+            if (!status.inCatalog) {
+                params.logHooks.warn(`hooks.gmail.model "${status.key}" not in the model catalog (may fail at runtime)`);
+            }
+        }
+    }
+    // Load internal hook handlers from configuration and directory discovery.
+    try {
+        // Clear any previously registered hooks to ensure fresh loading
+        clearInternalHooks();
+        const loadedCount = await loadInternalHooks(params.cfg, params.defaultWorkspaceDir);
+        if (loadedCount > 0) {
+            params.logHooks.info(`loaded ${loadedCount} internal hook handler${loadedCount > 1 ? "s" : ""}`);
+        }
+    }
+    catch (err) {
+        params.logHooks.error(`failed to load hooks: ${String(err)}`);
+    }
+    // Launch configured channels so gateway replies via the surface the message came from.
+    // Tests can opt out via CLAWDBOT_SKIP_CHANNELS (or legacy CLAWDBOT_SKIP_PROVIDERS).
+    const skipChannels = isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+        isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS);
+    if (!skipChannels) {
+        try {
+            await params.startChannels();
+        }
+        catch (err) {
+            params.logChannels.error(`channel startup failed: ${String(err)}`);
+        }
+    }
+    else {
+        params.logChannels.info("skipping channel start (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
+    }
+    if (params.cfg.hooks?.internal?.enabled) {
+        setTimeout(() => {
+            const hookEvent = createInternalHookEvent("gateway", "startup", "gateway:startup", {
+                cfg: params.cfg,
+                deps: params.deps,
+                workspaceDir: params.defaultWorkspaceDir,
+            });
+            void triggerInternalHook(hookEvent);
+        }, 250);
+    }
+    let pluginServices = null;
+    try {
+        pluginServices = await startPluginServices({
+            registry: params.pluginRegistry,
+            config: params.cfg,
+            workspaceDir: params.defaultWorkspaceDir,
+        });
+    }
+    catch (err) {
+        params.log.warn(`plugin services failed to start: ${String(err)}`);
+    }
+    if (shouldWakeFromRestartSentinel()) {
+        setTimeout(() => {
+            void scheduleRestartSentinelWake({ deps: params.deps });
+        }, 750);
+    }
+    return { browserControl, pluginServices };
+}