@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/config.js

@@ -0,0 +1,594 @@
+import { existsSync } from "node:fs";
+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 "@camerontaylor/paseo-protocol/provider-manifest";
+import { hashDaemonPassword } from "./auth.js";
+import { resolveSpeechConfig } from "./speech/speech-config-resolver.js";
+import { mergeHostnames, parseHostnamesEnv } from "./hostnames.js";
+import { resolveGitProcessPolicy } from "../utils/git-process-scheduler.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(input = {}) {
+    const moduleUrl = input.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") {
+        const appDistDir = input.resourcesPath ? path.join(input.resourcesPath, "app-dist") : null;
+        if (appDistDir && existsSync(appDistDir)) {
+            return appDistDir;
+        }
+        return path.resolve(moduleDir, "..", "web-ui");
+    }
+    return path.resolve(moduleDir, "web-ui");
+}
+const processResourcesPath = "resourcesPath" in process ? process.resourcesPath : undefined;
+const BUNDLED_WEB_UI_DIST_DIR = resolveBundledWebUiDistDir({
+    resourcesPath: typeof processResourcesPath === "string" ? processResourcesPath : undefined,
+});
+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 resolveGitProcessConfig(env, persisted) {
+    return resolveGitProcessPolicy({
+        env,
+        persisted: persisted.daemon?.git,
+    });
+}
+function resolveLogConfigFromEnv(env, persisted) {
+    const level = parseLogLevelEnv(env.PASEO_LOG_LEVEL ?? env.PASEO_LOG);
+    const format = parseLogFormatEnv(env.PASEO_LOG_FORMAT);
+    const console = resolveConsoleLogConfigFromEnv(env, persisted.log?.console);
+    const file = resolveFileLogConfigFromEnv(env, persisted.log?.file);
+    if (level === undefined && format === undefined && !console && !file) {
+        return persisted.log;
+    }
+    return {
+        ...persisted.log,
+        ...(level !== undefined ? { level } : {}),
+        ...(format !== undefined ? { format } : {}),
+        ...(console ? { console } : {}),
+        ...(file ? { file } : {}),
+    };
+}
+function resolveConsoleLogConfigFromEnv(env, persisted) {
+    const level = parseLogLevelEnv(env.PASEO_LOG_CONSOLE_LEVEL);
+    const format = parseLogFormatEnv(env.PASEO_LOG_CONSOLE_FORMAT);
+    if (level === undefined && format === undefined)
+        return undefined;
+    return {
+        ...persisted,
+        ...(level !== undefined ? { level } : {}),
+        ...(format !== undefined ? { format } : {}),
+    };
+}
+function resolveFileLogConfigFromEnv(env, persisted) {
+    const level = parseLogLevelEnv(env.PASEO_LOG_FILE_LEVEL);
+    const filePath = nonEmptyEnv(env.PASEO_LOG_FILE_PATH);
+    const maxSize = nonEmptyEnv(env.PASEO_LOG_FILE_ROTATE_SIZE);
+    const maxFiles = parsePositiveIntegerEnv(env.PASEO_LOG_FILE_ROTATE_COUNT);
+    const hasRotateOverride = maxSize !== undefined || maxFiles !== undefined;
+    if (level === undefined && filePath === undefined && !hasRotateOverride)
+        return undefined;
+    return {
+        ...persisted,
+        ...(level !== undefined ? { level } : {}),
+        ...(filePath !== undefined ? { path: filePath } : {}),
+        ...(hasRotateOverride
+            ? {
+                rotate: {
+                    ...persisted?.rotate,
+                    ...(maxSize !== undefined ? { maxSize } : {}),
+                    ...(maxFiles !== undefined ? { maxFiles } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function parseLogLevelEnv(value) {
+    const parsed = LogLevelSchema.safeParse(normalizeLogEnv(value));
+    return parsed.success ? parsed.data : undefined;
+}
+function parseLogFormatEnv(value) {
+    const parsed = LogFormatSchema.safeParse(normalizeLogEnv(value));
+    return parsed.success ? parsed.data : undefined;
+}
+function nonEmptyEnv(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function parsePositiveIntegerEnv(value) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+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 environmentEnabled = parseBooleanEnv(input.env.PASEO_RELAY_ENABLED);
+    // COMPAT(relayOptInDefault): daemons whose startup config omitted this field
+    // retain relay-on removal semantics until 2027-01-31. Modern homes use false.
+    const enabled = input.cliRelayEnabled ??
+        environmentEnabled ??
+        input.persisted.daemon?.relay?.enabled ??
+        input.enabledFallback;
+    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,
+        enabledMutable: input.cliRelayEnabled === undefined && environmentEnabled === undefined,
+        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;
+}
+/**
+ * Both profile lists stay `undefined` when absent rather than defaulting to an
+ * empty array: for terminal profiles that is what selects the built-in
+ * defaults, so an empty array has to keep meaning "the user removed them all".
+ */
+function resolveProfileLists(persisted) {
+    return {
+        terminalProfiles: persisted.daemon?.terminalProfiles,
+        agentProfiles: persisted.daemon?.agentProfiles,
+    };
+}
+function resolveStaticLoadConfigSettings(env, cli, persisted) {
+    return {
+        mcpEnabled: cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true,
+        mcpInjectIntoAgents: cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? false,
+        browserToolsEnabled: resolveBrowserToolsEnabled(persisted),
+        autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
+        appendSystemPrompt: resolveAppendSystemPrompt(persisted),
+        ...resolveProfileLists(persisted),
+        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 resolveConfigFromPersisted(paseoHome, persisted, options) {
+    const resolvedOptions = options ?? {};
+    const env = resolvedOptions.env ?? process.env;
+    const cli = resolvedOptions.cli;
+    const relayEnabledFallback = resolvedOptions.relayEnabledFallback ?? persisted.daemon?.relay?.enabled === undefined;
+    const listen = resolveListenAddress(env, cli, persisted);
+    const { mcpEnabled, mcpInjectIntoAgents, browserToolsEnabled, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, agentProfiles, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, cli, persisted);
+    const relay = resolveRelayConfig({
+        env,
+        persisted,
+        cliRelayEnabled: cli?.relayEnabled,
+        cliRelayUseTls: cli?.relayUseTls,
+        enabledFallback: relayEnabledFallback,
+    });
+    const serviceProxy = resolveServiceProxyConfig(env, persisted);
+    const webUi = resolveWebUiConfig(paseoHome, env, cli, persisted);
+    const { openai, speech } = resolveSpeechConfig({
+        paseoHome,
+        env,
+        persisted,
+    });
+    const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    const overrideControlledPaths = resolveOverrideControlledPaths(env, cli, speech.providers);
+    return {
+        listen,
+        paseoHome,
+        desktopManaged: env.PASEO_DESKTOP_MANAGED === "1",
+        worktreesRoot: resolveWorktreesRoot(paseoHome, persisted),
+        corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
+        hostnames,
+        trustedProxies,
+        mcpEnabled,
+        mcpInjectIntoAgents,
+        browserToolsEnabled,
+        git: resolveGitProcessConfig(env, persisted),
+        autoArchiveAfterMerge,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt,
+        terminalProfiles,
+        agentProfiles,
+        skillSelection: persisted.agents?.skills?.selection,
+        pluginsEnabled: persisted.pluginsEnabled ?? false,
+        plugins: persisted.plugins,
+        mcpDebug: env.MCP_DEBUG === "1",
+        isDev: resolvePaseoNodeEnv(env) === "development",
+        agentStoragePath: path.join(paseoHome, "agents"),
+        staticDir: "public",
+        agentClients: {},
+        relayEnabled: relay.enabled,
+        relayEnabledMutable: relay.enabledMutable,
+        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),
+        providerCatalogRefreshTimeoutMs: persisted.agents?.catalogRefreshTimeoutMs,
+        metadataGeneration: persisted.agents?.metadataGeneration,
+        providerOverrides,
+        log: resolveLogConfigFromEnv(env, persisted),
+        configReload: {
+            env: { ...env },
+            cli: cli ? { ...cli } : undefined,
+            overrideControlledPaths,
+            relayEnabledFallback,
+            startupPersisted: persisted,
+        },
+    };
+}
+export function loadConfig(paseoHome, options) {
+    const persisted = loadPersistedConfig(paseoHome);
+    return resolveConfigFromPersisted(paseoHome, persisted, options);
+}
+function parsePositiveGitOverride(value) {
+    if (value === undefined)
+        return false;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0;
+}
+function resolveOverrideControlledPaths(env, cli, speechProviders) {
+    return Array.from(new Set([
+        ...resolveDaemonOverrideControlledPaths(env, cli),
+        ...resolveLogOverrideControlledPaths(env),
+        ...resolveSpeechOverrideControlledPaths(env, speechProviders),
+    ])).sort();
+}
+function resolveDaemonOverrideControlledPaths(env, cli) {
+    return [
+        ...resolveCoreDaemonOverridePaths(env, cli),
+        ...resolveRelayOverridePaths(env, cli),
+        ...resolveServiceAndWebUiOverridePaths(env, cli),
+    ];
+}
+function resolveCoreDaemonOverridePaths(env, cli) {
+    const paths = [];
+    if (cli?.listen !== undefined || env.PASEO_LISTEN !== undefined) {
+        paths.push("daemon.listen");
+    }
+    if (cli?.mcpEnabled !== undefined)
+        paths.push("daemon.mcp.enabled");
+    if (cli?.mcpInjectIntoAgents !== undefined)
+        paths.push("daemon.mcp.injectIntoAgents");
+    // Hostname sources append instead of replacing one another, so a launch value
+    // does not prevent a persisted hostname edit from taking effect.
+    if (parseTrustedProxiesEnv(env.PASEO_TRUSTED_PROXIES) !== undefined) {
+        paths.push("daemon.trustedProxies");
+    }
+    if (parsePositiveGitOverride(env.PASEO_GIT_MAX_PROCESSES_PER_SECOND)) {
+        paths.push("daemon.git.maxProcessesPerSecond");
+    }
+    if (parsePositiveGitOverride(env.PASEO_GIT_MAX_PROCESS_CONCURRENCY ?? env.PASEO_GIT_CONCURRENCY)) {
+        paths.push("daemon.git.maxProcessConcurrency");
+    }
+    if (env.PASEO_APP_BASE_URL !== undefined)
+        paths.push("app.baseUrl");
+    if (env.PASEO_PASSWORD?.trim())
+        paths.push("daemon.auth.password");
+    return paths;
+}
+function resolveRelayOverridePaths(env, cli) {
+    const paths = [];
+    if (cli?.relayEnabled !== undefined || parseBooleanEnv(env.PASEO_RELAY_ENABLED) !== undefined) {
+        paths.push("daemon.relay.enabled");
+    }
+    if (env.PASEO_RELAY_ENDPOINT !== undefined)
+        paths.push("daemon.relay.endpoint");
+    if (env.PASEO_RELAY_PUBLIC_ENDPOINT !== undefined) {
+        paths.push("daemon.relay.publicEndpoint");
+    }
+    if (cli?.relayUseTls !== undefined || env.PASEO_RELAY_USE_TLS !== undefined) {
+        paths.push("daemon.relay.useTls");
+    }
+    if (env.PASEO_RELAY_PUBLIC_USE_TLS !== undefined) {
+        paths.push("daemon.relay.publicUseTls");
+    }
+    return paths;
+}
+function resolveServiceAndWebUiOverridePaths(env, cli) {
+    const paths = [];
+    const serviceProxyEnabled = parseBooleanEnv(env.PASEO_SERVICE_PROXY_ENABLED);
+    if (serviceProxyEnabled !== undefined)
+        paths.push("daemon.serviceProxy.enabled");
+    if (env.PASEO_SERVICE_PROXY_LISTEN !== undefined || serviceProxyEnabled === false) {
+        paths.push("daemon.serviceProxy.listen");
+    }
+    if (env.PASEO_SERVICE_PROXY_PUBLIC_BASE_URL !== undefined || serviceProxyEnabled === false) {
+        paths.push("daemon.serviceProxy.publicBaseUrl");
+    }
+    if (cli?.webUiEnabled !== undefined || parseBooleanEnv(env.PASEO_WEB_UI_ENABLED) !== undefined) {
+        paths.push("features.webUi.enabled");
+    }
+    if (env.PASEO_WEB_UI_DIST_DIR !== undefined)
+        paths.push("features.webUi.distDir");
+    return paths;
+}
+function resolveLogOverrideControlledPaths(env) {
+    const paths = [];
+    if (parseLogLevelEnv(env.PASEO_LOG_LEVEL ?? env.PASEO_LOG) !== undefined) {
+        paths.push("log.level");
+    }
+    if (parseLogFormatEnv(env.PASEO_LOG_FORMAT) !== undefined)
+        paths.push("log.format");
+    if (parseLogLevelEnv(env.PASEO_LOG_CONSOLE_LEVEL) !== undefined) {
+        paths.push("log.console.level");
+    }
+    if (parseLogFormatEnv(env.PASEO_LOG_CONSOLE_FORMAT) !== undefined) {
+        paths.push("log.console.format");
+    }
+    if (parseLogLevelEnv(env.PASEO_LOG_FILE_LEVEL) !== undefined)
+        paths.push("log.file.level");
+    if (nonEmptyEnv(env.PASEO_LOG_FILE_PATH) !== undefined)
+        paths.push("log.file.path");
+    if (nonEmptyEnv(env.PASEO_LOG_FILE_ROTATE_SIZE) !== undefined) {
+        paths.push("log.file.rotate.maxSize");
+    }
+    if (parsePositiveIntegerEnv(env.PASEO_LOG_FILE_ROTATE_COUNT) !== undefined) {
+        paths.push("log.file.rotate.maxFiles");
+    }
+    return paths;
+}
+function isEnabledSpeechProvider(provider, expected) {
+    return provider.enabled !== false && provider.provider === expected;
+}
+function resolveSpeechOverrideControlledPaths(env, providers) {
+    const paths = [];
+    const add = (envName, ...configPaths) => {
+        if (env[envName] !== undefined)
+            paths.push(...configPaths);
+    };
+    add("PASEO_DICTATION_ENABLED", "features.dictation.enabled");
+    add("PASEO_DICTATION_STT_PROVIDER", "features.dictation.stt.provider");
+    if (env.PASEO_DICTATION_LOCAL_STT_MODEL !== undefined &&
+        isEnabledSpeechProvider(providers.dictationStt, "local")) {
+        paths.push("features.dictation.stt.model");
+    }
+    add("PASEO_DICTATION_LANGUAGE", "features.dictation.stt.language");
+    add("PASEO_VOICE_MODE_ENABLED", "features.voiceMode.enabled");
+    add("PASEO_VOICE_LLM_PROVIDER", "features.voiceMode.llm.provider");
+    add("PASEO_VOICE_STT_PROVIDER", "features.voiceMode.stt.provider");
+    if (env.PASEO_VOICE_LOCAL_STT_MODEL !== undefined &&
+        isEnabledSpeechProvider(providers.voiceStt, "local")) {
+        paths.push("features.voiceMode.stt.model");
+    }
+    add("PASEO_VOICE_LANGUAGE", "features.voiceMode.stt.language");
+    add("PASEO_VOICE_TURN_DETECTION_PROVIDER", "features.voiceMode.turnDetection.provider");
+    add("PASEO_VOICE_TTS_PROVIDER", "features.voiceMode.tts.provider");
+    if (env.PASEO_VOICE_LOCAL_TTS_MODEL !== undefined &&
+        isEnabledSpeechProvider(providers.voiceTts, "local")) {
+        paths.push("features.voiceMode.tts.model");
+    }
+    add("PASEO_VOICE_LOCAL_TTS_SPEAKER_ID", "features.voiceMode.tts.speakerId");
+    add("PASEO_VOICE_LOCAL_TTS_SPEED", "features.voiceMode.tts.speed");
+    add("PASEO_LOCAL_MODELS_DIR", "providers.local.modelsDir");
+    const openAiDictationStt = isEnabledSpeechProvider(providers.dictationStt, "openai");
+    const openAiVoiceStt = isEnabledSpeechProvider(providers.voiceStt, "openai");
+    if (env.STT_CONFIDENCE_THRESHOLD !== undefined && (openAiDictationStt || openAiVoiceStt)) {
+        paths.push("features.dictation.stt.confidenceThreshold");
+    }
+    if (env.STT_MODEL !== undefined) {
+        if (openAiDictationStt)
+            paths.push("features.dictation.stt.model");
+        if (openAiVoiceStt)
+            paths.push("features.voiceMode.stt.model");
+    }
+    if (isEnabledSpeechProvider(providers.voiceTts, "openai")) {
+        add("TTS_MODEL", "features.voiceMode.tts.model");
+        add("TTS_VOICE", "features.voiceMode.tts.voice");
+    }
+    if (env.PASEO_DICTATION_LANGUAGE !== undefined && env.PASEO_VOICE_LANGUAGE === undefined) {
+        paths.push("features.voiceMode.stt.language");
+    }
+    return paths;
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,20 @@
+import { type ConnectionOffer } from "@camerontaylor/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

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

@@ -0,0 +1,59 @@
+import os from "node:os";
+import { ConnectionOfferV2Schema } from "@camerontaylor/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