create-walle 0.9.26 → 0.9.28

package/template/claude-task-manager/lib/macos-capabilities.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// macOS capability helpers — Full Disk Access (FDA) detection + non-local volume
+// classification. Used to stop the repeating "Coding Task Manager would like to access
+// files on a network volume" TCC prompt:
+//   - FDA is a superset of the network-volume / app-data / removable TCC services, so one
+//     FDA grant (persisting under the stable Dev-ID identity) ends all of those prompts.
+//   - isPathOnNonLocalVolume() lets the startup restore SKIP statting a Dropbox/NFS cwd at
+//     cold boot (no session is active yet), which is what fires the prompt today.
+//
+// Pure-with-injectable-deps so the logic is unit-testable without a real macOS; thin cached
+// wrappers (default exports) read the real `mount` table / filesystem once.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const FDA_SETTINGS_URL = 'x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles';
+
+// Filesystem types that are NOT the local boot volume — accessing files on these can trip the
+// macOS "network volume" / "removable volume" TCC services.
+const NONLOCAL_FS_TYPES = new Set([
+  'nfs', 'smbfs', 'afpfs', 'webdav', 'ftp', 'fusefs', 'macfuse', 'osxfuse',
+]);
+
+function _isDarwin() {
+  return process.platform === 'darwin';
+}
+
+// ---- non-local volume classification ------------------------------------------------
+
+// Parse `mount` output into the list of mountpoints whose fs type is non-local.
+// A macOS line looks like:
+//   OrbStack:/OrbStack on /Users/example/OrbStack (nfs, nodev, nosuid, noatime, mounted by example)
+// PURE: takes the raw text, returns mountpoints.
+function parseNonLocalMountpoints(mountOutput) {
+  const out = [];
+  for (const line of String(mountOutput || '').split('\n')) {
+    const m = line.match(/ on (.+?) \(([a-z0-9_]+)[,)]/i);
+    if (!m) continue;
+    const mountpoint = m[1];
+    const fstype = (m[2] || '').toLowerCase();
+    if (NONLOCAL_FS_TYPES.has(fstype)) out.push(mountpoint);
+  }
+  return out;
+}
+
+// Build the set of path prefixes that count as "non-local" (defer FS touch / FDA-covered).
+// PURE given { mountOutput, home }:
+//   - ~/Library/CloudStorage/  (Dropbox/iCloud/OneDrive File Provider — the actual Dropbox case)
+//   - every non-local mountpoint parsed from `mount` (NFS/SMB/AFP/WebDAV, e.g. ~/OrbStack)
+//   - /Volumes/  (external / network / disk-image mounts)
+function nonLocalVolumePrefixes({ mountOutput = '', home = os.homedir() } = {}) {
+  const prefixes = new Set();
+  prefixes.add(path.join(home, 'Library', 'CloudStorage') + path.sep);
+  // Legacy Dropbox folder (`~/Dropbox`) — older Dropbox installs and hand-made symlinks
+  // (e.g. `~/.codex -> ~/Dropbox/work/codex`) live here rather than under CloudStorage, but
+  // macOS still treats it as a File Provider and gates reads behind TCC.
+  prefixes.add(path.join(home, 'Dropbox') + path.sep);
+  prefixes.add('/Volumes' + path.sep);
+  for (const mp of parseNonLocalMountpoints(mountOutput)) {
+    if (mp && mp !== '/') prefixes.add(mp.endsWith(path.sep) ? mp : mp + path.sep);
+  }
+  return [...prefixes];
+}
+
+// PURE prefix match — NEVER touches the filesystem (so it cannot itself trigger a TCC prompt).
+function pathHasNonLocalPrefix(p, prefixes) {
+  if (!p) return false;
+  const s = String(p);
+  for (const pre of prefixes) {
+    if (s === pre.slice(0, -1) || s.startsWith(pre)) return true;
+  }
+  return false;
+}
+
+// ---- cached real-system wrappers ----------------------------------------------------
+
+let _cachedPrefixes = null;
+function _defaultPrefixes() {
+  if (_cachedPrefixes) return _cachedPrefixes;
+  let mountOutput = '';
+  if (_isDarwin()) {
+    try { mountOutput = execFileSync('/sbin/mount', [], { encoding: 'utf8', timeout: 3000 }); }
+    catch { mountOutput = ''; }
+  }
+  _cachedPrefixes = nonLocalVolumePrefixes({ mountOutput, home: os.homedir() });
+  return _cachedPrefixes;
+}
+
+// Convenience used by the startup restore guard: is this cwd/worktree on a non-local volume?
+function isPathOnNonLocalVolume(p, prefixes = _defaultPrefixes()) {
+  return pathHasNonLocalPrefix(p, prefixes);
+}
+
+// ---- Full Disk Access detection -----------------------------------------------------
+
+// Files that require Full Disk Access to read. Reading one of these is the canonical SILENT
+// FDA probe — a denial returns EPERM/EACCES with no dialog (unlike a network-volume access).
+function _fdaProbePaths(home = os.homedir()) {
+  return [
+    path.join(home, 'Library', 'Application Support', 'com.apple.TCC', 'TCC.db'),
+    path.join(home, 'Library', 'Safari', 'Bookmarks.plist'),
+    path.join(home, 'Library', 'Safari', 'CloudTabs.db'),
+  ];
+}
+
+// Returns true (granted), false (denied), or null (undeterminable → caller should NOT nag).
+// DI: accessSync + existsSync injectable for tests; defaults probe the real filesystem.
+function fullDiskAccessGranted({
+  platform = process.platform,
+  probePaths = _fdaProbePaths(),
+  accessSync = fs.accessSync,
+  existsSync = fs.existsSync,
+} = {}) {
+  if (platform !== 'darwin') return true; // n/a off macOS — never nag
+  let sawProbe = false;
+  for (const p of probePaths) {
+    if (!existsSync(p)) continue; // file absent on this machine — not a usable probe
+    sawProbe = true;
+    try {
+      accessSync(p, fs.constants.R_OK);
+      return true; // could read an FDA-gated file ⇒ FDA granted
+    } catch (e) {
+      if (e && (e.code === 'EPERM' || e.code === 'EACCES')) return false; // gated ⇒ no FDA
+      // ENOENT/other: not a reliable signal — try the next probe
+    }
+  }
+  return sawProbe ? false : null; // probes existed but all errored ⇒ denied; none existed ⇒ unknown
+}
+
+// ---- authoritative read-access probe ------------------------------------------------
+
+// Does reading this path FAIL with a permission denial (EPERM/EACCES)? Unlike the pure
+// prefix heuristics above, this is the GROUND TRUTH: it follows symlinks (so `~/.codex`
+// pointing into Dropbox is seen as the real target) and reports the actual OS verdict,
+// independent of where the file lives or how the volume is classified. EPERM is the
+// signature of a macOS File-Provider / TCC denial (the file is owner-readable yet the
+// process lacks Full Disk Access); EACCES is a plain permission denial. ENOENT / no path
+// ⇒ null (not a denial — nothing to ask for). DI for tests.
+function probePathReadDenied(p, {
+  platform = process.platform,
+  accessSync = fs.accessSync,
+  realpathSync = fs.realpathSync,
+} = {}) {
+  if (!p || platform !== 'darwin') return null;
+  let target = String(p);
+  try { target = realpathSync(target); } catch { /* broken symlink / unreadable parent — probe as-is */ }
+  try {
+    accessSync(target, fs.constants.R_OK);
+    return null; // readable ⇒ not denied
+  } catch (e) {
+    if (e && (e.code === 'EPERM' || e.code === 'EACCES')) return e.code;
+    return null; // ENOENT/other ⇒ not an access denial we can fix by granting FDA
+  }
+}
+
+// ---- FDA guidance (paths + deep link shown to the user) -----------------------------
+
+const BUNDLE_ROOT = process.env.WALLE_BUNDLE_DIR || path.join(os.homedir(), '.walle', 'bundles');
+
+function ctmBundleAppPath() {
+  return path.join(BUNDLE_ROOT, 'Coding Task Manager.app');
+}
+
+function fdaGuidance({ bundlePath = ctmBundleAppPath() } = {}) {
+  return {
+    bundlePath,
+    settingsUrl: FDA_SETTINGS_URL,
+    hint:
+      'Open System Settings → Privacy & Security → Full Disk Access, click +, press ⌘⇧G, ' +
+      `paste ${bundlePath}, add "Coding Task Manager", and turn it on. Then restart CTM once — ` +
+      'macOS will stop asking for network-volume / file access on every restart.',
+  };
+}
+
+module.exports = {
+  FDA_SETTINGS_URL,
+  NONLOCAL_FS_TYPES,
+  parseNonLocalMountpoints,
+  nonLocalVolumePrefixes,
+  pathHasNonLocalPrefix,
+  isPathOnNonLocalVolume,
+  probePathReadDenied,
+  fullDiskAccessGranted,
+  fdaGuidance,
+  ctmBundleAppPath,
+  _fdaProbePaths,
+};

package/template/claude-task-manager/lib/session-messages-projection.js

@@ -90,6 +90,189 @@ function _attachImageRefsIfNeeded(messages, manifests) {
   return attachSessionImageRefs(messages, manifests);
 }
 
+const COMPACT_ACTIVITY_KINDS = new Set([
+  'reasoning',
+  'tool_call',
+  'tool_result',
+  'patch',
+  'plan',
+  'activity',
+  'command',
+]);
+const COMPACT_ACTIVITY_PREFIX_RE = /^\s*(?:\[(?:Tool|Tool result|Reasoning|Patch)[^\]]*\]|(?:Exit code|Chunk ID|Plan updated|Success\. Updated|Would you like to run|Reason:|Bash\(|Read \d+ file|Listed \d+ director|Ran |Running |Waiting\.{0,3}|Process (?:exited|running)|Original token count:))/i;
+const COMPACT_PREVIEW_LIMIT = 180;
+const COMPACT_SUMMARY_PREVIEWS = 3;
+
+function _compactRole(message) {
+  return String(message?.role || '').trim().toLowerCase();
+}
+
+function _compactMetadata(message) {
+  return message && message.metadata && typeof message.metadata === 'object' ? message.metadata : {};
+}
+
+function _compactPreview(text) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!clean) return '';
+  return clean.length > COMPACT_PREVIEW_LIMIT ? `${clean.slice(0, COMPACT_PREVIEW_LIMIT - 1)}…` : clean;
+}
+
+function _compactActivityLabel(message) {
+  const meta = _compactMetadata(message);
+  const role = _compactRole(message);
+  const kind = String(meta.kind || meta.sourceKind || '').trim();
+  if (kind === 'tool_call' && meta.tool) return `tool:${meta.tool}`;
+  if (kind) return kind;
+  const text = sessionMessageText(message);
+  const prefix = String(text || '').match(/^\s*\[([^\]]+)\]/);
+  if (prefix) return prefix[1].toLowerCase();
+  return role || 'message';
+}
+
+function _assistantKeepIndexes(messages) {
+  const keep = new Set();
+  let lastAssistant = -1;
+  const flush = () => {
+    if (lastAssistant >= 0) keep.add(lastAssistant);
+    lastAssistant = -1;
+  };
+  for (let i = 0; i < messages.length; i += 1) {
+    const message = messages[i];
+    const role = _compactRole(message);
+    if (role === 'user') {
+      flush();
+      continue;
+    }
+    if (role === 'assistant' && sessionMessageText(message).trim()) lastAssistant = i;
+  }
+  flush();
+  return keep;
+}
+
+function _isConversationActivityDetail(message, options = {}) {
+  if (!message || typeof message !== 'object') return false;
+  const role = _compactRole(message);
+  if (role === 'user') return false;
+  if (role === 'assistant' && options.keepAssistant) return false;
+  const meta = _compactMetadata(message);
+  if (meta.sourceKind === 'subagent' && meta.originalRole === 'user') return false;
+  const kind = String(meta.kind || '').trim();
+  if (kind && COMPACT_ACTIVITY_KINDS.has(kind)) return true;
+  const text = sessionMessageText(message);
+  if (!String(text || '').trim()) return role !== 'assistant';
+  if (COMPACT_ACTIVITY_PREFIX_RE.test(text)) return true;
+  if (role === 'system' || role === 'tool' || role === 'function') return true;
+  // Non-final assistant updates inside a turn are progress chatter; keep the last assistant answer.
+  if (role === 'assistant' && !options.keepAssistant) return true;
+  return false;
+}
+
+function _emptyCompactGroup() {
+  return {
+    count: 0,
+    roleCounts: {},
+    labels: {},
+    previews: [],
+    firstTimestamp: '',
+    lastTimestamp: '',
+  };
+}
+
+function _trackCompactMessage(group, message) {
+  const role = _compactRole(message) || 'message';
+  const label = _compactActivityLabel(message);
+  group.count += 1;
+  group.roleCounts[role] = (group.roleCounts[role] || 0) + 1;
+  group.labels[label] = (group.labels[label] || 0) + 1;
+  const ts = String(message?.timestamp || message?.created_at || message?.createdAt || '').trim();
+  if (ts && !group.firstTimestamp) group.firstTimestamp = ts;
+  if (ts) group.lastTimestamp = ts;
+  if (group.previews.length < COMPACT_SUMMARY_PREVIEWS) {
+    const preview = _compactPreview(sessionMessageText(message));
+    if (preview) group.previews.push(preview);
+  }
+}
+
+function _formatCompactPairs(obj) {
+  return Object.entries(obj || {})
+    .sort((a, b) => b[1] - a[1] || String(a[0]).localeCompare(String(b[0])))
+    .slice(0, 5)
+    .map(([key, value]) => `${value} ${key}`)
+    .join(', ');
+}
+
+function _compactSummaryMessage(group) {
+  const roles = _formatCompactPairs(group.roleCounts);
+  const labels = _formatCompactPairs(group.labels);
+  const preview = group.previews.length ? ` Highlights: ${group.previews.join(' | ')}` : '';
+  const text = `Collapsed ${group.count} activity record${group.count === 1 ? '' : 's'}${roles ? ` (${roles})` : ''}${labels ? `: ${labels}.` : '.'}${preview}`;
+  return {
+    role: 'system',
+    text,
+    timestamp: group.lastTimestamp || group.firstTimestamp || '',
+    metadata: {
+      sourceKind: 'ctm-activity-summary',
+      compacted: true,
+      collapsedCount: group.count,
+      collapsedRoles: group.roleCounts,
+      collapsedLabels: group.labels,
+      previews: group.previews,
+    },
+  };
+}
+
+function compactConversationMessages(messages) {
+  const input = Array.isArray(messages) ? messages : [];
+  if (input.length === 0) {
+    return { messages: input, original_count: 0, compacted_count: 0, collapsed_count: 0, summary_count: 0 };
+  }
+  const keepAssistant = _assistantKeepIndexes(input);
+  const out = [];
+  let group = _emptyCompactGroup();
+  let collapsed = 0;
+  let summaries = 0;
+  const flush = () => {
+    if (!group.count) return;
+    out.push(_compactSummaryMessage(group));
+    collapsed += group.count;
+    summaries += 1;
+    group = _emptyCompactGroup();
+  };
+  for (let i = 0; i < input.length; i += 1) {
+    const message = input[i];
+    if (_isConversationActivityDetail(message, { keepAssistant: keepAssistant.has(i) })) {
+      _trackCompactMessage(group, message);
+    } else {
+      flush();
+      out.push(message);
+    }
+  }
+  flush();
+  return {
+    messages: out,
+    original_count: input.length,
+    compacted_count: out.length,
+    collapsed_count: collapsed,
+    summary_count: summaries,
+  };
+}
+
+function applyConversationCompactionToPage(page, options = {}) {
+  if (!options.compactConversation) return page;
+  const compacted = compactConversationMessages(page?.messages || []);
+  return {
+    ...(page || {}),
+    messages: compacted.messages,
+    conversationCompact: {
+      mode: 'activity-summary',
+      originalMessages: compacted.original_count,
+      renderedMessages: compacted.compacted_count,
+      collapsedMessages: compacted.collapsed_count,
+      summaryMessages: compacted.summary_count,
+    },
+  };
+}
+
 // The whole projection, off-thread-safe. Inputs are resolved + snapshotted on main:
 //   baseMessages         - the fetched page (getMessagesPage/TurnPage)
 //   streamEvents         - snapshot of the live stream ring (collectTimelineStreamEvents on main)
@@ -148,12 +331,42 @@ function _sourceWithStreamTail(source, added) {
 // skipStreamTail); publicIdentity = _publicTimelineIdentity(identity) (null for offset>0).
 function buildPaginatedPageResponse({
   baseMessages, streamEvents = [], skipStreamTail = false, exclusionRows = [], filterCodexSynthetic = false,
-  imageManifests = null, pageMeta = {}, extra = {}, publicIdentity = null,
+  imageManifests = null, pageMeta = {}, extra = {}, publicIdentity = null, compactConversation = false,
+} = {}) {
+  const proj = projectSessionMessagesPage({
+    baseMessages, streamEvents, skipStreamTail, exclusionRows, filterCodexSynthetic, imageManifests, allowEmptyBase: true,
+  });
+  const visibleMessages = proj.messages;
+  const visibleTailAdded = Math.max(0, (proj.visibleMergedCount || 0) - (proj.visibleBaseCount || 0));
+  const finalExtra = { ...extra };
+  delete finalExtra.skipStreamTail;
+  finalExtra.timelineIdentity = publicIdentity || null;
+  finalExtra.timelineFreshness = visibleTailAdded > 0 ? 'hot-tail' : 'durable';
+  finalExtra.streamEventCount = proj.streamEventCount || 0;
+  if (visibleTailAdded > 0) {
+    finalExtra.source = _sourceWithStreamTail(finalExtra.source, visibleTailAdded);
+    finalExtra.streamTailAdded = visibleTailAdded;
+  }
+  const response = { ...pageMeta, messages: visibleMessages, ...finalExtra };
+  return applyConversationCompactionToPage(response, { compactConversation: compactConversation === true });
+}
+
+// Stage C: the NON-paginated full read. Mirrors server.js sendMessages' projection + response
+// assembly EXACTLY so the worker can project + serialize the full conversation off the main loop
+// (the on-main merge/dedupText + exclusions sha256/msg + image-refs + stringify over a 3k-16k-msg
+// array was the profiled "reading conversational logs" freeze). Two response shapes, matching
+// sendMessages: a BARE ARRAY when the caller passed no extra (the common conversation read), else
+// { messages, ...finalExtra } with the same timeline fields sendMessages adds when hasCallerExtra.
+function buildFullMessagesResponse({
+  baseMessages, streamEvents = [], skipStreamTail = false, exclusionRows = [], filterCodexSynthetic = false,
+  imageManifests = null, extra = {}, publicIdentity = null, bareArray = false,
 } = {}) {
   const proj = projectSessionMessagesPage({
     baseMessages, streamEvents, skipStreamTail, exclusionRows, filterCodexSynthetic, imageManifests, allowEmptyBase: true,
   });
   const visibleMessages = proj.messages;
+  // Bare array: non-paginated read with no caller extra (sendMessages returns JSON.stringify(arr)).
+  if (bareArray) return visibleMessages;
   const visibleTailAdded = Math.max(0, (proj.visibleMergedCount || 0) - (proj.visibleBaseCount || 0));
   const finalExtra = { ...extra };
   delete finalExtra.skipStreamTail;
@@ -164,7 +377,15 @@ function buildPaginatedPageResponse({
     finalExtra.source = _sourceWithStreamTail(finalExtra.source, visibleTailAdded);
     finalExtra.streamTailAdded = visibleTailAdded;
   }
-  return { ...pageMeta, messages: visibleMessages, ...finalExtra };
+  return { messages: visibleMessages, ...finalExtra };
 }
 
-module.exports = { applyExclusions, sessionMessageTextHash, projectSessionMessagesPage, buildPaginatedPageResponse };
+module.exports = {
+  applyExclusions,
+  sessionMessageTextHash,
+  projectSessionMessagesPage,
+  buildPaginatedPageResponse,
+  buildFullMessagesResponse,
+  compactConversationMessages,
+  applyConversationCompactionToPage,
+};

package/template/claude-task-manager/lib/ttl-memo.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// Tiny single-value-per-key TTL memo with bounded LRU eviction.
+//
+// WHY: several hot read paths (e.g. the per-poll /api/session/prompts freshness
+// probe and the per-miss codex-source probe) run a synchronous SQLite read on the
+// MAIN event loop on every call. Under many sessions polling concurrently those
+// reads stack into multi-hundred-ms event-loop blocks (observed up to 790ms on a
+// dev storm, multi-second on the primary with cold pages). The values they read
+// change rarely (a user-prompt count, a session's codex-ness), so collapsing
+// repeated identical reads behind a short TTL removes the main-thread work without
+// changing the answer beyond a sub-second/short staleness window — strictly cheaper.
+//
+// compute() runs only on a miss or after the TTL expires. now() is injectable so
+// the behavior is deterministically unit-testable. ttlMs<=0 disables caching
+// entirely (every get() recomputes) so the cache can be turned off via env.
+
+function createTtlMemo({ ttlMs, max = 512, now = Date.now } = {}) {
+  const store = new Map(); // key -> { value, at }
+  const ttl = Number(ttlMs) || 0;
+  const cap = Math.max(1, Number(max) || 512);
+
+  // Return the cached value for `key` if still fresh, else run compute(), store the
+  // result (unless cacheIf(value) === false), and return it. cacheIf lets callers
+  // skip caching sentinel/error values (e.g. a null "do-not-trust" freshness key)
+  // so a transient failure isn't pinned for the whole TTL.
+  function get(key, compute, cacheIf) {
+    const t = now();
+    if (ttl > 0) {
+      const hit = store.get(key);
+      if (hit && (t - hit.at) < ttl) return hit.value;
+    }
+    const value = compute();
+    if (ttl > 0 && (typeof cacheIf !== 'function' || cacheIf(value))) {
+      set(key, value, t);
+    }
+    return value;
+  }
+
+  function set(key, value, at) {
+    if (ttl <= 0) return value;
+    store.delete(key); // refresh LRU recency
+    store.set(key, { value, at: at == null ? now() : at });
+    while (store.size > cap) {
+      const oldest = store.keys().next().value;
+      if (oldest === undefined) break;
+      store.delete(oldest);
+    }
+    return value;
+  }
+
+  return {
+    get,
+    set,
+    delete: (key) => store.delete(key),
+    clear: () => store.clear(),
+    get size() { return store.size; },
+  };
+}
+
+module.exports = { createTtlMemo };