@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/watch/notification-registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Watch-notification registry: maps an actionable push `notificationId` back to
+ * the agent + permission request it represents, so a watch-originated
+ * `watch.notificationAction` can resolve the right pending permission without
+ * scanning every agent's `pendingPermissions`.
+ *
+ * Populated by Story 1.5 (`watch.actionablePush` emit); read/cleared by the
+ * `watch.notificationAction` handler (Story 1.2).
+ */
+export interface WatchNotificationEntry {
+    agentId: string;
+    requestId: string;
+}
+/** Keyed by `notificationId`. */
+export type WatchNotificationRegistry = Map<string, WatchNotificationEntry>;
+//# sourceMappingURL=notification-registry.d.ts.map

package/dist/server/server/watch/notification-registry.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=notification-registry.js.map

package/dist/server/server/web-ui.d.ts

@@ -0,0 +1,10 @@
+import type { RequestHandler } from "express";
+import type { Logger } from "pino";
+export interface WebUiMiddlewareOptions {
+    enabled: boolean;
+    distDir: string | null;
+    label: string;
+    logger: Logger;
+}
+export declare function createWebUiMiddleware(options: WebUiMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=web-ui.d.ts.map

package/dist/server/server/web-ui.js

@@ -0,0 +1,205 @@
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const EXCLUDED_PATH_PREFIXES = ["/api/", "/mcp/", "/public/"];
+const EXCLUDED_PATHS = new Set(["/api", "/mcp", "/public"]);
+function isExcludedPath(requestPath) {
+    for (const prefix of EXCLUDED_PATH_PREFIXES) {
+        if (requestPath.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return EXCLUDED_PATHS.has(requestPath);
+}
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".eot": "application/vnd.ms-fontobject",
+    ".map": "application/json",
+};
+function getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function selectEncoding(acceptEncoding) {
+    if (!acceptEncoding) {
+        return null;
+    }
+    const normalized = acceptEncoding.toLowerCase();
+    if (normalized.includes("br")) {
+        return "br";
+    }
+    if (normalized.includes("gzip")) {
+        return "gzip";
+    }
+    return null;
+}
+function isHashedAsset(filePath) {
+    const base = path.basename(filePath);
+    // Match content hashes like index-abc123def456.js or main.abc123def456.css.
+    return /[-.][0-9a-f]{16,}[-.]/i.test(base);
+}
+function isInsideDir(targetPath, dirPath) {
+    const resolvedDir = path.resolve(dirPath);
+    const resolvedTarget = path.resolve(targetPath);
+    return resolvedTarget === resolvedDir || resolvedTarget.startsWith(resolvedDir + path.sep);
+}
+function resolveTargetFile(distDir, requestPath) {
+    const safePath = path.normalize(requestPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path.join(distDir, safePath);
+    const stat = safeStat(filePath);
+    if (stat?.isDirectory()) {
+        filePath = path.join(filePath, "index.html");
+    }
+    const finalStat = safeStat(filePath);
+    if (!finalStat?.isFile()) {
+        filePath = path.join(distDir, "index.html");
+        const fallbackStat = safeStat(filePath);
+        if (!fallbackStat?.isFile()) {
+            return null;
+        }
+    }
+    if (!isInsideDir(filePath, distDir)) {
+        return null;
+    }
+    const resolvedFile = path.resolve(filePath);
+    const isIndexHtml = path.basename(resolvedFile).toLowerCase() === "index.html";
+    return { resolvedFile, isIndexHtml };
+}
+function safeStat(filePath) {
+    try {
+        return statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveContentEncoding(resolvedFile, acceptEncoding) {
+    const encoding = selectEncoding(acceptEncoding);
+    if (!encoding) {
+        return { finalFile: resolvedFile, contentEncoding: null };
+    }
+    const compressedFile = `${resolvedFile}.${encoding === "br" ? "br" : "gz"}`;
+    const compressedStat = safeStat(compressedFile);
+    if (compressedStat?.isFile()) {
+        return { finalFile: compressedFile, contentEncoding: encoding };
+    }
+    return { finalFile: resolvedFile, contentEncoding: null };
+}
+function setResponseCacheHeaders(res, isIndexHtml, resolvedFile) {
+    if (isIndexHtml) {
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+    }
+    else if (isHashedAsset(resolvedFile)) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    }
+    else {
+        res.setHeader("Cache-Control", "no-cache");
+    }
+}
+export function createWebUiMiddleware(options) {
+    const { enabled, distDir, label, logger } = options;
+    const childLogger = logger.child({ module: "web-ui" });
+    if (!enabled || !distDir) {
+        childLogger.info({ enabled, hasDistDir: !!distDir }, "Daemon web UI disabled or missing dist directory");
+    }
+    else {
+        childLogger.info({ distDir }, "Daemon web UI mounted");
+    }
+    return (req, res, next) => {
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            next();
+            return;
+        }
+        if (isExcludedPath(req.path)) {
+            next();
+            return;
+        }
+        if (!enabled || !distDir) {
+            res.status(404).end();
+            return;
+        }
+        serveWebUiFile({ distDir, requestPath: req.path, label, req, res });
+    };
+}
+function serveWebUiFile(options) {
+    const { distDir, requestPath, label, req, res } = options;
+    const target = resolveTargetFile(distDir, requestPath);
+    if (!target) {
+        res.status(404).end();
+        return;
+    }
+    const { resolvedFile, isIndexHtml } = target;
+    const acceptEncoding = isIndexHtml ? undefined : req.headers["accept-encoding"];
+    const { finalFile, contentEncoding } = resolveContentEncoding(resolvedFile, acceptEncoding);
+    res.setHeader("Content-Type", getContentType(resolvedFile));
+    if (contentEncoding) {
+        res.setHeader("Content-Encoding", contentEncoding);
+        res.setHeader("Vary", "Accept-Encoding");
+    }
+    setResponseCacheHeaders(res, isIndexHtml, resolvedFile);
+    if (req.method === "HEAD") {
+        res.status(200).end();
+        return;
+    }
+    if (isIndexHtml) {
+        sendIndexHtml(res, finalFile, req, label);
+        return;
+    }
+    const stream = createReadStream(finalFile);
+    stream.on("error", () => {
+        if (!res.headersSent) {
+            res.status(500).end();
+        }
+        else {
+            res.end();
+        }
+    });
+    stream.pipe(res);
+}
+function sendIndexHtml(res, filePath, req, label) {
+    try {
+        const html = readFileSync(filePath, "utf-8");
+        const injected = injectConnectionHint(html, req, label);
+        res.status(200).send(injected);
+    }
+    catch {
+        res.status(500).end();
+    }
+}
+function serializeInlineScriptJson(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003C")
+        .replace(/>/g, "\\u003E")
+        .replace(/&/g, "\\u0026");
+}
+function injectConnectionHint(html, req, label) {
+    const host = typeof req.headers.host === "string" ? req.headers.host : "";
+    const useTls = req.protocol === "https";
+    const hint = {
+        listen: host,
+        useTls,
+        label,
+    };
+    const script = `<script>window.__PASEO_INITIAL_DAEMON_CONNECTION__=${serializeInlineScriptJson(hint)}</script>`;
+    const headClose = /<\/head>/i;
+    if (headClose.test(html)) {
+        return html.replace(headClose, `${script}</head>`);
+    }
+    return script + html;
+}
+//# sourceMappingURL=web-ui.js.map

package/dist/server/server/websocket/runtime-metrics.d.ts

@@ -0,0 +1,94 @@
+import type { WSOutboundMessage } from "../messages.js";
+import type { ProcessMemoryDiagnostics } from "../process-diagnostics.js";
+export interface WebSocketRuntimeCounters {
+    connectedAwaitingHello: number;
+    helloResumed: number;
+    helloNew: number;
+    pendingDisconnected: number;
+    sessionDisconnectedWaitingReconnect: number;
+    sessionSocketDisconnectedAttached: number;
+    sessionCleanup: number;
+    validationFailed: number;
+    binaryBeforeHelloRejected: number;
+    pendingMessageRejectedBeforeHello: number;
+    missingConnectionForMessage: number;
+    unexpectedHelloOnActiveConnection: number;
+    relayExternalSocketAttached: number;
+    originRejected: number;
+    hostRejected: number;
+}
+export interface WebSocketRuntimeMetricsSnapshot {
+    windowMs: number;
+    counters: WebSocketRuntimeCounters;
+    inboundMessageTypesTop: Array<[string, number]>;
+    inboundSessionRequestTypesTop: Array<[string, number]>;
+    outboundMessageTypesTop: Array<[string, number]>;
+    outboundSessionMessageTypesTop: Array<[string, number]>;
+    outboundAgentStreamTypesTop: Array<[string, number]>;
+    outboundAgentStreamAgentsTop: Array<[string, number]>;
+    outboundBinaryFrameTypesTop: Array<[string, number]>;
+    bufferedAmount: {
+        p95: number;
+        max: number;
+    };
+    latency: Array<{
+        type: string;
+        count: number;
+        minMs: number;
+        maxMs: number;
+        p50Ms: number;
+        totalMs: number;
+    }>;
+}
+export interface WebSocketRuntimeDiagnosticSnapshot<TRuntime = unknown, TAgents = unknown> extends WebSocketRuntimeMetricsSnapshot {
+    collectedAt: string;
+    final: boolean;
+    sessions: {
+        activeConnections: number;
+        externalSessionKeys: number;
+        reconnectGraceSessions: number;
+    };
+    sockets: {
+        activeSockets: number;
+        pendingConnections: number;
+    };
+    eventLoopDelay: {
+        p50Ms: number;
+        p99Ms: number;
+        maxMs: number;
+    } | null;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
+    runtime: TRuntime;
+    agents: TAgents;
+}
+type Clock = () => number;
+export declare class WebSocketRuntimeMetricsWindow {
+    private readonly clock;
+    private windowStartedAt;
+    private readonly counters;
+    private readonly inboundMessageCounts;
+    private readonly inboundSessionRequestCounts;
+    private readonly outboundMessageCounts;
+    private readonly outboundSessionMessageCounts;
+    private readonly outboundAgentStreamCounts;
+    private readonly outboundAgentStreamByAgentCounts;
+    private readonly outboundBinaryFrameCounts;
+    private readonly bufferedAmountSamples;
+    private readonly requestLatencies;
+    constructor(clock?: Clock);
+    incrementCounter(counter: keyof WebSocketRuntimeCounters): void;
+    recordInboundMessage(type: string): void;
+    recordInboundSessionRequest(type: string): void;
+    recordOutboundMessage(message: WSOutboundMessage, bufferedAmount?: number): void;
+    recordOutboundBinaryFrame(bufferedAmount?: number): void;
+    recordRequestLatency(type: string, durationMs: number): void;
+    snapshotAndReset(): WebSocketRuntimeMetricsSnapshot;
+    private recordOutboundAgentStreamMessage;
+    private recordBufferedAmount;
+    private computeLatencyStats;
+    private computeBufferedAmountStats;
+    private reset;
+}
+export {};
+//# sourceMappingURL=runtime-metrics.d.ts.map

package/dist/server/server/websocket/runtime-metrics.js

@@ -0,0 +1,148 @@
+export class WebSocketRuntimeMetricsWindow {
+    constructor(clock = Date.now) {
+        this.clock = clock;
+        this.counters = createRuntimeCounters();
+        this.inboundMessageCounts = new Map();
+        this.inboundSessionRequestCounts = new Map();
+        this.outboundMessageCounts = new Map();
+        this.outboundSessionMessageCounts = new Map();
+        this.outboundAgentStreamCounts = new Map();
+        this.outboundAgentStreamByAgentCounts = new Map();
+        this.outboundBinaryFrameCounts = new Map();
+        this.bufferedAmountSamples = [];
+        this.requestLatencies = new Map();
+        this.windowStartedAt = this.clock();
+    }
+    incrementCounter(counter) {
+        this.counters[counter] += 1;
+    }
+    recordInboundMessage(type) {
+        incrementCount(this.inboundMessageCounts, type);
+    }
+    recordInboundSessionRequest(type) {
+        incrementCount(this.inboundSessionRequestCounts, type);
+    }
+    recordOutboundMessage(message, bufferedAmount) {
+        if (message.type !== "session") {
+            incrementCount(this.outboundMessageCounts, message.type);
+            this.recordBufferedAmount(bufferedAmount);
+            return;
+        }
+        incrementCount(this.outboundMessageCounts, "session_message");
+        incrementCount(this.outboundSessionMessageCounts, message.message.type);
+        if (message.message.type === "agent_stream") {
+            this.recordOutboundAgentStreamMessage(message.message.payload);
+        }
+        this.recordBufferedAmount(bufferedAmount);
+    }
+    recordOutboundBinaryFrame(bufferedAmount) {
+        incrementCount(this.outboundBinaryFrameCounts, "binary");
+        this.recordBufferedAmount(bufferedAmount);
+    }
+    recordRequestLatency(type, durationMs) {
+        let latencies = this.requestLatencies.get(type);
+        if (!latencies) {
+            latencies = [];
+            this.requestLatencies.set(type, latencies);
+        }
+        latencies.push(durationMs);
+    }
+    snapshotAndReset() {
+        const now = this.clock();
+        const snapshot = {
+            windowMs: Math.max(0, now - this.windowStartedAt),
+            counters: { ...this.counters },
+            inboundMessageTypesTop: getTopCounts(this.inboundMessageCounts, 12),
+            inboundSessionRequestTypesTop: getTopCounts(this.inboundSessionRequestCounts, 20),
+            outboundMessageTypesTop: getTopCounts(this.outboundMessageCounts, 12),
+            outboundSessionMessageTypesTop: getTopCounts(this.outboundSessionMessageCounts, 20),
+            outboundAgentStreamTypesTop: getTopCounts(this.outboundAgentStreamCounts, 20),
+            outboundAgentStreamAgentsTop: getTopCounts(this.outboundAgentStreamByAgentCounts, 20),
+            outboundBinaryFrameTypesTop: getTopCounts(this.outboundBinaryFrameCounts, 12),
+            bufferedAmount: this.computeBufferedAmountStats(),
+            latency: this.computeLatencyStats(),
+        };
+        this.reset(now);
+        return snapshot;
+    }
+    recordOutboundAgentStreamMessage(payload) {
+        const { agentId, event } = payload;
+        const eventType = event.type === "timeline" ? `timeline:${event.item.type}` : event.type;
+        incrementCount(this.outboundAgentStreamCounts, eventType);
+        incrementCount(this.outboundAgentStreamByAgentCounts, agentId);
+    }
+    recordBufferedAmount(bufferedAmount) {
+        if (typeof bufferedAmount !== "number") {
+            return;
+        }
+        this.bufferedAmountSamples.push(bufferedAmount);
+    }
+    computeLatencyStats() {
+        const stats = [];
+        for (const [type, latencies] of this.requestLatencies) {
+            if (latencies.length === 0)
+                continue;
+            const sortedLatencies = [...latencies].sort((a, b) => a - b);
+            const count = sortedLatencies.length;
+            const minMs = Math.round(sortedLatencies[0]);
+            const maxMs = Math.round(sortedLatencies[count - 1]);
+            const p50Ms = Math.round(sortedLatencies[Math.floor(count / 2)]);
+            const totalMs = Math.round(sortedLatencies.reduce((sum, value) => sum + value, 0));
+            stats.push({ type, count, minMs, maxMs, p50Ms, totalMs });
+        }
+        stats.sort((a, b) => b.totalMs - a.totalMs);
+        return stats.slice(0, 15);
+    }
+    computeBufferedAmountStats() {
+        if (this.bufferedAmountSamples.length === 0) {
+            return { p95: 0, max: 0 };
+        }
+        const samples = [...this.bufferedAmountSamples].sort((a, b) => a - b);
+        const p95Index = Math.ceil(samples.length * 0.95) - 1;
+        return {
+            p95: samples[p95Index] ?? 0,
+            max: samples[samples.length - 1] ?? 0,
+        };
+    }
+    reset(windowStartedAt) {
+        for (const counter of Object.keys(this.counters)) {
+            this.counters[counter] = 0;
+        }
+        this.inboundMessageCounts.clear();
+        this.inboundSessionRequestCounts.clear();
+        this.outboundMessageCounts.clear();
+        this.outboundSessionMessageCounts.clear();
+        this.outboundAgentStreamCounts.clear();
+        this.outboundAgentStreamByAgentCounts.clear();
+        this.outboundBinaryFrameCounts.clear();
+        this.bufferedAmountSamples.length = 0;
+        this.requestLatencies.clear();
+        this.windowStartedAt = windowStartedAt;
+    }
+}
+function createRuntimeCounters() {
+    return {
+        connectedAwaitingHello: 0,
+        helloResumed: 0,
+        helloNew: 0,
+        pendingDisconnected: 0,
+        sessionDisconnectedWaitingReconnect: 0,
+        sessionSocketDisconnectedAttached: 0,
+        sessionCleanup: 0,
+        validationFailed: 0,
+        binaryBeforeHelloRejected: 0,
+        pendingMessageRejectedBeforeHello: 0,
+        missingConnectionForMessage: 0,
+        unexpectedHelloOnActiveConnection: 0,
+        relayExternalSocketAttached: 0,
+        originRejected: 0,
+        hostRejected: 0,
+    };
+}
+function incrementCount(map, key) {
+    map.set(key, (map.get(key) ?? 0) + 1);
+}
+function getTopCounts(map, limit) {
+    return [...map.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+}
+//# sourceMappingURL=runtime-metrics.js.map

package/dist/server/server/websocket-server.d.ts

@@ -0,0 +1,193 @@
+import type { Server as HTTPServer } from "http";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { WorkflowManager } from "./workflow/workflow-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import type { DownloadTokenStore } from "./file-download/token-store.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type pino from "pino";
+import type { ProjectRegistry, WorkspaceRegistry } from "./workspace-registry.js";
+import type { FileBackedChatService } from "./chat/chat-service.js";
+import type { LoopService } from "./loop-service.js";
+import type { ScheduleService } from "./schedule/service.js";
+import type { CheckoutDiffManager } from "./checkout-diff-manager.js";
+import type { DaemonConfigStore } from "./daemon-config-store.js";
+import { type ServerCapabilities, type WSOutboundMessage } from "./messages.js";
+import type { HostnamesConfig } from "./hostnames.js";
+import { Session, type SessionLifecycleIntent } from "./session.js";
+import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { WorkspaceAutoName } from "./workspace-auto-name.js";
+import { type PushNotificationSender } from "./push/notifications.js";
+import type { ScriptHealthState } from "./script-health-monitor.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import type { SpeechReadinessSnapshot, SpeechService } from "./speech/speech-runtime.js";
+import type { VoiceCallerContext, VoiceSpeakHandler } from "./voice-types.js";
+import { type GitHubService } from "../services/github-service.js";
+import { type DaemonAuthConfig } from "./auth.js";
+import type { BrowserToolsBroker } from "./browser-tools/broker.js";
+export interface ExternalSocketMetadata {
+    transport: "relay";
+    externalSessionKey?: string;
+    relayConnectionId?: string;
+}
+interface WebSocketServerConfig {
+    allowedOrigins: Set<string>;
+    hostnames?: HostnamesConfig;
+}
+interface WebSocketLike {
+    readyState: number;
+    bufferedAmount?: number;
+    send: (data: string | Uint8Array | ArrayBuffer) => void;
+    close: (code?: number, reason?: string) => void;
+    on: (event: "message" | "close" | "error", listener: (...args: unknown[]) => void) => void;
+    once: (event: "close" | "error", listener: (...args: unknown[]) => void) => void;
+}
+export declare class MissingDaemonVersionError extends Error {
+    constructor();
+}
+/**
+ * WebSocket server that only accepts sockets + parses/forwards messages to the session layer.
+ */
+export declare class VoiceAssistantWebSocketServer {
+    private readonly logger;
+    private readonly wss;
+    private readonly pendingConnections;
+    private readonly sessions;
+    private readonly socketIdentities;
+    private readonly externalSessionsByKey;
+    private readonly serverId;
+    private readonly daemonVersion;
+    private readonly daemonRuntimeConfig;
+    private readonly agentManager;
+    private readonly workflowManager;
+    private readonly agentStorage;
+    private readonly projectRegistry;
+    private readonly workspaceRegistry;
+    private readonly chatService;
+    private readonly loopService;
+    private readonly scheduleService;
+    private readonly checkoutDiffManager;
+    private readonly github;
+    private readonly workspaceGitService;
+    private readonly workspaceAutoName;
+    private readonly downloadTokenStore;
+    private readonly paseoHome;
+    private readonly worktreesRoot;
+    private readonly daemonConfigStore;
+    private readonly pushTokenStore;
+    private readonly pushNotificationSender;
+    private expoTokenBridge;
+    private extensionExecuteCommand;
+    private pushSubscriptionStore;
+    private vapidPublicKey;
+    private readonly mcpBaseUrl;
+    private speech;
+    private terminalManager;
+    private serviceProxy;
+    private scriptRuntimeStore;
+    private getDaemonTcpPort;
+    private getDaemonTcpHost;
+    private serviceProxyPublicBaseUrl;
+    private resolveScriptHealth;
+    private dictation;
+    private readonly voiceSpeakHandlers;
+    private readonly voiceCallerContexts;
+    private readonly workspaceSetupSnapshots;
+    private readonly providerSnapshotManager;
+    private onLifecycleIntent;
+    private onBranchChanged;
+    private serverCapabilities;
+    private readonly runtimeMetrics;
+    private lastRuntimeMetricsSnapshot;
+    private runtimeMetricsInterval;
+    private eventLoopDelayMonitor;
+    private unsubscribeSpeechReadiness;
+    private unsubscribeDaemonConfigChange;
+    private readonly providerUsageService;
+    private unsubscribeTerminalActivity;
+    private readonly browserToolsBroker;
+    private readonly browserToolsRegistrations;
+    constructor(server: HTTPServer, logger: pino.Logger, serverId: string, agentManager: AgentManager, agentStorage: AgentStorage, downloadTokenStore: DownloadTokenStore, paseoHome: string, daemonConfigStore: DaemonConfigStore, mcpBaseUrl: string | null, wsConfig: WebSocketServerConfig, workspaceAutoName: WorkspaceAutoName, auth?: DaemonAuthConfig, speech?: SpeechService | null, terminalManager?: TerminalManager | null, dictation?: {
+        finalTimeoutMs?: number;
+    }, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, serviceProxy?: ServiceProxySubsystem | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, providerSnapshotManager?: ProviderSnapshotManager, daemonRuntimeConfig?: {
+        listen: string | null;
+        worktreesRoot?: string;
+        appBaseUrl?: string;
+        relay: {
+            enabled: boolean;
+            endpoint: string;
+            publicEndpoint: string;
+            useTls: boolean;
+            publicUseTls: boolean;
+        };
+    }, workflowManager?: WorkflowManager, serviceProxyPublicBaseUrl?: string | null, browserToolsBroker?: BrowserToolsBroker | null);
+    /**
+     * Story 1.3 — register a bridge that re-publishes Expo tokens registered via
+     * the legacy `register_push_token` WebSocket message into the new
+     * PushSubscriptionStore. Called once from bootstrap after the push subsystem
+     * is wired. Replays existing tokens so already-registered devices land in
+     * the subscription store at startup, not only on the next registration.
+     */
+    setExtensionExecuteCommand(fn: ((commandId: string, args: unknown[]) => Promise<unknown>) | null): void;
+    setExpoTokenBridge(bridge: ((token: string) => void) | null): void;
+    /**
+     * Wire the Story-1.2 push subscription store + VAPID public key into every
+     * future Session. Called once from bootstrap right after the websocket
+     * server is constructed. Required for the chat-actions
+     * `subscribe_push_request` / `get_vapid_public_key_request` WS bridges
+     * (relay-safe replacements for the HTTP /push/* routes).
+     */
+    setPushSubscriptionBridge(store: import("./push/subscriptions.js").PushSubscriptionStore | null, vapidPublicKey: string | null): void;
+    private assignOptionalServices;
+    private createWebSocketServer;
+    private startRuntimeMetricsInterval;
+    private snapshotEventLoopDelay;
+    private verifyWsUpgrade;
+    private attachAuthenticatedSocket;
+    broadcast(message: WSOutboundMessage): void;
+    listActiveSessions(): Session[];
+    publishSpeechReadiness(readiness: SpeechReadinessSnapshot | null): void;
+    updateServerCapabilities(capabilities: ServerCapabilities | null | undefined): void;
+    attachExternalSocket(ws: WebSocketLike, metadata?: ExternalSocketMetadata): Promise<void>;
+    close(): Promise<void>;
+    private sendToClient;
+    private sendBinaryToClient;
+    private sendToConnection;
+    private sendBinaryToConnection;
+    private attachSocket;
+    private createSessionConnection;
+    private clearPendingConnection;
+    private handleHello;
+    private buildServerInfoStatusPayload;
+    private createServerInfoMessage;
+    private createDaemonConfigChangedMessage;
+    private broadcastCapabilitiesUpdate;
+    private broadcastDaemonConfigChanged;
+    private bindSocketHandlers;
+    resolveVoiceSpeakHandler(callerAgentId: string): VoiceSpeakHandler | null;
+    resolveVoiceCallerContext(callerAgentId: string): VoiceCallerContext | null;
+    private detachSocket;
+    private cleanupConnection;
+    private syncBrowserToolsClientRegistration;
+    private unregisterBrowserToolsClient;
+    private handleInvalidInboundMessage;
+    private maybeHandleBinaryFrame;
+    private handlePendingConnectionMessage;
+    private handleRawMessage;
+    private dispatchSessionMessage;
+    private handleRawMessageError;
+    private decodeRawMessagePayloadForError;
+    private incrementRuntimeCounter;
+    private recordInboundMessageType;
+    private recordInboundSessionRequestType;
+    private recordRequestLatency;
+    private collectSessionRuntimeMetrics;
+    private flushRuntimeMetrics;
+    private getClientActivityState;
+    private broadcastAgentAttention;
+    private broadcastTerminalAttention;
+}
+export declare function isWebSocketSameOrigin(origin: string | undefined, requestHost: string | null): boolean;
+export {};
+//# sourceMappingURL=websocket-server.d.ts.map