create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/walle-external-actions.js

@@ -41,6 +41,11 @@ const EXTERNAL_COMPLETION_PAIR_RE = new RegExp(
   'i',
 );
 const NEGATED_COMPLETION_RE = /\b(?:not|never|didn'?t|haven'?t|hasn'?t|wasn'?t|isn'?t)\s+(?:actually\s+)?(?:done|complete|completed|executed|sent|emailed|created|scheduled|booked|stored|saved)\b/i;
+const EMAIL_APPROVAL_RE = /\b(?:email|emails|e-mail|e-mails|mail|mails)\b/i;
+const CALENDAR_APPROVAL_RE = /\b(?:calendar|calendars|event|events|invite|invites|schedule|scheduled|book|booked)\b/i;
+const SLACK_APPROVAL_RE = /\bslack\b/i;
+const REMINDER_APPROVAL_RE = /\b(?:reminder|reminders)\b/i;
+const NOTIFICATION_APPROVAL_RE = /\b(?:notification|notifications|notify)\b/i;
 
 function normalizeApprovalText(text, { removeSpaces = false } = {}) {
   let value = String(text || '')
@@ -133,6 +138,26 @@ function isExternalActionConfirmationText(text, { pendingActions = [] } = {}) {
   return false;
 }
 
+function externalActionDomainsForApprovalText(text) {
+  const value = String(text || '');
+  const domains = new Set();
+  if (EMAIL_APPROVAL_RE.test(value)) domains.add('email');
+  if (CALENDAR_APPROVAL_RE.test(value)) domains.add('calendar');
+  if (SLACK_APPROVAL_RE.test(value)) domains.add('slack');
+  if (REMINDER_APPROVAL_RE.test(value)) domains.add('reminder');
+  if (NOTIFICATION_APPROVAL_RE.test(value)) domains.add('notification');
+  return [...domains];
+}
+
+function isCurrentTurnExternalActionApprovalText(text) {
+  const value = String(text || '').trim();
+  if (!value) return false;
+  const negative = NEGATIVE_RE.test(value);
+  if (negative && !APPROVAL_WAIVER_RE.test(value)) return false;
+  if (!CONFIRMATION_RE.test(value) || !EXTERNAL_VERB_RE.test(value)) return false;
+  return externalActionDomainsForApprovalText(value).length > 0;
+}
+
 function parseMaybeJson(value) {
   if (!value) return null;
   if (typeof value === 'object') return value;
@@ -140,9 +165,39 @@ function parseMaybeJson(value) {
   try { return JSON.parse(value); } catch { return null; }
 }
 
-function externalActionFromToolCall(toolCall) {
-  if (!toolCall || typeof toolCall !== 'object') return null;
-  const parsed = parseMaybeJson(toolCall.output || toolCall.result);
+function parsedPayloadsFromValue(value) {
+  if (!value) return [];
+  const parsed = parseMaybeJson(value);
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return [parsed];
+  if (!Array.isArray(value)) return [];
+  const payloads = [];
+  for (const item of value) {
+    const itemParsed = parseMaybeJson(item);
+    if (itemParsed && typeof itemParsed === 'object' && !Array.isArray(itemParsed)) {
+      payloads.push(itemParsed);
+      continue;
+    }
+    if (!item || typeof item !== 'object') continue;
+    for (const key of ['content', 'text', 'output', 'result']) {
+      const nested = parseMaybeJson(item[key]);
+      if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+        payloads.push(nested);
+      }
+    }
+  }
+  return payloads;
+}
+
+function messageContentBlocks(message) {
+  const blocks = [];
+  for (const content of [message?.content, message?.message?.content]) {
+    if (Array.isArray(content)) blocks.push(...content);
+    else if (content && typeof content === 'object') blocks.push(content);
+  }
+  return blocks;
+}
+
+function externalActionFromParsedPayload(parsed) {
   if (!parsed || parsed.external_action !== true || parsed.blocked !== true) return null;
   const action = parsed.action;
   if (!action || typeof action !== 'object') return null;
@@ -150,22 +205,65 @@ function externalActionFromToolCall(toolCall) {
   return action;
 }
 
+function externalActionFromToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== 'object') return null;
+  for (const parsed of parsedPayloadsFromValue(toolCall.output || toolCall.result)) {
+    const action = externalActionFromParsedPayload(parsed);
+    if (action) return action;
+  }
+  return null;
+}
+
+function externalActionFromContentBlock(block) {
+  if (!block || typeof block !== 'object') return null;
+  const type = block.type || block.kind || '';
+  if (type && type !== 'tool_result' && type !== 'tool_call_result') return null;
+  for (const key of ['content', 'text', 'output', 'result']) {
+    for (const parsed of parsedPayloadsFromValue(block[key])) {
+      const action = externalActionFromParsedPayload(parsed);
+      if (action) return action;
+    }
+  }
+  return null;
+}
+
+function collectPendingExternalActionsFromMessage(message) {
+  const seen = new Set();
+  const actions = [];
+  const add = (action) => {
+    if (!action) return;
+    const key = action.payloadHash || action.id;
+    if (seen.has(key)) return;
+    seen.add(key);
+    actions.push(action);
+  };
+
+  for (const toolCall of message?.toolCalls || []) {
+    add(externalActionFromToolCall(toolCall));
+  }
+  for (const block of messageContentBlocks(message)) {
+    add(externalActionFromContentBlock(block));
+  }
+
+  return actions;
+}
+
+function isSyntheticToolResultMessage(message) {
+  if (!message || message.role !== 'user') return false;
+  return messageContentBlocks(message).some((block) => {
+    const type = block?.type || block?.kind || '';
+    return type === 'tool_result' || type === 'tool_call_result';
+  });
+}
+
 function extractLatestPendingExternalActions(history = []) {
   if (!Array.isArray(history)) return [];
   for (let i = history.length - 1; i >= 0; i -= 1) {
     const message = history[i];
-    if (!message || message.role !== 'assistant') continue;
-    const seen = new Set();
-    const actions = [];
-    for (const toolCall of message.toolCalls || []) {
-      const action = externalActionFromToolCall(toolCall);
-      if (!action) continue;
-      const key = action.payloadHash || action.id;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      actions.push(action);
-    }
-    return actions;
+    if (!message) continue;
+    const actions = collectPendingExternalActionsFromMessage(message);
+    if (actions.length) return actions;
+    if (message.role === 'user' && !isSyntheticToolResultMessage(message)) break;
   }
   return [];
 }
@@ -195,9 +293,29 @@ function buildExternalActionApprovalsForMessage({
   }));
 }
 
+function buildCurrentTurnExternalActionApprovalsForMessage({
+  userText = '',
+  ctmSessionId = '',
+  chatSessionId = '',
+  now = () => new Date(),
+} = {}) {
+  if (!isCurrentTurnExternalActionApprovalText(userText)) return [];
+  return [{
+    decision: 'allow',
+    scope: 'current_turn_external_actions',
+    approvalScope: 'current_turn_external_actions',
+    domains: externalActionDomainsForApprovalText(userText),
+    source: 'ctm_user_current_turn_confirmation',
+    ctmSessionId,
+    chatSessionId,
+    confirmedAt: now().toISOString(),
+    confirmedByUserMessage: String(userText || '').slice(0, 500),
+  }];
+}
+
 function parseToolResultPayload(toolCall) {
   if (!toolCall || typeof toolCall !== 'object') return null;
-  return parseMaybeJson(toolCall.output || toolCall.result);
+  return parsedPayloadsFromValue(toolCall.output || toolCall.result)[0] || null;
 }
 
 function isSuccessfulExternalActionResult(toolCall) {
@@ -282,6 +400,7 @@ function buildPendingExternalActionNotExecutedReply({ actions = [] } = {}) {
 }
 
 module.exports = {
+  buildCurrentTurnExternalActionApprovalsForMessage,
   buildExternalActionApprovalsForMessage,
   buildPendingExternalActionNotExecutedReply,
   extractLatestPendingExternalActions,

package/template/claude-task-manager/lib/walle-history-hydration.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const DEFAULT_WALLE_HISTORY_RETRY_MS = 2500;
+
+function isWalleLikeSession(session) {
+  if (!session || typeof session !== 'object') return false;
+  return session.type === 'walle'
+    || session.agentType === 'walle'
+    || session.meta?.type === 'walle'
+    || session._restoreTask?.type === 'walle'
+    || !!session._restoreTask?.chat_session_id
+    || !!session.chatSessionId;
+}
+
+function shouldAutoStartDeferredRestore(session, msg, source) {
+  if (!session?._restoreDeferred || !msg?.autoStartRestore) return false;
+  if (!isWalleLikeSession(session)) return true;
+  const normalizedSource = String(source || msg.type || '').trim();
+  // Wall-E history is not a terminal frame. A visible attach from older clients
+  // may still start the runtime, but snapshots/reflow/prewarm must not.
+  return normalizedSource === 'attach';
+}
+
+function shouldRequestWalleHistory(input = {}, opts = {}) {
+  if (opts.force === true) return true;
+  if (input.hasRenderableMessages === true) return false;
+  if (input.historyStatus === 'loaded' || input.loaded === true) return false;
+
+  const requested = input.requested === true || input.historyStatus === 'loading' || input.loading === true;
+  if (!requested) return true;
+
+  const retryAfterMs = Number.isFinite(Number(opts.retryAfterMs))
+    ? Math.max(0, Number(opts.retryAfterMs))
+    : DEFAULT_WALLE_HISTORY_RETRY_MS;
+  const requestedAt = Number(input.requestedAt || 0);
+  if (!requestedAt) return true;
+  const now = Number.isFinite(Number(opts.now)) ? Number(opts.now) : Date.now();
+  return now - requestedAt >= retryAfterMs;
+}
+
+module.exports = {
+  DEFAULT_WALLE_HISTORY_RETRY_MS,
+  isWalleLikeSession,
+  shouldAutoStartDeferredRestore,
+  shouldRequestWalleHistory,
+};

package/template/claude-task-manager/lib/walle-native-health.js

@@ -0,0 +1,403 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+
+const WALL_E_NATIVE_DEPENDENCIES = Object.freeze([
+  'better-sqlite3',
+  'sqlite-vec',
+  'tree-sitter-bash',
+]);
+
+function safeRealpath(value) {
+  try { return fs.realpathSync.native ? fs.realpathSync.native(value) : fs.realpathSync(value); } catch {}
+  return '';
+}
+
+function inspectWalleNodeModules(cwd) {
+  const root = path.resolve(cwd);
+  const nodeModulesPath = path.join(root, 'node_modules');
+  const rootRealpath = safeRealpath(root) || root;
+  const expectedRealpath = path.join(rootRealpath, 'node_modules');
+  let stat = null;
+  try { stat = fs.lstatSync(nodeModulesPath); } catch {}
+  const exists = !!stat;
+  const symlink = !!(stat && stat.isSymbolicLink());
+  const realpath = exists ? (safeRealpath(nodeModulesPath) || nodeModulesPath) : '';
+  const ownedByWalleDir = !exists || realpath === expectedRealpath;
+  return {
+    path: nodeModulesPath,
+    realpath,
+    exists,
+    symlink,
+    ownedByWalleDir,
+    shared: exists && !ownedByWalleDir,
+  };
+}
+
+const NATIVE_CHECK_SCRIPT = `
+const checked = ${JSON.stringify(WALL_E_NATIVE_DEPENDENCIES)};
+function done(ok, payload) {
+  const base = {
+    ok,
+    node: {
+      execPath: process.execPath,
+      version: process.version,
+      modules: process.versions.modules || '',
+      platform: process.platform,
+      arch: process.arch
+    }
+  };
+  process.stdout.write(JSON.stringify(Object.assign(base, payload || {})));
+  process.exit(ok ? 0 : 42);
+}
+try {
+  const Database = require('better-sqlite3');
+  const db = new Database(':memory:');
+  const quick = db.pragma('quick_check');
+  let sqliteVec = 'not_checked';
+  let treeSitterBash = 'not_checked';
+  try {
+    const vec = require('sqlite-vec');
+    if (vec && typeof vec.load === 'function') {
+      vec.load(db);
+      sqliteVec = 'loaded';
+    } else {
+      sqliteVec = 'present';
+    }
+  } catch (err) {
+    throw new Error('sqlite-vec failed: ' + err.message);
+  } finally {
+    try { db.close(); } catch {}
+  }
+  try {
+    require('tree-sitter-bash');
+    treeSitterBash = 'loaded';
+  } catch (err) {
+    throw new Error('tree-sitter-bash failed: ' + err.message);
+  }
+  done(true, {
+    checked,
+    sqlite: { quick_check: quick && quick[0] ? quick[0].quick_check : 'unknown' },
+    sqlite_vec: sqliteVec,
+    tree_sitter_bash: treeSitterBash
+  });
+} catch (err) {
+  done(false, {
+    checked,
+    error: {
+      name: err && err.name || 'Error',
+      code: err && err.code || '',
+      message: err && err.message || String(err || '')
+    }
+  });
+}
+`;
+
+function execFileJson(file, args, options = {}) {
+  const execFileImpl = options.execFileImpl || execFile;
+  return new Promise((resolve) => {
+    execFileImpl(file, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      timeout: options.timeoutMs || 5000,
+      maxBuffer: 1024 * 1024,
+    }, (err, stdout, stderr) => {
+      resolve({
+        err,
+        stdout: String(stdout || ''),
+        stderr: String(stderr || ''),
+        code: err && typeof err.code !== 'undefined' ? err.code : 0,
+        signal: err && err.signal || null,
+      });
+    });
+  });
+}
+
+function classifyNativeDependencyError(message, code = '') {
+  const text = String(message || '');
+  if (/NODE_MODULE_VERSION/i.test(text) || /compiled against a different Node\.js version/i.test(text)) {
+    return 'native_dependency_abi_mismatch';
+  }
+  if (/Cannot find module/i.test(text) || code === 'MODULE_NOT_FOUND') {
+    return 'native_dependency_missing';
+  }
+  if (/ERR_DLOPEN_FAILED|dlopen|invalid ELF|mach-o|was built for/i.test(text) || code === 'ERR_DLOPEN_FAILED') {
+    return 'native_dependency_load_failed';
+  }
+  if (/timed out/i.test(text)) return 'native_dependency_check_timeout';
+  return 'native_dependency_failed';
+}
+
+function parseJsonOutput(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text.split(/\r?\n/).filter(Boolean).pop());
+  } catch {
+    return null;
+  }
+}
+
+function normalizeNativeHealth(raw, fallbackMessage = '') {
+  const payload = raw && typeof raw === 'object' ? raw : {};
+  if (payload.ok) {
+    return {
+      ok: true,
+      code: 'ok',
+      message: 'Wall-E native dependencies are loadable.',
+      checked: payload.checked || [],
+      node: payload.node || {},
+      sqlite: payload.sqlite || {},
+      sqlite_vec: payload.sqlite_vec || '',
+      tree_sitter_bash: payload.tree_sitter_bash || '',
+      rebuild_attempted: false,
+    };
+  }
+
+  const error = payload.error || {};
+  const message = error.message || fallbackMessage || 'Wall-E native dependency check failed.';
+  const code = classifyNativeDependencyError(message, error.code);
+  return {
+    ok: false,
+    code,
+    message,
+    checked: payload.checked || WALL_E_NATIVE_DEPENDENCIES,
+    node: payload.node || {},
+    error: {
+      name: error.name || 'Error',
+      code: error.code || '',
+      message,
+    },
+    rebuild_hint: `npm rebuild ${WALL_E_NATIVE_DEPENDENCIES.join(' ')} --loglevel=warn`,
+    rebuild_attempted: false,
+  };
+}
+
+async function checkWalleNativeDeps({
+  walleDir,
+  nodePath = process.execPath,
+  execFileImpl = execFile,
+  timeoutMs = 5000,
+} = {}) {
+  const cwd = walleDir || path.resolve(__dirname, '..', '..', 'wall-e');
+  const nodeModules = inspectWalleNodeModules(cwd);
+  const result = await execFileJson(nodePath, ['-e', NATIVE_CHECK_SCRIPT], {
+    cwd,
+    execFileImpl,
+    timeoutMs,
+  });
+  const payload = parseJsonOutput(result.stdout);
+  if (payload) {
+    return {
+      ...normalizeNativeHealth(payload, result.stderr || result.err?.message),
+      node_modules: nodeModules,
+    };
+  }
+  return {
+    ...normalizeNativeHealth(null, result.stderr || result.err?.message || 'Native dependency check produced no JSON output.'),
+    node_modules: nodeModules,
+  };
+}
+
+function shouldRebuildNativeDeps(health) {
+  if (health?.node_modules?.shared) return false;
+  return Boolean(health && !health.ok && [
+    'native_dependency_abi_mismatch',
+    'native_dependency_load_failed',
+    'native_dependency_missing',
+  ].includes(health.code));
+}
+
+function dependencyPackagePath(cwd, dependency) {
+  return path.join(cwd, 'node_modules', ...dependency.split('/'), 'package.json');
+}
+
+function missingNativeDependencies(cwd) {
+  return WALL_E_NATIVE_DEPENDENCIES.filter(dep => !fs.existsSync(dependencyPackagePath(cwd, dep)));
+}
+
+function normalizeNpmExecPath(value) {
+  if (!value) return null;
+  const resolved = path.resolve(value);
+  if (path.basename(resolved) === 'npx-cli.js') {
+    return path.join(path.dirname(resolved), 'npm-cli.js');
+  }
+  return resolved;
+}
+
+function npmCliCandidates(nodePath = process.execPath) {
+  const binDir = path.dirname(nodePath);
+  return [
+    path.join(binDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(binDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(binDir, '..', 'libexec', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(binDir, '..', '..', '..', '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ].map(candidate => path.resolve(candidate));
+}
+
+function resolveNpmRunner({ env = process.env, nodePath = process.execPath } = {}) {
+  // Only trust the ambient npm_execpath when resolving npm for the SAME Node that
+  // launched this process. When rebuilding native deps for a specific (possibly
+  // different) target Node, that Node's own bundled npm must win — the ambient
+  // npm_execpath points at whatever npm launched CTM (or the test runner) and
+  // would rebuild against the wrong install/ABI.
+  let resolvingForCurrentNode = true;
+  try {
+    resolvingForCurrentNode = path.resolve(nodePath) === path.resolve(process.execPath);
+  } catch { resolvingForCurrentNode = true; }
+  if (resolvingForCurrentNode) {
+    const envPath = normalizeNpmExecPath(env.npm_execpath);
+    if (envPath && fs.existsSync(envPath)) return { type: 'node-cli', path: envPath };
+  }
+  for (const candidate of npmCliCandidates(nodePath)) {
+    if (fs.existsSync(candidate)) return { type: 'node-cli', path: candidate };
+  }
+  return { type: 'bin', path: 'npm' };
+}
+
+function npmChildEnv(nodePath = process.execPath) {
+  const nodeDir = path.dirname(nodePath);
+  return {
+    ...process.env,
+    PATH: [nodeDir, process.env.PATH || ''].filter(Boolean).join(path.delimiter),
+    npm_config_update_notifier: 'false',
+  };
+}
+
+async function runNpmForNode({
+  cwd,
+  args,
+  nodePath = process.execPath,
+  execFileImpl = execFile,
+  timeoutMs = 120000,
+} = {}) {
+  const runner = resolveNpmRunner({ nodePath });
+  const env = npmChildEnv(nodePath);
+  if (runner.type === 'node-cli') {
+    const result = await execFileJson(nodePath, [runner.path, ...args], {
+      cwd,
+      env,
+      execFileImpl,
+      timeoutMs,
+    });
+    return {
+      ...result,
+      command: `node ${runner.path} ${args.join(' ')}`,
+      runner,
+    };
+  }
+
+  const result = await execFileJson('npm', args, {
+    cwd,
+    env,
+    execFileImpl,
+    timeoutMs,
+  });
+  return {
+    ...result,
+    command: `npm ${args.join(' ')}`,
+    runner,
+  };
+}
+
+async function rebuildWalleNativeDeps({
+  walleDir,
+  nodePath = process.execPath,
+  execFileImpl = execFile,
+  timeoutMs = 120000,
+} = {}) {
+  const cwd = walleDir || path.resolve(__dirname, '..', '..', 'wall-e');
+
+  // Backstop against the ABI ping-pong: never let a process running under a
+  // non-pinned Node major rebuild the shared native binary (that flip is what
+  // crash-loops the daemon). The entry guard normally prevents reaching here
+  // under the wrong Node; this also covers direct/CLI rebuild callers.
+  try {
+    const { findPinRoot, readPin } = require('./node-pin-guard');
+    const pinRoot = findPinRoot(__dirname);
+    const pin = pinRoot ? readPin(pinRoot) : '';
+    if (pin && pin.split('.')[0] !== process.versions.node.split('.')[0]) {
+      return {
+        ok: false,
+        code: 'native_dependency_wrong_node_major',
+        message: `Refusing to rebuild Wall-E native dependencies under Node v${process.versions.node}: this repo is pinned to v${pin}. Rebuilding here would flip the shared better-sqlite3 ABI and crash-loop the daemon. Re-run under the pinned Node ("$(bash ${path.join(pinRoot, 'bin', 'node-bin.sh')})") or follow the deliberate upgrade procedure.`,
+        pinned: pin,
+        running: process.versions.node,
+      };
+    }
+  } catch { /* no pin guard available — non-owner/shipped context, proceed */ }
+
+  const nodeModules = inspectWalleNodeModules(cwd);
+  if (nodeModules.shared) {
+    return {
+      ok: false,
+      code: 'native_dependency_shared_node_modules',
+      message: `Refusing to rebuild Wall-E native dependencies because ${nodeModules.path} resolves outside this Wall-E checkout (${nodeModules.realpath}). Use the same Node runtime as the owner or install isolated Wall-E dependencies in this worktree.`,
+      node_modules: nodeModules,
+    };
+  }
+
+  const attempts = [];
+  const missing = missingNativeDependencies(cwd);
+  if (missing.length > 0) {
+    const install = await runNpmForNode({
+      cwd,
+      nodePath,
+      args: ['install', '--omit=dev', '--loglevel=warn'],
+      execFileImpl,
+      timeoutMs,
+    });
+    attempts.push(install);
+    if (install.err) {
+      const output = `${install.stdout}\n${install.stderr}`.trim();
+      return {
+        ok: false,
+        code: 'native_dependency_install_failed',
+        message: output || install.err.message || 'npm install failed',
+        command: attempts.map(a => a.command).join(' && '),
+        missing,
+      };
+    }
+  }
+
+  const result = await runNpmForNode({
+    cwd,
+    nodePath,
+    args: ['rebuild', ...WALL_E_NATIVE_DEPENDENCIES, '--loglevel=warn'],
+    execFileImpl,
+    timeoutMs,
+  });
+  attempts.push(result);
+  const output = `${result.stdout}\n${result.stderr}`.trim();
+  if (result.err) {
+    return {
+      ok: false,
+      code: 'native_dependency_rebuild_failed',
+      message: output || result.err.message || 'npm rebuild failed',
+      command: attempts.map(a => a.command).join(' && '),
+      missing,
+    };
+  }
+  return {
+    ok: true,
+    code: 'ok',
+    message: output || 'rebuilt dependencies successfully',
+    command: attempts.map(a => a.command).join(' && '),
+    missing,
+  };
+}
+
+module.exports = {
+  WALL_E_NATIVE_DEPENDENCIES,
+  checkWalleNativeDeps,
+  classifyNativeDependencyError,
+  inspectWalleNodeModules,
+  normalizeNativeHealth,
+  npmCliCandidates,
+  rebuildWalleNativeDeps,
+  resolveNpmRunner,
+  shouldRebuildNativeDeps,
+  _NATIVE_CHECK_SCRIPT: NATIVE_CHECK_SCRIPT,
+};