create-walle 0.9.13 → 0.9.14

package/template/claude-task-manager/lib/update-telemetry.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const SERVER_EVENTS = new Set([
+  'check_started',
+  'check_completed',
+  'check_failed',
+  'update_available',
+  'api_check',
+  'apply_requested',
+  'apply_ignored',
+  'apply_started',
+  'apply_spawn_error',
+]);
+
+const CLIENT_EVENTS = new Set([
+  'ui_prompt_shown',
+  'ui_action',
+]);
+
+const SURFACES = new Set(['banner', 'wizard', 'api', 'startup', 'scheduled', 'manual', 'unknown']);
+const ACTIONS = new Set(['later', 'skip', 'apply', 'apply_started', 'apply_failed', 'already_up_to_date']);
+const RESULTS = new Set(['available', 'up_to_date', 'error', 'started', 'ignored']);
+
+function cleanEnum(value, allowed, fallback = 'unknown') {
+  const normalized = String(value || '').trim().toLowerCase().replace(/[^a-z0-9_-]/g, '_');
+  return allowed.has(normalized) ? normalized : fallback;
+}
+
+function cleanVersion(value) {
+  const raw = String(value || '').trim().replace(/^v/i, '');
+  if (!raw || raw.length > 64) return '';
+  return /^[0-9A-Za-z.+_-]+$/.test(raw) ? raw : '';
+}
+
+function cleanBool(value) {
+  return value === true ? true : value === false ? false : undefined;
+}
+
+function errorKind(error) {
+  const message = String(error?.message || error || '').toLowerCase();
+  if (!message) return 'unknown';
+  if (/timeout|timed out|abort/.test(message)) return 'timeout';
+  if (/network|fetch|enotfound|eai_again|econn|socket/.test(message)) return 'network';
+  if (/npm registry returned 4\d\d/.test(message)) return 'registry_client_error';
+  if (/npm registry returned 5\d\d/.test(message)) return 'registry_server_error';
+  if (/spawn|enoent/.test(message)) return 'spawn_error';
+  return 'error';
+}
+
+function sanitizePayload(details = {}) {
+  const payload = {};
+  const source = cleanEnum(details.source, SURFACES, '');
+  const surface = cleanEnum(details.surface, SURFACES, '');
+  const action = cleanEnum(details.action, ACTIONS, '');
+  const result = cleanEnum(details.result, RESULTS, '');
+  const currentVersion = cleanVersion(details.currentVersion || details.current || details.current_version);
+  const latestVersion = cleanVersion(details.latestVersion || details.latest || details.latest_version);
+  const updateAvailable = cleanBool(details.updateAvailable);
+
+  if (source) payload.source = source;
+  if (surface) payload.surface = surface;
+  if (action) payload.action = action;
+  if (result) payload.result = result;
+  if (currentVersion) payload.current_version = currentVersion;
+  if (latestVersion) payload.latest_version = latestVersion;
+  if (updateAvailable !== undefined) payload.update_available = updateAvailable;
+  if (details.error || details.errorKind) payload.error_kind = details.errorKind || errorKind(details.error);
+
+  return payload;
+}
+
+function trackUpdateTelemetry(telemetry, event, details = {}) {
+  const normalized = cleanEnum(event, new Set([...SERVER_EVENTS, ...CLIENT_EVENTS]), '');
+  if (!normalized) return false;
+  try {
+    telemetry?.track?.(`ctm_update_${normalized}`, sanitizePayload(details));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function clientUpdateTelemetryEvent(body = {}) {
+  const rawEvent = String(body.event || '').trim().toLowerCase();
+  if (rawEvent === 'prompt_shown') {
+    return {
+      event: 'ui_prompt_shown',
+      details: sanitizePayload({
+        surface: body.surface,
+        currentVersion: body.currentVersion,
+        latestVersion: body.latestVersion,
+      }),
+    };
+  }
+  if (rawEvent === 'action') {
+    return {
+      event: 'ui_action',
+      details: sanitizePayload({
+        surface: body.surface,
+        action: body.action,
+        currentVersion: body.currentVersion,
+        latestVersion: body.latestVersion,
+      }),
+    };
+  }
+  return null;
+}
+
+module.exports = {
+  clientUpdateTelemetryEvent,
+  errorKind,
+  sanitizePayload,
+  trackUpdateTelemetry,
+};

package/template/claude-task-manager/lib/walle-default-model.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { sanitizeSetupProviderType } = require('./setup-provider-config');
+
+function _kv(brain, key) {
+  try {
+    if (brain && typeof brain.getKv === 'function') return brain.getKv(key) || '';
+    if (brain && typeof brain.getDb === 'function') {
+      return brain.getDb().prepare('SELECT value FROM brain_metadata WHERE key = ?').get(key)?.value || '';
+    }
+  } catch (e) {
+    if (process.env.CTM_DEBUG_WALLE_DEFAULTS === '1') {
+      console.warn('[walle-default-model] metadata lookup failed:', e.message);
+    }
+  }
+  return '';
+}
+
+function _providerDefault(provider, providerRegistry) {
+  if (!provider) return '';
+  try {
+    const registry = providerRegistry || require('../../wall-e/llm/registry');
+    if (typeof registry.ensureBootstrapped === 'function') registry.ensureBootstrapped();
+    return registry.getDefaultModel(provider) || '';
+  } catch (e) {
+    if (process.env.CTM_DEBUG_WALLE_DEFAULTS === '1') {
+      console.warn('[walle-default-model] provider default lookup failed:', e.message);
+    }
+    return '';
+  }
+}
+
+function resolveWalleDefaultModelSelection(opts = {}) {
+  const env = opts.env || process.env;
+  const brain = opts.brain || null;
+  const provider = sanitizeSetupProviderType(
+    _kv(brain, 'walle_provider')
+      || env.WALLE_PROVIDER
+      || 'anthropic'
+  ) || 'anthropic';
+  const model = _kv(brain, 'walle_model_' + provider)
+    || _kv(brain, 'walle_model')
+    || env.WALLE_MODEL
+    || _providerDefault(provider, opts.providerRegistry)
+    || '';
+
+  return {
+    model_id: model,
+    model_provider: provider,
+  };
+}
+
+module.exports = {
+  resolveWalleDefaultModelSelection,
+};

package/template/claude-task-manager/lib/walle-mcp-auto-config.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const path = require('path');
+
+let lastEnsureAt = 0;
+
+function isMcpAutoConfigDisabled(env = process.env) {
+  const value = String(env.WALLE_MCP_AUTO_CONFIG || '').toLowerCase();
+  return value === '0' || value === 'false' || value === 'off';
+}
+
+function isMcpCapableAgentCommand(cmd) {
+  const base = path.basename(String(cmd || '')).toLowerCase();
+  return base === 'claude' || base === 'codex';
+}
+
+function loadMcpIntegration() {
+  return require(path.resolve(__dirname, '..', '..', 'wall-e', 'lib', 'mcp-integration'));
+}
+
+function ensureWalleMcpForAgentSession({
+  cmd,
+  wallePort,
+  homeDir,
+  env = process.env,
+  logger = console,
+  now = Date.now(),
+  minIntervalMs = 30000,
+} = {}) {
+  if (!isMcpCapableAgentCommand(cmd)) return { skipped: 'not_mcp_capable_agent' };
+  if (isMcpAutoConfigDisabled(env)) return { skipped: 'disabled' };
+  if (lastEnsureAt && now - lastEnsureAt < minIntervalMs) return { skipped: 'throttled' };
+  lastEnsureAt = now;
+
+  try {
+    const { ensureMcpIntegrations } = loadMcpIntegration();
+    const results = ensureMcpIntegrations(wallePort, { homeDir: homeDir || env.HOME || process.env.HOME });
+    const changed = results.filter(r => r.action === 'added' || r.action === 'updated');
+    const errors = results.filter(r => r.action === 'error');
+    if (changed.length) {
+      logger.log(`[ctm] Auto-configured Wall-E MCP for ${changed.length} AI tool(s) before agent launch`);
+    }
+    if (errors.length) {
+      logger.warn(`[ctm] Wall-E MCP auto-config skipped ${errors.length} invalid config file(s): ${errors.map(r => r.tool).join(', ')}`);
+    }
+    return { results, changed: changed.length, errors: errors.length };
+  } catch (err) {
+    logger.warn(`[ctm] Wall-E MCP auto-config failed: ${err.message}`);
+    return { error: err.message };
+  }
+}
+
+function _resetWalleMcpAutoConfigState() {
+  lastEnsureAt = 0;
+}
+
+module.exports = {
+  ensureWalleMcpForAgentSession,
+  isMcpAutoConfigDisabled,
+  isMcpCapableAgentCommand,
+  _resetWalleMcpAutoConfigState,
+};

package/template/claude-task-manager/lib/walle-supervisor.js

@@ -124,6 +124,44 @@ function createWalleSupervisor({
     return pidSet;
   }
 
+  function readPidFile() {
+    try {
+      const pid = parseInt(fs.readFileSync(pidFile(), 'utf8').trim(), 10);
+      return pid || null;
+    } catch {
+      return null;
+    }
+  }
+
+  function isAlive(pid) {
+    if (!pid || pid === (processOps.pid || process.pid)) return false;
+    try {
+      processOps.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function writePidFile(pid) {
+    try {
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(pidFile(), String(pid));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function removePidFile() {
+    try {
+      fs.unlinkSync(pidFile());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   async function killAll() {
     const pidSet = await collectManagedPids();
     if (pidSet.size === 0) return waitForPortFree();
@@ -225,27 +263,53 @@ function createWalleSupervisor({
     return nextChild.pid;
   }
 
-  function getStatus() {
-    let running = false;
-    let pid = null;
-    if (childPid) {
-      try {
-        process.kill(childPid, 0);
-        running = true;
-        pid = childPid;
-      } catch {}
+  async function getStatus() {
+    const savedPid = readPidFile();
+    let stalePid = null;
+
+    if (childPid && isAlive(childPid)) {
+      return {
+        running: true,
+        pid: childPid,
+        pidSource: 'child',
+        stalePid: savedPid && savedPid !== childPid ? savedPid : null,
+        repairedPidFile: savedPid !== childPid ? writePidFile(childPid) : false,
+      };
     }
-    if (!running) {
-      try {
-        const orphanPid = parseInt(fs.readFileSync(pidFile(), 'utf8').trim(), 10);
-        if (orphanPid && orphanPid !== process.pid) {
-          process.kill(orphanPid, 0);
-          running = true;
-          pid = orphanPid;
-        }
-      } catch {}
+
+    if (savedPid && isAlive(savedPid)) {
+      return { running: true, pid: savedPid, pidSource: 'pid_file' };
     }
-    return { running, pid };
+    if (savedPid) stalePid = savedPid;
+
+    const title = processTitle();
+    let discovered = [];
+    try {
+      const results = await Promise.all([
+        processOps.findPidsByExactCommand ? processOps.findPidsByExactCommand(title) : [],
+        processOps.findListeningPidsByExactCommand ? processOps.findListeningPidsByExactCommand(wallePort, title) : [],
+      ]);
+      discovered = [...new Set(results.flat().filter(pid => pid && isAlive(pid)))];
+    } catch {}
+
+    if (discovered.length > 0) {
+      const pid = discovered[0];
+      return {
+        running: true,
+        pid,
+        pidSource: 'discovered',
+        stalePid,
+        repairedPidFile: writePidFile(pid),
+      };
+    }
+
+    return {
+      running: false,
+      pid: null,
+      pidSource: stalePid ? 'stale_pid_file' : 'none',
+      stalePid,
+      removedStalePidFile: stalePid ? removePidFile() : false,
+    };
   }
 
   function apiStop(req, res) {

package/template/claude-task-manager/lib/worktree-cwd.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+function fail(error, status) {
+  return { ok: false, status: status || 400, error };
+}
+
+function gitText(cwd, args) {
+  return execFileSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 5000,
+  }).trim();
+}
+
+function firstWorktreePath(porcelain) {
+  for (const line of String(porcelain || '').split('\n')) {
+    if (line.startsWith('worktree ')) return line.slice('worktree '.length).trim();
+  }
+  return '';
+}
+
+function realpathOrResolve(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch (_) {
+    return path.resolve(p);
+  }
+}
+
+function resolveWorktreeRepoRoot(cwd) {
+  if (typeof cwd !== 'string' || !cwd.trim()) return fail('cwd is required');
+  const raw = cwd.trim();
+  if (raw.includes('~')) {
+    return fail('cwd must be an absolute path with no `~` (the literal-tilde is the source of ghost worktrees).');
+  }
+  if (!path.isAbsolute(raw)) return fail('cwd must be an absolute path');
+
+  let realCwd;
+  try {
+    realCwd = fs.realpathSync(raw);
+  } catch (_) {
+    return fail('cwd does not exist');
+  }
+
+  let stat;
+  try {
+    stat = fs.statSync(realCwd);
+  } catch (_) {
+    return fail('cwd does not exist');
+  }
+  if (!stat.isDirectory()) return fail('cwd must be a directory');
+
+  let topLevel;
+  try {
+    topLevel = gitText(realCwd, ['rev-parse', '--show-toplevel']);
+  } catch (_) {
+    return fail('cwd must be inside a Git work tree');
+  }
+  if (!topLevel) return fail('cwd must be inside a Git work tree');
+
+  let primaryRoot = '';
+  try {
+    primaryRoot = firstWorktreePath(gitText(realCwd, ['worktree', 'list', '--porcelain']));
+  } catch (_) {
+    primaryRoot = '';
+  }
+
+  return {
+    ok: true,
+    cwd: realpathOrResolve(primaryRoot || topLevel),
+    requestedCwd: realCwd,
+  };
+}
+
+module.exports = {
+  resolveWorktreeRepoRoot,
+};

package/template/claude-task-manager/providers/codex-mcp.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// Codex MCP permission form:
+//
+//   Calling wall-e.walle_memory_status({})
+//   Field 1/1 ...
+//   Allow the wall-e MCP server to run tool "walle_memory_status"?
+//   1. Allow
+//   2. Allow for this session
+//   3. Always allow
+//   4. Cancel
+//   enter to submit | esc to cancel
+
+const CALLING_RE = /\bCalling\s+([A-Za-z0-9_.-]+)\.([A-Za-z0-9_.-]+)\s*\(/i;
+const QUESTION_RE = /Allow the ([A-Za-z0-9_.-]+) MCP server to run tool ["']?([A-Za-z0-9_.-]+)["']?\?/i;
+const ANCHOR_RE = /enter to submit\s*\|\s*esc to cancel/i;
+const ALLOW_RE = /^\s*[❯›> ]?\s*1\.\s*Allow\b/i;
+const OPTION_RE = /^\s*[❯›> ]?\s*(\d+)\.\s*(Allow for this session|Always allow|Allow|Cancel)\b/i;
+
+function extractMcpTool(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const q = lines[i].match(QUESTION_RE);
+    if (q) return { server: q[1], tool: q[2], questionIdx: i };
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const c = lines[i].match(CALLING_RE);
+    if (c) return { server: c[1], tool: c[2], questionIdx: -1 };
+  }
+  return null;
+}
+
+function parseOptions(lines) {
+  const out = {
+    allowShortcut: '1',
+    sessionShortcut: null,
+    alwaysShortcut: null,
+  };
+
+  for (const line of lines) {
+    const match = line.match(OPTION_RE);
+    if (!match) continue;
+    const index = match[1];
+    const label = match[2].toLowerCase();
+    if (label === 'allow for this session') out.sessionShortcut = index;
+    else if (label === 'always allow') out.alwaysShortcut = index;
+    else if (label === 'allow') out.allowShortcut = index;
+  }
+  return out;
+}
+
+module.exports = {
+  id: 'codex-mcp',
+  name: 'Codex MCP Permission',
+
+  detect(text) {
+    const lines = String(text || '').split('\n').map(l => l.trim()).filter(Boolean);
+    if (lines.length < 5) return false;
+    if (!lines.slice(-5).some(l => ANCHOR_RE.test(l))) return false;
+    if (!lines.some(l => ALLOW_RE.test(l))) return false;
+    return lines.some(l => QUESTION_RE.test(l)) || lines.some(l => CALLING_RE.test(l));
+  },
+
+  parse(text) {
+    const lines = String(text || '').split('\n').map(l => l.trim()).filter(Boolean);
+    const mcp = extractMcpTool(lines);
+    if (!mcp) return null;
+
+    let allowIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (ALLOW_RE.test(lines[i])) { allowIdx = i; break; }
+    }
+    if (allowIdx < 0) return null;
+
+    const options = parseOptions(lines.slice(allowIdx, allowIdx + 8));
+    const ctxAnchor = mcp.questionIdx >= 0 ? mcp.questionIdx : allowIdx;
+    const ctxStart = Math.max(0, ctxAnchor - 5);
+    const ctxEnd = Math.min(lines.length, allowIdx + 8);
+    const command = `${mcp.server}.${mcp.tool}({})`;
+
+    return {
+      toolName: 'MCP',
+      command: command.slice(0, 2000),
+      warning: '',
+      fullContext: lines.slice(ctxStart, ctxEnd).join('\n').slice(0, 2000),
+      hasAllowAll: !!options.sessionShortcut,
+      approveShortcut: options.allowShortcut,
+      approveAllShortcut: options.sessionShortcut,
+      alwaysAllowShortcut: options.alwaysShortcut,
+      mcpServer: mcp.server,
+      mcpTool: mcp.tool,
+      providerId: 'codex-mcp',
+    };
+  },
+
+  approveKeystroke(ctx) {
+    return ctx.approveAllShortcut || ctx.approveShortcut || '1';
+  },
+
+  approveAllKeystroke(ctx) {
+    return ctx.approveAllShortcut || null;
+  },
+
+  requiresEnter: true,
+};

package/template/claude-task-manager/providers/index.js

@@ -4,6 +4,7 @@
 // Detection order: most distinctive signals first to minimize false positives.
 
 const claudeCode = require('./claude-code');
+const codexMcp = require('./codex-mcp');
 const codex = require('./codex');
 const gemini = require('./gemini');
 const amazonQ = require('./amazon-q');
@@ -19,6 +20,7 @@ const opencode = require('./opencode');
 // Numbered-widget providers (Claude Code, Codex, Cursor, OpenCode, Kimi)
 // run before inline [Y/n] providers (Gemini, Aider, Amazon Q, Cline, Copilot).
 const providers = [
+  codexMcp,
   claudeCode,
   codex,
   cursor,

package/template/claude-task-manager/public/css/setup.css

@@ -161,6 +161,7 @@
 #setup-panel .integration-icon { font-size: 18px; width: 28px; text-align: center; }
 #setup-panel .integration-name { font-weight: 500; font-size: 13px; }
 #setup-panel .integration-desc { color: var(--fg-dim); font-size: 12px; }
+#setup-panel .integration-action { color: var(--fg-muted, #8b949e); margin-top: 2px; }
 
 /* Badges */
 #setup-panel .badge { font-size: 11px; padding: 2px 8px; border-radius: 10px; font-weight: 500; }
@@ -168,7 +169,7 @@
 #setup-panel .badge-ready { background: rgba(88,166,255,0.1); color: var(--fg-dim); }
 #setup-panel .badge-missing { background: rgba(210,153,34,0.15); color: var(--yellow, #e0af68); }
 #setup-panel .badge-warn { background: rgba(248,81,73,0.15); color: var(--red, #f7768e); }
-#setup-panel .badge-dim { background: rgba(139,148,158,0.1); color: #484f58; }
+#setup-panel .badge-dim { background: rgba(139,148,158,0.12); color: #8b949e; }
 #setup-panel .badge-free { background: rgba(63,185,80,0.15); color: var(--green, #9ece6a); font-size: 10px; padding: 1px 6px; border-radius: 8px; font-weight: 600; letter-spacing: 0.03em; }
 
 /* Embedding rows */

package/template/claude-task-manager/public/css/walle.css

@@ -345,9 +345,14 @@
   overflow-wrap: anywhere;
 }
 .we-service-alert-action {
+  border: 0;
+  background: transparent;
   color: #74c0fc;
   font-weight: 700;
   text-decoration: underline;
+  cursor: pointer;
+  padding: 0;
+  font: inherit;
 }
 
 /* Conversation turn group — user question + assistant response paired together */