mixdog 0.9.2 → 0.9.4

package/src/session-runtime/settings-api.mjs

@@ -0,0 +1,319 @@
+// settings-api.mjs — pure settings delegate methods extracted from the main
+// runtime API object in mixdog-session-runtime.mjs. These are the small
+// config/settings members with NO heavy closure deps beyond the injected
+// helpers; the returned object is SPREAD into the facade's API object so the
+// external surface stays byte-identical. Methods that reference `this.*`
+// resolve against the spread target, so cross-member calls (e.g.
+// setProfile -> this.getProfile) keep working when spread into the facade.
+
+export function createSettingsApi({
+  // config accessors / mutable state
+  getConfig,
+  getRoute,
+  getSession,
+  getRemoteEnabled,
+  // config-lifecycle
+  saveConfigAndAdopt,
+  scheduleBackendSave,
+  // normalizers / helpers
+  cfgMod,
+  hasOwn,
+  normalizeAutoClearConfig,
+  autoClearIdleMsForProvider,
+  normalizeCompactionConfig,
+  normalizeCompactTypeSetting,
+  normalizeSystemShellConfig,
+  normalizeSystemShellCommand,
+  setConfiguredShell,
+  setRecapEnabledInConfig,
+  setModuleEnabledInConfig,
+  summarizeWorkflowRoutes,
+  parseDurationMs,
+  formatDurationMs,
+  localPackageVersion,
+  // state getters / feature flags
+  memoryEnabled,
+  recapEnabledFn,
+  channelsEnabled,
+  autoUpdateEnabled,
+  getUpdateCheckState,
+  getUpdateProcessState,
+  // side-effect callbacks
+  invalidateContextStatusCache,
+  invalidatePreSessionToolSurface,
+  scheduleChannelStart,
+  channels,
+  clearChannelStartTimer,
+  checkForUpdateInternal,
+  runUpdateNowInternal,
+  reloadChannelsSoon,
+  ONBOARDING_VERSION,
+  // channel-admin token delegates
+  saveDiscordToken,
+  forgetDiscordToken,
+  saveTelegramToken,
+  forgetTelegramToken,
+  saveWebhookAuthtoken,
+  forgetWebhookAuthtoken,
+  setBackend,
+}) {
+  return {
+    getOnboardingStatus() {
+      const nextConfig = getConfig();
+      return {
+        completed: nextConfig?.onboarding?.completed === true,
+        version: nextConfig?.onboarding?.version || 0,
+        default: nextConfig?.default || null,
+        workflowRoutes: summarizeWorkflowRoutes(nextConfig),
+      };
+    },
+    // Mark onboarding as done WITHOUT touching routes/agents/provider. Used by
+    // the TUI "skip" (Esc) path so the wizard doesn't reappear next launch,
+    // while leaving any existing config routes untouched.
+    skipOnboarding() {
+      const config = getConfig();
+      const nextConfig = { ...config };
+      nextConfig.onboarding = {
+        ...(nextConfig.onboarding || {}),
+        completed: true,
+        version: ONBOARDING_VERSION,
+        completedAt: new Date().toISOString(),
+        skipped: true,
+      };
+      saveConfigAndAdopt(nextConfig);
+      return this.getOnboardingStatus();
+    },
+    getAutoClear() {
+      const config = getConfig();
+      const route = getRoute();
+      const normalized = normalizeAutoClearConfig(config.autoClear);
+      const provider = route?.provider || null;
+      const providerDefault = autoClearIdleMsForProvider(provider);
+      const idleMs = normalized.custom ? normalized.idleMs : providerDefault;
+      return {
+        enabled: normalized.enabled,
+        idleMs,
+        custom: normalized.custom,
+        providerDefault,
+        provider,
+      };
+    },
+    // --- User profile (/profile statusline command) ---------------------
+    // getProfile returns the normalized { title, language } plus the resolved
+    // language catalog entry and the full language list for the picker UI.
+    getProfile() {
+      const config = getConfig();
+      const profile = cfgMod.normalizeProfileConfig(config.profile);
+      return {
+        ...profile,
+        languageEntry: cfgMod.profileLanguageEntry(profile.language),
+        languages: cfgMod.PROFILE_LANGUAGES,
+      };
+    },
+    // setProfile patches title and/or language and persists. Unknown language
+    // ids normalize back to 'system'. Prompt-side injection is wired separately
+    // (composeSystemPrompt) — this only owns the stored value.
+    setProfile(input = {}) {
+      const config = getConfig();
+      const current = cfgMod.normalizeProfileConfig(config.profile);
+      const next = { ...current };
+      if (hasOwn(input, 'title') || hasOwn(input, 'name')) {
+        next.title = input.title ?? input.name ?? '';
+      }
+      if (hasOwn(input, 'language') || hasOwn(input, 'lang')) {
+        next.language = input.language ?? input.lang ?? 'system';
+      }
+      const normalized = cfgMod.normalizeProfileConfig(next);
+      saveConfigAndAdopt({ ...config, profile: normalized });
+      return this.getProfile();
+    },
+    getCompactionSettings() {
+      const config = getConfig();
+      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    setCompactionSettings(input = {}) {
+      const config = getConfig();
+      const current = normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+      const next = { ...current };
+      if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
+      if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
+      if (hasOwn(input, 'type') || hasOwn(input, 'compactType') || hasOwn(input, 'compact_type')) {
+        const requestedType = input.type ?? input.compactType ?? input.compact_type;
+        const compactType = normalizeCompactTypeSetting(requestedType, current.compactType || current.type || 'semantic');
+        next.type = compactType;
+        next.compactType = compactType;
+      }
+      const nextConfig = { ...config };
+      nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
+      saveConfigAndAdopt(nextConfig);
+      const config2 = getConfig();
+      const session = getSession();
+      if (session) {
+        session.compaction = {
+          ...(session.compaction || {}),
+          ...normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() }),
+        };
+      }
+      invalidateContextStatusCache();
+      return normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    // Recap toggle: user-facing switch that gates ONLY the background memory
+    // cycles (1/2/3). The memory module (transcript watcher/ingest, on-demand
+    // recall/fasttrack drains) is always-on. Persisted via the same
+    // saveConfigAndAdopt path as compaction/autoClear. The memory daemon
+    // re-reads recap from the agent config section each cycle tick, so toggling
+    // takes effect without a restart (no memory-service stop/start here).
+    getRecapSettings() {
+      return { enabled: recapEnabledFn() };
+    },
+    setRecapEnabled(enabled) {
+      const config = getConfig();
+      const nextConfig = setRecapEnabledInConfig({ ...config }, enabled !== false);
+      saveConfigAndAdopt(nextConfig);
+      invalidatePreSessionToolSurface();
+      invalidateContextStatusCache();
+      return this.getRecapSettings();
+    },
+    // Thin aliases kept for the current TUI callsites (updated separately).
+    // enabled here reflects the recap toggle; memory itself is always-on.
+    getMemorySettings() {
+      return {
+        enabled: recapEnabledFn(),
+        compactFastTrackAvailable: true,
+      };
+    },
+    async setMemoryEnabled(enabled) {
+      return this.setRecapEnabled(enabled);
+    },
+    getChannelSettings(options = {}) {
+      return {
+        enabled: channelsEnabled(),
+        ...(options?.includeStatus === false ? {} : { status: channels.status() }),
+      };
+    },
+    async setChannelsEnabled(enabled) {
+      const config = getConfig();
+      const nextConfig = setModuleEnabledInConfig({ ...config }, 'channels', enabled !== false);
+      saveConfigAndAdopt(nextConfig);
+      if (!channelsEnabled()) {
+        clearChannelStartTimer();
+        await channels.stop('settings-disabled', { waitForExit: false }).catch(() => {});
+      } else {
+        // Enabling channels in settings only boots the worker when this session
+        // is in remote mode; otherwise the toggle just persists config.
+        if (getRemoteEnabled()) scheduleChannelStart(0);
+      }
+      invalidatePreSessionToolSurface();
+      return this.getChannelSettings();
+    },
+    getSystemShell() {
+      const config = getConfig();
+      return normalizeSystemShellConfig(config.shell);
+    },
+    setSystemShell(input = {}) {
+      const config = getConfig();
+      const command = normalizeSystemShellCommand(typeof input === 'string' ? input : input?.command);
+      saveConfigAndAdopt({
+        ...config,
+        shell: command ? { ...(config.shell || {}), command } : {},
+      });
+      setConfiguredShell(command);
+      return normalizeSystemShellConfig(getConfig().shell);
+    },
+    setAutoClear(input = {}) {
+      const config = getConfig();
+      const current = normalizeAutoClearConfig(config.autoClear);
+      const next = { ...current };
+      if (hasOwn(input, 'enabled')) next.enabled = input.enabled !== false;
+      if (input.reset === true || (hasOwn(input, 'idleMs') && input.idleMs == null)) {
+        next.idleMs = null;
+      } else if (hasOwn(input, 'idleMs')) {
+        const idleMs = Number(input.idleMs);
+        if (!Number.isFinite(idleMs) || idleMs <= 0) throw new Error('autoclear idleMs must be a positive number');
+        next.idleMs = Math.max(60_000, Math.round(idleMs));
+      }
+      if (hasOwn(input, 'duration')) {
+        const idleMs = parseDurationMs(input.duration);
+        if (!idleMs) throw new Error('usage: /autoclear [on|off|status|<minutes|1h|90m>]');
+        next.idleMs = idleMs;
+        if (!hasOwn(input, 'enabled')) next.enabled = true;
+      }
+      saveConfigAndAdopt({ ...config, autoClear: next });
+      const resolved = this.getAutoClear();
+      return { ...resolved, label: formatDurationMs(resolved.idleMs) };
+    },
+    getUpdateSettings() {
+      const updateCheckState = getUpdateCheckState();
+      return {
+        autoUpdate: autoUpdateEnabled(),
+        currentVersion: updateCheckState.currentVersion || localPackageVersion(),
+        latestVersion: updateCheckState.latestVersion,
+        updateAvailable: updateCheckState.updateAvailable,
+        lastCheckedAt: updateCheckState.lastCheckedAt,
+      };
+    },
+    setAutoUpdate(enabled) {
+      const config = getConfig();
+      saveConfigAndAdopt({
+        ...config,
+        update: { ...(config.update || {}), auto: enabled === true },
+      });
+      return this.getUpdateSettings();
+    },
+    async checkForUpdate(options = {}) {
+      await checkForUpdateInternal({ force: options?.force === true });
+      return this.getUpdateSettings();
+    },
+    async runUpdateNow() {
+      const state = await runUpdateNowInternal();
+      return { ok: state.phase === 'installed', ...state };
+    },
+    getUpdateStatus() {
+      return { ...getUpdateProcessState() };
+    },
+    saveDiscordToken(token) {
+      const result = saveDiscordToken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetDiscordToken() {
+      const result = forgetDiscordToken();
+      reloadChannelsSoon();
+      return result;
+    },
+    saveTelegramToken(token) {
+      const result = saveTelegramToken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetTelegramToken() {
+      const result = forgetTelegramToken();
+      reloadChannelsSoon();
+      return result;
+    },
+    setBackend(name) {
+      // Validate synchronously (same contract as before: bad input throws on
+      // this call so the TUI's try/catch can react immediately). The actual
+      // channels-section file read-modify-write is the hitch source on the
+      // settings-toggle key handler, so defer it through the same debounce
+      // pattern as saveConfigAndAdopt/flushConfigSave instead of writing to
+      // disk synchronously inside the key handler.
+      const value = String(name || '').trim();
+      if (value !== 'discord' && value !== 'telegram') {
+        throw new Error('backend must be discord or telegram');
+      }
+      scheduleBackendSave(value);
+      return { ok: true, backend: value };
+    },
+    saveWebhookAuthtoken(token) {
+      const result = saveWebhookAuthtoken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetWebhookAuthtoken() {
+      const result = forgetWebhookAuthtoken();
+      reloadChannelsSoon();
+      return result;
+    },
+  };
+}

package/src/session-runtime/statusline-route.mjs

@@ -0,0 +1,35 @@
+// Statusline route serialization. Pure helpers.
+import { clean, hasOwn } from './session-text.mjs';
+
+export function routeForStatusline(route) {
+  const out = {
+    mode: 'fixed',
+    defaultProvider: route.provider,
+    defaultModel: route.model,
+  };
+  const preset = route.preset || {};
+  if (preset.id) out.presetId = preset.id;
+  if (preset.name) out.presetName = preset.name;
+  // Prefer the preset's curated label, then the route's resolved model display
+  // (set by refreshRouteEffort from the live/offline catalog). Without the
+  // route fallback, a preset-less direct model (e.g. claude-fable-5) reaches
+  // the statusline with no display and renders as the raw id.
+  const modelDisplay = clean(preset.modelDisplay) || clean(route.modelDisplay);
+  if (modelDisplay) out.modelDisplay = modelDisplay;
+  if (route.fast === true || route.fast === false) out.fast = route.fast;
+  else if (preset.fast === true || preset.fast === false) out.fast = preset.fast;
+  if (route.effectiveEffort) {
+    out.effort = route.effectiveEffort;
+    out.displayEffort = route.effectiveEffort;
+  } else if (hasOwn(route, 'effort')) {
+    delete out.effort;
+    delete out.displayEffort;
+  }
+  return out;
+}
+
+export function writeStatuslineRoute(statusRoutes, session, route) {
+  if (!session?.id || !route) return;
+  const clientHostPid = session?.clientHostPid || process.pid;
+  statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route), { clientHostPid });
+}