@getpaseo/server 0.1.101 → 0.1.102

package/dist/server/server/session.js

@@ -18,11 +18,13 @@ import { createWorkspaceScriptsService, } from "./session/workspace-scripts/work
 import { getErrorMessage, getErrorMessageOr } from "@getpaseo/protocol/error-utils";
 import { getAgentStatusPriority } from "@getpaseo/protocol/agent-state-bucket";
 import { getParentAgentIdFromLabels } from "@getpaseo/protocol/agent-labels";
+import { CLIENT_SHUTDOWN_RPC_REASON, normalizeClientRestartRpcReason, } from "./lifecycle-reasons.js";
 import { createAgentCommand } from "./agent/create-agent/create.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, detachAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
 import { buildStoredAgentPayload, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectProjectedTimelinePage, } from "./agent/timeline-projection.js";
+import { buildAgentForkContextAttachment } from "./agent/activity-curator.js";
 import { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.js";
 import { ImportSessionsRequestError, importProviderSession, listImportableProviderSessions, normalizeImportAgentRequest, } from "./agent/import-sessions.js";
 import { checkoutLiteFromGitSnapshot, deriveWorkspaceDisplayName, } from "./workspace-registry-model.js";
@@ -355,7 +357,9 @@ export class Session {
         this.daemonSession = new DaemonSession({
             host: {
                 emit: (msg) => this.emit(msg),
+                emitLifecycleIntent: (intent) => this.emitLifecycleIntent(intent),
             },
+            clientId: this.clientId,
             paseoHome: this.paseoHome,
             serverId,
             daemonVersion,
@@ -746,12 +750,6 @@ export class Session {
         };
     }
     async buildProjectPlacementForWorkspaceId(workspaceId) {
-        const workspace = await this.workspaceRegistry.get(workspaceId);
-        if (!workspace)
-            return null;
-        return this.buildProjectPlacementForWorkspace(workspace);
-    }
-    async buildProjectPlacementForExistingWorkspaceProject(workspaceId) {
         const workspace = await this.workspaceRegistry.get(workspaceId);
         if (!workspace)
             return null;
@@ -815,6 +813,7 @@ export class Session {
         const promise = this.dispatchVoiceAndControlMessage(msg) ??
             this.dispatchAgentRewindMessage(msg) ??
             this.dispatchAgentRelationshipMessage(msg) ??
+            this.dispatchAgentTimelineMessage(msg) ??
             this.dispatchAgentLifecycleMessage(msg) ??
             this.dispatchAgentConfigMessage(msg) ??
             this.dispatchCheckoutMessage(msg) ??
@@ -891,6 +890,16 @@ export class Session {
                 return undefined;
         }
     }
+    dispatchAgentTimelineMessage(msg) {
+        switch (msg.type) {
+            case "fetch_agent_timeline_request":
+                return this.handleFetchAgentTimelineRequest(msg);
+            case "agent.fork_context.request":
+                return this.handleAgentForkContextRequest(msg);
+            default:
+                return undefined;
+        }
+    }
     dispatchAgentLifecycleMessage(msg) {
         switch (msg.type) {
             case "fetch_agents_request":
@@ -925,8 +934,6 @@ export class Session {
                 return this.handleRefreshAgentRequest(msg);
             case "cancel_agent_request":
                 return this.handleCancelAgentRequest(msg.agentId, msg.requestId);
-            case "fetch_agent_timeline_request":
-                return this.handleFetchAgentTimelineRequest(msg);
             case "agent_permission_response":
                 return this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
             case "clear_agent_attention":
@@ -957,6 +964,8 @@ export class Session {
                 return this.daemonSession.handleGetPairingOfferRequest(msg);
             case "diagnostics.request":
                 return this.daemonSession.handleDiagnosticsRequest(msg);
+            case "daemon.update.request":
+                return this.daemonSession.handleUpdateRequest(msg);
             case "set_daemon_config_request":
                 this.emit({
                     type: "set_daemon_config_response",
@@ -1164,6 +1173,9 @@ export class Session {
     resetPeakInflight() {
         this.peakInflightRequests = this.inflightRequests;
     }
+    getSessionId() {
+        return this.sessionId;
+    }
     async handleBinaryFrame(binaryFrame) {
         if (binaryFrame.kind === "file_transfer") {
             await this.workspaceFilesSession.handleFileTransferFrame(binaryFrame.frame);
@@ -1172,6 +1184,7 @@ export class Session {
         this.terminalController.handleBinaryFrame(binaryFrame.frame);
     }
     async handleRestartServerRequest(requestId, reason) {
+        const lifecycleReason = normalizeClientRestartRpcReason(reason);
         const payload = {
             status: "restart_requested",
             clientId: this.clientId,
@@ -1180,7 +1193,7 @@ export class Session {
             payload.reason = reason;
         }
         payload.requestId = requestId;
-        this.sessionLogger.warn({ reason }, "Restart requested via websocket");
+        this.sessionLogger.warn({ reason: lifecycleReason }, "Restart requested via websocket");
         this.emit({
             type: "status",
             payload,
@@ -1189,11 +1202,12 @@ export class Session {
             type: "restart",
             clientId: this.clientId,
             requestId,
-            ...(reason ? { reason } : {}),
+            reason: lifecycleReason,
         });
     }
     async handleShutdownServerRequest(requestId) {
-        this.sessionLogger.warn("Shutdown requested via websocket");
+        const reason = CLIENT_SHUTDOWN_RPC_REASON;
+        this.sessionLogger.warn({ reason }, "Shutdown requested via websocket");
         this.emit({
             type: "status",
             payload: {
@@ -1206,6 +1220,7 @@ export class Session {
             type: "shutdown",
             clientId: this.clientId,
             requestId,
+            reason,
         });
     }
     emitLifecycleIntent(intent) {
@@ -1691,6 +1706,7 @@ export class Session {
                 cwd: createAgentConfig.cwd,
                 initialTitle: workspacePromptTitle,
             });
+            const createdDirectoryWorkspaceForAgent = !createdWorktree && !msg.workspaceId;
             const { snapshot, liveSnapshot } = await createAgentCommand({
                 agentManager: this.agentManager,
                 agentStorage: this.agentStorage,
@@ -1716,11 +1732,8 @@ export class Session {
                 buildSessionConfig: (sessionConfig, gitOptions, legacyWorktreeName, ctx) => this.buildAgentSessionConfig(sessionConfig, gitOptions, legacyWorktreeName, ctx),
             });
             createdAgentId = snapshot.id;
-            if (!createdWorktree && msg.workspaceId) {
-                await this.writeInitialWorkspaceTitleIfUntitled(workspaceId, workspacePromptTitle);
-            }
             await this.agentUpdates.forwardLiveAgent(snapshot);
-            if (!createdWorktree && trimmedPrompt) {
+            if (createdDirectoryWorkspaceForAgent && trimmedPrompt) {
                 await this.scheduleAutoNameLocalWorkspaceTitleForFirstAgent({
                     workspaceId,
                     cwd: createAgentConfig.cwd,
@@ -2118,20 +2131,6 @@ export class Session {
             updatedAt: new Date().toISOString(),
         });
     }
-    async writeInitialWorkspaceTitleIfUntitled(workspaceId, title) {
-        if (!title) {
-            return;
-        }
-        const current = await this.workspaceRegistry.get(workspaceId);
-        if (!current || current.title) {
-            return;
-        }
-        await this.workspaceRegistry.upsert({
-            ...current,
-            title,
-            updatedAt: new Date().toISOString(),
-        });
-    }
     // Wraps the injected workspace-name generator for a directory workspace.
     async generateWorkspaceTitleFromContext(input) {
         return this.generateWorkspaceName({
@@ -2624,9 +2623,7 @@ export class Session {
             if (existing) {
                 return existing;
             }
-            const placementPromise = request.type === "fetch_agent_history_request"
-                ? this.buildProjectPlacementForExistingWorkspaceProject(workspaceId)
-                : this.buildProjectPlacementForWorkspaceId(workspaceId);
+            const placementPromise = this.buildProjectPlacementForWorkspaceId(workspaceId);
             placementByWorkspaceId.set(workspaceId, placementPromise);
             return placementPromise;
         };
@@ -4038,6 +4035,51 @@ export class Session {
             });
         }
     }
+    async handleAgentForkContextRequest(msg) {
+        try {
+            const snapshot = await ensureAgentLoaded(msg.agentId, {
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                logger: this.sessionLogger,
+            });
+            const agentPayload = await this.buildAgentPayload(snapshot);
+            const rows = this.agentManager.fetchTimeline(msg.agentId, {
+                direction: "tail",
+                limit: 0,
+            }).rows;
+            const forkContext = buildAgentForkContextAttachment({
+                rows,
+                boundaryMessageId: msg.boundaryMessageId,
+                agentTitle: agentPayload.title,
+                cwd: snapshot.cwd,
+            });
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: forkContext.attachment,
+                    itemCount: forkContext.itemCount,
+                    boundaryMessageId: forkContext.boundaryMessageId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle agent.fork_context.request");
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: null,
+                    itemCount: 0,
+                    boundaryMessageId: msg.boundaryMessageId ?? null,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     async handleSendAgentMessageRequest(msg) {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {

package/dist/server/server/speech/providers/openai/config.d.ts

@@ -4,8 +4,6 @@ import type { STTConfig } from "./stt.js";
 import type { TTSConfig } from "./tts.js";
 export declare const DEFAULT_OPENAI_TTS_MODEL = "tts-1";
 export interface OpenAiSpeechProviderConfig {
-    apiKey?: string;
-    baseUrl?: string;
     stt?: Partial<STTConfig> & {
         apiKey?: string;
     };

package/dist/server/server/speech/providers/openai/config.js

@@ -9,11 +9,21 @@ const OptionalTrimmedStringSchema = z
     .trim()
     .optional()
     .transform((value) => (value && value.length > 0 ? value : undefined));
-const OpenAiSpeechResolutionSchema = z.object({
-    apiKey: OptionalTrimmedStringSchema,
-    baseUrl: OptionalTrimmedStringSchema,
+// Endpoint credentials only — plain trimmed strings, so this never throws on a
+// malformed value. The STT/TTS option groups parse separately and only for the
+// endpoint that is actually configured, so a stale env var for an unused endpoint
+// (e.g. a leftover TTS_VOICE in an STT-only setup) can't break the other one.
+const OpenAiEndpointKeysSchema = z.object({
+    sttApiKey: OptionalTrimmedStringSchema,
+    sttBaseUrl: OptionalTrimmedStringSchema,
+    ttsApiKey: OptionalTrimmedStringSchema,
+    ttsBaseUrl: OptionalTrimmedStringSchema,
+});
+const OpenAiSttOptionsSchema = z.object({
     sttConfidenceThreshold: OptionalFiniteNumberSchema,
     sttModel: OptionalTrimmedStringSchema,
+});
+const OpenAiTtsOptionsSchema = z.object({
     ttsVoice: z.string().trim().toLowerCase().pipe(OpenAiTtsVoiceSchema).default("alloy"),
     ttsModel: z
         .string()
@@ -30,9 +40,15 @@ function pickIfOpenAi(provider, value) {
 }
 function firstDefined(values) {
     for (const value of values) {
-        if (value !== undefined && value !== null) {
-            return value;
+        if (value === undefined || value === null) {
+            continue;
+        }
+        // Empty/whitespace env vars (e.g. a copied .env.example with OPENAI_STT_API_KEY=)
+        // must not shadow a later fallback such as OPENAI_API_KEY.
+        if (typeof value === "string" && value.trim().length === 0) {
+            continue;
         }
+        return value;
     }
     return undefined;
 }
@@ -66,46 +82,67 @@ function buildOpenAiTtsInput(params) {
     };
 }
 function buildOpenAiResolutionInput(params) {
+    const { env } = params;
+    const openai = params.persisted.providers?.openai;
     return {
-        apiKey: firstDefined([
-            params.persisted.providers?.openai?.voice?.apiKey,
-            params.env.OPENAI_VOICE_API_KEY,
-            params.persisted.providers?.openai?.apiKey,
-            params.env.OPENAI_API_KEY,
+        sttApiKey: firstDefined([
+            openai?.stt?.apiKey,
+            env.OPENAI_STT_API_KEY,
+            openai?.apiKey,
+            env.OPENAI_API_KEY,
         ]),
-        baseUrl: firstDefined([
-            params.persisted.providers?.openai?.voice?.baseUrl,
-            params.env.OPENAI_VOICE_BASE_URL,
-            params.persisted.providers?.openai?.baseUrl,
-            params.env.OPENAI_BASE_URL,
+        sttBaseUrl: firstDefined([
+            openai?.stt?.baseUrl,
+            env.OPENAI_STT_BASE_URL,
+            openai?.baseUrl,
+            env.OPENAI_BASE_URL,
+        ]),
+        ttsApiKey: firstDefined([
+            openai?.tts?.apiKey,
+            env.OPENAI_TTS_API_KEY,
+            openai?.apiKey,
+            env.OPENAI_API_KEY,
+        ]),
+        ttsBaseUrl: firstDefined([
+            openai?.tts?.baseUrl,
+            env.OPENAI_TTS_BASE_URL,
+            openai?.baseUrl,
+            env.OPENAI_BASE_URL,
         ]),
         ...buildOpenAiSttInput(params),
         ...buildOpenAiTtsInput(params),
     };
 }
 export function resolveOpenAiSpeechConfig(params) {
-    const parsed = OpenAiSpeechResolutionSchema.parse(buildOpenAiResolutionInput(params));
-    if (!parsed.apiKey) {
+    const input = buildOpenAiResolutionInput(params);
+    const keys = OpenAiEndpointKeysSchema.parse(input);
+    if (!keys.sttApiKey && !keys.ttsApiKey) {
         return undefined;
     }
     return {
-        apiKey: parsed.apiKey,
-        ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
-        stt: {
-            apiKey: parsed.apiKey,
-            ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
-            ...(parsed.sttConfidenceThreshold !== undefined
-                ? { confidenceThreshold: parsed.sttConfidenceThreshold }
-                : {}),
-            ...(parsed.sttModel ? { model: parsed.sttModel } : {}),
-        },
-        tts: {
-            apiKey: parsed.apiKey,
-            ...(parsed.baseUrl ? { baseUrl: parsed.baseUrl } : {}),
-            voice: parsed.ttsVoice,
-            model: parsed.ttsModel,
-            responseFormat: "pcm",
-        },
+        ...(keys.sttApiKey ? { stt: buildSttConfig(keys.sttApiKey, keys.sttBaseUrl, input) } : {}),
+        ...(keys.ttsApiKey ? { tts: buildTtsConfig(keys.ttsApiKey, keys.ttsBaseUrl, input) } : {}),
+    };
+}
+function buildSttConfig(apiKey, baseUrl, input) {
+    const options = OpenAiSttOptionsSchema.parse(input);
+    return {
+        apiKey,
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(options.sttConfidenceThreshold !== undefined
+            ? { confidenceThreshold: options.sttConfidenceThreshold }
+            : {}),
+        ...(options.sttModel ? { model: options.sttModel } : {}),
+    };
+}
+function buildTtsConfig(apiKey, baseUrl, input) {
+    const options = OpenAiTtsOptionsSchema.parse(input);
+    return {
+        apiKey,
+        ...(baseUrl ? { baseUrl } : {}),
+        voice: options.ttsVoice,
+        model: options.ttsModel,
+        responseFormat: "pcm",
     };
 }
 //# sourceMappingURL=config.js.map

package/dist/server/server/speech/providers/openai/runtime.js

@@ -2,11 +2,11 @@ import { DEFAULT_OPENAI_TTS_MODEL } from "./config.js";
 import { OpenAISTT } from "./stt.js";
 import { OpenAITTS } from "./tts.js";
 function resolveOpenAiCredentials(openaiConfig) {
-    const openaiApiKey = openaiConfig?.apiKey;
+    const sttApiKey = openaiConfig?.stt?.apiKey;
     return {
-        openaiSttApiKey: openaiConfig?.stt?.apiKey ?? openaiApiKey,
-        openaiTtsApiKey: openaiConfig?.tts?.apiKey ?? openaiApiKey,
-        openaiDictationApiKey: openaiApiKey,
+        openaiSttApiKey: sttApiKey,
+        openaiTtsApiKey: openaiConfig?.tts?.apiKey,
+        openaiDictationApiKey: sttApiKey,
     };
 }
 export function getOpenAiSpeechAvailability(openaiConfig) {

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

@@ -1,4 +1,5 @@
 import type { WSOutboundMessage } from "../messages.js";
+import type { ProcessMemoryDiagnostics } from "../process-diagnostics.js";
 export interface WebSocketRuntimeCounters {
     connectedAwaitingHello: number;
     helloResumed: number;
@@ -56,6 +57,8 @@ export interface WebSocketRuntimeDiagnosticSnapshot<TRuntime = unknown, TAgents
         p99Ms: number;
         maxMs: number;
     } | null;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
     runtime: TRuntime;
     agents: TAgents;
 }

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

@@ -26,6 +26,7 @@ import { type DaemonAuthConfig } from "./auth.js";
 export interface ExternalSocketMetadata {
     transport: "relay";
     externalSessionKey?: string;
+    relayConnectionId?: string;
 }
 interface WebSocketServerConfig {
     allowedOrigins: Set<string>;
@@ -50,6 +51,7 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly wss;
     private readonly pendingConnections;
     private readonly sessions;
+    private readonly socketIdentities;
     private readonly externalSessionsByKey;
     private readonly serverId;
     private readonly daemonVersion;
@@ -156,5 +158,6 @@ export declare class VoiceAssistantWebSocketServer {
     private broadcastAgentAttention;
     private broadcastTerminalAttention;
 }
+export declare function isWebSocketSameOrigin(origin: string | undefined, requestHost: string | null): boolean;
 export {};
 //# sourceMappingURL=websocket-server.d.ts.map