mixdog 0.7.1

package/src/agent/orchestrator/config.mjs

@@ -0,0 +1,358 @@
+import { resolvePluginData } from '../../shared/plugin-paths.mjs';
+import { readSection, updateSection, getAgentApiKey } from '../../shared/config.mjs';
+import { hasAnthropicOAuthCredentials } from './providers/anthropic-oauth.mjs';
+import { hasOpenAIOAuthCredentials } from './providers/openai-oauth.mjs';
+import { hasGrokOAuthCredentials } from './providers/grok-oauth.mjs';
+
+// Thin wrapper around resolvePluginData so callers in this orchestrator tree
+// can import a single helper without reaching into shared/.
+export function getPluginData() {
+    return resolvePluginData();
+}
+const ENV_KEY_MAP = {
+    openai: 'OPENAI_API_KEY',
+    anthropic: 'ANTHROPIC_API_KEY',
+    gemini: 'GEMINI_API_KEY',
+    deepseek: 'DEEPSEEK_API_KEY',
+    xai: 'XAI_API_KEY',
+    nvidia: 'NVIDIA_API_KEY',
+};
+// Canonical maintenance defaults. Single source of truth — imported by
+// llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
+//
+// Every hidden maintenance slot carries a CONCRETE preset here, so
+// resolvePresetName() (bridge-llm) always resolves a model directly from
+// `maint[slot]` — no shared `defaultPreset` fallback is needed or used.
+// Memory cycles + Lead helper fan-out (explore/cycle1/cycle2/cycle3) and
+// entry-driven dispatch (scheduler/webhook) all default to `haiku`.
+// scheduler/webhook still let a per-entry config.json model win first (the
+// caller passes it explicitly via opts.preset); the haiku default below only
+// applies when an entry omits its own model.
+export const DEFAULT_MAINTENANCE = Object.freeze({
+    explore: 'haiku',
+    cycle1: 'haiku',
+    cycle2: 'haiku',
+    cycle3: 'haiku',
+    scheduler: 'haiku',
+    webhook: 'haiku',
+});
+
+// Slots surfaced as tunable rows in the Maintenance Setup panel. This is the
+// UI / allow-list view (GET cleanup + POST validation) and is intentionally a
+// SUBSET of DEFAULT_MAINTENANCE: scheduler/webhook carry a per-entry model and
+// are not shown as shared rows, but still inherit the haiku default above when
+// an entry omits its own model.
+export const MAINTENANCE_SLOTS = Object.freeze(['explore', 'cycle1', 'cycle2', 'cycle3']);
+
+// Map short Anthropic family labels to the full model ids used by the API.
+// Honors ANTHROPIC_DEFAULT_{OPUS|SONNET|HAIKU}_MODEL env overrides.
+const ANTHROPIC_FAMILY_MODEL = Object.freeze({
+    opus: 'claude-opus-4-8',
+    sonnet: 'claude-sonnet-4-6',
+    haiku: 'claude-haiku-4-5-20251001',
+});
+function resolveAnthropicFamilyModel(family) {
+    const key = String(family || '').toLowerCase();
+    if (!key) return null;
+    const envVar = `ANTHROPIC_DEFAULT_${key.toUpperCase()}_MODEL`;
+    if (process.env[envVar]) return process.env[envVar];
+    return ANTHROPIC_FAMILY_MODEL[key] || null;
+}
+
+// Seed presets keyed by preset.name so workflow/maintenance references stay
+// consistent with the resolve-by-name lookup in presetKey().
+export const DEFAULT_PRESETS = Object.freeze([
+    Object.freeze({ id: 'haiku', name: 'HAIKU', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('haiku'), tools: 'full' }),
+    Object.freeze({ id: 'sonnet-mid', name: 'SONNET MID', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'medium', tools: 'full' }),
+    Object.freeze({ id: 'sonnet-high', name: 'SONNET HIGH', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'high', tools: 'full' }),
+    Object.freeze({ id: 'opus-mid', name: 'OPUS MID', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'medium', tools: 'full' }),
+    Object.freeze({ id: 'opus-high', name: 'OPUS HIGH', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'high', tools: 'full' }),
+]);
+function buildDefaultConfig() {
+    const providers = {};
+    // API providers — enabled if env key exists
+    for (const [name, envKey] of Object.entries(ENV_KEY_MAP)) {
+        const apiKey = process.env[envKey];
+        providers[name] = {
+            enabled: !!apiKey,
+            apiKey: apiKey || undefined,
+        };
+    }
+    // OAuth provider detection delegates to each provider module so the
+    // canonical credential loader (loadTokens / loadCredentials) is the
+    // single source of truth. WebSocket transport is on by default —
+    // measured ~96% cross-session cache hit with delta payloads. Users who
+    // need to force SSE (e.g. a corporate proxy blocking WSS) can set
+    // `websocket: false` in mixdog-config.json (agent.providers.openai-oauth).
+    providers['openai-oauth'] = { enabled: hasOpenAIOAuthCredentials(), websocket: true };
+    providers['anthropic-oauth'] = { enabled: hasAnthropicOAuthCredentials() };
+    // Grok CLI OAuth ("Grok Build"). Like the other OAuth entries it is not
+    // stored in mixdog-config.json — enabled at runtime from the presence of
+    // either token source (own store or ~/.grok/auth.json) via
+    // hasGrokOAuthCredentials().
+    providers['grok-oauth'] = { enabled: hasGrokOAuthCredentials() };
+    // Local providers — opt-in via setup UI after HTTP ping confirms server is running
+    providers.ollama = { enabled: false, baseURL: 'http://localhost:11434/v1' };
+    providers.lmstudio = { enabled: false, baseURL: 'http://localhost:1234/v1' };
+    return { providers };
+}
+
+function hasKeys(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+
+// Persist the agent section. `build` receives the section value read INSIDE
+// the file lock (current on-disk state) and returns the full replacement.
+// Building from `current` rather than a snapshot taken before the lock keeps
+// the whole-section save linearizable: a concurrent writer (each Claude Code
+// session runs its own server under MIXDOG_MULTI_INSTANCE) that lands between
+// our read and write is rebased onto, not silently clobbered (lost-update).
+function persistAgentConfig(build) {
+    updateSection('agent', (current) => build(hasKeys(current) ? current : {}));
+}
+
+export function loadConfig() {
+    const sectionRaw = readSection('agent');
+    if (hasKeys(sectionRaw)) {
+        try {
+            let raw = sectionRaw;
+            if (raw.agent && raw.agent.providers) {
+                raw = raw.agent;
+            }
+            const defaults = buildDefaultConfig();
+            // Deep-merge provider subkeys: unknown per-provider values are
+            // preserved through save/load so future fields round-trip
+            // without schema updates here.
+            const mergedProviders = { ...defaults.providers };
+            if (raw.providers && typeof raw.providers === 'object') {
+                for (const [name, val] of Object.entries(raw.providers)) {
+                    if (val && typeof val === 'object') {
+                        mergedProviders[name] = { ...(mergedProviders[name] || {}), ...val };
+                    } else {
+                        mergedProviders[name] = val;
+                    }
+                }
+            }
+            // Provider API keys live in the OS keychain (std env / MIXDOG_AGENT_*
+            // -> keychain), never plaintext in config. Overlay them so the
+            // provider clients see config.apiKey populated.
+            for (const name of Object.keys(ENV_KEY_MAP)) {
+                const kc = getAgentApiKey(name);
+                if (kc) mergedProviders[name] = { ...(mergedProviders[name] || {}), apiKey: kc, enabled: true };
+            }
+            // Drop unknown maintenance keys (e.g. truly legacy slot names from
+            // pre-removal installs). Every valid slot — incl. scheduler/webhook —
+            // lives in DEFAULT_MAINTENANCE, so the allow-list below is the single
+            // ingress gate and unknown keys are dropped here.
+            const allowedMaintKeys = new Set([...Object.keys(DEFAULT_MAINTENANCE), ...MAINTENANCE_SLOTS]);
+            const rawMaint = {};
+            for (const [k, v] of Object.entries(raw.maintenance || {})) {
+                if (allowedMaintKeys.has(k)) rawMaint[k] = v;
+            }
+            // Self-ref guard: mcpServers.mixdog / mcpServers["trib-plugin"]
+            // would self-spawn through the in-process tool bridge. Strip on
+            // ingress so user-edited configs cannot brick the agent boot.
+            const mcpServers = (raw.mcpServers && typeof raw.mcpServers === 'object') ? { ...raw.mcpServers } : {};
+            if (mcpServers['mixdog'] || mcpServers['trib-plugin']) {
+                delete mcpServers['mixdog'];
+                delete mcpServers['trib-plugin'];
+                raw.mcpServers = mcpServers;
+                try {
+                    // Rebase the self-ref strip onto the in-lock current so a
+                    // concurrent writer's unrelated edits are not reverted by
+                    // this read-time sanitize.
+                    persistAgentConfig((current) => {
+                        const cur = { ...current };
+                        // Strip self-refs at the same level loadConfig reads
+                        // mcpServers from: the legacy nested shape keeps them
+                        // under cur.agent, the flat shape at top level. Cleaning
+                        // only the top level would leave a nested config dirty
+                        // on disk even though runtime is sanitized.
+                        const target = (cur.agent && cur.agent.providers)
+                            ? (cur.agent = { ...cur.agent })
+                            : cur;
+                        const curMcp = (target.mcpServers && typeof target.mcpServers === 'object') ? { ...target.mcpServers } : {};
+                        delete curMcp['mixdog'];
+                        delete curMcp['trib-plugin'];
+                        target.mcpServers = curMcp;
+                        return cur;
+                    });
+                } catch (err) {
+                    process.stderr.write(`[config] persist sanitized config failed: ${err?.message}\n`);
+                }
+            }
+            const rawPresets = Array.isArray(raw.presets) ? raw.presets : [];
+            const normalizedPresets = rawPresets.map(p => normalizePreset(p)).filter(Boolean);
+            return {
+                providers: mergedProviders,
+                mcpServers,
+                presets: normalizedPresets,
+                default: raw.default || null,
+                maintenance: { ...DEFAULT_MAINTENANCE, ...rawMaint },
+                agentMaintenance: { enabled: true, interval: '1h', ...raw.agentMaintenance },
+                trajectory: { enabled: true, ...raw.trajectory },
+                bridge: raw.bridge && typeof raw.bridge === 'object' ? raw.bridge : {},
+            };
+        }
+        catch { /* fall through */ }
+    }
+    const defaults = buildDefaultConfig();
+    return {
+        ...defaults,
+        mcpServers: {},
+        presets: DEFAULT_PRESETS.map(p => ({ ...p })),
+        default: 'opus-high',
+        maintenance: { ...DEFAULT_MAINTENANCE },
+        agentMaintenance: { enabled: true, interval: '1h' },
+        trajectory: { enabled: true },
+        bridge: {},
+    };
+}
+/**
+ * Atomically save the agent section in mixdog-config.json. Caller passes the
+ * full config object. Only persists mcpServers, presets, default, and user-set
+ * provider entries (enabled, baseURL) — defaults are recomputed on next load.
+ * apiKey is NEVER persisted: provider keys live only in the OS keychain, and
+ * loadConfig overlays them into memory, so they must be stripped on save or
+ * they would leak back into mixdog-config.json as plaintext.
+ *
+ * WARNING: whole-section overwrite. Managed fields (presets/default/mcpServers/
+ * maintenance/...) are replaced from the passed snapshot (last-writer-wins);
+ * only unmanaged keys are rebased on the in-lock current. Safe only for a
+ * caller holding a fresh full config. For a single-field change, patch in-lock
+ * via persistAgentConfig((current) => ({ ...current, <field> })) — see
+ * setDefaultPreset — so a concurrent instance's edits are not reverted.
+ */
+export function saveConfig(config) {
+    // Strip ephemeral defaults from providers but preserve any unknown
+    // per-provider subkey so future schema additions round-trip through the
+    // setup UI without changes here. apiKey is intentionally omitted —
+    // provider keys are keychain-only (loadConfig overlays them into memory;
+    // persisting would leak plaintext back into mixdog-config.json). It stays
+    // in KNOWN_PROVIDER_KEYS so the generic passthrough loop also skips it.
+    const KNOWN_PROVIDER_KEYS = new Set(['apiKey', 'enabled', 'baseURL']);
+    const persistedProviders = {};
+    if (config.providers) {
+        for (const [name, val] of Object.entries(config.providers)) {
+            if (!val || typeof val !== 'object') continue;
+            const slim = {};
+            if (typeof val.enabled === 'boolean') slim.enabled = val.enabled;
+            if (val.baseURL) slim.baseURL = val.baseURL;
+            for (const [k, v] of Object.entries(val)) {
+                if (KNOWN_PROVIDER_KEYS.has(k)) continue;
+                if (v === undefined) continue;
+                slim[k] = v;
+            }
+            if (Object.keys(slim).length)
+                persistedProviders[name] = slim;
+        }
+    }
+    // Build the replacement from `existingRaw` — the section read INSIDE the
+    // file lock — not a snapshot taken before it, so unmanaged keys written by
+    // a concurrent instance survive the save (lost-update guard).
+    persistAgentConfig((existingRaw) => ({
+        ...existingRaw,
+        guide: config.guide || existingRaw.guide || undefined,
+        providers: persistedProviders,
+        mcpServers: config.mcpServers || {},
+        presets: Array.isArray(config.presets) ? config.presets : [],
+        default: config.default || null,
+        maintenance: config.maintenance || {},
+        agentMaintenance: config.agentMaintenance || {},
+        trajectory: config.trajectory || {},
+        bridge: config.bridge || {},
+    }));
+}
+// --- Preset helpers ---
+// preset shape: { id, name, type: 'bridge', provider, model, effort?, fast?, tools? }
+const AGENT_PROVIDER_ALIASES = Object.freeze({
+    'openai-api': 'openai',
+    'gemini-api': 'gemini',
+    'xai-api': 'xai',
+});
+const FAST_CAPABLE_PRESET_PROVIDERS = new Set([
+    'anthropic',
+    'anthropic-oauth',
+    'openai',
+    'openai-oauth',
+]);
+function normalizeAgentProviderId(provider) {
+    const id = String(provider || '').trim();
+    return AGENT_PROVIDER_ALIASES[id] || id;
+}
+function presetKey(p) { return p?.id || p?.name || ''; }
+function normalizePreset(preset) {
+    if (!preset || typeof preset !== 'object')
+        return null;
+    const id = String(preset.id || preset.name || '').trim();
+    const name = String(preset.name || preset.id || '').trim();
+    const model = String(preset.model || '').trim();
+    const provider = normalizeAgentProviderId(preset.provider);
+    if (!name || !model || !provider) return null;
+    const out = { id, name, type: 'bridge', provider, model };
+    if (preset.effort)
+        out.effort = String(preset.effort).trim();
+    if (preset.fast === true && FAST_CAPABLE_PRESET_PROVIDERS.has(provider))
+        out.fast = true;
+    out.tools = ['full', 'readonly', 'mcp'].includes(preset.tools) ? preset.tools : 'full';
+    return out;
+}
+export function getPreset(config, key) {
+    const presets = Array.isArray(config?.presets) ? config.presets : [];
+    if (key == null || key === '')
+        return null;
+    // Numeric → index
+    if (typeof key === 'number' || /^\d+$/.test(String(key))) {
+        const idx = Number(key);
+        return presets[idx] || null;
+    }
+    // String → name or id match
+    return presets.find(p => p && presetKey(p) === key) || null;
+}
+export function getDefaultPreset(config) {
+    if (!config?.default)
+        return null;
+    return getPreset(config, config.default);
+}
+export function listPresets(config) {
+    return Array.isArray(config?.presets) ? config.presets : [];
+}
+// --- Lane-scoped runtime spec ---
+// Phase D-2: scopeKey is (role, provider, model), not (role, preset). Spec
+// §4.5 calls for "at most one live session per Sub role × provider"; we
+// widen provider to (provider, model) because two presets on the same
+// provider that differ only in effort/fast should keep sharing a session
+// (both cache shards are identical there), while swapping the model itself
+// legitimately needs a fresh session (cache shard is model-specific). Two
+// presets mapping to the same (provider, model) therefore collapse into
+// one Bridge session, so opus-mid / opus-max no longer fragment the pool.
+//
+//   bridge lane: "bridge:<agentId>:<provider>:<model>"  — per Sub role
+//   other lane:  "bridge:<provider>:<model>"            — shared utility
+export function resolveRuntimeSpec(preset, ctx) {
+    const lane = ctx.lane || 'bridge';
+    const provider = String(preset?.provider || '').trim() || 'unknown';
+    const model = String(preset?.model || '').trim() || '_';
+    let scopeKey;
+    if (lane === 'bridge') {
+        if (!ctx.agentId) throw new Error('bridge lane requires agentId');
+        scopeKey = `bridge:${ctx.agentId}:${provider}:${model}`;
+    } else {
+        scopeKey = `bridge:${provider}:${model}`;
+    }
+    return { lane, scopeKey, reuse: true, preset };
+}
+
+export function setDefaultPreset(config, key) {
+    const preset = getPreset(config, key);
+    if (!preset)
+        throw new Error(`preset "${key}" not found`);
+    const nextDefault = presetKey(preset);
+    // Patch only `default` under the file lock. saveConfig(config) would
+    // rewrite the whole agent section from this possibly-stale snapshot and
+    // could revert a concurrent instance's preset edits; an in-lock single
+    // field patch cannot.
+    persistAgentConfig((current) => ({ ...current, default: nextDefault }));
+    config.default = nextDefault;
+    return preset;
+}