@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/connection-offer.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import { ConnectionOfferV2Schema, } from "@hyperdrive.bot/paseo-protocol/connection-offer";
+export function buildOfferEndpoints({ listenHost, port }) {
+    const endpoints = [];
+    const isLoopbackHost = listenHost === "127.0.0.1" || listenHost === "localhost";
+    const isWildcardHost = listenHost === "0.0.0.0" || listenHost === "::" || listenHost === "[::]";
+    if (isWildcardHost) {
+        const lanIp = getPrimaryLanIp();
+        if (lanIp) {
+            endpoints.push(`${lanIp}:${port}`);
+        }
+    }
+    else if (!isLoopbackHost) {
+        endpoints.push(`${listenHost}:${port}`);
+    }
+    endpoints.push(`localhost:${port}`);
+    return dedupePreserveOrder(endpoints);
+}
+export async function createConnectionOfferV2(args) {
+    return ConnectionOfferV2Schema.parse({
+        v: 2,
+        serverId: args.serverId,
+        daemonPublicKeyB64: args.daemonPublicKeyB64,
+        relay: args.relay,
+    });
+}
+export function encodeOfferToFragmentUrl(args) {
+    const json = JSON.stringify(args.offer);
+    const encoded = Buffer.from(json, "utf8").toString("base64url");
+    return `${args.appBaseUrl.replace(/\/$/, "")}/#offer=${encoded}`;
+}
+function getPrimaryLanIp() {
+    const override = process.env.PASEO_PRIMARY_LAN_IP?.trim();
+    if (override)
+        return override;
+    const nets = os.networkInterfaces();
+    const names = Object.keys(nets).sort();
+    for (const name of names) {
+        const addrs = nets[name] ?? [];
+        for (const addr of addrs) {
+            if (addr.family === "IPv4" && !addr.internal) {
+                return addr.address;
+            }
+        }
+    }
+    return null;
+}
+function dedupePreserveOrder(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+//# sourceMappingURL=connection-offer.js.map

package/dist/server/server/daemon-config-store.d.ts

@@ -0,0 +1,25 @@
+export type { MutableDaemonConfig, MutableDaemonConfigPatch, } from "@hyperdrive.bot/paseo-protocol/messages";
+type MutableDaemonConfig = import("@hyperdrive.bot/paseo-protocol/messages").MutableDaemonConfig;
+type MutableDaemonConfigPatch = import("@hyperdrive.bot/paseo-protocol/messages").MutableDaemonConfigPatch;
+type ProviderOverride = import("./agent/provider-launch-config.js").ProviderOverride;
+interface LoggerLike {
+    child(bindings: Record<string, unknown>): LoggerLike;
+    info(...args: unknown[]): void;
+}
+type ConfigListener = (config: MutableDaemonConfig) => void;
+type FieldChangeHandler = (value: unknown) => void;
+export declare function applyMutableProviderConfigToOverrides(baseOverrides: Record<string, ProviderOverride> | undefined, mutableProviders: MutableDaemonConfig["providers"] | undefined): Record<string, ProviderOverride> | undefined;
+export declare class DaemonConfigStore {
+    private current;
+    private readonly paseoHome;
+    private readonly logger;
+    private readonly changeListeners;
+    private readonly fieldChangeHandlers;
+    constructor(paseoHome: string, initial: MutableDaemonConfig, logger?: LoggerLike);
+    get(): MutableDaemonConfig;
+    patch(partial: MutableDaemonConfigPatch): MutableDaemonConfig;
+    onFieldChange(path: string, handler: FieldChangeHandler): () => void;
+    onChange(listener: ConfigListener): () => void;
+    private persistConfig;
+}
+//# sourceMappingURL=daemon-config-store.d.ts.map

package/dist/server/server/daemon-config-store.js

@@ -0,0 +1,194 @@
+import { loadPersistedConfig, savePersistedConfig, } from "./persisted-config.js";
+import { ProviderOverrideSchema } from "./agent/provider-launch-config.js";
+import { MutableDaemonConfigSchema, MutableDaemonConfigPatchSchema, } from "@hyperdrive.bot/paseo-protocol/messages";
+function getLogger(logger) {
+    return logger?.child({ module: "daemon-config-store" });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(current, patch) {
+    const next = { ...current };
+    for (const [key, patchValue] of Object.entries(patch)) {
+        if (patchValue === undefined) {
+            continue;
+        }
+        const currentValue = next[key];
+        if (isRecord(currentValue) && isRecord(patchValue)) {
+            next[key] = deepMerge(currentValue, patchValue);
+            continue;
+        }
+        next[key] = patchValue;
+    }
+    return next;
+}
+function getValueAtPath(config, path) {
+    return path
+        .split(".")
+        .reduce((value, segment) => (isRecord(value) ? value[segment] : undefined), config);
+}
+function isEqualValue(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export function applyMutableProviderConfigToOverrides(baseOverrides, mutableProviders) {
+    if (!baseOverrides && (!mutableProviders || Object.keys(mutableProviders).length === 0)) {
+        return undefined;
+    }
+    const nextOverrides = { ...baseOverrides };
+    for (const [providerId, providerConfig] of Object.entries(mutableProviders ?? {})) {
+        nextOverrides[providerId] = {
+            ...nextOverrides[providerId],
+            ...ProviderOverrideSchema.strip().parse(providerConfig),
+        };
+    }
+    return nextOverrides;
+}
+export class DaemonConfigStore {
+    constructor(paseoHome, initial, logger) {
+        this.changeListeners = new Set();
+        this.fieldChangeHandlers = new Map();
+        this.paseoHome = paseoHome;
+        this.logger = getLogger(logger);
+        this.current = MutableDaemonConfigSchema.parse(initial);
+    }
+    get() {
+        return this.current;
+    }
+    patch(partial) {
+        const parsedPatch = MutableDaemonConfigPatchSchema.parse(partial);
+        const next = MutableDaemonConfigSchema.parse(deepMerge(this.current, parsedPatch));
+        const changedFieldPaths = Array.from(this.fieldChangeHandlers.keys()).filter((path) => {
+            return !isEqualValue(getValueAtPath(this.current, path), getValueAtPath(next, path));
+        });
+        if (changedFieldPaths.length === 0 && isEqualValue(this.current, next)) {
+            return this.current;
+        }
+        // Persist before updating in-memory state so that if persistence fails,
+        // runtime and disk stay consistent.
+        this.persistConfig(next);
+        this.current = next;
+        for (const path of changedFieldPaths) {
+            const handlers = this.fieldChangeHandlers.get(path);
+            if (!handlers) {
+                continue;
+            }
+            const value = getValueAtPath(next, path);
+            for (const handler of handlers) {
+                handler(value);
+            }
+        }
+        for (const listener of this.changeListeners) {
+            listener(next);
+        }
+        return next;
+    }
+    onFieldChange(path, handler) {
+        const handlers = this.fieldChangeHandlers.get(path) ?? new Set();
+        handlers.add(handler);
+        this.fieldChangeHandlers.set(path, handlers);
+        return () => {
+            const currentHandlers = this.fieldChangeHandlers.get(path);
+            if (!currentHandlers) {
+                return;
+            }
+            currentHandlers.delete(handler);
+            if (currentHandlers.size === 0) {
+                this.fieldChangeHandlers.delete(path);
+            }
+        };
+    }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    persistConfig(config) {
+        const persisted = loadPersistedConfig(this.paseoHome, this.logger);
+        const nextPersisted = mergeMutableConfigIntoPersistedConfig({
+            persisted,
+            mutable: config,
+        });
+        savePersistedConfig(this.paseoHome, nextPersisted, this.logger);
+    }
+}
+function mergeMutableConfigIntoPersistedConfig(params) {
+    const { persisted, mutable } = params;
+    const browserToolsEnabled = readBrowserToolsEnabled(mutable);
+    const metadataGenerationProviders = readMetadataGenerationProviders(mutable);
+    const providerOverrides = applyMutableProviderConfigToOverrides(persisted.agents?.providers, mutable.providers);
+    const persistedAgents = persisted.agents;
+    const persistedMetadataGeneration = {
+        providers: metadataGenerationProviders,
+    };
+    const shouldPersistMetadataGeneration = metadataGenerationProviders.length > 0 || persisted.agents?.metadataGeneration !== undefined;
+    let nextAgents = persisted.agents;
+    if (providerOverrides && Object.keys(providerOverrides).length > 0) {
+        nextAgents = {
+            ...persistedAgents,
+            providers: providerOverrides,
+            ...(shouldPersistMetadataGeneration
+                ? { metadataGeneration: persistedMetadataGeneration }
+                : {}),
+        };
+    }
+    else if (shouldPersistMetadataGeneration) {
+        nextAgents = {
+            ...persistedAgents,
+            metadataGeneration: persistedMetadataGeneration,
+        };
+    }
+    return {
+        ...persisted,
+        daemon: {
+            ...persisted.daemon,
+            mcp: {
+                ...persisted.daemon?.mcp,
+                injectIntoAgents: mutable.mcp.injectIntoAgents,
+            },
+            browserTools: {
+                ...persisted.daemon?.browserTools,
+                enabled: browserToolsEnabled,
+            },
+            autoArchiveAfterMerge: mutable.autoArchiveAfterMerge,
+            enableTerminalAgentHooks: mutable.enableTerminalAgentHooks,
+            appendSystemPrompt: mutable.appendSystemPrompt,
+            ...(mutable.terminalProfiles !== undefined
+                ? { terminalProfiles: mutable.terminalProfiles }
+                : {}),
+        },
+        agents: nextAgents,
+    };
+}
+function readBrowserToolsEnabled(mutable) {
+    const browserTools = mutable.browserTools;
+    if (!isRecord(browserTools)) {
+        return false;
+    }
+    return browserTools["enabled"] === true;
+}
+function readMetadataGenerationProviders(mutable) {
+    const metadataGeneration = mutable.metadataGeneration;
+    if (!isRecord(metadataGeneration)) {
+        return [];
+    }
+    const providers = metadataGeneration["providers"];
+    if (!Array.isArray(providers)) {
+        return [];
+    }
+    return providers.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry["provider"] !== "string") {
+            return [];
+        }
+        return [
+            {
+                provider: entry["provider"],
+                ...(typeof entry["model"] === "string" ? { model: entry["model"] } : {}),
+                ...(typeof entry["thinkingOptionId"] === "string"
+                    ? { thinkingOptionId: entry["thinkingOptionId"] }
+                    : {}),
+            },
+        ];
+    });
+}
+//# sourceMappingURL=daemon-config-store.js.map

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

@@ -0,0 +1,8 @@
+import type pino from "pino";
+import { type KeyPair } from "@hyperdrive.bot/paseo-relay/e2ee";
+export interface DaemonKeyPairBundle {
+    keyPair: KeyPair;
+    publicKeyB64: string;
+}
+export declare function loadOrCreateDaemonKeyPair(paseoHome: string, logger?: pino.Logger): Promise<DaemonKeyPairBundle>;
+//# sourceMappingURL=daemon-keypair.d.ts.map

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

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { generateKeyPair, exportPublicKey, exportSecretKey, importPublicKey, importSecretKey, } from "@hyperdrive.bot/paseo-relay/e2ee";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
+const KeyPairSchema = z.object({
+    v: z.literal(2),
+    publicKeyB64: z.string().min(1),
+    secretKeyB64: z.string().min(1),
+});
+const KEYPAIR_FILENAME = "daemon-keypair.json";
+export async function loadOrCreateDaemonKeyPair(paseoHome, logger) {
+    const log = logger?.child({ module: "daemon-keypair" });
+    const filePath = path.join(paseoHome, KEYPAIR_FILENAME);
+    if (existsSync(filePath)) {
+        try {
+            ensurePrivateFile(filePath);
+            const raw = readFileSync(filePath, "utf8");
+            const parsed = KeyPairSchema.parse(JSON.parse(raw));
+            const publicKey = importPublicKey(parsed.publicKeyB64);
+            const secretKey = importSecretKey(parsed.secretKeyB64);
+            const publicKeyB64 = exportPublicKey(publicKey);
+            log?.info({ filePath }, "Loaded daemon keypair");
+            return { keyPair: { publicKey, secretKey }, publicKeyB64 };
+        }
+        catch (error) {
+            log?.warn({ err: error, filePath }, "Failed to load daemon keypair, regenerating");
+        }
+    }
+    const keyPair = generateKeyPair();
+    const publicKeyB64 = exportPublicKey(keyPair.publicKey);
+    const secretKeyB64 = exportSecretKey(keyPair.secretKey);
+    const payload = {
+        v: 2,
+        publicKeyB64,
+        secretKeyB64,
+    };
+    writePrivateFileAtomicSync(filePath, JSON.stringify(payload, null, 2) + "\n");
+    log?.info({ filePath }, "Saved daemon keypair");
+    return { keyPair, publicKeyB64 };
+}
+//# sourceMappingURL=daemon-keypair.js.map

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

@@ -0,0 +1,5 @@
+import { PackageVersionResolutionError } from "./package-version.js";
+export declare class DaemonVersionResolutionError extends PackageVersionResolutionError {
+}
+export declare function resolveDaemonVersion(moduleUrl?: string): string;
+//# sourceMappingURL=daemon-version.d.ts.map

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

@@ -0,0 +1,22 @@
+import { PackageVersionResolutionError, resolvePackageVersion } from "./package-version.js";
+const SERVER_PACKAGE_NAME = "@hyperdrive.bot/paseo-server";
+export class DaemonVersionResolutionError extends PackageVersionResolutionError {
+}
+export function resolveDaemonVersion(moduleUrl = import.meta.url) {
+    try {
+        return resolvePackageVersion({
+            moduleUrl,
+            packageName: SERVER_PACKAGE_NAME,
+        });
+    }
+    catch (error) {
+        if (error instanceof PackageVersionResolutionError) {
+            throw new DaemonVersionResolutionError({
+                moduleUrl,
+                packageName: SERVER_PACKAGE_NAME,
+            });
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=daemon-version.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=daemon-worker.d.ts.map

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

@@ -0,0 +1,251 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+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 {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (typeof err === "object" && err !== null && "code" in err && err.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+function writeWorkerLifecycleLog(paseoHome, message, fields = {}) {
+    try {
+        const logPath = path.join(paseoHome, "daemon.log");
+        mkdirSync(path.dirname(logPath), { recursive: true });
+        appendFileSync(logPath, `${JSON.stringify({
+            level: "warn",
+            time: new Date().toISOString(),
+            pid: process.pid,
+            name: "DaemonWorker",
+            msg: message,
+            ...fields,
+        })}\n`, "utf8");
+    }
+    catch {
+        // Exit-reason logging must never prevent the worker from exiting.
+    }
+}
+function bootstrapFromEnvironment() {
+    try {
+        const paseoHome = resolvePaseoHome();
+        const config = loadConfig(paseoHome);
+        const logger = createRootLogger({ log: config.log }, { paseoHome, file: false });
+        return { paseoHome, logger, config };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    }
+}
+function applyCliFlagOverrides(config) {
+    if (process.argv.includes("--no-relay")) {
+        config.relayEnabled = false;
+    }
+    if (process.argv.includes("--relay-use-tls")) {
+        config.relayUseTls = true;
+    }
+    if (process.argv.includes("--no-mcp")) {
+        config.mcpEnabled = false;
+    }
+    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();
+    let daemon = null;
+    let shutdownPromise = null;
+    let exitHookInstalled = false;
+    applyCliFlagOverrides(config);
+    const installExitHook = () => {
+        if (exitHookInstalled || !shutdownPromise) {
+            return;
+        }
+        exitHookInstalled = true;
+        void shutdownPromise.then((exitCode) => {
+            process.exit(exitCode);
+        });
+    };
+    const beginShutdown = (signal, options) => {
+        const reason = options?.reason ?? `worker_received_${signal}`;
+        if (!shutdownPromise) {
+            logger.info({ signal, reason, ...getProcessDiagnostics() }, `${signal} received, shutting down gracefully...`);
+            shutdownPromise = (async () => {
+                const forceExit = setTimeout(() => {
+                    logger.warn({ signal, reason, ...getProcessDiagnostics() }, "Forcing shutdown - HTTP server didn't close in time");
+                    process.exit(1);
+                }, 10000);
+                try {
+                    if (!daemon) {
+                        logger.error("Shutdown requested before daemon initialization completed");
+                        clearTimeout(forceExit);
+                        return 1;
+                    }
+                    await daemon.stop();
+                    clearTimeout(forceExit);
+                    logger.info("Server closed");
+                    return options?.successExitCode ?? 0;
+                }
+                catch (err) {
+                    clearTimeout(forceExit);
+                    logger.error({ err }, "Shutdown failed");
+                    return 1;
+                }
+            })();
+        }
+        else {
+            logger.info({ signal, reason, ...getProcessDiagnostics() }, `${signal} received while shutdown is already in progress`);
+        }
+        installExitHook();
+    };
+    const sendSupervisorLifecycleMessage = (message) => {
+        if (typeof process.send !== "function") {
+            return false;
+        }
+        try {
+            process.send(message);
+            return true;
+        }
+        catch (err) {
+            logger.error({ err, message }, "Failed to send lifecycle IPC message to supervisor");
+            return false;
+        }
+    };
+    const handleLifecycleIntent = (intent) => {
+        if (intent.type === "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", { reason: intent.reason });
+            return;
+        }
+        logger.warn({ clientId: intent.clientId, requestId: intent.requestId, reason: intent.reason }, "Restart requested via websocket");
+        if (sendSupervisorLifecycleMessage({
+            type: "paseo:restart",
+            ...(intent.reason ? { reason: intent.reason } : {}),
+        })) {
+            return;
+        }
+        beginShutdown("restart lifecycle intent", {
+            reason: intent.reason,
+            successExitCode: 0,
+        });
+    };
+    const installSupervisorLivenessGuard = () => {
+        if (typeof process.send !== "function") {
+            return;
+        }
+        const supervisorPid = process.ppid;
+        let lastSupervisorHeartbeatAt = Date.now();
+        let supervisorExitRequested = false;
+        const exitAfterSupervisorLoss = (reason) => {
+            if (supervisorExitRequested) {
+                return;
+            }
+            supervisorExitRequested = true;
+            writeWorkerLifecycleLog(paseoHome, "Supervisor liveness lost; worker exiting", {
+                reason,
+                ...getProcessDiagnostics(),
+                supervisorPid,
+                currentParentPid: process.ppid,
+                ipcConnected: typeof process.connected === "boolean" ? process.connected : null,
+                heartbeatAgeMs: Date.now() - lastSupervisorHeartbeatAt,
+            });
+            // The supervisor owns the worker's stdout/stderr pipes. Once it is gone,
+            // logging during graceful shutdown can block on the broken pipe and leave
+            // the daemon orphaned, so supervisor loss is a hard process boundary.
+            process.exit(0);
+        };
+        process.on("message", (message) => {
+            if (typeof message === "object" &&
+                message !== null &&
+                "type" in message &&
+                message.type === "paseo:supervisor-heartbeat") {
+                lastSupervisorHeartbeatAt = Date.now();
+            }
+        });
+        process.on("disconnect", () => exitAfterSupervisorLoss("ipc_disconnect_event"));
+        const timer = setInterval(() => {
+            const ipcConnected = typeof process.connected === "boolean" ? process.connected : true;
+            const heartbeatExpired = Date.now() - lastSupervisorHeartbeatAt > 3500;
+            const supervisorChanged = process.ppid !== supervisorPid;
+            if (ipcConnected === false) {
+                exitAfterSupervisorLoss("ipc_disconnected");
+                return;
+            }
+            if (supervisorChanged) {
+                exitAfterSupervisorLoss("supervisor_parent_pid_changed");
+                return;
+            }
+            if (heartbeatExpired && !isPidAlive(supervisorPid)) {
+                exitAfterSupervisorLoss("supervisor_pid_dead");
+            }
+        }, 1000);
+        timer.unref();
+    };
+    installSupervisorLivenessGuard();
+    try {
+        daemon = await createPaseoDaemon({
+            ...config,
+            onLifecycleIntent: handleLifecycleIntent,
+        }, logger);
+    }
+    catch (err) {
+        logger.fatal({ err }, "Daemon bootstrap failed");
+        throw err;
+    }
+    try {
+        await daemon.start();
+        const listenTarget = daemon.getListenTarget();
+        const listen = listenTarget?.type === "tcp"
+            ? `${listenTarget.host}:${listenTarget.port}`
+            : listenTarget?.path;
+        if (!listen) {
+            throw new Error("Daemon did not expose a listen target after startup");
+        }
+        sendSupervisorLifecycleMessage({ type: "paseo:ready", listen });
+    }
+    catch (err) {
+        logger.fatal({ err }, "Daemon failed to start listening");
+        throw err;
+    }
+    process.on("SIGTERM", () => beginShutdown("SIGTERM"));
+    process.on("SIGINT", () => beginShutdown("SIGINT"));
+    process.on("uncaughtException", (err) => {
+        logger.fatal({ err }, "Uncaught exception — daemon crashing");
+        exitAfterPinoFlush();
+    });
+    process.on("unhandledRejection", (reason) => {
+        logger.fatal({ err: reason }, "Unhandled promise rejection — daemon crashing");
+        exitAfterPinoFlush();
+    });
+}
+// Give pino async streams a moment to flush the fatal log entry to daemon.log
+// before the process exits. Without this, the last few entries that explain
+// why the daemon crashed can be lost.
+function exitAfterPinoFlush() {
+    setTimeout(() => process.exit(1), 200);
+}
+main().catch((err) => {
+    process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+    exitAfterPinoFlush();
+});
+//# sourceMappingURL=daemon-worker.js.map