create-walle 0.9.13 → 0.9.15

package/README.md

@@ -20,10 +20,10 @@ A web dashboard for running and managing AI coding sessions across multiple prov
 
 An always-on AI agent that learns from your Slack, email, calendar, and coding sessions.
 
-- **Second Brain** — Automatically ingests your digital life into a searchable memory store with full-text search, knowledge extraction, and pattern detection
+- **Second Brain** — Automatically ingests your digital life and coding sessions into a searchable memory store with full-text search, knowledge extraction, and pattern detection
 - **Proactive Intelligence** — Surfaces time-sensitive items, suggests actions, and delivers morning briefings and weekly reflections without being asked
-- **Chat with Tools** — Talk to Wall-E in the browser — it can search your memories, look up people, run skills, and call external tools via MCP (Slack, Glean, etc.)
-- **19 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model training, model pricing sync, and more
+- **Chat with Tools** — Talk to Wall-E in the browser — it can search memories, recall prior coding sessions, look up people, run skills, and call external tools via MCP
+- **20 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, memory search, model training, model pricing sync, and more
 - **Multi-Model** — Works with Claude, GPT, Gemini, DeepSeek, and local models via Ollama, LM Studio, or MLX with smart routing
 - **Skill Management GUI** — Search, filter, create, edit, and monitor skills from the browser with rich cards, config forms, execution history, export/import, and pre-flight validation
 - **Multi-Device** — Share your brain across machines via Dropbox or iCloud
@@ -49,6 +49,11 @@ npx create-walle uninstall       # Remove the auto-start service
 npx create-walle -v              # Show version
 ```
 
+Install, update, and start verify Node-native modules such as `better-sqlite3`
+against the exact Node.js binary Wall-E will use. If you switch Node versions,
+Wall-E automatically runs the needed `npm rebuild` before starting so CTM does
+not crash with a `NODE_MODULE_VERSION` mismatch.
+
 ## Setup
 
 On first launch, the browser setup page guides you through:

package/bin/create-walle.js

@@ -17,37 +17,70 @@ const { injectMcpConfigs } = require('./mcp-inject');
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
 const LABEL = 'com.walle.server';
 const INSTALL_PATH_FILE = path.join(process.env.HOME, '.walle', 'install-path');
+const TELEMETRY_DATA_DIR = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME || '/tmp', '.walle', 'data');
+const CLI_LIFECYCLE_FILE = path.join(TELEMETRY_DATA_DIR, '.cli-lifecycle.jsonl');
+const MANAGED_PACKAGE_DIRS = ['claude-task-manager', 'wall-e'];
+const NATIVE_DEPENDENCIES = new Set([
+  'better-sqlite3',
+  'node-pty',
+  'sqlite-vec',
+  'tree-sitter-bash',
+]);
 
 // Files to preserve during update (user config, not code)
 const PRESERVE_ON_UPDATE = ['.env', 'wall-e/wall-e-config.json'];
 
+function writeCliLifecycleEvent(event, meta = {}) {
+  if (process.env.WALLE_TELEMETRY === '0' || process.env.WALLE_TELEMETRY === 'false') return;
+  try {
+    fs.mkdirSync(TELEMETRY_DATA_DIR, { recursive: true });
+    const pkg = require('../package.json');
+    const entry = {
+      event,
+      meta: {
+        command: meta.command || '',
+        package_version: pkg.version || 'unknown',
+        elapsed_ms: Number.isFinite(meta.elapsed_ms) ? meta.elapsed_ms : undefined,
+      },
+      t: Date.now(),
+    };
+    fs.appendFileSync(CLI_LIFECYCLE_FILE, JSON.stringify(entry) + '\n', { mode: 0o600 });
+  } catch {}
+}
+
 // ── CLI Router ──
 
-const command = process.argv[2] || '';
-
-if (command === 'install') {
-  install(process.argv[3]);
-} else if (command === 'update' || command === 'upgrade') {
-  update();
-} else if (command === 'start') {
-  start();
-} else if (command === 'stop') {
-  stop();
-} else if (command === 'status') {
-  status();
-} else if (command === 'logs') {
-  logs();
-} else if (command === 'uninstall') {
-  uninstall();
-} else if (command === '--help' || command === '-h' || command === 'help') {
-  usage();
-} else if (command === '--version' || command === '-v') {
-  const pkg = require('../package.json');
-  console.log(pkg.version);
-} else if (command && !command.startsWith('-')) {
-  install(command);
-} else {
-  usage();
+if (require.main === module) {
+  main(process.argv.slice(2));
+}
+
+function main(argv = []) {
+  const command = argv[0] || '';
+
+  if (command === 'install') {
+    install(argv[1]);
+  } else if (command === 'update' || command === 'upgrade') {
+    update();
+  } else if (command === 'start') {
+    start();
+  } else if (command === 'stop') {
+    stop();
+  } else if (command === 'status') {
+    status();
+  } else if (command === 'logs') {
+    logs();
+  } else if (command === 'uninstall') {
+    uninstall();
+  } else if (command === '--help' || command === '-h' || command === 'help') {
+    usage();
+  } else if (command === '--version' || command === '-v') {
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+  } else if (command && !command.startsWith('-')) {
+    install(command);
+  } else {
+    usage();
+  }
 }
 
 // ── Commands ──
@@ -84,9 +117,11 @@ function printMcpResults(wallePort) {
       } else if (r.action === 'already_configured') {
         console.log(`     ${DIM}=  ${r.tool} -- already configured${RESET}`);
       } else if (r.action === 'updated') {
-        console.log(`     ${GREEN}~  ${r.tool}${RESET} -- updated port in ${DIM}${r.configPath}${RESET}`);
+        const label = r.kind === 'agent_instructions' ? 'updated memory routing in' : 'updated port in';
+        console.log(`     ${GREEN}~  ${r.tool}${RESET} -- ${label} ${DIM}${r.configPath}${RESET}`);
       } else {
-        console.log(`     ${GREEN}+  ${r.tool}${RESET} -- added Wall-E to ${DIM}${r.configPath}${RESET}`);
+        const label = r.kind === 'agent_instructions' ? 'added memory routing to' : 'added Wall-E to';
+        console.log(`     ${GREEN}+  ${r.tool}${RESET} -- ${label} ${DIM}${r.configPath}${RESET}`);
       }
     }
     console.log(`\n  ${DIM}Your AI coding tools can now access Wall-E's memory and knowledge.`);
@@ -127,6 +162,8 @@ function install(targetDir) {
     console.error('  Template not found. Try: npm cache clean --force && npx create-walle@latest');
     process.exit(1);
   }
+  const installStartedAt = Date.now();
+  writeCliLifecycleEvent('cli_install_started', { command: 'install' });
 
   const ownerName = detectName().replace(/[\r\n=]/g, '').trim().slice(0, 200);
   const timezone = detectTimezone();
@@ -203,12 +240,18 @@ function install(targetDir) {
     npx create-walle logs        ${DIM}View logs${RESET}
 `);
   printMcpResults(parseInt(wallePort));
+  writeCliLifecycleEvent('cli_install_completed', {
+    command: 'install',
+    elapsed_ms: Date.now() - installStartedAt,
+  });
 }
 
 function update() {
   const dir = findWalleDir();
   const port = readPort(dir);
   const pkg = require('../package.json');
+  const updateStartedAt = Date.now();
+  writeCliLifecycleEvent('cli_update_started', { command: 'update' });
 
   console.log(`${BOLD}${CYAN}  Wall-E${RESET} — Updating to v${pkg.version}...\n`);
   console.log(`  ${DIM}Directory: ${dir}${RESET}`);
@@ -261,12 +304,25 @@ function update() {
   ${DIM}Your .env and config were preserved.${RESET}
 `);
   printMcpResults(parseInt(readWallePort(dir)));
+  writeCliLifecycleEvent('cli_update_completed', {
+    command: 'update',
+    elapsed_ms: Date.now() - updateStartedAt,
+  });
 }
 
 function start() {
   const dir = findWalleDir();
   const port = readPort(dir);
   console.log(`\n  Starting Wall-E from ${DIM}${dir}${RESET} on port ${port}...`);
+  try {
+    repairNativeDependencies(dir, { phase: 'start' });
+  } catch (err) {
+    console.error(`\n  ${RED}Native module repair failed.${RESET}`);
+    console.error(`  ${DIM}${err.message}${RESET}`);
+    console.error(`  Try: ${BOLD}cd ${dir}/claude-task-manager && npm rebuild better-sqlite3 node-pty${RESET}`);
+    console.error(`       ${BOLD}cd ${dir}/wall-e && npm rebuild better-sqlite3 sqlite-vec tree-sitter-bash${RESET}\n`);
+    process.exit(1);
+  }
   installService(dir, port);
   console.log(`  ${GREEN}Running!${RESET}  http://localhost:${port}\n`);
   printMcpResults(parseInt(readWallePort(dir)));
@@ -326,7 +382,7 @@ function stopQuiet(dir, port) {
   const wallePort = dir ? readWallePort(dir) : String(parseInt(port) + 1);
   for (const p of [port, wallePort]) {
     try {
-      const pids = execFileSync('lsof', ['-ti', ':' + p], { encoding: 'utf8', timeout: 3000 }).trim().split('\n').filter(Boolean);
+      const pids = execFileSync('lsof', ['-ti', '-sTCP:LISTEN', ':' + p], { encoding: 'utf8', timeout: 3000 }).trim().split('\n').filter(Boolean);
       for (const pid of pids) { try { process.kill(parseInt(pid), 'SIGTERM'); } catch {} }
     } catch {}
   }
@@ -464,14 +520,146 @@ done
 
 function npmInstall(dir) {
   try {
-    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(dir, 'claude-task-manager'), stdio: 'inherit' });
-    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(dir, 'wall-e'), stdio: 'inherit' });
-  } catch {
-    console.error(`\n  ${RED}npm install failed.${RESET} Try manually:\n    cd ${dir}/claude-task-manager && npm install\n    cd ${dir}/wall-e && npm install\n`);
+    for (const relDir of MANAGED_PACKAGE_DIRS) {
+      runNpm(path.join(dir, relDir), ['install', '--loglevel=warn']);
+    }
+    repairNativeDependencies(dir, { phase: 'install' });
+  } catch (err) {
+    console.error(`\n  ${RED}npm install failed.${RESET}`);
+    if (err && err.message) console.error(`  ${DIM}${err.message}${RESET}`);
+    console.error(`  Try manually with the same Node version used by Wall-E:\n    cd ${dir}/claude-task-manager && npm install && npm rebuild better-sqlite3 node-pty\n    cd ${dir}/wall-e && npm install && npm rebuild better-sqlite3 sqlite-vec tree-sitter-bash\n`);
     process.exit(1);
   }
 }
 
+function repairNativeDependencies(walleDir, {
+  phase = 'install',
+  checkDependency = checkNativeDependency,
+  runNpmCommand = runNpm,
+  log = console.log,
+} = {}) {
+  const repairs = [];
+  for (const relDir of MANAGED_PACKAGE_DIRS) {
+    const packageDir = path.join(walleDir, relDir);
+    const deps = nativeDependenciesForPackage(packageDir);
+    if (!deps.length) continue;
+
+    const failed = [];
+    for (const dep of deps) {
+      const check = checkDependency(packageDir, dep);
+      if (!check.ok) failed.push(dep);
+    }
+    if (!failed.length) continue;
+
+    log(`  ${YELLOW}Rebuilding native modules for ${relDir}${RESET} ${DIM}(Node ${process.version}, ABI ${process.versions.modules})${RESET}`);
+    runNpmCommand(packageDir, ['rebuild', ...failed, '--loglevel=warn']);
+
+    const stillBroken = [];
+    for (const dep of failed) {
+      const check = checkDependency(packageDir, dep);
+      if (!check.ok) stillBroken.push(`${dep}: ${firstLine(check.error)}`);
+    }
+    if (stillBroken.length) {
+      throw new Error(`Native module repair failed in ${relDir} after ${phase}: ${stillBroken.join('; ')}`);
+    }
+    repairs.push(`${relDir}: ${failed.join(', ')}`);
+  }
+
+  if (repairs.length) {
+    log(`  ${GREEN}Native modules rebuilt successfully${RESET} ${DIM}(${repairs.join('; ')})${RESET}`);
+  }
+  return repairs;
+}
+
+function nativeDependenciesForPackage(packageDir) {
+  const pkgPath = path.join(packageDir, 'package.json');
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return [];
+  }
+  const declared = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.optionalDependencies || {}),
+  };
+  return Object.keys(declared).filter((name) => NATIVE_DEPENDENCIES.has(name));
+}
+
+function checkNativeDependency(packageDir, dependency) {
+  try {
+    execFileSync(process.execPath, ['-e', `require(${JSON.stringify(dependency)})`], {
+      cwd: packageDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 15000,
+      env: npmChildEnv(),
+    });
+    return { ok: true };
+  } catch (err) {
+    const error = [err && err.message, err && err.stdout, err && err.stderr].filter(Boolean).join('\n');
+    return { ok: false, error };
+  }
+}
+
+function runNpm(cwd, args) {
+  const runner = resolveNpmRunner();
+  if (runner.type === 'node-cli') {
+    execFileSync(process.execPath, [runner.path, ...args], {
+      cwd,
+      stdio: 'inherit',
+      env: npmChildEnv(),
+    });
+    return;
+  }
+  execFileSync('npm', args, {
+    cwd,
+    stdio: 'inherit',
+    env: npmChildEnv(),
+  });
+}
+
+function resolveNpmRunner(env = process.env, execPath = process.execPath) {
+  const envPath = normalizeNpmExecPath(env.npm_execpath);
+  if (envPath && fs.existsSync(envPath)) return { type: 'node-cli', path: envPath };
+
+  for (const candidate of npmCliCandidates(execPath)) {
+    if (fs.existsSync(candidate)) return { type: 'node-cli', path: candidate };
+  }
+  return { type: 'bin', path: 'npm' };
+}
+
+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(execPath = process.execPath) {
+  const binDir = path.dirname(execPath);
+  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'),
+  ].map((candidate) => path.resolve(candidate));
+}
+
+function npmChildEnv() {
+  const nodeDir = path.dirname(process.execPath);
+  return {
+    ...process.env,
+    PATH: [nodeDir, process.env.PATH || ''].filter(Boolean).join(path.delimiter),
+    npm_config_update_notifier: 'false',
+  };
+}
+
+function firstLine(value) {
+  return String(value || '').split(/\r?\n/).find(Boolean) || 'unknown error';
+}
+
 function stampVersion(dir) {
   try {
     const ver = require('../package.json').version;
@@ -568,3 +756,15 @@ function copyRecursive(src, dest) {
     fs.copyFileSync(src, dest);
   }
 }
+
+module.exports = {
+  checkNativeDependency,
+  firstLine,
+  main,
+  nativeDependenciesForPackage,
+  normalizeNpmExecPath,
+  npmCliCandidates,
+  repairNativeDependencies,
+  resolveNpmRunner,
+  writeCliLifecycleEvent,
+};

package/bin/mcp-inject.js

@@ -1,60 +1,25 @@
 'use strict';
-const fs = require('fs');
-const path = require('path');
-
-const MCP_TARGETS = [
-  { tool: 'Claude Code', configPath: '.claude/mcp.json', detectDir: '.claude' },
-  { tool: 'Cursor', configPath: '.cursor/mcp.json', detectDir: '.cursor' },
-  { tool: 'Windsurf', configPath: '.codeium/windsurf/mcp_config.json', detectDir: '.codeium/windsurf' },
-  { tool: 'Claude Desktop', configPath: 'Library/Application Support/Claude/claude_desktop_config.json', detectDir: 'Library/Application Support/Claude' },
-];
-
-/**
- * Inject Wall-E MCP server config into detected AI tool config files.
- * @param {number} wallePort - The Wall-E HTTP port
- * @param {string} [homeDir] - Home directory override for testing
- * @returns {Array<{tool: string, action: string, configPath?: string}>}
- */
-function injectMcpConfigs(wallePort, homeDir) {
-  const home = homeDir || process.env.HOME;
-  const walleUrl = `http://localhost:${wallePort}/mcp`;
-  const results = [];
-
-  for (const target of MCP_TARGETS) {
-    const detectPath = path.join(home, target.detectDir);
-    const configPath = path.join(home, target.configPath);
-
-    if (!fs.existsSync(detectPath)) {
-      results.push({ tool: target.tool, action: 'not_installed' });
-      continue;
-    }
 
-    let config = {};
-    if (fs.existsSync(configPath)) {
-      try {
-        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      } catch {
-        config = {};
-      }
-    }
-
-    if (!config.mcpServers) config.mcpServers = {};
-
-    const existing = config.mcpServers['wall-e'];
-    if (existing && existing.url === walleUrl) {
-      results.push({ tool: target.tool, action: 'already_configured', configPath });
-      continue;
-    }
+const path = require('path');
 
-    const action = existing ? 'updated' : 'added';
-    config.mcpServers['wall-e'] = { type: 'http', url: walleUrl };
+const runtimePath = path.join(__dirname, '..', 'template', 'wall-e', 'lib', 'mcp-integration');
+let runtime = null;
 
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    results.push({ tool: target.tool, action, configPath });
+function loadRuntime() {
+  if (runtime) return runtime;
+  try {
+    runtime = require(runtimePath);
+  } catch {
+    runtime = require('../../wall-e/lib/mcp-integration');
   }
-
-  return results;
+  return runtime;
 }
 
-module.exports = { injectMcpConfigs, MCP_TARGETS };
+module.exports = {
+  get MCP_TARGETS() { return loadRuntime().MCP_TARGETS; },
+  detectMcpIntegrations: (...args) => loadRuntime().detectMcpIntegrations(...args),
+  ensureMcpIntegrations: (...args) => loadRuntime().ensureMcpIntegrations(...args),
+  injectMcpConfigs: (...args) => loadRuntime().injectMcpConfigs(...args),
+  testWallEMcpEndpoint: (...args) => loadRuntime().testWallEMcpEndpoint(...args),
+  wallEMcpUrl: (...args) => loadRuntime().wallEMcpUrl(...args),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-walle",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "CTM + Wall-E \u2014 AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini, Aider, OpenCode, and more, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"
@@ -12,6 +12,8 @@
   ],
   "scripts": {
     "build": "bash build.sh",
+    "test": "node --test tests/*.test.js",
+    "test:npx-e2e": "CREATE_WALLE_NPX_E2E=1 node --test tests/npx-install-update.e2e.test.js",
     "prepublishOnly": "bash build.sh"
   },
   "license": "MIT",

package/template/claude-task-manager/api-prompts.js

@@ -10,6 +10,12 @@ const walleClient = require('./lib/walle-client');
 const claudeDesktopSessions = require('./lib/claude-desktop-sessions');
 // AI search uses direct HTTP calls to Claude API (supports Portkey proxy)
 
+let dbMaintenanceRunner = null;
+
+function setDbMaintenanceRunner(fn) {
+  dbMaintenanceRunner = typeof fn === 'function' ? fn : null;
+}
+
 // Embed a prompt (async, fire-and-forget)
 async function _embedPrompt(promptId, title, content) {
   try {
@@ -1467,7 +1473,10 @@ async function handleRestoreBackup(req, res) {
   try {
     const data = await readBody(req);
     if (!data.name) return jsonResponse(res, 400, { error: 'Missing backup name' });
-    const result = db.restoreBackup(data.name);
+    const restore = () => db.restoreBackup(data.name);
+    const result = dbMaintenanceRunner
+      ? await dbMaintenanceRunner({ kind: 'restore-backup', backupName: data.name }, restore)
+      : restore();
     jsonResponse(res, 200, result);
   } catch (e) { jsonResponse(res, 500, { error: e.message }); }
 }
@@ -2814,4 +2823,4 @@ function safeParse(json, fallback) {
   try { return JSON.parse(json); } catch { return fallback; }
 }
 
-module.exports = { handlePromptApi, queueEngine, importPermissionsToDb, runIncrementalConversationImport, importSessionFile, setUiPrefsBroadcaster };
+module.exports = { handlePromptApi, queueEngine, importPermissionsToDb, runIncrementalConversationImport, importSessionFile, setUiPrefsBroadcaster, setDbMaintenanceRunner };

package/template/claude-task-manager/approval-agent.js

@@ -356,6 +356,13 @@ function reviewWithHeuristics(context) {
   const tool = (context.toolName || '').replace(/^[⏺●\s]+/, '').toLowerCase();
   const warning = (context.warning || '').toLowerCase();
 
+  if (/^mcp\b/.test(tool)
+      && /\bwall-e\.walle_memory_status\b|\bwall-e\b[\s\S]*\bwalle_memory_status\b/.test(cmd)) {
+    return { decision: 'approve', reasoning: 'Read-only Wall-E memory status MCP call (heuristic)', riskLevel: 'low',
+      ruleLabel: 'Wall-E memory status', rulePattern: 'wall-e.*walle_memory_status',
+      ruleDescription: 'Read Wall-E MCP memory status' };
+  }
+
   // Low-risk tools — auto-approve immediately (before high-risk content check,
   // because Edit/Write diffs may contain code with "drop table" or "rm -rf" as
   // string literals — those are code content, not dangerous operations).