@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/checkout-diff-manager.d.ts

@@ -0,0 +1,41 @@
+import type pino from "pino";
+import type { SubscribeCheckoutDiffRequest, SessionOutboundMessage } from "./messages.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+export type CheckoutDiffCompareInput = SubscribeCheckoutDiffRequest["compare"];
+export type CheckoutDiffSnapshotPayload = Omit<Extract<SessionOutboundMessage, {
+    type: "checkout_diff_update";
+}>["payload"], "subscriptionId">;
+export interface CheckoutDiffMetrics {
+    checkoutDiffTargetCount: number;
+    checkoutDiffSubscriptionCount: number;
+    checkoutDiffWatcherCount: number;
+    checkoutDiffFallbackRefreshTargetCount: number;
+}
+export declare class CheckoutDiffManager {
+    private readonly workspaceGitService;
+    private readonly targets;
+    constructor(options: {
+        logger: pino.Logger;
+        paseoHome: string;
+        workspaceGitService: WorkspaceGitService;
+    });
+    subscribe(params: {
+        cwd: string;
+        compare: CheckoutDiffCompareInput;
+    }, listener: (snapshot: CheckoutDiffSnapshotPayload) => void): Promise<{
+        initial: CheckoutDiffSnapshotPayload;
+        unsubscribe: () => void;
+    }>;
+    scheduleRefreshForCwd(cwd: string): void;
+    getMetrics(): CheckoutDiffMetrics;
+    dispose(): void;
+    private normalizeCompare;
+    private buildTargetKey;
+    private closeTarget;
+    private removeListener;
+    private scheduleTargetRefresh;
+    private computeCheckoutDiffSnapshot;
+    private refreshTarget;
+    private ensureTarget;
+}
+//# sourceMappingURL=checkout-diff-manager.d.ts.map

package/dist/server/server/checkout-diff-manager.js

@@ -0,0 +1,189 @@
+import { expandTilde } from "../utils/path.js";
+import { toCheckoutError } from "./checkout-git-utils.js";
+const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
+export class CheckoutDiffManager {
+    constructor(options) {
+        this.targets = new Map();
+        this.workspaceGitService = options.workspaceGitService;
+    }
+    async subscribe(params, listener) {
+        const cwd = params.cwd;
+        const compare = this.normalizeCompare(params.compare);
+        const target = await this.ensureTarget(cwd, compare);
+        target.listeners.add(listener);
+        const initial = target.latestPayload ??
+            (await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
+                diffCwd: target.diffCwd,
+            }));
+        target.latestPayload = initial;
+        target.latestFingerprint = JSON.stringify(initial);
+        return {
+            initial,
+            unsubscribe: () => {
+                this.removeListener(target.key, listener);
+            },
+        };
+    }
+    scheduleRefreshForCwd(cwd) {
+        const resolvedCwd = expandTilde(cwd);
+        for (const target of this.targets.values()) {
+            if (target.cwd !== resolvedCwd && target.diffCwd !== resolvedCwd) {
+                continue;
+            }
+            this.scheduleTargetRefresh(target);
+        }
+    }
+    getMetrics() {
+        let checkoutDiffSubscriptionCount = 0;
+        for (const target of this.targets.values()) {
+            checkoutDiffSubscriptionCount += target.listeners.size;
+        }
+        return {
+            checkoutDiffTargetCount: this.targets.size,
+            checkoutDiffSubscriptionCount,
+            checkoutDiffWatcherCount: 0,
+            checkoutDiffFallbackRefreshTargetCount: 0,
+        };
+    }
+    dispose() {
+        for (const target of this.targets.values()) {
+            this.closeTarget(target);
+        }
+        this.targets.clear();
+    }
+    normalizeCompare(compare) {
+        const ignoreWhitespace = compare.ignoreWhitespace === true;
+        if (compare.mode === "uncommitted") {
+            return { mode: "uncommitted", ignoreWhitespace };
+        }
+        const trimmedBaseRef = compare.baseRef?.trim();
+        return trimmedBaseRef
+            ? { mode: "base", baseRef: trimmedBaseRef, ignoreWhitespace }
+            : { mode: "base", ignoreWhitespace };
+    }
+    buildTargetKey(cwd, compare) {
+        return JSON.stringify([
+            cwd,
+            compare.mode,
+            compare.mode === "base" ? (compare.baseRef ?? "") : "",
+            compare.ignoreWhitespace === true,
+        ]);
+    }
+    closeTarget(target) {
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+            target.debounceTimer = null;
+        }
+        target.workingTreeWatchUnsubscribe?.();
+        target.workingTreeWatchUnsubscribe = null;
+        target.listeners.clear();
+    }
+    removeListener(targetKey, listener) {
+        const target = this.targets.get(targetKey);
+        if (!target) {
+            return;
+        }
+        target.listeners.delete(listener);
+        if (target.listeners.size > 0) {
+            return;
+        }
+        this.closeTarget(target);
+        this.targets.delete(targetKey);
+    }
+    scheduleTargetRefresh(target) {
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+        }
+        target.debounceTimer = setTimeout(() => {
+            target.debounceTimer = null;
+            void this.refreshTarget(target);
+        }, CHECKOUT_DIFF_WATCH_DEBOUNCE_MS);
+    }
+    async computeCheckoutDiffSnapshot(cwd, compare, options) {
+        const diffCwd = options?.diffCwd ?? cwd;
+        try {
+            const diffResult = await this.workspaceGitService.getCheckoutDiff(diffCwd, {
+                mode: compare.mode,
+                baseRef: compare.baseRef,
+                ignoreWhitespace: compare.ignoreWhitespace,
+                includeStructured: true,
+            }, options?.force
+                ? { force: true, reason: options.reason ?? "checkout-diff-refresh" }
+                : undefined);
+            const files = [...(diffResult.structured ?? [])];
+            files.sort((a, b) => {
+                if (a.path === b.path)
+                    return 0;
+                return a.path < b.path ? -1 : 1;
+            });
+            return {
+                cwd,
+                files,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                cwd,
+                files: [],
+                error: toCheckoutError(error),
+            };
+        }
+    }
+    async refreshTarget(target) {
+        if (target.refreshPromise) {
+            target.refreshQueued = true;
+            return;
+        }
+        target.refreshPromise = (async () => {
+            do {
+                target.refreshQueued = false;
+                const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
+                    diffCwd: target.diffCwd,
+                    force: true,
+                    reason: "working-tree-watch",
+                });
+                target.latestPayload = snapshot;
+                const fingerprint = JSON.stringify(snapshot);
+                if (fingerprint !== target.latestFingerprint) {
+                    target.latestFingerprint = fingerprint;
+                    for (const listener of target.listeners) {
+                        listener(snapshot);
+                    }
+                }
+            } while (target.refreshQueued);
+        })();
+        try {
+            await target.refreshPromise;
+        }
+        finally {
+            target.refreshPromise = null;
+        }
+    }
+    async ensureTarget(cwd, compare) {
+        const targetKey = this.buildTargetKey(cwd, compare);
+        const existing = this.targets.get(targetKey);
+        if (existing) {
+            return existing;
+        }
+        const target = {
+            key: targetKey,
+            cwd,
+            diffCwd: cwd,
+            compare,
+            listeners: new Set(),
+            workingTreeWatchUnsubscribe: null,
+            debounceTimer: null,
+            refreshPromise: null,
+            refreshQueued: false,
+            latestPayload: null,
+            latestFingerprint: null,
+        };
+        const { repoRoot, unsubscribe } = await this.workspaceGitService.requestWorkingTreeWatch(cwd, () => this.scheduleTargetRefresh(target));
+        target.diffCwd = repoRoot ?? cwd;
+        target.workingTreeWatchUnsubscribe = unsubscribe;
+        this.targets.set(targetKey, target);
+        return target;
+    }
+}
+//# sourceMappingURL=checkout-diff-manager.js.map

package/dist/server/server/checkout-git-utils.d.ts

@@ -0,0 +1,11 @@
+export declare const READ_ONLY_GIT_ENV: {
+    readonly GIT_OPTIONAL_LOCKS: "0";
+};
+export type CheckoutErrorCode = "NOT_GIT_REPO" | "NOT_ALLOWED" | "MERGE_CONFLICT" | "UNKNOWN";
+export interface CheckoutErrorPayload {
+    code: CheckoutErrorCode;
+    message: string;
+}
+export declare function resolveCheckoutGitDir(cwd: string): Promise<string | null>;
+export declare function toCheckoutError(error: unknown): CheckoutErrorPayload;
+//# sourceMappingURL=checkout-git-utils.d.ts.map

package/dist/server/server/checkout-git-utils.js

@@ -0,0 +1,34 @@
+import { MergeConflictError, MergeFromBaseConflictError, NotGitRepoError, } from "../utils/checkout-git.js";
+import { runGitCommand } from "../utils/run-git-command.js";
+export const READ_ONLY_GIT_ENV = {
+    GIT_OPTIONAL_LOCKS: "0",
+};
+export async function resolveCheckoutGitDir(cwd) {
+    try {
+        const { stdout } = await runGitCommand(["rev-parse", "--absolute-git-dir"], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        const gitDir = stdout.trim();
+        return gitDir.length > 0 ? gitDir : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function toCheckoutError(error) {
+    if (error instanceof NotGitRepoError) {
+        return { code: "NOT_GIT_REPO", message: error.message };
+    }
+    if (error instanceof MergeConflictError) {
+        return { code: "MERGE_CONFLICT", message: error.message };
+    }
+    if (error instanceof MergeFromBaseConflictError) {
+        return { code: "MERGE_CONFLICT", message: error.message };
+    }
+    if (error instanceof Error) {
+        return { code: "UNKNOWN", message: error.message };
+    }
+    return { code: "UNKNOWN", message: String(error) };
+}
+//# sourceMappingURL=checkout-git-utils.js.map

package/dist/server/server/client-message-id.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeClientMessageId(clientMessageId: string | undefined): string | undefined;
+export declare function resolveClientMessageId(clientMessageId: string | undefined, generateId?: () => string): string;
+//# sourceMappingURL=client-message-id.d.ts.map

package/dist/server/server/client-message-id.js

@@ -0,0 +1,12 @@
+import { v4 as uuidv4 } from "uuid";
+export function normalizeClientMessageId(clientMessageId) {
+    if (typeof clientMessageId !== "string") {
+        return undefined;
+    }
+    const trimmed = clientMessageId.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function resolveClientMessageId(clientMessageId, generateId = uuidv4) {
+    return normalizeClientMessageId(clientMessageId) ?? generateId();
+}
+//# sourceMappingURL=client-message-id.js.map

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

@@ -0,0 +1,17 @@
+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?: {
+    env?: NodeJS.ProcessEnv;
+    cli?: CliConfigOverrides;
+}): PaseoDaemonConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/server/server/config.js

@@ -0,0 +1,320 @@
+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";
+import { loadPersistedConfig, LogFormatSchema, LogLevelSchema, } from "./persisted-config.js";
+import { ProviderOverrideSchema } from "./agent/provider-launch-config.js";
+import { AgentProviderSchema } from "@hyperdrive.bot/paseo-protocol/provider-manifest";
+import { hashDaemonPassword } from "./auth.js";
+import { resolveSpeechConfig } from "./speech/speech-config-resolver.js";
+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;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
+function normalizeLogEnv(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value.trim().toLowerCase();
+}
+function resolveLogConfigFromEnv(env, persisted) {
+    const envLogLevel = LogLevelSchema.safeParse(normalizeLogEnv(env.PASEO_LOG_LEVEL));
+    const envLogFormat = LogFormatSchema.safeParse(normalizeLogEnv(env.PASEO_LOG_FORMAT));
+    if (!envLogLevel.success && !envLogFormat.success) {
+        return persisted.log;
+    }
+    return {
+        ...persisted.log,
+        ...(envLogLevel.success ? { level: envLogLevel.data } : {}),
+        ...(envLogFormat.success ? { format: envLogFormat.data } : {}),
+    };
+}
+const OptionalVoiceLlmProviderSchema = z
+    .union([z.string(), z.null(), z.undefined()])
+    .transform((value) => typeof value === "string" ? value.trim().toLowerCase() : null)
+    .pipe(z.union([AgentProviderSchema, z.null()]));
+function parseOptionalVoiceLlmProvider(value) {
+    const parsed = OptionalVoiceLlmProviderSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function extractProviderOverrides(providers) {
+    if (!providers) {
+        return undefined;
+    }
+    const providerOverrides = Object.entries(providers).flatMap(([providerId, provider]) => {
+        const parsed = ProviderOverrideSchema.safeParse(provider);
+        return parsed.success ? [[providerId, parsed.data]] : [];
+    });
+    return providerOverrides.length > 0 ? Object.fromEntries(providerOverrides) : undefined;
+}
+function extractAgentProviderSettings(providerOverrides) {
+    if (!providerOverrides) {
+        return undefined;
+    }
+    const runtimeSettings = Object.entries(providerOverrides).flatMap(([providerId, provider]) => {
+        const parsedProviderId = AgentProviderSchema.safeParse(providerId);
+        if (!parsedProviderId.success || (!provider.command && !provider.env)) {
+            return [];
+        }
+        return [
+            [
+                parsedProviderId.data,
+                {
+                    command: provider.command
+                        ? {
+                            mode: "replace",
+                            argv: provider.command,
+                        }
+                        : undefined,
+                    env: provider.env,
+                },
+            ],
+        ];
+    });
+    return runtimeSettings.length > 0
+        ? Object.fromEntries(runtimeSettings)
+        : undefined;
+}
+function resolveTlsFromEnv(envValue, persistedValue, fallback) {
+    if (envValue !== undefined) {
+        return parseBooleanEnv(envValue) ?? false;
+    }
+    return persistedValue ?? fallback;
+}
+function resolveRelayConfig(input) {
+    const enabled = input.cliRelayEnabled ??
+        parseBooleanEnv(input.env.PASEO_RELAY_ENABLED) ??
+        input.persisted.daemon?.relay?.enabled ??
+        true;
+    const endpoint = input.env.PASEO_RELAY_ENDPOINT ??
+        input.persisted.daemon?.relay?.endpoint ??
+        DEFAULT_RELAY_ENDPOINT;
+    const publicEndpoint = input.env.PASEO_RELAY_PUBLIC_ENDPOINT ??
+        input.persisted.daemon?.relay?.publicEndpoint ??
+        endpoint;
+    const useTls = input.cliRelayUseTls ??
+        resolveTlsFromEnv(input.env.PASEO_RELAY_USE_TLS, input.persisted.daemon?.relay?.useTls, endpoint === DEFAULT_RELAY_ENDPOINT);
+    const publicUseTls = resolveTlsFromEnv(input.env.PASEO_RELAY_PUBLIC_USE_TLS, input.persisted.daemon?.relay?.publicUseTls, useTls);
+    return { enabled, endpoint, publicEndpoint, useTls, publicUseTls };
+}
+function resolveServiceProxyPublicBaseUrl(value) {
+    if (value === null) {
+        return null;
+    }
+    try {
+        return new URL(value).toString().replace(/\/$/, "");
+    }
+    catch {
+        throw new Error(`Invalid PASEO_SERVICE_PROXY_PUBLIC_BASE_URL: ${value}`);
+    }
+}
+function resolveServiceProxyConfig(env, persisted) {
+    const enabledShim = parseBooleanEnv(env.PASEO_SERVICE_PROXY_ENABLED) ?? persisted.daemon?.serviceProxy?.enabled;
+    // COMPAT(serviceProxyEnabled): added 2026-06-02, remove after 2026-12-02.
+    // `enabled=false` used to disable the separate service proxy listener. Localhost
+    // service proxying is now always enabled; this only suppresses optional layers.
+    const optionalLayersEnabled = enabledShim !== false;
+    const publicBaseUrl = optionalLayersEnabled
+        ? resolveServiceProxyPublicBaseUrl(env.PASEO_SERVICE_PROXY_PUBLIC_BASE_URL ??
+            persisted.daemon?.serviceProxy?.publicBaseUrl ??
+            null)
+        : null;
+    const standaloneListen = optionalLayersEnabled
+        ? (env.PASEO_SERVICE_PROXY_LISTEN ?? persisted.daemon?.serviceProxy?.listen ?? null)
+        : 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);
+    return {
+        provider: envVoiceLlmProvider ?? persistedVoiceLlmProvider ?? null,
+        providerExplicit: envVoiceLlmProvider !== null || persistedVoiceLlmProvider !== null,
+        model: persisted.features?.voiceMode?.llm?.model ?? null,
+    };
+}
+function resolveCorsAllowedOrigins(env, persisted) {
+    const envCorsOrigins = env.PASEO_CORS_ORIGINS
+        ? env.PASEO_CORS_ORIGINS.split(",").map((s) => s.trim())
+        : [];
+    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)
+// - unix:///path/to/socket (Unix socket)
+// Default is TCP at 127.0.0.1:6767
+function resolveListenAddress(env, cli, persisted) {
+    return (cli?.listen ??
+        env.PASEO_LISTEN ??
+        persisted.daemon?.listen ??
+        `127.0.0.1:${env.PORT ?? DEFAULT_PORT}`);
+}
+function resolveAuthConfig(env, persisted) {
+    const envPassword = env.PASEO_PASSWORD?.trim();
+    if (envPassword) {
+        return { password: hashDaemonPassword(envPassword) };
+    }
+    return persisted.daemon?.auth?.password
+        ? { password: persisted.daemon.auth.password }
+        : undefined;
+}
+function resolveWorktreesRoot(paseoHome, persisted) {
+    const configuredRoot = persisted.worktrees?.root?.trim();
+    if (!configuredRoot) {
+        return undefined;
+    }
+    const expandedRoot = expandTilde(configuredRoot);
+    return path.isAbsolute(expandedRoot)
+        ? path.resolve(expandedRoot)
+        : path.resolve(paseoHome, expandedRoot);
+}
+function resolveAppendSystemPrompt(persisted) {
+    return persisted.daemon?.appendSystemPrompt ?? "";
+}
+function resolveBrowserToolsEnabled(persisted) {
+    return persisted.daemon?.browserTools?.enabled ?? false;
+}
+function resolveStaticLoadConfigSettings(env, cli, persisted) {
+    return {
+        mcpEnabled: cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true,
+        mcpInjectIntoAgents: cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? true,
+        browserToolsEnabled: resolveBrowserToolsEnabled(persisted),
+        autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
+        appendSystemPrompt: resolveAppendSystemPrompt(persisted),
+        terminalProfiles: persisted.daemon?.terminalProfiles,
+        hostnames: mergeHostnames([
+            persisted.daemon?.hostnames,
+            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,
+    };
+}
+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, browserToolsEnabled, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, options?.cli, persisted);
+    const relay = resolveRelayConfig({
+        env,
+        persisted,
+        cliRelayEnabled: options?.cli?.relayEnabled,
+        cliRelayUseTls: options?.cli?.relayUseTls,
+    });
+    const serviceProxy = resolveServiceProxyConfig(env, persisted);
+    const webUi = resolveWebUiConfig(paseoHome, env, options?.cli, persisted);
+    const { openai, speech } = resolveSpeechConfig({
+        paseoHome,
+        env,
+        persisted,
+    });
+    const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    return {
+        listen,
+        paseoHome,
+        worktreesRoot: resolveWorktreesRoot(paseoHome, persisted),
+        corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
+        hostnames,
+        trustedProxies,
+        mcpEnabled,
+        mcpInjectIntoAgents,
+        browserToolsEnabled,
+        autoArchiveAfterMerge,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt,
+        terminalProfiles,
+        mcpDebug: env.MCP_DEBUG === "1",
+        isDev: resolvePaseoNodeEnv(env) === "development",
+        agentStoragePath: path.join(paseoHome, "agents"),
+        staticDir: "public",
+        agentClients: {},
+        relayEnabled: relay.enabled,
+        relayEndpoint: relay.endpoint,
+        relayPublicEndpoint: relay.publicEndpoint,
+        relayUseTls: relay.useTls,
+        relayPublicUseTls: relay.publicUseTls,
+        serviceProxy,
+        webUi,
+        appBaseUrl,
+        auth: resolveAuthConfig(env, persisted),
+        openai,
+        speech,
+        voiceLlmProvider: voiceLlm.provider,
+        voiceLlmProviderExplicit: voiceLlm.providerExplicit,
+        voiceLlmModel: voiceLlm.model,
+        agentProviderSettings: extractAgentProviderSettings(providerOverrides),
+        metadataGeneration: persisted.agents?.metadataGeneration,
+        providerOverrides,
+        log: resolveLogConfigFromEnv(env, persisted),
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/server/server/connection-offer.d.ts

@@ -0,0 +1,20 @@
+import { type ConnectionOffer } from "@hyperdrive.bot/paseo-protocol/connection-offer";
+interface BuildOfferEndpointsArgs {
+    listenHost: string;
+    port: number;
+}
+export declare function buildOfferEndpoints({ listenHost, port }: BuildOfferEndpointsArgs): string[];
+export declare function createConnectionOfferV2(args: {
+    serverId: string;
+    daemonPublicKeyB64: string;
+    relay: {
+        endpoint: string;
+        useTls?: boolean;
+    };
+}): Promise<ConnectionOffer>;
+export declare function encodeOfferToFragmentUrl(args: {
+    offer: ConnectionOffer;
+    appBaseUrl: string;
+}): string;
+export {};
+//# sourceMappingURL=connection-offer.d.ts.map