@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/dist/server/server/config.d.ts

@@ -0,0 +1,22 @@
+import type { BySpaceDaemonConfig } from "./bootstrap.js";
+import { type HostnamesConfig } from "./hostnames.js";
+interface ResolveBundledWebUiDistDirInput {
+    moduleUrl?: string | URL;
+    resourcesPath?: string;
+}
+export declare function resolveBundledWebUiDistDir(input?: ResolveBundledWebUiDistDirInput): string;
+export type CliConfigOverrides = Partial<{
+    listen: string;
+    relayEnabled: boolean;
+    relayUseTls: boolean;
+    mcpEnabled: boolean;
+    mcpInjectIntoAgents: boolean;
+    webUiEnabled: boolean;
+    hostnames: HostnamesConfig;
+}>;
+export declare function loadConfig(byspaceHome: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    cli?: CliConfigOverrides;
+}): BySpaceDaemonConfig;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/config.js

@@ -0,0 +1,324 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveBySpaceNodeEnv } from "./byspace-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 "@bytetrue/byspace-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 = 6777;
+const DEFAULT_RELAY_ENDPOINT = "byspace-relay.bytetrue.workers.dev:443";
+const DEFAULT_APP_BASE_URL = "https://byspace.pages.dev";
+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.BYSPACE_LOG_LEVEL));
+    const envLogFormat = LogFormatSchema.safeParse(normalizeLogEnv(env.BYSPACE_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.BYSPACE_RELAY_ENABLED) ??
+        input.persisted.daemon?.relay?.enabled ??
+        true;
+    const endpoint = input.env.BYSPACE_RELAY_ENDPOINT ??
+        input.persisted.daemon?.relay?.endpoint ??
+        DEFAULT_RELAY_ENDPOINT;
+    const publicEndpoint = input.env.BYSPACE_RELAY_PUBLIC_ENDPOINT ??
+        input.persisted.daemon?.relay?.publicEndpoint ??
+        endpoint;
+    const useTls = input.cliRelayUseTls ??
+        resolveTlsFromEnv(input.env.BYSPACE_RELAY_USE_TLS, input.persisted.daemon?.relay?.useTls, endpoint === DEFAULT_RELAY_ENDPOINT);
+    const publicUseTls = resolveTlsFromEnv(input.env.BYSPACE_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 BYSPACE_SERVICE_PROXY_PUBLIC_BASE_URL: ${value}`);
+    }
+}
+function resolveServiceProxyConfig(env, persisted) {
+    const enabledShim = parseBooleanEnv(env.BYSPACE_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.BYSPACE_SERVICE_PROXY_PUBLIC_BASE_URL ??
+            persisted.daemon?.serviceProxy?.publicBaseUrl ??
+            null)
+        : null;
+    const standaloneListen = optionalLayersEnabled
+        ? (env.BYSPACE_SERVICE_PROXY_LISTEN ?? persisted.daemon?.serviceProxy?.listen ?? null)
+        : null;
+    return { publicBaseUrl, standaloneListen };
+}
+function resolveWebUiConfig(byspaceHome, env, cli, persisted) {
+    const enabled = cli?.webUiEnabled ??
+        parseBooleanEnv(env.BYSPACE_WEB_UI_ENABLED) ??
+        persisted.features?.webUi?.enabled ??
+        false;
+    const rawDistDir = env.BYSPACE_WEB_UI_DIST_DIR ?? persisted.features?.webUi?.distDir;
+    const trimmedDistDir = rawDistDir?.trim();
+    const distDir = trimmedDistDir
+        ? path.resolve(path.isAbsolute(trimmedDistDir) ? trimmedDistDir : byspaceHome, trimmedDistDir)
+        : BUNDLED_WEB_UI_DIST_DIR;
+    return {
+        enabled,
+        distDir,
+    };
+}
+function resolveVoiceLlmConfig(env, persisted) {
+    const envVoiceLlmProvider = parseOptionalVoiceLlmProvider(env.BYSPACE_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.BYSPACE_CORS_ORIGINS
+        ? env.BYSPACE_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.BYSPACE_TRUSTED_PROXIES) ??
+        persisted.daemon?.trustedProxies ??
+        DEFAULT_TRUSTED_PROXIES);
+}
+// BYSPACE_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:6777
+function resolveListenAddress(env, cli, persisted) {
+    return (cli?.listen ??
+        env.BYSPACE_LISTEN ??
+        persisted.daemon?.listen ??
+        `127.0.0.1:${env.PORT ?? DEFAULT_PORT}`);
+}
+function resolveAuthConfig(env, persisted) {
+    const envPassword = env.BYSPACE_PASSWORD?.trim();
+    if (envPassword) {
+        return { password: hashDaemonPassword(envPassword) };
+    }
+    return persisted.daemon?.auth?.password
+        ? { password: persisted.daemon.auth.password }
+        : undefined;
+}
+function resolveWorktreesRoot(byspaceHome, persisted) {
+    const configuredRoot = persisted.worktrees?.root?.trim();
+    if (!configuredRoot) {
+        return undefined;
+    }
+    const expandedRoot = expandTilde(configuredRoot);
+    return path.isAbsolute(expandedRoot)
+        ? path.resolve(expandedRoot)
+        : path.resolve(byspaceHome, expandedRoot);
+}
+function resolveAppendSystemPrompt(persisted) {
+    return persisted.daemon?.appendSystemPrompt ?? "";
+}
+function resolveStaticLoadConfigSettings(env, cli, persisted) {
+    return {
+        mcpEnabled: cli?.mcpEnabled ?? persisted.daemon?.mcp?.enabled ?? true,
+        mcpInjectIntoAgents: cli?.mcpInjectIntoAgents ?? persisted.daemon?.mcp?.injectIntoAgents ?? false,
+        autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
+        appendSystemPrompt: resolveAppendSystemPrompt(persisted),
+        terminalProfiles: persisted.daemon?.terminalProfiles,
+        hostnames: mergeHostnames([
+            persisted.daemon?.hostnames,
+            parseHostnamesEnv(env.BYSPACE_HOSTNAMES ?? env.BYSPACE_ALLOWED_HOSTS),
+            cli?.hostnames,
+        ]),
+        trustedProxies: resolveTrustedProxiesConfig(env, persisted),
+        appBaseUrl: env.BYSPACE_APP_BASE_URL ?? persisted.app?.baseUrl ?? DEFAULT_APP_BASE_URL,
+    };
+}
+export function loadConfig(byspaceHome, options) {
+    const env = options?.env ?? process.env;
+    const persisted = loadPersistedConfig(byspaceHome);
+    const listen = resolveListenAddress(env, options?.cli, persisted);
+    const { mcpEnabled, mcpInjectIntoAgents, 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(byspaceHome, env, options?.cli, persisted);
+    const { openai, speech } = resolveSpeechConfig({
+        byspaceHome,
+        env,
+        persisted,
+    });
+    const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    return {
+        listen,
+        byspaceHome,
+        worktreesRoot: resolveWorktreesRoot(byspaceHome, persisted),
+        corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
+        hostnames,
+        trustedProxies,
+        mcpEnabled,
+        mcpInjectIntoAgents,
+        autoArchiveAfterMerge,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+        appendSystemPrompt,
+        terminalProfiles,
+        mcpDebug: env.MCP_DEBUG === "1",
+        isDev: resolveBySpaceNodeEnv(env) === "development",
+        agentStoragePath: path.join(byspaceHome, "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/node_modules/@bytetrue/byspace-server/dist/server/server/connection-offer.d.ts

@@ -0,0 +1,20 @@
+import { type ConnectionOffer } from "@bytetrue/byspace-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/node_modules/@bytetrue/byspace-server/dist/server/server/connection-offer.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import { ConnectionOfferV2Schema, } from "@bytetrue/byspace-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.BYSPACE_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/node_modules/@bytetrue/byspace-server/dist/server/server/daemon-config-store.d.ts

@@ -0,0 +1,25 @@
+export type { MutableDaemonConfig, MutableDaemonConfigPatch, } from "@bytetrue/byspace-protocol/messages";
+type MutableDaemonConfig = import("@bytetrue/byspace-protocol/messages").MutableDaemonConfig;
+type MutableDaemonConfigPatch = import("@bytetrue/byspace-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 byspaceHome;
+    private readonly logger;
+    private readonly changeListeners;
+    private readonly fieldChangeHandlers;
+    constructor(byspaceHome: 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/node_modules/@bytetrue/byspace-server/dist/server/server/daemon-config-store.js

@@ -0,0 +1,182 @@
+import { loadPersistedConfig, savePersistedConfig, } from "./persisted-config.js";
+import { ProviderOverrideSchema } from "./agent/provider-launch-config.js";
+import { MutableDaemonConfigSchema, MutableDaemonConfigPatchSchema, } from "@bytetrue/byspace-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(byspaceHome, initial, logger) {
+        this.changeListeners = new Set();
+        this.fieldChangeHandlers = new Map();
+        this.byspaceHome = byspaceHome;
+        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.byspaceHome, this.logger);
+        const nextPersisted = mergeMutableConfigIntoPersistedConfig({
+            persisted,
+            mutable: config,
+        });
+        savePersistedConfig(this.byspaceHome, nextPersisted, this.logger);
+    }
+}
+function mergeMutableConfigIntoPersistedConfig(params) {
+    const { persisted, mutable } = params;
+    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,
+            },
+            autoArchiveAfterMerge: mutable.autoArchiveAfterMerge,
+            enableTerminalAgentHooks: mutable.enableTerminalAgentHooks,
+            appendSystemPrompt: mutable.appendSystemPrompt,
+            ...(mutable.terminalProfiles !== undefined
+                ? { terminalProfiles: mutable.terminalProfiles }
+                : {}),
+        },
+        agents: nextAgents,
+    };
+}
+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