@otto-code/server 0.5.0

package/dist/server/server/config.js

@@ -0,0 +1,330 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveOttoNodeEnv } from "./otto-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 "@otto-code/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 = 6868;
+const DEFAULT_RELAY_ENDPOINT = "relay.otto-code.me:443";
+const DEFAULT_APP_BASE_URL = "https://app.otto-code.me";
+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 resolveLogConfigFromEnv(env, persisted) {
+    const envLogLevel = LogLevelSchema.safeParse(normalizeLogEnv(env.OTTO_LOG_LEVEL));
+    const envLogFormat = LogFormatSchema.safeParse(normalizeLogEnv(env.OTTO_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.OTTO_RELAY_ENABLED) ??
+        input.persisted.daemon?.relay?.enabled ??
+        true;
+    const endpoint = input.env.OTTO_RELAY_ENDPOINT ??
+        input.persisted.daemon?.relay?.endpoint ??
+        DEFAULT_RELAY_ENDPOINT;
+    const publicEndpoint = input.env.OTTO_RELAY_PUBLIC_ENDPOINT ??
+        input.persisted.daemon?.relay?.publicEndpoint ??
+        endpoint;
+    const useTls = input.cliRelayUseTls ??
+        resolveTlsFromEnv(input.env.OTTO_RELAY_USE_TLS, input.persisted.daemon?.relay?.useTls, endpoint === DEFAULT_RELAY_ENDPOINT);
+    const publicUseTls = resolveTlsFromEnv(input.env.OTTO_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 OTTO_SERVICE_PROXY_PUBLIC_BASE_URL: ${value}`);
+    }
+}
+function resolveServiceProxyConfig(env, persisted) {
+    const enabledShim = parseBooleanEnv(env.OTTO_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.OTTO_SERVICE_PROXY_PUBLIC_BASE_URL ??
+            persisted.daemon?.serviceProxy?.publicBaseUrl ??
+            null)
+        : null;
+    const standaloneListen = optionalLayersEnabled
+        ? (env.OTTO_SERVICE_PROXY_LISTEN ?? persisted.daemon?.serviceProxy?.listen ?? null)
+        : null;
+    return { publicBaseUrl, standaloneListen };
+}
+function resolveWebUiConfig(ottoHome, env, cli, persisted) {
+    const enabled = cli?.webUiEnabled ??
+        parseBooleanEnv(env.OTTO_WEB_UI_ENABLED) ??
+        persisted.features?.webUi?.enabled ??
+        false;
+    const rawDistDir = env.OTTO_WEB_UI_DIST_DIR ?? persisted.features?.webUi?.distDir;
+    const trimmedDistDir = rawDistDir?.trim();
+    const distDir = trimmedDistDir
+        ? path.resolve(path.isAbsolute(trimmedDistDir) ? trimmedDistDir : ottoHome, trimmedDistDir)
+        : BUNDLED_WEB_UI_DIST_DIR;
+    return {
+        enabled,
+        distDir,
+    };
+}
+function resolveVoiceLlmConfig(env, persisted) {
+    const envVoiceLlmProvider = parseOptionalVoiceLlmProvider(env.OTTO_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.OTTO_CORS_ORIGINS
+        ? env.OTTO_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.OTTO_TRUSTED_PROXIES) ??
+        persisted.daemon?.trustedProxies ??
+        DEFAULT_TRUSTED_PROXIES);
+}
+// OTTO_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:6868
+function resolveListenAddress(env, cli, persisted) {
+    return (cli?.listen ??
+        env.OTTO_LISTEN ??
+        persisted.daemon?.listen ??
+        `127.0.0.1:${env.PORT ?? DEFAULT_PORT}`);
+}
+function resolveAuthConfig(env, persisted) {
+    const envPassword = env.OTTO_PASSWORD?.trim();
+    if (envPassword) {
+        return { password: hashDaemonPassword(envPassword) };
+    }
+    return persisted.daemon?.auth?.password
+        ? { password: persisted.daemon.auth.password }
+        : undefined;
+}
+function resolveWorktreesRoot(ottoHome, persisted) {
+    const configuredRoot = persisted.worktrees?.root?.trim();
+    if (!configuredRoot) {
+        return undefined;
+    }
+    const expandedRoot = expandTilde(configuredRoot);
+    return path.isAbsolute(expandedRoot)
+        ? path.resolve(expandedRoot)
+        : path.resolve(ottoHome, 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 ?? false,
+        browserToolsEnabled: resolveBrowserToolsEnabled(persisted),
+        autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
+        appendSystemPrompt: resolveAppendSystemPrompt(persisted),
+        terminalProfiles: persisted.daemon?.terminalProfiles,
+        hostnames: mergeHostnames([
+            persisted.daemon?.hostnames,
+            parseHostnamesEnv(env.OTTO_HOSTNAMES ?? env.OTTO_ALLOWED_HOSTS),
+            cli?.hostnames,
+        ]),
+        trustedProxies: resolveTrustedProxiesConfig(env, persisted),
+        appBaseUrl: env.OTTO_APP_BASE_URL ?? persisted.app?.baseUrl ?? DEFAULT_APP_BASE_URL,
+    };
+}
+export function loadConfig(ottoHome, options) {
+    const env = options?.env ?? process.env;
+    const persisted = loadPersistedConfig(ottoHome);
+    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(ottoHome, env, options?.cli, persisted);
+    const { openai, speech } = resolveSpeechConfig({
+        ottoHome,
+        env,
+        persisted,
+    });
+    const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    return {
+        listen,
+        ottoHome,
+        worktreesRoot: resolveWorktreesRoot(ottoHome, persisted),
+        corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
+        hostnames,
+        trustedProxies,
+        mcpEnabled,
+        mcpInjectIntoAgents,
+        browserToolsEnabled,
+        autoArchiveAfterMerge,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt,
+        terminalProfiles,
+        mcpDebug: env.MCP_DEBUG === "1",
+        isDev: resolveOttoNodeEnv(env) === "development",
+        agentStoragePath: path.join(ottoHome, "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,
+        agentPersonalities: persisted.agents?.agentPersonalities,
+        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 "@otto-code/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 "@otto-code/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.OTTO_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,44 @@
+export type { MutableDaemonConfig, MutableDaemonConfigPatch } from "@otto-code/protocol/messages";
+type MutableDaemonConfig = import("@otto-code/protocol/messages").MutableDaemonConfig;
+type MutableDaemonConfigPatch = import("@otto-code/protocol/messages").MutableDaemonConfigPatch;
+type AgentPersonality = import("@otto-code/protocol/messages").AgentPersonality;
+type ProviderOverride = import("./agent/provider-launch-config.js").ProviderOverride;
+interface LoggerLike {
+    child(bindings: Record<string, unknown>): LoggerLike;
+    info(...args: unknown[]): void;
+}
+export interface ConfigChangeDetails {
+    /** Provider ids whose config entries were removed by this patch. */
+    removedProviderIds: string[];
+}
+type ConfigListener = (config: MutableDaemonConfig, details: ConfigChangeDetails) => void;
+type FieldChangeHandler = (value: unknown) => void;
+export declare const DAEMON_CONFIG_SECRET_SENTINEL = "__otto_secret_present__";
+export declare function redactDaemonConfigForClient(config: MutableDaemonConfig): MutableDaemonConfig;
+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 ottoHome;
+    private readonly logger;
+    private readonly changeListeners;
+    private readonly fieldChangeHandlers;
+    constructor(ottoHome: string, initial: MutableDaemonConfig, logger?: LoggerLike);
+    get(): MutableDaemonConfig;
+    /**
+     * Seed the shipped default Agent Personalities onto disk the first time this
+     * host runs the feature — but ONLY when the persisted config has never carried
+     * an agentPersonalities section. Once the section exists on disk (even as an
+     * empty roster the user cleared), this is a no-op, so deleting the whole team
+     * sticks across restarts instead of silently re-seeding. The in-memory config
+     * is seeded separately at construction (see bootstrap); this only records the
+     * one-time initialization on disk, writing just the personalities branch so
+     * unrelated defaults (speech, etc.) are never frozen onto disk as a side
+     * effect.
+     */
+    seedDefaultPersonalitiesIfAbsent(defaults: readonly AgentPersonality[]): void;
+    patch(partial: MutableDaemonConfigPatch): MutableDaemonConfig;
+    onFieldChange(path: string, handler: FieldChangeHandler): () => void;
+    onChange(listener: ConfigListener): () => void;
+    private persistConfig;
+}
+//# sourceMappingURL=daemon-config-store.d.ts.map