mixdog 0.9.2 → 0.9.4

package/src/session-runtime/prewarm.mjs

@@ -0,0 +1,142 @@
+// Background prewarm/start schedulers, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory: timer handles live
+// in a caller-owned `timers` object (so the facade's clearTimeout teardown
+// still sees them) and all state reads go through supplied accessors. Byte-for-
+// byte identical behavior; only grouping changes.
+import { performance } from 'node:perf_hooks';
+
+export function createPrewarmSchedulers({
+  timers,
+  bootProfile,
+  getCurrentCwd,
+  isCloseRequested,
+  getActiveTurnCount,
+  getSessionCreatePromise,
+  getSession,
+  isRemoteEnabled,
+  channelsEnabled,
+  getCodeGraphModule,
+  createCurrentSession,
+  channels,
+  envFlag,
+  delays,
+  flags,
+  state,
+}) {
+  const { codeGraphPrewarmDelayMs, channelStartDelayMs, sessionPrewarmDelayMs, backgroundBusyRetryMs } = delays;
+  const { codeGraphPrewarmEnabled, sessionPrewarmEnabled } = flags;
+
+  function scheduleCodeGraphPrewarm(delayMs = codeGraphPrewarmDelayMs, reason = 'cwd') {
+    if (!codeGraphPrewarmEnabled) {
+      bootProfile('code-graph:prewarm-skipped', { reason: 'disabled' });
+      return;
+    }
+    if (isCloseRequested()) return;
+    state.codeGraphPrewarmQueuedCwd = getCurrentCwd();
+    if (timers.codeGraphPrewarmTimer) return;
+    timers.codeGraphPrewarmTimer = setTimeout(() => {
+      timers.codeGraphPrewarmTimer = null;
+      if (isCloseRequested()) return;
+      if (getActiveTurnCount() > 0 || getSessionCreatePromise()) {
+        bootProfile('code-graph:prewarm-deferred', { reason: getActiveTurnCount() > 0 ? 'turn-active' : 'session-create' });
+        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'busy');
+        return;
+      }
+      if (state.codeGraphPrewarmInFlight) {
+        bootProfile('code-graph:prewarm-deferred', { reason: 'in-flight' });
+        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'in-flight');
+        return;
+      }
+      const prewarmCwd = state.codeGraphPrewarmQueuedCwd || getCurrentCwd();
+      state.codeGraphPrewarmQueuedCwd = '';
+      state.codeGraphPrewarmInFlight = true;
+      const startedAt = performance.now();
+      bootProfile('code-graph:prewarm:start', { cwd: prewarmCwd, reason });
+      void getCodeGraphModule()
+        .then((mod) => {
+          if (typeof mod?.prewarmCodeGraphIfProject !== 'function') return false;
+          return mod.prewarmCodeGraphIfProject(prewarmCwd);
+        })
+        .then((scheduled) => bootProfile(scheduled ? 'code-graph:prewarm:scheduled' : 'code-graph:prewarm:no-project', {
+          cwd: prewarmCwd,
+          ms: (performance.now() - startedAt).toFixed(1),
+        }))
+        .catch((error) => bootProfile('code-graph:prewarm:failed', {
+          cwd: prewarmCwd,
+          ms: (performance.now() - startedAt).toFixed(1),
+          error: error?.message || String(error),
+        }))
+        .finally(() => {
+          state.codeGraphPrewarmInFlight = false;
+          if (state.codeGraphPrewarmQueuedCwd && !isCloseRequested()) {
+            scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'queued');
+          }
+        });
+    }, delayMs);
+    timers.codeGraphPrewarmTimer.unref?.();
+  }
+
+  function scheduleLeadSessionPrewarm() {
+    if (!sessionPrewarmEnabled) {
+      bootProfile('session:prewarm-skipped');
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (isCloseRequested() || getSession()?.id || getSessionCreatePromise() || getActiveTurnCount() > 0) return;
+      void createCurrentSession('prewarm')
+        .then(() => bootProfile('session:prewarm:ready'))
+        .catch((error) => bootProfile('session:prewarm:failed', { error: error?.message || String(error) }));
+    }, sessionPrewarmDelayMs);
+    timer.unref?.();
+  }
+
+  function invokeChannelStart() {
+    if (state.channelStartPromise) return state.channelStartPromise;
+    const startedAt = performance.now();
+    bootProfile('channels:start:begin');
+    state.channelStartPromise = channels.start()
+      .then(() => bootProfile('channels:start:ready', { ms: (performance.now() - startedAt).toFixed(1) }))
+      .catch((error) => bootProfile('channels:start:failed', {
+        ms: (performance.now() - startedAt).toFixed(1),
+        error: error?.message || String(error),
+      }))
+      .finally(() => {
+        state.channelStartPromise = null;
+      });
+    return state.channelStartPromise;
+  }
+
+  function scheduleChannelStart(delayMs = channelStartDelayMs) {
+    if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
+      bootProfile('channels:start-skipped');
+      return;
+    }
+    if (!channelsEnabled()) {
+      bootProfile('channels:start-disabled');
+      return;
+    }
+    if (timers.channelStartTimer || state.channelStartPromise || isCloseRequested()) return;
+    bootProfile('channels:start-scheduled', { delayMs });
+    timers.channelStartTimer = setTimeout(() => {
+      timers.channelStartTimer = null;
+      if (isCloseRequested()) return;
+      // A deferred start may straddle a stopRemote(); re-check before booting so
+      // a turned-off session neither starts channels nor keeps rescheduling.
+      if (!isRemoteEnabled()) return;
+      if (getActiveTurnCount() > 0 || getSessionCreatePromise()) {
+        bootProfile('channels:start-deferred', { reason: getActiveTurnCount() > 0 ? 'turn-active' : 'session-create' });
+        scheduleChannelStart(backgroundBusyRetryMs);
+        return;
+      }
+      void invokeChannelStart();
+    }, delayMs);
+    timers.channelStartTimer.unref?.();
+  }
+
+  return {
+    scheduleCodeGraphPrewarm,
+    scheduleLeadSessionPrewarm,
+    invokeChannelStart,
+    scheduleChannelStart,
+  };
+}

package/src/session-runtime/provider-models.mjs

@@ -0,0 +1,278 @@
+// Provider/search model catalog + cache glue, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory following the
+// createWarmupSchedulers/createNativeSearch pattern: mutable cache state lives
+// in a caller-owned `caches` object (so the facade's invalidateProviderCaches
+// teardown still sees the same references) and all route/config/registry reads
+// go through supplied accessors so live-binding is preserved (no stale
+// snapshot of route/config/searchRoute).
+import { clean } from './session-text.mjs';
+import { effortItemsFor } from './effort.mjs';
+import { fastCapableFor, fastPreferenceFor } from './model-capabilities.mjs';
+import { modelSettingsFor } from './config-helpers.mjs';
+import { isSelectableLlmModel } from './model-recency.mjs';
+
+export function createProviderModels({
+  caches,
+  modelMetaByRoute,
+  getRoute,
+  getConfig,
+  getReg,
+  searchCapableFor,
+  sortProviderModelsRaw,
+  providerModelCacheRowRaw,
+  normalizeSearchProviderId,
+  isSearchCapableProvider,
+  ensureFullConfig,
+  ensureProvidersReady,
+  bootProfile,
+  scheduleProviderModelWarmup,
+  // Quick-row helpers wired in after createQuickModelRows resolves.
+  quickHelpers,
+}) {
+  const config = () => getConfig();
+  const route = () => getRoute();
+  const reg = () => getReg();
+
+  function modelMetaKey(providerId, modelId) {
+    return `${clean(providerId)}\n${clean(modelId)}`;
+  }
+
+  async function lookupModelMeta(providerId, modelId, { allowFetch = false } = {}) {
+    const key = modelMetaKey(providerId, modelId);
+    if (modelMetaByRoute.has(key)) return modelMetaByRoute.get(key);
+    const providerImpl = reg().getProvider(providerId);
+    if (!providerImpl || typeof providerImpl.listModels !== 'function') {
+      const fallback = { id: modelId, provider: providerId };
+      modelMetaByRoute.set(key, fallback);
+      return fallback;
+    }
+    if (typeof providerImpl.getCachedModelInfo === 'function') {
+      const cached = providerImpl.getCachedModelInfo(modelId);
+      if (cached) {
+        const meta = { ...cached, id: cached.id || modelId, provider: providerId };
+        modelMetaByRoute.set(key, meta);
+        return meta;
+      }
+    }
+    if (!allowFetch) {
+      const fallback = { id: modelId, provider: providerId };
+      modelMetaByRoute.set(key, fallback);
+      scheduleProviderModelWarmup();
+      return fallback;
+    }
+    try {
+      const models = await providerImpl.listModels();
+      const found = Array.isArray(models) ? models.find((m) => m?.id === modelId) : null;
+      const meta = found || { id: modelId, provider: providerId };
+      modelMetaByRoute.set(key, meta);
+      return meta;
+    } catch {
+      const fallback = { id: modelId, provider: providerId };
+      modelMetaByRoute.set(key, fallback);
+      return fallback;
+    }
+  }
+
+  function hydrateProviderModelRow(row) {
+    const cfg = config();
+    return {
+      ...row,
+      effortOptions: effortItemsFor(row.provider, row, null),
+      fastCapable: fastCapableFor(row.provider, row),
+      fastPreferred: fastPreferenceFor(cfg, row.provider, row.id),
+      savedEffort: modelSettingsFor(cfg, row.provider, row.id).effort || null,
+      savedFast: modelSettingsFor(cfg, row.provider, row.id).fast === true,
+    };
+  }
+
+  const sortProviderModels = (models) => sortProviderModelsRaw(models, route().provider);
+  const providerModelCacheRow = (name, m) => providerModelCacheRowRaw(name, m, searchCapableFor);
+
+  function providerModelsFromCacheRows(rows) {
+    return sortProviderModels((rows || []).map(hydrateProviderModelRow));
+  }
+
+  function enabledSearchProviderConfig() {
+    ensureFullConfig();
+    const out = {};
+    for (const [name, providerConfig] of Object.entries(config().providers || {})) {
+      const providerName = normalizeSearchProviderId(name);
+      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
+      out[providerName] = { ...providerConfig, enabled: true };
+    }
+    return out;
+  }
+
+  async function loadSearchProviderModelsFresh({ forceRefresh = false } = {}) {
+    const searchProviders = enabledSearchProviderConfig();
+    const providerNames = Object.keys(searchProviders);
+    if (!providerNames.length) return [];
+    await ensureProvidersReady(config().providers || {});
+    const providerResults = await Promise.all(providerNames.map(async (name) => {
+      const provider = reg().getProvider(name);
+      if (typeof provider?.listModels !== 'function') return [];
+      try {
+        let models = null;
+        if (forceRefresh && typeof provider._refreshModelCache === 'function') {
+          models = await provider._refreshModelCache();
+        }
+        if (!Array.isArray(models)) {
+          models = await provider.listModels();
+        }
+        if (!Array.isArray(models)) return [];
+        const rows = [];
+        for (const m of models) {
+          if (!m?.id || !isSelectableLlmModel(m)) continue;
+          const row = providerModelCacheRow(name, m);
+          if (row.supportsWebSearch !== true) continue;
+          rows.push({
+            ...row,
+            provider: normalizeSearchProviderId(row.provider),
+            searchCapable: true,
+            searchToolType: row.searchToolType || 'web_search',
+          });
+          modelMetaByRoute.set(modelMetaKey(name, m.id), row);
+        }
+        return rows;
+      } catch {
+        // Keep the picker responsive if one search-capable provider has a
+        // transient catalog/auth failure.
+        return [];
+      }
+    }));
+    const results = [];
+    const seen = new Set();
+    quickHelpers.addDefaultSearchModel(results, seen);
+    for (const row of providerResults.flat()) {
+      const key = `${normalizeSearchProviderId(row.provider)}:${row.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(row);
+    }
+    return results;
+  }
+
+  async function loadProviderModelsFresh({ forceRefresh = false } = {}) {
+    ensureFullConfig();
+    await ensureProvidersReady(config().providers || {});
+    const allProviders = [...reg().getAllProviders()];
+    const providerResults = await Promise.all(allProviders.map(async ([name, provider]) => {
+      if (typeof provider?.listModels !== 'function') return [];
+      try {
+        let models = null;
+        if (forceRefresh && typeof provider._refreshModelCache === 'function') {
+          models = await provider._refreshModelCache();
+        }
+        if (!Array.isArray(models)) {
+          models = await provider.listModels();
+        }
+        if (!Array.isArray(models)) return [];
+        const rows = [];
+        for (const m of models) {
+          if (!m?.id) continue;
+          if (!isSelectableLlmModel(m)) continue;
+          rows.push(providerModelCacheRow(name, m));
+        }
+        return rows;
+      } catch {
+        // Ignore per-provider catalog failures so one bad credential or
+        // transient /models error does not hide other authenticated models.
+        return [];
+      }
+    }));
+    const results = [];
+    const seen = new Set();
+    for (const row of providerResults.flat()) {
+      const key = `${row.provider}:${row.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(row);
+      modelMetaByRoute.set(modelMetaKey(row.provider, row.id), row);
+    }
+    return results;
+  }
+
+  async function collectSearchProviderModels({ force = false } = {}) {
+    if (!force && Array.isArray(caches.searchProviderModelsCache.models)) {
+      return providerModelsFromCacheRows(quickHelpers.searchRowsWithDefault(caches.searchProviderModelsCache.models));
+    }
+    if (!force && Array.isArray(caches.providerModelsCache.models)) {
+      const rows = quickHelpers.searchRowsWithDefault(quickHelpers.searchModelsFromRows(caches.providerModelsCache.models));
+      caches.searchProviderModelsCache = { models: rows, at: Date.now() };
+      return providerModelsFromCacheRows(rows);
+    }
+    if (!force) {
+      const rows = quickHelpers.searchRowsWithDefault(quickHelpers.quickSearchProviderModelRows());
+      caches.searchProviderModelsCache = { models: rows, at: Date.now() };
+      return providerModelsFromCacheRows(rows);
+    }
+    if (force) {
+      const models = await loadSearchProviderModelsFresh({ forceRefresh: true });
+      caches.searchProviderModelsCache = { models, at: Date.now() };
+      return providerModelsFromCacheRows(models);
+    }
+  }
+
+  async function collectProviderModels({ force = false, quick = false } = {}) {
+    if (!force && Array.isArray(caches.providerModelsCache.models)) {
+      return providerModelsFromCacheRows(caches.providerModelsCache.models);
+    }
+    if (!force && quick) {
+      warmProviderModelCache();
+      return quickHelpers.quickProviderModelRows();
+    }
+    if (force) {
+      const seq = ++caches.providerModelsLoadSeq;
+      const models = await loadProviderModelsFresh({ forceRefresh: true });
+      if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
+      return providerModelsFromCacheRows(models);
+    }
+    if (!caches.providerModelsPromise) {
+      const seq = ++caches.providerModelsLoadSeq;
+      caches.providerModelsPromise = loadProviderModelsFresh()
+        .then((models) => {
+          if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
+          return models;
+        })
+        .finally(() => {
+          caches.providerModelsPromise = null;
+        });
+    }
+    return providerModelsFromCacheRows(await caches.providerModelsPromise);
+  }
+
+  function warmProviderModelCache() {
+    if (Array.isArray(caches.providerModelsCache.models) || caches.providerModelsPromise) return caches.providerModelsPromise;
+    const seq = ++caches.providerModelsLoadSeq;
+    caches.providerModelsPromise = loadProviderModelsFresh()
+      .then((models) => {
+        if (seq === caches.providerModelsLoadSeq) caches.providerModelsCache = { models, at: Date.now() };
+        bootProfile('provider-models:warm-ready', { count: models.length });
+        return models;
+      })
+      .catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        bootProfile('provider-models:warm-failed', { error: msg });
+        return [];
+      })
+      .finally(() => {
+        caches.providerModelsPromise = null;
+      });
+    return caches.providerModelsPromise;
+  }
+
+  return {
+    modelMetaKey,
+    lookupModelMeta,
+    hydrateProviderModelRow,
+    sortProviderModels,
+    providerModelCacheRow,
+    providerModelsFromCacheRows,
+    enabledSearchProviderConfig,
+    loadSearchProviderModelsFresh,
+    loadProviderModelsFresh,
+    collectSearchProviderModels,
+    collectProviderModels,
+    warmProviderModelCache,
+  };
+}

package/src/session-runtime/provider-usage.mjs

@@ -0,0 +1,120 @@
+// Provider-setup snapshot + usage-dashboard cache glue, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory following the same
+// pattern as createProviderModels: mutable cache state lives in a caller-owned
+// `caches` object (so invalidateProviderCaches still resets the same
+// references) and all config/registry reads flow through supplied accessors so
+// live-binding is preserved.
+import { clean } from './session-text.mjs';
+
+export function createProviderUsage({
+  caches,
+  getConfig,
+  getReg,
+  displayConfig,
+  providerSetup,
+  createUsageDashboard,
+  fetchOAuthUsageSnapshot,
+  isCloseRequested,
+  getProviderSetupWarmupTimer,
+  scheduleProviderSetupWarmup,
+}) {
+  const reg = () => getReg();
+
+  function refreshStatuslineUsageSnapshot(routeLike = {}) {
+    const providerId = clean(routeLike.provider);
+    const modelId = clean(routeLike.model);
+    if (!providerId || !providerId.includes('oauth')) return;
+    const providerObj = reg().getProvider(providerId);
+    if (!providerObj) return;
+    void fetchOAuthUsageSnapshot({ provider: providerId, model: modelId }, providerObj, (message) => {
+      if (process.env.MIXDOG_STATUSLINE_TRACE) {
+        try { process.stderr.write(`[statusline] ${message}\n`); } catch {}
+      }
+    }).catch(() => {});
+  }
+
+  async function cachedProviderSetup({ force = false, quick = false } = {}) {
+    if (!force && caches.providerSetupCache.setup) {
+      return caches.providerSetupCache.setup;
+    }
+    if (quick) {
+      if (!force && caches.providerSetupQuickCache.setup) {
+        return caches.providerSetupQuickCache.setup;
+      }
+      const setup = await providerSetup(displayConfig(), { detectLocal: false, checkSecrets: false });
+      caches.providerSetupQuickCache = { setup, at: Date.now() };
+      if (!caches.providerSetupPromise && !getProviderSetupWarmupTimer() && !isCloseRequested()) {
+        scheduleProviderSetupWarmup(0);
+      }
+      return setup;
+    }
+    if (caches.providerSetupPromise) return await caches.providerSetupPromise;
+    caches.providerSetupPromise = providerSetup(displayConfig(), { detectLocal: true })
+      .then((setup) => {
+        caches.providerSetupCache = { setup, at: Date.now() };
+        return setup;
+      })
+      .finally(() => {
+        caches.providerSetupPromise = null;
+      });
+    return await caches.providerSetupPromise;
+  }
+
+  async function getUsageDashboard(options = {}) {
+    const forceSetup = options?.force === true || options?.refresh === true;
+    if (!forceSetup && caches.usageDashboardCache.dashboard) {
+      const cached = {
+        ...caches.usageDashboardCache.dashboard,
+        refresh: false,
+        checking: false,
+        cached: true,
+        cachedAt: caches.usageDashboardCache.at,
+      };
+      if (typeof options?.onUpdate === 'function') {
+        try { options.onUpdate(cached); } catch {}
+      }
+      return cached;
+    }
+    if (!forceSetup && caches.usageDashboardPromise) return await caches.usageDashboardPromise;
+    const quickSetup = options?.quickSetup !== false;
+    const getProvider = (providerId) => reg().getProvider(providerId);
+    const log = (message) => {
+      if (process.env.MIXDOG_USAGE_TRACE) {
+        try { process.stderr.write(`[usage] ${message}\n`); } catch {}
+      }
+    };
+    if (quickSetup && typeof options?.onUpdate === 'function') {
+      const previewConfig = displayConfig();
+      const previewSetup = await cachedProviderSetup({ force: false, quick: true });
+      await createUsageDashboard(previewConfig, {
+        ...(options || {}),
+        preview: true,
+        setup: previewSetup,
+        getProvider,
+        log,
+      });
+    }
+    const buildDashboard = async () => {
+      const dashboard = await createUsageDashboard(displayConfig(), {
+        ...(options || {}),
+        setup: await cachedProviderSetup({ force: forceSetup, quick: false }),
+        getProvider,
+        log,
+      });
+      caches.usageDashboardCache = { dashboard, at: Date.now() };
+      return dashboard;
+    };
+    if (forceSetup) return await buildDashboard();
+    caches.usageDashboardPromise = buildDashboard()
+      .finally(() => {
+        caches.usageDashboardPromise = null;
+      });
+    return await caches.usageDashboardPromise;
+  }
+
+  return {
+    refreshStatuslineUsageSnapshot,
+    cachedProviderSetup,
+    getUsageDashboard,
+  };
+}