@getpaseo/server 0.1.101 → 0.1.102-beta.2

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;
@@ -241,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

@@ -126,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),
@@ -187,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(),
@@ -252,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);

package/dist/server/server/resolve-worktree-creation-intent.js

@@ -64,9 +64,10 @@ async function resolveGitHubPrCheckoutIntent(params) {
     const baseRefName = checkoutTarget?.baseRefName?.trim() ||
         (await resolveDefaultBranch(params.repoRoot, params.deps));
     const localBranchName = buildGitHubPrLocalBranchName({ headRef, checkoutTarget });
-    const pushRemoteUrl = checkoutTarget
+    const pushRemoteUrl = checkoutTarget?.isCrossRepository
         ? checkoutTarget.headRepositorySshUrl || checkoutTarget.headRepositoryUrl || undefined
         : undefined;
+    const trackOriginHead = checkoutTarget ? !checkoutTarget.isCrossRepository : false;
     return {
         kind: "checkout-github-pr",
         githubPrNumber: params.githubPrNumber,
@@ -74,6 +75,7 @@ async function resolveGitHubPrCheckoutIntent(params) {
         baseRefName,
         ...(localBranchName !== headRef ? { localBranchName } : {}),
         ...(pushRemoteUrl ? { pushRemoteUrl } : {}),
+        ...(trackOriginHead ? { trackOriginHead } : {}),
     };
 }
 async function resolveGitHubPrCheckoutTarget(params) {

package/dist/server/server/session/daemon/daemon-self-update-session-controller.d.ts

@@ -0,0 +1,32 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type DaemonSelfUpdater } from "./daemon-self-updater.js";
+interface DaemonSelfUpdateRestartIntent {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+}
+export interface DaemonSelfUpdateSessionControllerOptions {
+    clientId: string;
+    daemonVersion: string | null;
+    emit: (msg: SessionOutboundMessage) => void;
+    emitLifecycleIntent: (intent: DaemonSelfUpdateRestartIntent) => void;
+    sessionLogger: pino.Logger;
+    updater?: Pick<DaemonSelfUpdater, "update">;
+}
+export declare class DaemonSelfUpdateSessionController {
+    private readonly clientId;
+    private readonly daemonVersion;
+    private readonly emit;
+    private readonly emitLifecycleIntent;
+    private readonly sessionLogger;
+    private readonly updater;
+    constructor(options: DaemonSelfUpdateSessionControllerOptions);
+    dispatch(msg: SessionInboundMessage): Promise<void> | undefined;
+    private handleDaemonUpdateRequest;
+    private emitProgress;
+    private emitResponse;
+}
+export {};
+//# sourceMappingURL=daemon-self-update-session-controller.d.ts.map

package/dist/server/server/session/daemon/daemon-self-update-session-controller.js

@@ -0,0 +1,88 @@
+import { daemonSelfUpdater, DaemonSelfUpdateInProgressError, } from "./daemon-self-updater.js";
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+const DAEMON_SELF_UPDATE_MESSAGE_TYPES = new Set([
+    "daemon.update.request",
+]);
+function isDaemonSelfUpdateMessage(msg) {
+    return DAEMON_SELF_UPDATE_MESSAGE_TYPES.has(msg.type);
+}
+export class DaemonSelfUpdateSessionController {
+    constructor(options) {
+        this.clientId = options.clientId;
+        this.daemonVersion = options.daemonVersion;
+        this.emit = options.emit;
+        this.emitLifecycleIntent = options.emitLifecycleIntent;
+        this.sessionLogger = options.sessionLogger;
+        this.updater = options.updater ?? daemonSelfUpdater;
+    }
+    dispatch(msg) {
+        if (!isDaemonSelfUpdateMessage(msg)) {
+            return undefined;
+        }
+        return this.handleDaemonUpdateRequest(msg);
+    }
+    async handleDaemonUpdateRequest(msg) {
+        const previousVersion = this.daemonVersion;
+        try {
+            const result = await this.updater.update({
+                daemonVersion: previousVersion,
+                onProgress: (phase) => this.emitProgress(msg.requestId, phase),
+                logger: this.sessionLogger,
+            });
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: result.success,
+                error: result.error,
+                previousVersion,
+                newVersion: result.newVersion,
+            });
+            if (!result.success) {
+                return;
+            }
+            this.emitLifecycleIntent({
+                type: "restart",
+                clientId: this.clientId,
+                requestId: msg.requestId,
+                reason: "daemon_update",
+            });
+        }
+        catch (error) {
+            if (error instanceof DaemonSelfUpdateInProgressError) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId: msg.requestId,
+                        requestType: "daemon.update.request",
+                        error: error.message,
+                        code: "already_updating",
+                    },
+                });
+                return;
+            }
+            this.sessionLogger.error({ err: error }, "Daemon update failed with exception");
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: false,
+                error: getErrorMessage(error),
+                previousVersion,
+                newVersion: null,
+            });
+        }
+    }
+    emitProgress(requestId, phase) {
+        this.emit({
+            type: "daemon.update.progress",
+            payload: {
+                requestId,
+                phase,
+            },
+        });
+    }
+    emitResponse(payload) {
+        this.emit({
+            type: "daemon.update.response",
+            payload,
+        });
+    }
+}
+//# sourceMappingURL=daemon-self-update-session-controller.js.map

package/dist/server/server/session/daemon/daemon-self-updater.d.ts

@@ -0,0 +1,32 @@
+import { type DaemonInstallOriginRuntime } from "./install-origin.js";
+import { type NpmGlobalPaseoCli } from "./npm-global-cli.js";
+export type DaemonSelfUpdatePhase = "starting" | "downloading" | "installing" | "complete";
+export interface DaemonSelfUpdateResult {
+    success: boolean;
+    error: string | null;
+    newVersion: string | null;
+}
+export interface DaemonSelfUpdateInput {
+    daemonVersion: string | null;
+    onProgress: (phase: DaemonSelfUpdatePhase) => void;
+    logger: DaemonSelfUpdateLogger;
+}
+export interface DaemonSelfUpdateLogger {
+    error(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+}
+export interface DaemonSelfUpdateRuntime {
+    npm: NpmGlobalPaseoCli;
+    installOrigin: DaemonInstallOriginRuntime;
+}
+export declare class DaemonSelfUpdateInProgressError extends Error {
+    constructor();
+}
+export declare class DaemonSelfUpdater {
+    private readonly runtime;
+    private inProgress;
+    constructor(runtime?: DaemonSelfUpdateRuntime);
+    update(input: DaemonSelfUpdateInput): Promise<DaemonSelfUpdateResult>;
+}
+export declare const daemonSelfUpdater: DaemonSelfUpdater;
+//# sourceMappingURL=daemon-self-updater.d.ts.map

package/dist/server/server/session/daemon/daemon-self-updater.js

@@ -0,0 +1,56 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { daemonInstallOriginRuntime, validateDaemonInstallOrigin, } from "./install-origin.js";
+import { npmGlobalPaseoCli } from "./npm-global-cli.js";
+export class DaemonSelfUpdateInProgressError extends Error {
+    constructor() {
+        super("An update is already in progress");
+        this.name = "DaemonSelfUpdateInProgressError";
+    }
+}
+const defaultRuntime = {
+    npm: npmGlobalPaseoCli,
+    installOrigin: daemonInstallOriginRuntime,
+};
+export class DaemonSelfUpdater {
+    constructor(runtime = defaultRuntime) {
+        this.runtime = runtime;
+        this.inProgress = false;
+    }
+    async update(input) {
+        if (this.inProgress) {
+            throw new DaemonSelfUpdateInProgressError();
+        }
+        this.inProgress = true;
+        try {
+            input.onProgress("starting");
+            const install = await this.runtime.npm.inspect();
+            const unsupportedReason = validateDaemonInstallOrigin(install, input.daemonVersion, this.runtime.installOrigin);
+            if (unsupportedReason) {
+                return { success: false, error: unsupportedReason, newVersion: null };
+            }
+            input.onProgress("downloading");
+            input.onProgress("installing");
+            const result = await this.runtime.npm.installLatest();
+            if (result.exitCode !== 0) {
+                const error = result.stderr.trim() || result.stdout.trim() || `npm exited with code ${result.exitCode}`;
+                input.logger.error({ exitCode: result.exitCode, stderr: result.stderr }, "Daemon self-update failed");
+                return { success: false, error, newVersion: null };
+            }
+            const updatedInstall = await this.runtime.npm.inspect().catch((error) => {
+                input.logger.warn({ err: error }, "Unable to read updated npm package version");
+                return null;
+            });
+            input.onProgress("complete");
+            return { success: true, error: null, newVersion: updatedInstall?.version ?? null };
+        }
+        catch (error) {
+            input.logger.error({ err: error }, "Daemon self-update failed with exception");
+            return { success: false, error: getErrorMessage(error), newVersion: null };
+        }
+        finally {
+            this.inProgress = false;
+        }
+    }
+}
+export const daemonSelfUpdater = new DaemonSelfUpdater();
+//# sourceMappingURL=daemon-self-updater.js.map

package/dist/server/server/session/daemon/daemon-session.d.ts

@@ -17,9 +17,16 @@ export interface DaemonRuntimeConfig {
 }
 export interface DaemonSessionHost {
     emit(msg: SessionOutboundMessage): void;
+    emitLifecycleIntent(intent: {
+        type: "restart";
+        clientId: string;
+        requestId: string;
+        reason: string;
+    }): void;
 }
 export interface DaemonSessionOptions {
     host: DaemonSessionHost;
+    clientId: string;
     paseoHome: string;
     serverId: string | undefined;
     daemonVersion: string | undefined;
@@ -40,6 +47,7 @@ export interface DaemonSessionOptions {
  */
 export declare class DaemonSession {
     private readonly host;
+    private readonly clientId;
     private readonly paseoHome;
     private readonly serverId;
     private readonly daemonVersion;
@@ -50,6 +58,7 @@ export declare class DaemonSession {
     private readonly listProviderAvailability;
     private readonly getWebSocketRuntimeMetrics;
     private readonly logger;
+    private readonly selfUpdate;
     constructor(options: DaemonSessionOptions);
     handleGetStatusRequest(msg: Extract<SessionInboundMessage, {
         type: "daemon.get_status.request";
@@ -60,5 +69,8 @@ export declare class DaemonSession {
     handleDiagnosticsRequest(msg: Extract<SessionInboundMessage, {
         type: "diagnostics.request";
     }>): Promise<void>;
+    handleUpdateRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.update.request";
+    }>): Promise<void>;
 }
 //# sourceMappingURL=daemon-session.d.ts.map

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

@@ -1,6 +1,7 @@
 import { getPidLockInfo } from "../../pid-lock.js";
 import { generateLocalPairingOffer } from "../../pairing-offer.js";
 import { collectDaemonDiagnostics, } from "./diagnostics.js";
+import { DaemonSelfUpdateSessionController } from "./daemon-self-update-session-controller.js";
 /**
  * A client's read surface for the daemon process itself: its runtime status
  * (pid-lock start time, listen address, relay config, provider availability) and
@@ -11,6 +12,7 @@ import { collectDaemonDiagnostics, } from "./diagnostics.js";
 export class DaemonSession {
     constructor(options) {
         this.host = options.host;
+        this.clientId = options.clientId;
         this.paseoHome = options.paseoHome;
         this.serverId = options.serverId;
         this.daemonVersion = options.daemonVersion;
@@ -21,6 +23,13 @@ export class DaemonSession {
         this.listProviderAvailability = options.listProviderAvailability;
         this.getWebSocketRuntimeMetrics = options.getWebSocketRuntimeMetrics ?? (() => null);
         this.logger = options.logger;
+        this.selfUpdate = new DaemonSelfUpdateSessionController({
+            clientId: this.clientId,
+            daemonVersion: this.daemonVersion ?? null,
+            emit: (msg) => this.host.emit(msg),
+            emitLifecycleIntent: (intent) => this.host.emitLifecycleIntent(intent),
+            sessionLogger: this.logger,
+        });
     }
     async handleGetStatusRequest(msg) {
         try {
@@ -132,5 +141,8 @@ export class DaemonSession {
             });
         }
     }
+    async handleUpdateRequest(msg) {
+        await this.selfUpdate.dispatch(msg);
+    }
 }
 //# sourceMappingURL=daemon-session.js.map

package/dist/server/server/session/daemon/diagnostics.js

@@ -154,6 +154,16 @@ function collectWebSocketRuntimeEntries(options) {
     return [
         { label: "Collected at", value: snapshot.collectedAt },
         { label: "Window", value: formatDurationMs(snapshot.windowMs) },
+        { label: "Process uptime", value: formatDurationMs(snapshot.uptimeSeconds * 1000) },
+        {
+            label: "Process memory",
+            value: [
+                `rss=${formatBytes(snapshot.memory.rss)}`,
+                `heap=${formatBytes(snapshot.memory.heapUsed)} / ${formatBytes(snapshot.memory.heapTotal)}`,
+                `external=${formatBytes(snapshot.memory.external)}`,
+                `arrayBuffers=${formatBytes(snapshot.memory.arrayBuffers)}`,
+            ].join(", "),
+        },
         { label: "Final", value: String(snapshot.final) },
         {
             label: "Sessions",

package/dist/server/server/session/daemon/install-origin.d.ts

@@ -0,0 +1,7 @@
+import { type NpmGlobalPaseoInstall } from "./npm-global-cli.js";
+export interface DaemonInstallOriginRuntime {
+    resolveCurrentServerPackageRoot(): string | null;
+}
+export declare const daemonInstallOriginRuntime: DaemonInstallOriginRuntime;
+export declare function validateDaemonInstallOrigin(install: NpmGlobalPaseoInstall, daemonVersion: string | null, runtime?: DaemonInstallOriginRuntime): string | null;
+//# sourceMappingURL=install-origin.d.ts.map