mixdog 0.9.1 → 0.9.3

package/src/runtime/shared/transcript-writer.mjs

@@ -0,0 +1,156 @@
+/**
+ * Transcript writer for remote (Discord) mode.
+ *
+ * The channel worker's OutputForwarder tails a newline-delimited JSON
+ * transcript and forwards the "surface" view (assistant text + one-line tool
+ * summaries) to Discord. Nothing wrote that file for standalone sessions, so
+ * remote outbound never worked. This module writes the JSONL in the exact
+ * schema the forwarder parses (see channels/lib/output-forwarder.mjs
+ * extractNewText) plus a session record the forwarder's discovery reads
+ * (channels/lib/session-discovery.mjs readSessionRecord).
+ *
+ * All writes are best-effort: a failure must never break the ask() turn. We
+ * log the FIRST occurrence of each distinct failure string to stderr (prefix
+ * `mixdog: transcript-writer: `) and suppress duplicates so a broken path
+ * cannot spam the terminal.
+ */
+import { existsSync, mkdirSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { appendBuffered, drainPathSync, hasInFlightWrite } from './buffered-appender.mjs';
+
+// Rotate the JSONL transcript once it exceeds this size, keeping one prior
+// generation (`<path>.1`). Checked on each append; the check itself is a
+// cheap statSync so no extra timer/interval is needed.
+const TRANSCRIPT_ROTATE_BYTES = 10 * 1024 * 1024;
+
+// Byte-identical to cwdToProjectSlug() in
+// src/runtime/channels/lib/session-discovery.mjs. Inlined to avoid a
+// shared -> channels import coupling; keep the two in sync if either changes.
+function cwdToProjectSlug(cwd) {
+  return resolve(cwd).replace(/\\/g, '/').replace(/^([A-Za-z]):/, '$1-').replace(/\//g, '-');
+}
+
+export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {}) {
+  if (!mixdogHome) throw new Error('transcript-writer: mixdogHome is required');
+  if (!sessionId) throw new Error('transcript-writer: sessionId is required');
+  if (!cwd) throw new Error('transcript-writer: cwd is required');
+
+  const resolvedCwd = resolve(cwd);
+  const projectDir = join(mixdogHome, 'projects', cwdToProjectSlug(resolvedCwd));
+  const transcriptPath = join(projectDir, `${sessionId}.jsonl`);
+  const sessionRecordPath = join(mixdogHome, 'sessions', `${pid ?? process.pid}.json`);
+  const startedAt = Date.now();
+
+  // Repeated-failure guard: log the first time each distinct message is seen,
+  // then stay quiet so a persistently-broken path does not flood stderr.
+  const seenErrors = new Set();
+  function logOnce(err) {
+    const msg = err && err.message ? err.message : String(err);
+    if (seenErrors.has(msg)) return;
+    seenErrors.add(msg);
+    try { process.stderr.write(`mixdog: transcript-writer: ${msg}\n`); } catch { /* stderr broken */ }
+  }
+
+  let projectDirReady = false;
+  function ensureProjectDir() {
+    if (projectDirReady) return;
+    try {
+      mkdirSync(projectDir, { recursive: true });
+      projectDirReady = true;
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function rotateIfNeeded() {
+    try {
+      if (!existsSync(transcriptPath)) return;
+      const { size } = statSync(transcriptPath);
+      if (size < TRANSCRIPT_ROTATE_BYTES) return;
+      // An async appendFile may be in flight for this path; renaming out
+      // from under it races the write on Windows. Skip this round and
+      // retry rotation on the next append instead.
+      if (hasInFlightWrite(transcriptPath)) return;
+      // Force any still-buffered bytes onto disk before renaming, so the
+      // rotated-out file ends with everything queued for it and the fresh
+      // file post-rename doesn't inherit stale in-memory chunks.
+      drainPathSync(transcriptPath);
+      const rotatedPath = `${transcriptPath}.1`;
+      try { renameSync(transcriptPath, rotatedPath); } catch (err) { logOnce(err); }
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function appendLine(entry) {
+    ensureProjectDir();
+    rotateIfNeeded();
+    try {
+      appendBuffered(transcriptPath, `${JSON.stringify(entry)}\n`);
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function writeSessionRecord() {
+    try {
+      mkdirSync(dirname(sessionRecordPath), { recursive: true });
+      writeFileSync(sessionRecordPath, JSON.stringify({
+        sessionId,
+        cwd: resolvedCwd,
+        transcriptPath,
+        startedAt,
+        updatedAt: Date.now(),
+        kind: 'interactive',
+        entrypoint: 'cli',
+      }));
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  // Refresh only the session record's updatedAt so discovery keeps ranking
+  // this session as live across long-lived remote sessions.
+  function refresh() {
+    writeSessionRecord();
+  }
+
+  function appendAssistant(text) {
+    const value = typeof text === 'string' ? text : (text == null ? '' : String(text));
+    if (!value.trim()) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'text', text: value }] },
+    });
+  }
+
+  function appendToolUse(name, input) {
+    if (!name) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'tool_use', name, input: input || {} }] },
+    });
+  }
+
+  function appendToolResult(toolUseResult) {
+    if (!toolUseResult) return;
+    appendLine({
+      type: 'user',
+      sessionId,
+      message: { content: [{ type: 'tool_result' }] },
+      toolUseResult,
+    });
+  }
+
+  return {
+    transcriptPath,
+    sessionRecordPath,
+    writeSessionRecord,
+    refresh,
+    appendAssistant,
+    appendToolUse,
+    appendToolResult,
+  };
+}

package/src/runtime/shared/update-checker.mjs

@@ -0,0 +1,214 @@
+/**
+ * update-checker.mjs — npm registry version check + self-update for the
+ * globally-installed `mixdog` CLI package.
+ *
+ * checkLatestVersion({force}) hits the npm registry for the `latest`
+ * dist-tag, compares against the local package.json version, and caches
+ * the result on disk (TTL 24h) so repeated calls (e.g. on every TUI mount)
+ * don't hammer the registry. Network/parse failures are silent — this is a
+ * best-effort convenience check, never a boot-blocking dependency.
+ *
+ * runGlobalUpdate() shells out to `npm install -g mixdog@latest` in the
+ * background (windowsHide so no console flash on Windows) and resolves once
+ * the child exits, reporting the resolved version on success.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { resolvePluginData } from './plugin-paths.mjs';
+
+const PACKAGE_NAME = 'mixdog';
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const FETCH_TIMEOUT_MS = 5_000;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_FILE_NAME = 'update-check-cache.json';
+
+// Resolve the local package.json shipped alongside src/ (two levels up from
+// src/runtime/shared/).
+const _MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const _PACKAGE_JSON_PATH = join(_MODULE_DIR, '..', '..', '..', 'package.json');
+
+let _localVersionCache = null;
+export function localPackageVersion() {
+  if (_localVersionCache) return _localVersionCache;
+  try {
+    const raw = JSON.parse(readFileSync(_PACKAGE_JSON_PATH, 'utf8'));
+    _localVersionCache = String(raw?.version || '0.0.0');
+  } catch {
+    _localVersionCache = '0.0.0';
+  }
+  return _localVersionCache;
+}
+
+function cacheFilePath(dataDir) {
+  const dir = dataDir || resolvePluginData();
+  return join(dir, CACHE_FILE_NAME);
+}
+
+function readCache(dataDir) {
+  try {
+    const raw = JSON.parse(readFileSync(cacheFilePath(dataDir), 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(dataDir, payload) {
+  try {
+    const dir = dataDir || resolvePluginData();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(cacheFilePath(dataDir), JSON.stringify(payload), 'utf8');
+  } catch {
+    // Best-effort — cache miss just means the next call re-fetches.
+  }
+}
+
+/** Parse a semver-ish string into { parts:[maj,min,patch], prerelease }. */
+function parseSemver(value) {
+  const text = String(value || '').trim().replace(/^v/i, '');
+  const [core, ...preParts] = text.split('-');
+  const parts = core.split('.').map((n) => {
+    const num = Number.parseInt(n, 10);
+    return Number.isFinite(num) ? num : 0;
+  });
+  while (parts.length < 3) parts.push(0);
+  return { parts, prerelease: preParts.join('-') };
+}
+
+/**
+ * Compare two semver strings. Returns positive if `a` > `b`, negative if
+ * `a` < `b`, 0 if equal. A version with a prerelease tag is considered
+ * lower than the same core version without one (standard semver rule).
+ */
+export function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa.parts[i] || 0) - (pb.parts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  if (pa.prerelease && !pb.prerelease) return -1;
+  if (!pa.prerelease && pb.prerelease) return 1;
+  if (pa.prerelease !== pb.prerelease) return pa.prerelease < pb.prerelease ? -1 : 1;
+  return 0;
+}
+
+export function isNewerVersion(latest, current) {
+  if (!latest || !current) return false;
+  return compareSemver(latest, current) > 0;
+}
+
+async function fetchLatestFromRegistry() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    if (!res.ok) return null;
+    const body = await res.json();
+    const version = body && typeof body === 'object' ? String(body.version || '').trim() : '';
+    return version || null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * checkLatestVersion({force, dataDir}) — resolve the latest published
+ * version of the `mixdog` npm package.
+ *
+ * Returns:
+ *   { currentVersion, latestVersion, updateAvailable, lastCheckedAt, fromCache }
+ * `latestVersion` is null when the registry could not be reached and no
+ * usable cache exists — this call never throws.
+ */
+export async function checkLatestVersion({ force = false, dataDir } = {}) {
+  const currentVersion = localPackageVersion();
+  const cache = force ? null : readCache(dataDir);
+  const now = Date.now();
+  if (cache && typeof cache.lastCheckedAt === 'number' && now - cache.lastCheckedAt < CACHE_TTL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion || null,
+      updateAvailable: isNewerVersion(cache.latestVersion, currentVersion),
+      lastCheckedAt: cache.lastCheckedAt,
+      fromCache: true,
+    };
+  }
+  const latestVersion = await fetchLatestFromRegistry();
+  if (latestVersion) {
+    const payload = { latestVersion, lastCheckedAt: now };
+    writeCache(dataDir, payload);
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: isNewerVersion(latestVersion, currentVersion),
+      lastCheckedAt: now,
+      fromCache: false,
+    };
+  }
+  // Registry unreachable: fall back to a stale cache (if any) rather than
+  // reporting "no update info" every time the network hiccups.
+  if (cache && cache.latestVersion) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      updateAvailable: isNewerVersion(cache.latestVersion, currentVersion),
+      lastCheckedAt: cache.lastCheckedAt || now,
+      fromCache: true,
+    };
+  }
+  return {
+    currentVersion,
+    latestVersion: null,
+    updateAvailable: false,
+    lastCheckedAt: now,
+    fromCache: false,
+  };
+}
+
+/**
+ * runGlobalUpdate() — `npm install -g mixdog@latest` in a background child
+ * process (windowsHide so no console flash on Windows). Resolves once the
+ * child exits; never throws — failures come back as {ok:false, error}.
+ */
+export function runGlobalUpdate() {
+  return new Promise((resolvePromise) => {
+    let child;
+    try {
+      const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      child = spawn(npmCmd, ['install', '-g', `${PACKAGE_NAME}@latest`], {
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: process.platform === 'win32',
+      });
+    } catch (err) {
+      resolvePromise({ ok: false, error: err?.message || String(err) });
+      return;
+    }
+    child.once('error', (err) => {
+      resolvePromise({ ok: false, error: err?.message || String(err) });
+    });
+    // Detach from the event-loop keep-alive so a boot-time auto-update can
+    // never hold the TUI/node process open after the user quits; the exit
+    // listener still fires as long as the process is otherwise alive.
+    child.unref?.();
+    child.once('exit', async (code) => {
+      if (code === 0) {
+        // Best-effort: report whichever version the registry now reports as
+        // latest (the just-installed one), falling back to 'unknown'.
+        const version = await fetchLatestFromRegistry();
+        resolvePromise({ ok: true, version: version || 'unknown' });
+      } else {
+        resolvePromise({ ok: false, error: `npm install exited with code ${code}` });
+      }
+    });
+  });
+}
+
+export { PACKAGE_NAME as UPDATE_PACKAGE_NAME };

package/src/session-runtime/config-helpers.mjs

@@ -0,0 +1,209 @@
+// Config normalization helpers: default provider, presets/routes, module
+// enable flags, shell/auto-clear/compaction config, and duration formatting.
+import { clean, hasOwn } from './session-text.mjs';
+import { normalizeEffortInput, normalizeSavedEffort } from './effort.mjs';
+import { routeFastKey, fastPreferenceFor } from './model-capabilities.mjs';
+
+export const DEFAULT_PROVIDER = 'anthropic-oauth';
+export const DEFAULT_MODEL = '';
+
+// Resolve the provider to use when a route carries no explicit provider.
+// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
+export function makeResolveDefaultProvider(isKnownProvider) {
+  return function resolveDefaultProvider(config) {
+    const configured = clean(config?.defaultProvider);
+    if (configured && isKnownProvider(configured)) return configured;
+    return DEFAULT_PROVIDER;
+  };
+}
+
+export function modelSettingsFor(config, provider, model) {
+  const key = routeFastKey(provider, model);
+  const value = key ? config?.modelSettings?.[key] : null;
+  return value && typeof value === 'object' ? value : {};
+}
+
+export function findPreset(config, key) {
+  const wanted = clean(key).toLowerCase();
+  if (!wanted) return null;
+  const presets = Array.isArray(config?.presets) ? config.presets : [];
+  return presets.find((p) => {
+    const id = clean(p?.id).toLowerCase();
+    const name = clean(p?.name).toLowerCase();
+    return id === wanted || name === wanted;
+  }) || null;
+}
+
+export function makeResolveRoute(resolveDefaultProvider) {
+  return function resolveRoute(config, { provider, model, effort, fast } = {}) {
+    const explicitProvider = clean(provider);
+    const explicitModel = clean(model);
+    const hasExplicitEffort = effort !== undefined;
+    const explicitEffort = hasExplicitEffort ? normalizeEffortInput(effort) : undefined;
+    const hasExplicitFast = fast !== undefined;
+    const explicitFast = fast === true;
+
+    if (explicitModel && !explicitProvider) {
+      const preset = findPreset(config, explicitModel);
+      if (preset) {
+        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const m = clean(preset.model) || DEFAULT_MODEL;
+        const saved = modelSettingsFor(config, p, m);
+        return {
+          provider: p,
+          model: m,
+          preset,
+          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+        };
+      }
+    }
+
+    if (!explicitProvider && !explicitModel) {
+      const defaultKey = config?.default;
+      const preset = findPreset(config, defaultKey);
+      if (preset) {
+        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const m = clean(preset.model) || DEFAULT_MODEL;
+        const saved = modelSettingsFor(config, p, m);
+        return {
+          provider: p,
+          model: m,
+          preset,
+          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+        };
+      }
+    }
+
+    const p = explicitProvider || resolveDefaultProvider(config);
+    const m = explicitModel || DEFAULT_MODEL;
+    const saved = modelSettingsFor(config, p, m);
+    return {
+      provider: p,
+      model: m,
+      preset: null,
+      effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort),
+      fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : fastPreferenceFor(config, p, m)),
+    };
+  };
+}
+
+export function isLikelyRawModelId(value) {
+  const model = clean(value);
+  if (!model || model.length > 160) return false;
+  if (/\s/.test(model)) return false;
+  return /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(model);
+}
+
+export function validateRequestedModelSelector(config, requested = {}) {
+  const model = clean(requested.model);
+  if (!model) return;
+  if (findPreset(config, model)) return;
+  if (isLikelyRawModelId(model)) return;
+  throw new Error(`Invalid model selector "${model}". Use a preset or a model id; free-form text cannot be used as a model.`);
+}
+
+export function ensureProviderEnabled(config, provider) {
+  const providers = { ...(config?.providers || {}) };
+  providers[provider] = { ...(providers[provider] || {}), enabled: true };
+  return providers;
+}
+
+const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
+
+export function normalizeSystemShellConfig(value = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
+  const envCommand = clean(process.env.MIXDOG_SHELL);
+  return {
+    command,
+    effective: command || envCommand || '',
+    source: command ? 'config' : (envCommand ? 'env' : 'auto'),
+  };
+}
+
+export function normalizeSystemShellCommand(value) {
+  const command = clean(value).replace(/^auto$/i, '').replace(/^['"](.+)['"]$/, '$1').trim();
+  if (!command) return '';
+  if (process.platform === 'win32') {
+    const stem = command.split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
+    if (stem !== 'powershell' && stem !== 'pwsh') {
+      throw new Error('system shell command must be powershell.exe or pwsh on Windows');
+    }
+  }
+  return command;
+}
+
+export function normalizeAutoClearConfig(value = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  return {
+    enabled: raw.enabled !== false,
+    idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
+  };
+}
+
+export function normalizeCompactTypeSetting(value, fallback = 'semantic') {
+  const raw = clean(value).toLowerCase().replace(/_/g, '-');
+  if (!raw) return fallback;
+  if (raw === '1' || raw === 'type1' || raw === 'type-1' || raw === 'semantic' || raw === 'summary' || raw === 'default') return 'semantic';
+  if (raw === '2' || raw === 'type2' || raw === 'type-2' || raw === 'recall' || raw === 'recall-fast' || raw === 'recall-fasttrack' || raw === 'recall-fast-track' || raw === 'fasttrack' || raw === 'fast-track') return 'recall-fasttrack';
+  return fallback;
+}
+
+export function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'semantic');
+  if (compactType === 'recall-fasttrack' && memoryEnabled === false) compactType = 'semantic';
+  return {
+    ...raw,
+    auto: raw.auto !== false && raw.enabled !== false,
+    type: compactType,
+    compactType,
+  };
+}
+
+export function moduleEnabled(configLike, name, fallback = true) {
+  const entry = configLike?.modules?.[name];
+  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+  return fallback !== false;
+}
+
+export function setModuleEnabledInConfig(configLike, name, enabled) {
+  const next = { ...(configLike || {}) };
+  next.modules = { ...(next.modules || {}) };
+  next.modules[name] = {
+    ...(next.modules[name] || {}),
+    enabled: enabled !== false,
+  };
+  return next;
+}
+
+export function formatDurationMs(ms) {
+  const value = Math.max(0, Number(ms) || 0);
+  if (value % 3_600_000 === 0) return `${value / 3_600_000}h`;
+  if (value % 60_000 === 0) return `${value / 60_000}m`;
+  return `${Math.round(value / 1000)}s`;
+}
+
+export function parseDurationMs(input) {
+  const text = clean(input).toLowerCase();
+  if (!text) return null;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(text);
+  if (!match) return null;
+  const n = Number(match[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = match[2] || 'm';
+  const mult = unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1000 : 1;
+  return Math.max(60_000, Math.round(n * mult));
+}
+
+// A resolved model meta carries catalog-derived fields (contextWindow, pricing,
+// capabilities, …). The lookupModelMeta() fallback for an unknown id is the
+// bare shape `{ id, provider }`, so "more than id/provider" reliably tells a
+// real catalog hit apart from that placeholder.
+export function modelMetaLooksResolved(meta) {
+  if (!meta || typeof meta !== 'object') return false;
+  return Object.keys(meta).some((key) => key !== 'id' && key !== 'provider');
+}