@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/server/server/agent/tools/types.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+export interface PaseoToolExecutionContext {
+    signal?: AbortSignal;
+}
+export interface PaseoToolResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+export interface PaseoToolConfig {
+    title?: string;
+    description?: string;
+    inputSchema?: z.ZodRawShape | z.ZodType;
+    outputSchema?: z.ZodRawShape | z.ZodType;
+}
+export interface PaseoToolDefinition extends PaseoToolConfig {
+    name: string;
+    description: string;
+    handler: (input: unknown, context: PaseoToolExecutionContext) => Promise<PaseoToolResult>;
+}
+export interface PaseoToolCatalog {
+    tools: ReadonlyMap<string, PaseoToolDefinition>;
+    getTool(name: string): PaseoToolDefinition | undefined;
+    executeTool(name: string, input: unknown, context?: PaseoToolExecutionContext): Promise<PaseoToolResult>;
+}
+export interface PaseoToolRuntimeContext {
+    callerAgentId?: string;
+    enableVoiceTools?: boolean;
+    voiceOnly?: boolean;
+}
+export type PaseoToolCatalogFactory = (context: PaseoToolRuntimeContext) => PaseoToolCatalog | Promise<PaseoToolCatalog>;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/server/agent/tools/types.js

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

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

@@ -44,11 +44,12 @@ export type DaemonLifecycleIntent = {
     type: "shutdown";
     clientId: string;
     requestId: string;
+    reason: string;
 } | {
     type: "restart";
     clientId: string;
     requestId: string;
-    reason?: string;
+    reason: string;
 };
 export interface PaseoDaemonConfig {
     listen: string;
@@ -57,6 +58,7 @@ export interface PaseoDaemonConfig {
     corsAllowedOrigins: string[];
     allowedHosts?: HostnamesConfig;
     hostnames?: HostnamesConfig;
+    trustedProxies?: true | string[];
     mcpEnabled?: boolean;
     mcpInjectIntoAgents?: boolean;
     autoArchiveAfterMerge?: boolean;
@@ -77,6 +79,10 @@ export interface PaseoDaemonConfig {
         publicBaseUrl: string | null;
         standaloneListen: string | null;
     };
+    webUi?: {
+        enabled: boolean;
+        distDir: string | null;
+    };
     appBaseUrl?: string;
     auth?: DaemonAuthConfig;
     openai?: PaseoOpenAIConfig;

package/dist/server/server/bootstrap.js

@@ -83,6 +83,7 @@ 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 { createPaseoToolCatalog, } from "./agent/tools/paseo-tools.js";
 import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
 import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
@@ -112,6 +113,7 @@ import { createManagedProcessRegistry, createSystemManagedProcessTable, } from "
 import { terminateWithTreeKill } from "../utils/tree-kill.js";
 import { isHostnameAllowed } from "./hostnames.js";
 import { createRequireBearerMiddleware, isAgentMcpRequestAuthorized, } from "./auth.js";
+import { createWebUiMiddleware } from "./web-ui.js";
 const MAX_MCP_DEBUG_BATCH_ITEMS = 10;
 const REDACTED_LOG_VALUE = "[redacted]";
 const DOWNLOAD_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW;
@@ -229,6 +231,17 @@ async function reconcileManagedProcessLedger(managedProcesses, logger) {
         logger.info(reapResult, "Managed helper process ledger reconciled");
     }
 }
+function mountWebUi(app, config, logger) {
+    app.use(createWebUiMiddleware({
+        enabled: config.webUi?.enabled ?? false,
+        distDir: config.webUi?.distDir ?? null,
+        label: getHostname(),
+        logger,
+    }));
+}
+function resolveExpressTrustProxySetting(config) {
+    return config.trustedProxies ?? ["loopback"];
+}
 export async function createPaseoDaemon(config, rootLogger) {
     const logger = rootLogger.child({ module: "bootstrap" });
     const bootstrapStart = performance.now();
@@ -278,6 +291,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     const agentMcpAuthToken = randomUUID();
     const listenTarget = parseListenString(config.listen);
     const app = express();
+    app.set("trust proxy", resolveExpressTrustProxySetting(config));
     let boundListenTarget = null;
     let workspaceRegistry = null;
     const terminalManager = createConfiguredTerminalManager({
@@ -362,6 +376,11 @@ export async function createPaseoDaemon(config, rootLogger) {
     });
     // Local, harmless, and token-gated; deliberately skips daemon auth.
     app.post("/api/terminal-activity", express.json(), createTerminalActivityRouteHandler(terminalManager));
+    // Serve the bundled browser web UI when enabled. Mounted after service-proxy
+    // classification and host/CORS handling, but before daemon bearer auth, so
+    // static app files load without the daemon password while API/WebSocket calls
+    // remain protected.
+    mountWebUi(app, config, logger);
     app.use(createRequireBearerMiddleware(config.auth, (context) => {
         logger.warn(context, "Rejected HTTP request with invalid daemon password");
     }));
@@ -612,73 +631,79 @@ export async function createPaseoDaemon(config, rootLogger) {
         clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
         emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
     });
+    const createPaseoWorktreeForTools = async (input, serviceOptions) => {
+        return createPaseoWorktreeWorkflow({
+            paseoHome: config.paseoHome,
+            worktreesRoot: config.worktreesRoot,
+            createPaseoWorktree: async (workflowInput, workflowOptions) => {
+                return createRegisteredPaseoWorktree(workflowInput, {
+                    github,
+                    ...(workflowOptions?.resolveDefaultBranch
+                        ? {
+                            resolveDefaultBranch: workflowOptions.resolveDefaultBranch,
+                        }
+                        : {}),
+                    projectRegistry,
+                    workspaceRegistry,
+                    workspaceGitService,
+                });
+            },
+            warmWorkspaceGitData: async (workspace) => {
+                await Promise.all(wsServer
+                    ?.listActiveSessions()
+                    .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
+            },
+            emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+                await emitWorkspaceUpdatesExternal([workspaceId]);
+            },
+            cacheWorkspaceSetupSnapshot: () => { },
+            emit: emitExternalSessionMessage,
+            sessionLogger: logger,
+            terminalManager,
+            archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+            serviceProxy,
+            scriptRuntimeStore,
+            getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+            getDaemonTcpHost: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.host : null),
+            serviceProxyPublicBaseUrl,
+            onScriptsChanged: null,
+        }, input, serviceOptions);
+    };
+    const createAgentToolHostDependencies = (runtime) => ({
+        agentManager,
+        agentStorage,
+        terminalManager,
+        getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+        scheduleService,
+        providerSnapshotManager,
+        github,
+        workspaceGitService,
+        findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+        listActiveWorkspaces: listActiveWorkspacesExternal,
+        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+        emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+        markWorkspaceArchiving: markWorkspaceArchivingExternal,
+        clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+        ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
+        createPaseoWorktree: createPaseoWorktreeForTools,
+        paseoHome: config.paseoHome,
+        worktreesRoot: config.worktreesRoot,
+        callerAgentId: runtime.callerAgentId,
+        enableVoiceTools: runtime.enableVoiceTools,
+        voiceOnly: runtime.voiceOnly,
+        resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
+        resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
+        logger,
+    });
+    const createAgentToolCatalog = (runtime) => createPaseoToolCatalog(createAgentToolHostDependencies(runtime));
+    agentManager.setPaseoToolCatalogFactory(createAgentToolCatalog);
+    agentManager.setPaseoToolsEnabled(config.mcpInjectIntoAgents !== false);
     const mcpEnabled = config.mcpEnabled ?? true;
     let agentMcpBaseUrl = null;
     if (mcpEnabled) {
         const agentMcpRoute = "/mcp/agents";
         const createAgentMcpSession = async (callerAgentId) => {
-            const agentMcpServer = await createAgentMcpServer({
-                agentManager,
-                agentStorage,
-                terminalManager,
-                getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
-                scheduleService,
-                providerSnapshotManager,
-                github,
-                workspaceGitService,
-                findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
-                listActiveWorkspaces: listActiveWorkspacesExternal,
-                archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
-                emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
-                markWorkspaceArchiving: markWorkspaceArchivingExternal,
-                clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
-                ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
-                createPaseoWorktree: async (input, serviceOptions) => {
-                    return createPaseoWorktreeWorkflow({
-                        paseoHome: config.paseoHome,
-                        worktreesRoot: config.worktreesRoot,
-                        createPaseoWorktree: async (workflowInput, workflowOptions) => {
-                            return createRegisteredPaseoWorktree(workflowInput, {
-                                github,
-                                ...(workflowOptions?.resolveDefaultBranch
-                                    ? {
-                                        resolveDefaultBranch: workflowOptions.resolveDefaultBranch,
-                                    }
-                                    : {}),
-                                projectRegistry,
-                                workspaceRegistry,
-                                workspaceGitService,
-                            });
-                        },
-                        warmWorkspaceGitData: async (workspace) => {
-                            await Promise.all(wsServer
-                                ?.listActiveSessions()
-                                .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
-                        },
-                        emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
-                            await emitWorkspaceUpdatesExternal([workspaceId]);
-                        },
-                        cacheWorkspaceSetupSnapshot: () => { },
-                        emit: emitExternalSessionMessage,
-                        sessionLogger: logger,
-                        terminalManager,
-                        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
-                        serviceProxy,
-                        scriptRuntimeStore,
-                        getDaemonTcpPort: () => boundListenTarget?.type === "tcp" ? boundListenTarget.port : null,
-                        getDaemonTcpHost: () => boundListenTarget?.type === "tcp" ? boundListenTarget.host : null,
-                        serviceProxyPublicBaseUrl,
-                        onScriptsChanged: null,
-                    }, input, serviceOptions);
-                },
-                paseoHome: config.paseoHome,
-                worktreesRoot: config.worktreesRoot,
-                callerAgentId,
-                enableVoiceTools: false,
-                resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
-                resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
-                logger,
-            });
+            const agentMcpServer = await createAgentMcpServer(createAgentToolHostDependencies({ callerAgentId }));
             // Stateless mode: each HTTP request builds a fresh server + transport that is
             // torn down when the response closes, so no per-session state is retained between
             // requests. The agent control plane only lists and calls tools, neither of which
@@ -810,8 +835,10 @@ export async function createPaseoDaemon(config, rootLogger) {
                         const mcpBaseUrl = mcpEnabled ? createAgentMcpBaseUrl(boundListenTarget) : null;
                         agentMcpBaseUrl = config.mcpInjectIntoAgents === false ? null : mcpBaseUrl;
                         agentManager.setMcpBaseUrl(agentMcpBaseUrl);
+                        agentManager.setPaseoToolsEnabled(config.mcpInjectIntoAgents !== false);
                         daemonConfigStore.onFieldChange("mcp.injectIntoAgents", (value) => {
                             agentManager.setMcpBaseUrl(value ? mcpBaseUrl : null);
+                            agentManager.setPaseoToolsEnabled(value !== false);
                         });
                         daemonConfigStore.onFieldChange("appendSystemPrompt", (value) => {
                             agentManager.setAppendSystemPrompt(typeof value === "string" ? value : "");

package/dist/server/server/config.d.ts

@@ -1,11 +1,13 @@
 import type { PaseoDaemonConfig } from "./bootstrap.js";
 import { type HostnamesConfig } from "./hostnames.js";
+export declare function resolveBundledWebUiDistDir(moduleUrl?: string | URL): string;
 export type CliConfigOverrides = Partial<{
     listen: string;
     relayEnabled: boolean;
     relayUseTls: boolean;
     mcpEnabled: boolean;
     mcpInjectIntoAgents: boolean;
+    webUiEnabled: boolean;
     hostnames: HostnamesConfig;
 }>;
 export declare function loadConfig(paseoHome: string, options?: {

package/dist/server/server/config.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { resolvePaseoNodeEnv } from "./paseo-env.js";
 import { z } from "zod";
 import { expandTilde } from "../utils/path.js";
@@ -11,6 +12,20 @@ import { mergeHostnames, parseHostnamesEnv } from "./hostnames.js";
 const DEFAULT_PORT = 6767;
 const DEFAULT_RELAY_ENDPOINT = "relay.paseo.sh:443";
 const DEFAULT_APP_BASE_URL = "https://app.paseo.sh";
+const DEFAULT_TRUSTED_PROXIES = ["loopback"];
+export function resolveBundledWebUiDistDir(moduleUrl = import.meta.url) {
+    const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+    if (path.basename(moduleDir) === "server" && path.basename(path.dirname(moduleDir)) === "src") {
+        return path.resolve(moduleDir, "..", "..", "dist", "server", "web-ui");
+    }
+    if (path.basename(moduleDir) === "server" &&
+        path.basename(path.dirname(moduleDir)) === "server" &&
+        path.basename(path.dirname(path.dirname(moduleDir))) === "dist") {
+        return path.resolve(moduleDir, "..", "web-ui");
+    }
+    return path.resolve(moduleDir, "web-ui");
+}
+const BUNDLED_WEB_UI_DIST_DIR = resolveBundledWebUiDistDir();
 function parseBooleanEnv(value) {
     if (value === undefined) {
         return undefined;
@@ -137,6 +152,21 @@ function resolveServiceProxyConfig(env, persisted) {
         : null;
     return { publicBaseUrl, standaloneListen };
 }
+function resolveWebUiConfig(paseoHome, env, cli, persisted) {
+    const enabled = cli?.webUiEnabled ??
+        parseBooleanEnv(env.PASEO_WEB_UI_ENABLED) ??
+        persisted.features?.webUi?.enabled ??
+        false;
+    const rawDistDir = env.PASEO_WEB_UI_DIST_DIR ?? persisted.features?.webUi?.distDir;
+    const trimmedDistDir = rawDistDir?.trim();
+    const distDir = trimmedDistDir
+        ? path.resolve(path.isAbsolute(trimmedDistDir) ? trimmedDistDir : paseoHome, trimmedDistDir)
+        : BUNDLED_WEB_UI_DIST_DIR;
+    return {
+        enabled,
+        distDir,
+    };
+}
 function resolveVoiceLlmConfig(env, persisted) {
     const envVoiceLlmProvider = parseOptionalVoiceLlmProvider(env.PASEO_VOICE_LLM_PROVIDER);
     const persistedVoiceLlmProvider = parseOptionalVoiceLlmProvider(persisted.features?.voiceMode?.llm?.provider);
@@ -153,6 +183,28 @@ function resolveCorsAllowedOrigins(env, persisted) {
     const persistedCorsOrigins = persisted.daemon?.cors?.allowedOrigins ?? [];
     return Array.from(new Set([...persistedCorsOrigins, ...envCorsOrigins].filter((s) => s.length > 0)));
 }
+function parseTrustedProxiesEnv(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = trimmed.toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return [];
+    }
+    return trimmed
+        .split(",")
+        .map((proxy) => proxy.trim())
+        .filter((proxy) => proxy.length > 0);
+}
+function resolveTrustedProxiesConfig(env, persisted) {
+    return (parseTrustedProxiesEnv(env.PASEO_TRUSTED_PROXIES) ??
+        persisted.daemon?.trustedProxies ??
+        DEFAULT_TRUSTED_PROXIES);
+}
 // PASEO_LISTEN can be:
 // - host:port (TCP)
 // - /path/to/socket (Unix socket)
@@ -198,6 +250,7 @@ function resolveStaticLoadConfigSettings(env, cli, persisted) {
             parseHostnamesEnv(env.PASEO_HOSTNAMES ?? env.PASEO_ALLOWED_HOSTS),
             cli?.hostnames,
         ]),
+        trustedProxies: resolveTrustedProxiesConfig(env, persisted),
         appBaseUrl: env.PASEO_APP_BASE_URL ?? persisted.app?.baseUrl ?? DEFAULT_APP_BASE_URL,
     };
 }
@@ -205,7 +258,7 @@ export function loadConfig(paseoHome, options) {
     const env = options?.env ?? process.env;
     const persisted = loadPersistedConfig(paseoHome);
     const listen = resolveListenAddress(env, options?.cli, persisted);
-    const { mcpEnabled, mcpInjectIntoAgents, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, hostnames, appBaseUrl, } = resolveStaticLoadConfigSettings(env, options?.cli, persisted);
+    const { mcpEnabled, mcpInjectIntoAgents, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, options?.cli, persisted);
     const relay = resolveRelayConfig({
         env,
         persisted,
@@ -213,6 +266,7 @@ export function loadConfig(paseoHome, options) {
         cliRelayUseTls: options?.cli?.relayUseTls,
     });
     const serviceProxy = resolveServiceProxyConfig(env, persisted);
+    const webUi = resolveWebUiConfig(paseoHome, env, options?.cli, persisted);
     const { openai, speech } = resolveSpeechConfig({
         paseoHome,
         env,
@@ -226,6 +280,7 @@ export function loadConfig(paseoHome, options) {
         worktreesRoot: resolveWorktreesRoot(paseoHome, persisted),
         corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
         hostnames,
+        trustedProxies,
         mcpEnabled,
         mcpInjectIntoAgents,
         autoArchiveAfterMerge,
@@ -243,6 +298,7 @@ export function loadConfig(paseoHome, options) {
         relayUseTls: relay.useTls,
         relayPublicUseTls: relay.publicUseTls,
         serviceProxy,
+        webUi,
         appBaseUrl,
         auth: resolveAuthConfig(env, persisted),
         openai,

package/dist/server/server/daemon-worker.js

@@ -4,6 +4,7 @@ import { createPaseoDaemon } from "./bootstrap.js";
 import { loadConfig } from "./config.js";
 import { resolvePaseoHome } from "./paseo-home.js";
 import { createRootLogger } from "./logger.js";
+import { getProcessDiagnostics } from "./process-diagnostics.js";
 process.title = "Paseo Daemon";
 function isPidAlive(pid) {
     try {
@@ -60,6 +61,12 @@ function applyCliFlagOverrides(config) {
     if (process.argv.includes("--no-inject-mcp")) {
         config.mcpInjectIntoAgents = false;
     }
+    if (process.argv.includes("--web-ui")) {
+        config.webUi = { ...(config.webUi ?? { distDir: null }), enabled: true };
+    }
+    if (process.argv.includes("--no-web-ui")) {
+        config.webUi = { ...(config.webUi ?? { distDir: null }), enabled: false };
+    }
 }
 async function main() {
     const { paseoHome, logger, config } = bootstrapFromEnvironment();
@@ -77,11 +84,12 @@ async function main() {
         });
     };
     const beginShutdown = (signal, options) => {
+        const reason = options?.reason ?? `worker_received_${signal}`;
         if (!shutdownPromise) {
-            logger.info(`${signal} received, shutting down gracefully...`);
+            logger.info({ signal, reason, ...getProcessDiagnostics() }, `${signal} received, shutting down gracefully...`);
             shutdownPromise = (async () => {
                 const forceExit = setTimeout(() => {
-                    logger.warn("Forcing shutdown - HTTP server didn't close in time");
+                    logger.warn({ signal, reason, ...getProcessDiagnostics() }, "Forcing shutdown - HTTP server didn't close in time");
                     process.exit(1);
                 }, 10000);
                 try {
@@ -103,7 +111,7 @@ async function main() {
             })();
         }
         else {
-            logger.info(`${signal} received while shutdown is already in progress`);
+            logger.info({ signal, reason, ...getProcessDiagnostics() }, `${signal} received while shutdown is already in progress`);
         }
         installExitHook();
     };
@@ -122,11 +130,11 @@ async function main() {
     };
     const handleLifecycleIntent = (intent) => {
         if (intent.type === "shutdown") {
-            logger.warn({ clientId: intent.clientId, requestId: intent.requestId }, "Shutdown requested via websocket");
-            if (sendSupervisorLifecycleMessage({ type: "paseo:shutdown" })) {
+            logger.warn({ clientId: intent.clientId, requestId: intent.requestId, reason: intent.reason }, "Shutdown requested via websocket");
+            if (sendSupervisorLifecycleMessage({ type: "paseo:shutdown", reason: intent.reason })) {
                 return;
             }
-            beginShutdown("shutdown lifecycle intent");
+            beginShutdown("shutdown lifecycle intent", { reason: intent.reason });
             return;
         }
         logger.warn({ clientId: intent.clientId, requestId: intent.requestId, reason: intent.reason }, "Restart requested via websocket");
@@ -136,7 +144,10 @@ async function main() {
         })) {
             return;
         }
-        beginShutdown("restart lifecycle intent", { successExitCode: 0 });
+        beginShutdown("restart lifecycle intent", {
+            reason: intent.reason,
+            successExitCode: 0,
+        });
     };
     const installSupervisorLivenessGuard = () => {
         if (typeof process.send !== "function") {
@@ -152,6 +163,7 @@ async function main() {
             supervisorExitRequested = true;
             writeWorkerLifecycleLog(paseoHome, "Supervisor liveness lost; worker exiting", {
                 reason,
+                ...getProcessDiagnostics(),
                 supervisorPid,
                 currentParentPid: process.ppid,
                 ipcConnected: typeof process.connected === "boolean" ? process.connected : null,

package/dist/server/server/lifecycle-reasons.d.ts

@@ -0,0 +1,4 @@
+export declare const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export declare const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export declare function normalizeClientRestartRpcReason(reason: string | undefined): string;
+//# sourceMappingURL=lifecycle-reasons.d.ts.map

package/dist/server/server/lifecycle-reasons.js

@@ -0,0 +1,6 @@
+export const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export function normalizeClientRestartRpcReason(reason) {
+    return reason?.trim() || DEFAULT_CLIENT_RESTART_RPC_REASON;
+}
+//# sourceMappingURL=lifecycle-reasons.js.map

package/dist/server/server/persisted-config.d.ts

@@ -19,6 +19,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen: z.ZodOptional<z.ZodString>;
         hostnames: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
         allowedHosts: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+        trustedProxies: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
         mcp: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             injectIntoAgents: z.ZodOptional<z.ZodBoolean>;
@@ -54,6 +55,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodTransform<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
+        trustedProxies?: true | string[] | undefined;
         mcp?: {
             [x: string]: unknown;
             enabled?: boolean | undefined;
@@ -92,6 +94,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
+        trustedProxies?: true | string[] | undefined;
         mcp?: {
             [x: string]: unknown;
             enabled?: boolean | undefined;
@@ -133,6 +136,11 @@ export declare const PersistedConfigSchema: z.ZodObject<{
     providers: z.ZodOptional<z.ZodObject<{
         openai: z.ZodOptional<z.ZodObject<{
             apiKey: z.ZodOptional<z.ZodString>;
+            voice: z.ZodOptional<z.ZodObject<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                baseUrl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            baseUrl: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         local: z.ZodOptional<z.ZodObject<{
             modelsDir: z.ZodOptional<z.ZodString>;
@@ -236,6 +244,10 @@ export declare const PersistedConfigSchema: z.ZodObject<{
                 speed: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        webUi: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            distDir: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     log: z.ZodOptional<z.ZodObject<{
         level: z.ZodOptional<z.ZodEnum<{

package/dist/server/server/persisted-config.js

@@ -34,9 +34,17 @@ const LogConfigSchema = z
         .optional(),
 })
     .strict();
-const ProviderCredentialsSchema = z
+const OpenAiVoiceProviderSchema = z
+    .object({
+    apiKey: z.string().trim().min(1).optional(),
+    baseUrl: z.string().trim().min(1).optional(),
+})
+    .strict();
+const OpenAiProviderSchema = z
     .object({
     apiKey: z.string().min(1).optional(),
+    voice: OpenAiVoiceProviderSchema.optional(),
+    baseUrl: z.string().trim().min(1).optional(),
 })
     .strict();
 const LocalSpeechProviderSchema = z
@@ -46,7 +54,7 @@ const LocalSpeechProviderSchema = z
     .strict();
 const ProvidersSchema = z
     .object({
-    openai: ProviderCredentialsSchema.optional(),
+    openai: OpenAiProviderSchema.optional(),
     local: LocalSpeechProviderSchema.optional(),
 })
     .strict();
@@ -118,6 +126,12 @@ const FeatureVoiceModeSchema = z
         .optional(),
 })
     .strict();
+const FeatureWebUiSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    distDir: z.string().min(1).optional(),
+})
+    .strict();
 const StructuredGenerationProviderConfigSchema = z
     .object({
     provider: z.string().min(1),
@@ -179,6 +193,7 @@ export const PersistedConfigSchema = z
         listen: z.string().optional(),
         hostnames: z.union([z.literal(true), z.array(z.string())]).optional(),
         allowedHosts: z.union([z.literal(true), z.array(z.string())]).optional(),
+        trustedProxies: z.union([z.literal(true), z.array(z.string())]).optional(),
         mcp: z
             .object({
             enabled: z.boolean().optional(),
@@ -244,6 +259,7 @@ export const PersistedConfigSchema = z
         .object({
         dictation: FeatureDictationSchema.optional(),
         voiceMode: FeatureVoiceModeSchema.optional(),
+        webUi: FeatureWebUiSchema.optional(),
     })
         .strict()
         .optional(),

package/dist/server/server/process-diagnostics.d.ts

@@ -0,0 +1,17 @@
+export interface ProcessMemoryDiagnostics {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}
+export interface ProcessDiagnostics {
+    pid: number;
+    ppid: number;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
+}
+export declare function getProcessMemoryDiagnostics(): ProcessMemoryDiagnostics;
+export declare function getProcessUptimeSeconds(): number;
+export declare function getProcessDiagnostics(): ProcessDiagnostics;
+//# sourceMappingURL=process-diagnostics.d.ts.map

package/dist/server/server/process-diagnostics.js

@@ -0,0 +1,22 @@
+export function getProcessMemoryDiagnostics() {
+    const memory = process.memoryUsage();
+    return {
+        rss: memory.rss,
+        heapTotal: memory.heapTotal,
+        heapUsed: memory.heapUsed,
+        external: memory.external,
+        arrayBuffers: memory.arrayBuffers,
+    };
+}
+export function getProcessUptimeSeconds() {
+    return Math.round(process.uptime() * 1000) / 1000;
+}
+export function getProcessDiagnostics() {
+    return {
+        pid: process.pid,
+        ppid: process.ppid,
+        uptimeSeconds: getProcessUptimeSeconds(),
+        memory: getProcessMemoryDiagnostics(),
+    };
+}
+//# sourceMappingURL=process-diagnostics.js.map

package/dist/server/server/relay-transport.js

@@ -335,6 +335,7 @@ export function startRelayTransport({ logger, attachSocket, relayEndpoint, relay
             const externalMetadata = {
                 transport: "relay",
                 externalSessionKey: `session:${connectionId}`,
+                relayConnectionId: connectionId,
             };
             if (daemonKeyPair) {
                 void attachEncryptedSocket(socket, daemonKeyPair, relayLogger.child({ connectionId }), attachSocket, externalMetadata);