aegiscode 5.2.32 → 6.0.0

package/vendor/client/foreign-memory.js

@@ -0,0 +1,666 @@
+'use strict';
+
+/**
+ * foreign-memory.js — scan the local memory/transcript stores that *other* AI
+ * coding tools leave on disk, and normalise them into AEGIS cloud memory
+ * entries (the shape `POST /api/memory/save {entries}` accepts).
+ *
+ * Why this file exists: AEGIS memory is only as useful as what's in it. A user
+ * arriving from Claude Code (or Codex, Cursor, Gemini CLI, …) already has
+ * months of durable context sitting in a proprietary directory that AEGIS
+ * cannot see. This module is the read-only importer for that.
+ *
+ * Design rules (all of them load-bearing):
+ *
+ *  1. Zero runtime deps, pure Node — like client/aegis.js it is shared verbatim
+ *     between the CLI/MCP server (requires ../client/…) and AEGIS Desktop
+ *     (vendored to desktop/vendor/ by scripts/predist.mjs, because
+ *     electron-builder cannot reach outside the app dir).
+ *
+ *  2. READ-ONLY. Nothing here writes, moves, or deletes inside a foreign
+ *     tool's directory. Ever.
+ *
+ *  3. Probe-and-skip, never assume. Every source declares its candidate roots
+ *     and is simply absent if those paths don't exist. A missing source is a
+ *     normal result (`present: false`), not an error — the whole point is that
+ *     we cannot know which of these tools a given machine has.
+ *
+ *  4. Deterministic ids. `/api/memory/save` upserts on (user_id, id), so an id
+ *     derived from the *content* makes a re-scan idempotent instead of
+ *     duplicating every entry on every run.
+ *
+ *  5. Bounded session fan-out. aegis1's free tier meters distinct
+ *     memory_entries.session values via _memory_sync_access(). If we minted one
+ *     session per foreign transcript, a single import would blow the free
+ *     session limit and 402 the entire batch. So every entry from a source
+ *     collapses into ONE session, `import:<source>`. Importing from ten tools
+ *     costs at most ten sessions, and re-runs cost zero (upsert).
+ *
+ * Local-only and offline: this module never opens a socket. Scanning and
+ * uploading are separate steps (see mcp/server.js `aegis_memory_import`),
+ * precisely so `scan()` can be dry-run and unit-tested with no network.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+// --- bounds ---------------------------------------------------------------
+// A memory store is not a transcript dump. These keep one import from turning
+// into a 100k-entry upload that helps nobody.
+const DEFAULTS = {
+  minChars: 24, // skip "ok", "yes", "continue" — fragments carry no memory value
+  maxChars: 2000, // truncate long agent replies
+  maxEntriesPerSource: 500,
+  maxFilesPerSource: 400,
+  maxFileBytes: 8 * 1024 * 1024, // don't read a multi-GB transcript into RAM
+};
+
+// Noise that shows up in these stores and is never worth remembering.
+const NOISE = [
+  /^<command-name>/i,
+  /^<local-command-stdout>/i,
+  /^\[Request interrupted by user/i,
+  /^Caveat: The messages below were generated by the user while running local commands/i,
+  /^(ok|okay|yes|no|yep|nope|sure|thanks|thank you|continue|proceed|go on|done)[.!]?$/i,
+];
+
+function isNoise(text) {
+  return NOISE.some((re) => re.test(text));
+}
+
+function homeDir(home) {
+  return home || os.homedir();
+}
+
+// --- per-platform root layout ---------------------------------------------
+// Every source below declares its roots through these helpers instead of
+// hardcoding `path.join(home, '.config', name)`. That hardcoding was a
+// cross-platform bug, not a style choice: `~/.config` is the XDG convention on
+// Linux only. On Windows the equivalent trees are `%APPDATA%` (Roaming) and
+// `%LOCALAPPDATA%` (Local), and several of these tools use
+// `~/Library/Application Support` on macOS. Resolving only `~/.config` meant
+// the entire scan silently reported `present: false` for every source on a
+// Windows install — the app packaged and ran fine, it simply found nothing to
+// import, with no error to explain why.
+//
+// `platform` is a parameter (not a bare `process.platform` read) so the
+// Windows and macOS layouts stay unit-testable from Linux CI.
+
+function platformOf(platform) {
+  return platform || process.platform;
+}
+
+/** Roaming app data (`%APPDATA%`), or null off Windows. */
+function roamingDir(home, plat) {
+  if (plat !== 'win32') return null;
+  // A redirected profile can move %APPDATA% off the home dir, so prefer the
+  // real env var — but only when scanning the real home. A caller-supplied
+  // home (tests, overrides) is the source of truth.
+  if (home === os.homedir() && process.env.APPDATA) return process.env.APPDATA;
+  return path.join(home, 'AppData', 'Roaming');
+}
+
+/** Local app data / cache (`%LOCALAPPDATA%`), or null off Windows. */
+function localDir(home, plat) {
+  if (plat !== 'win32') return null;
+  if (home === os.homedir() && process.env.LOCALAPPDATA) return process.env.LOCALAPPDATA;
+  return path.join(home, 'AppData', 'Local');
+}
+
+/** macOS `~/Library/Application Support`, or null elsewhere. */
+function macSupportDir(home, plat) {
+  return plat === 'darwin' ? path.join(home, 'Library', 'Application Support') : null;
+}
+
+/**
+ * Candidate roots for one app, across all three platform layouts.
+ *
+ * Deliberately additive: the POSIX paths are always included, so a source can
+ * never *lose* a root it used to match, and the Windows/macOS alternates are
+ * appended only when they apply. `present` is still a probe of existing
+ * directories, so extra candidates that don't exist change nothing.
+ *
+ * @param {boolean} [opts.config]     include `<config>/<name>` layouts
+ * @param {boolean} [opts.data]       include `<data>/<name>` (XDG share) layouts
+ * @param {boolean} [opts.macSupport] include `~/Library/Application Support/<name>`
+ */
+function appRoots(home, plat, name, { config = true, data = false, macSupport = false } = {}) {
+  const roots = [];
+  if (config) roots.push(path.join(home, '.config', name)); // linux (and XDG-following mac apps)
+  if (data) roots.push(path.join(home, '.local', 'share', name)); // linux XDG data
+  const roaming = roamingDir(home, plat);
+  if (roaming && config) roots.push(path.join(roaming, name)); // windows %APPDATA%
+  const local = localDir(home, plat);
+  if (local) roots.push(path.join(local, name)); // windows %LOCALAPPDATA%
+  if (macSupport) {
+    const support = macSupportDir(home, plat);
+    if (support) roots.push(path.join(support, name)); // macOS
+  }
+  return roots;
+}
+
+/** Collapse whitespace, strip control chars, trim. */
+function cleanText(value) {
+  if (typeof value !== 'string') return '';
+  // eslint-disable-next-line no-control-regex
+  return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+/** Content-addressed id: same text from the same place always maps to one row. */
+function stableId(...parts) {
+  return `import-${crypto.createHash('sha1').update(parts.join('|')).digest('hex').slice(0, 32)}`;
+}
+
+function readJsonl(file) {
+  const out = [];
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return out;
+  }
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      /* torn/partial line — skip, never throw on foreign data */
+    }
+  }
+  return out;
+}
+
+/**
+ * Depth-first file walk, bounded. Skips node_modules/.git and any directory
+ * the source marks as off-limits. Never follows symlinks (a foreign store is
+ * untrusted input; a symlink loop must not hang the importer).
+ */
+function walkFiles(root, { ext, limit }) {
+  const found = [];
+  const stack = [root];
+  while (stack.length && found.length < limit) {
+    const dir = stack.pop();
+    let items;
+    try {
+      items = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      if (found.length >= limit) break;
+      if (item.isSymbolicLink()) continue;
+      const full = path.join(dir, item.name);
+      if (item.isDirectory()) {
+        if (item.name === 'node_modules' || item.name === '.git') continue;
+        stack.push(full);
+      } else if (item.isFile()) {
+        if (ext && !ext.some((e) => item.name.endsWith(e))) continue;
+        found.push(full);
+      }
+    }
+  }
+  return found;
+}
+
+function fileSize(file) {
+  try {
+    return fs.statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// --- extractors -----------------------------------------------------------
+
+/**
+ * Claude Code / Claude Desktop style transcript line:
+ *   {type:'user', message:{content: 'string' | [{type:'text',text}]}}
+ *   {type:'assistant', message:{content:[{type:'text'|'tool_use'|'thinking'}]}}
+ * Only human text and assistant *text* blocks are memory-worthy; tool calls,
+ * results and hidden reasoning are not (and would flood the store).
+ */
+function textFromClaudeMessage(message) {
+  if (!message) return '';
+  const content = message.content;
+  if (typeof content === 'string') return cleanText(content);
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('\n');
+}
+
+function extractClaudeJsonl(file, ctx) {
+  const out = [];
+  const rel = ctx.rel(file);
+  for (const [index, row] of readJsonl(file).entries()) {
+    const type = row && row.type;
+    const role = type === 'user' ? 'user' : type === 'assistant' ? 'assistant' : null;
+    if (!role) continue;
+    if (row.isSidechain) continue; // subagent chatter, not user context
+    const text = cleanText(textFromClaudeMessage(row.message));
+    if (!text) continue;
+    out.push({ role, text, timestamp: row.timestamp || '', where: `${rel}#${index}` });
+  }
+  return out;
+}
+
+/**
+ * Best-effort generic `{role, content}` JSONL — the shape most OpenAI-compatible
+ * CLIs (and several agent frameworks) persist. We only claim what we can prove:
+ * a row must carry a recognisable role AND string content.
+ */
+function extractGenericJsonl(file, ctx) {
+  const out = [];
+  const rel = ctx.rel(file);
+  for (const [index, row] of readJsonl(file).entries()) {
+    if (!row || typeof row !== 'object') continue;
+    const role = row.role || (row.message && row.message.role);
+    if (role !== 'user' && role !== 'assistant') continue;
+    const content = row.content != null ? row.content : row.message && row.message.content;
+    const text = cleanText(typeof content === 'string' ? content : textFromClaudeMessage({ content }));
+    if (!text) continue;
+    out.push({ role, text, timestamp: row.timestamp || row.created_at || '', where: `${rel}#${index}` });
+  }
+  return out;
+}
+
+/** A markdown/text note file is itself one memory entry. */
+function extractMarkdown(file, ctx) {
+  if (fileSize(file) > DEFAULTS.maxFileBytes) return [];
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const text = cleanText(raw);
+  if (!text) return [];
+  return [{ role: 'user', text, timestamp: '', where: ctx.rel(file) }];
+}
+
+/** A JSON memory file: array of entries, or {entries|memories|memory: [...]}. */
+function extractJsonMemory(file, ctx) {
+  if (fileSize(file) > DEFAULTS.maxFileBytes) return [];
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return [];
+  }
+  const list = Array.isArray(data)
+    ? data
+    : data && Array.isArray(data.entries)
+      ? data.entries
+      : data && Array.isArray(data.memories)
+        ? data.memories
+        : data && Array.isArray(data.memory)
+          ? data.memory
+          : [];
+  const rel = ctx.rel(file);
+  return list
+    .map((item, index) => {
+      if (typeof item === 'string') {
+        return { role: 'user', text: cleanText(item), timestamp: '', where: `${rel}#${index}` };
+      }
+      const text = cleanText(item && (item.content || item.text || item.value || item.fact));
+      return { role: 'user', text, timestamp: (item && (item.timestamp || item.createdAt)) || '', where: `${rel}#${index}` };
+    })
+    .filter((e) => e.text);
+}
+
+// --- source registry ------------------------------------------------------
+
+/**
+ * Every known foreign store. `roots` are candidates — a source is present only
+ * if at least one root exists, and only the roots that exist are walked.
+ *
+ * `verified` marks how much trust the extractor has earned:
+ *   verified: true  — format confirmed against real files on this machine (or
+ *                     in a test fixture), schema-pinned.
+ *   verified: false — best-effort probe over a documented/observed layout.
+ *                     Counts from these should be treated as a lower bound.
+ */
+const SOURCES = [
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    verified: true,
+    // ~/.claude/projects/<slug>/<session-uuid>.jsonl is the canonical store.
+    roots: (home) => [path.join(home, '.claude', 'projects')],
+    files: (home) => [path.join(home, '.claude', 'history.jsonl')],
+    extract: { '**/*.jsonl': extractClaudeJsonl, '*.jsonl': extractClaudeJsonl },
+  },
+  {
+    id: 'claude-memory',
+    label: 'Claude memory files',
+    verified: true,
+    roots: (home) => [path.join(home, '.claude', 'memory')],
+    files: (home) => [path.join(home, '.claude', 'memory.json')],
+    extract: { '.json': extractJsonMemory, '.md': extractMarkdown, '.txt': extractMarkdown },
+  },
+  {
+    id: 'aegiscodex',
+    label: 'AEGIS Codex engine',
+    verified: true,
+    roots: (home) => [path.join(home, '.aegiscodex', 'memory')],
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'codex',
+    label: 'OpenAI Codex CLI',
+    verified: false,
+    roots: (home) => [path.join(home, '.codex')],
+    files: () => [],
+    extract: { '.jsonl': extractGenericJsonl, '.json': extractJsonMemory, '.md': extractMarkdown },
+  },
+  {
+    id: 'gemini-cli',
+    label: 'Gemini CLI',
+    verified: false,
+    roots: (home) => [path.join(home, '.gemini')],
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor',
+    verified: false,
+    roots: (home) => [path.join(home, '.cursor')],
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'continue',
+    label: 'Continue',
+    verified: false,
+    roots: (home) => [path.join(home, '.continue')],
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'goose',
+    label: 'Goose',
+    verified: false,
+    roots: (home, plat) => appRoots(home, plat, 'goose', { data: true }),
+    files: () => [],
+    extract: { '.jsonl': extractGenericJsonl, '.json': extractJsonMemory, '.md': extractMarkdown },
+  },
+  {
+    id: 'opencode',
+    label: 'opencode',
+    verified: false,
+    roots: (home, plat) => appRoots(home, plat, 'opencode', { data: true }),
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'windsurf',
+    label: 'Windsurf / Codeium',
+    verified: false,
+    // Home-relative dot-dirs on every platform; macOS additionally stores the
+    // app under Application Support.
+    roots: (home, plat) => [
+      path.join(home, '.windsurf'),
+      path.join(home, '.codeium'),
+      ...appRoots(home, plat, 'Windsurf', { config: false, macSupport: true }),
+      ...appRoots(home, plat, 'Codeium', { config: false, macSupport: true }),
+    ],
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl, '.md': extractMarkdown },
+  },
+  {
+    id: 'zed',
+    label: 'Zed',
+    verified: false,
+    // Zed follows XDG on Linux, uses %APPDATA% on Windows, and keeps
+    // ~/.config/zed on macOS too — `config: true` covers all three.
+    roots: (home, plat) => appRoots(home, plat, 'zed'),
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractGenericJsonl },
+  },
+  {
+    id: 'claude-desktop',
+    label: 'Claude Desktop app',
+    verified: false,
+    roots: (home, plat) => appRoots(home, plat, 'Claude', { macSupport: true }),
+    files: () => [],
+    extract: { '.json': extractJsonMemory, '.jsonl': extractClaudeJsonl, '.md': extractMarkdown },
+  },
+];
+
+/**
+ * Reduce an extractor pattern to its literal trailing filename suffix.
+ *   '**\/*.jsonl' -> '.jsonl'   '*.jsonl' -> '.jsonl'   '.json' -> '.json'
+ * Everything before the last `*` is a glob, not part of the literal suffix.
+ */
+function suffixOf(pattern) {
+  const star = pattern.lastIndexOf('*');
+  return star === -1 ? pattern : pattern.slice(star + 1);
+}
+
+/** Pick the extractor whose suffix matches the file; first match wins. */
+function extractorFor(extract, file) {
+  for (const [pattern, fn] of Object.entries(extract)) {
+    if (file.endsWith(suffixOf(pattern))) return fn;
+  }
+  return null;
+}
+
+function sourceById(id) {
+  return SOURCES.find((s) => s.id === id) || null;
+}
+
+/**
+ * Which sources exist on this machine. Cheap (stat only) — safe to call from a
+ * UI before the user commits to an import.
+ */
+function listSources(home, platform) {
+  const h = homeDir(home);
+  const plat = platformOf(platform);
+  return SOURCES.map((source) => {
+    const roots = source.roots(h, plat).filter(isDir);
+    const files = (source.files ? source.files(h) : []).filter(isFile);
+    return {
+      id: source.id,
+      label: source.label,
+      verified: source.verified,
+      roots: roots.concat(files),
+      present: roots.length > 0 || files.length > 0,
+    };
+  });
+}
+
+/**
+ * Scan foreign stores into normalised AEGIS memory entries.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.home]        override home dir (tests)
+ * @param {string[]} [opts.sources]   restrict to these source ids
+ * @param {number} [opts.limit]       max entries returned overall
+ * @param {number} [opts.minChars]    drop entries shorter than this
+ * @param {number} [opts.maxChars]    truncate entries longer than this
+ * @param {number} [opts.maxEntriesPerSource]
+ * @param {string} [opts.platform]    override platform (tests); defaults to process.platform
+ * @returns {{entries: Array, sources: Array, totals: object, scannedAt: string}}
+ */
+function scan(opts = {}) {
+  const home = homeDir(opts.home);
+  const plat = platformOf(opts.platform);
+  const minChars = opts.minChars != null ? opts.minChars : DEFAULTS.minChars;
+  const maxChars = opts.maxChars != null ? opts.maxChars : DEFAULTS.maxChars;
+  const perSource = opts.maxEntriesPerSource != null ? opts.maxEntriesPerSource : DEFAULTS.maxEntriesPerSource;
+  const overall = opts.limit != null ? opts.limit : Infinity;
+  const wanted = opts.sources && opts.sources.length ? new Set(opts.sources) : null;
+
+  const results = [];
+  const entries = [];
+  const seen = new Set(); // dedupe identical text within one scan
+
+  for (const source of SOURCES) {
+    if (wanted && !wanted.has(source.id)) continue;
+
+    const roots = source.roots(home, plat).filter(isDir);
+    const looseFiles = (source.files ? source.files(home) : []).filter(isFile);
+    const present = roots.length > 0 || looseFiles.length > 0;
+
+    const record = {
+      id: source.id,
+      label: source.label,
+      verified: source.verified,
+      present,
+      files: 0,
+      scanned: 0,
+      count: 0,
+      skipped: 0,
+      roots,
+      session: `import:${source.id}`,
+    };
+
+    if (!present) {
+      results.push(record);
+      continue;
+    }
+
+    const candidates = looseFiles.slice();
+    for (const root of roots) {
+      // Literal suffixes only — a glob like '**/*.jsonl' is not a filename
+      // suffix, and passing it to endsWith() silently matched nothing.
+      const suffixes = Object.keys(source.extract).map(suffixOf);
+      candidates.push(...walkFiles(root, { ext: suffixes, limit: DEFAULTS.maxFilesPerSource }));
+    }
+
+    const ctx = { rel: (f) => path.relative(home, f) };
+
+    for (const file of candidates) {
+      if (record.count >= perSource || entries.length >= overall) break;
+      if (fileSize(file) > DEFAULTS.maxFileBytes) {
+        record.skipped += 1;
+        continue;
+      }
+      const extractor = extractorFor(source.extract, file);
+      if (!extractor) continue;
+      record.files += 1;
+
+      let found;
+      try {
+        found = extractor(file, ctx);
+      } catch {
+        continue; // foreign data is untrusted: a bad file must not kill the scan
+      }
+
+      for (const item of found) {
+        if (record.count >= perSource || entries.length >= overall) break;
+        record.scanned += 1;
+        let text = item.text;
+        if (text.length > maxChars) text = `${text.slice(0, maxChars)}…`;
+        if (text.length < minChars || isNoise(text)) {
+          record.skipped += 1;
+          continue;
+        }
+        // Include role in the id so a prompt and an identical reply stay distinct.
+        const id = stableId(source.id, item.where, item.role, text);
+        if (seen.has(id)) continue;
+        seen.add(id);
+
+        entries.push({
+          id,
+          content: text,
+          role: item.role,
+          source: source.id,
+          session: record.session, // bounded fan-out: one session per source
+          tags: ['imported', source.id],
+          importance: 5,
+          timestamp: item.timestamp || new Date().toISOString(),
+        });
+        record.count += 1;
+      }
+    }
+
+    results.push(record);
+  }
+
+  return {
+    entries,
+    sources: results,
+    totals: {
+      entries: entries.length,
+      sourcesPresent: results.filter((r) => r.present).length,
+      sourcesWithEntries: results.filter((r) => r.count > 0).length,
+      scanned: results.reduce((n, r) => n + r.scanned, 0),
+      skipped: results.reduce((n, r) => n + r.skipped, 0),
+    },
+    scannedAt: new Date().toISOString(),
+  };
+}
+
+/** Split entries into upload-sized chunks (server takes a batch per request). */
+function chunk(entries, size = 200) {
+  const out = [];
+  for (let i = 0; i < entries.length; i += size) out.push(entries.slice(i, i + size));
+  return out;
+}
+
+/** One-line human summary — shared by the MCP tool and the desktop UI. */
+function describe(report) {
+  const present = report.sources.filter((s) => s.present);
+  if (!present.length) {
+    return 'No other AI tool memory found on this machine.';
+  }
+  const lines = present.map((s) => {
+    const tag = s.verified ? '' : ' (best-effort layout)';
+    return `  ${s.label}${tag}: ${s.count} entries from ${s.files} file(s), ${s.skipped} skipped`;
+  });
+  const header = `Found ${report.totals.entries} importable entries across ${report.totals.sourcesWithEntries} source(s):`;
+  return [header, ...lines].join('\n');
+}
+
+module.exports = {
+  DEFAULTS,
+  SOURCES,
+  scan,
+  listSources,
+  describe,
+  chunk,
+  stableId,
+  sourceById,
+  // exported for tests
+  _internal: {
+    walkFiles,
+    extractClaudeJsonl,
+    extractGenericJsonl,
+    extractJsonMemory,
+    extractMarkdown,
+    cleanText,
+    isNoise,
+    suffixOf,
+    // Platform-layout resolution: exported so the Windows/macOS branch can be
+    // exercised from a Linux CI runner (the roots themselves are probed with
+    // isDir, so they are unobservable on the host that lacks them).
+    platformOf,
+    roamingDir,
+    localDir,
+    macSupportDir,
+    appRoots,
+  },
+};