create-walle 0.9.21 → 0.9.23

package/template/wall-e/coding/tool-registry.js

@@ -13,11 +13,13 @@ class ToolRegistry {
     agentRuntime = null,
     brain = null,
     transcript = null,
+    lifecycleHooks = null,
     projectRoot = process.cwd(),
     enableTaskTool = false,
     sessionIndex = null,
     enableSessionTools = false,
     specialHandlers = {},
+    unknownToolHandler = null,
   } = {}) {
     this.middleware = middleware || null;
     this.localTools = localTools || null;
@@ -35,9 +37,11 @@ class ToolRegistry {
         agentRuntime,
         brain,
         transcript,
+        lifecycleHooks,
       });
     }
     this.specialHandlers = { ...specialHandlers };
+    this.unknownToolHandler = typeof unknownToolHandler === 'function' ? unknownToolHandler : null;
     this.tools = new Map();
     for (const tool of builtinTools || []) {
       this.register(tool.name, tool);
@@ -153,6 +157,9 @@ class ToolRegistry {
       const result = this.sessionIndex.getSession(prepared.args.sessionId, prepared.args);
       return result || invalidTool(name, `Unknown Wall-E session: ${prepared.args.sessionId}`);
     }
+    if (this.unknownToolHandler) {
+      return this.unknownToolHandler(name, args, ctx);
+    }
 
     const local = this.localTools || safeLocalTools();
     if (local?.executeLocalTool) {
@@ -289,6 +296,10 @@ function normalizeDefinition(def = {}) {
   const readOnly = Boolean(def.readOnly ?? def.read_only ?? sideEffect === 'read');
   const approval = normalizeApproval(def.approval || def.approvalPolicy || (readOnly ? 'never' : 'required'));
   const supportsParallel = Boolean(def.supportsParallel ?? def.supports_parallel ?? (readOnly && approval === 'never'));
+  const interruptBehavior = normalizeInterruptBehavior(def.interruptBehavior || def.interrupt_behavior || (readOnly ? 'cancel' : 'block'));
+  const resultBudgetBytes = Number.isFinite(Number(def.resultBudgetBytes || def.result_budget_bytes))
+    ? Number(def.resultBudgetBytes || def.result_budget_bytes)
+    : undefined;
   return {
     ...def,
     name: def.name,
@@ -298,7 +309,12 @@ function normalizeDefinition(def = {}) {
     sideEffect,
     approval,
     supportsParallel,
+    interruptBehavior,
     outputPolicy: normalizeOutputPolicy(def.outputPolicy || def.output_policy || 'inline'),
+    resultBudgetBytes,
+    telemetryPolicy: def.telemetryPolicy || def.telemetry_policy || 'safe-summary',
+    renderHint: def.renderHint || def.render_hint || (readOnly ? 'collapsed-read' : 'expanded-action'),
+    sandboxProfile: def.sandboxProfile || def.sandbox_profile || (sideEffect === 'read' ? 'readonly' : 'workspace'),
     source: String(def.source || def.kind || ''),
   };
 }
@@ -321,7 +337,12 @@ function toolSpec(def = {}) {
     sideEffect: normalized.sideEffect,
     approval: normalized.approval,
     supportsParallel: normalized.supportsParallel,
+    interruptBehavior: normalized.interruptBehavior,
     outputPolicy: normalized.outputPolicy,
+    resultBudgetBytes: normalized.resultBudgetBytes,
+    telemetryPolicy: normalized.telemetryPolicy,
+    renderHint: normalized.renderHint,
+    sandboxProfile: normalized.sandboxProfile,
     source: normalized.source || '',
     toolsets: nameList(normalized.toolsets || normalized.toolset),
   };
@@ -497,7 +518,19 @@ async function prepareExecution(name, definition, args, ctx = {}) {
   if (!availability.available) {
     return invalidTool(name, availability.reason || `Tool is unavailable: ${name}`);
   }
-  return validateArguments(name, args, def.input_schema);
+  let preparedArgs = args;
+  if (typeof def.prepareArgs === 'function') {
+    try {
+      const transformed = await def.prepareArgs(args, ctx);
+      if (transformed?.invalid) return transformed;
+      preparedArgs = transformed && Object.prototype.hasOwnProperty.call(transformed, 'args')
+        ? transformed.args
+        : transformed;
+    } catch (error) {
+      return invalidTool(name, error?.message || 'Tool argument normalization failed');
+    }
+  }
+  return validateArguments(name, preparedArgs, def.input_schema);
 }
 
 function prepareBridgeArgs(name, args) {
@@ -596,16 +629,16 @@ function sanitizeInputSchema(schema) {
 
 function inferSideEffect(name) {
   const toolName = String(name || '');
-  if (/^(read_file|list_directory|search_files|ripgrep|grep|find_files|lsp_|session_search|session_load|load_skill)$/.test(toolName)) {
+  if (/^(think|read_file|read_project_file|list_directory|search_files|search_project|ripgrep|grep|grep_files|glob|find_files|lsp_|session_search|session_load|load_skill|ctm_context|ctm_remote_access_status|ctm_session_search|lookup_person|list_mcp_tools|list_tasks|calendar_events|calendar_list|mail_messages|mail_read|mail_search|slack_search|slack_read_channel|system_info|clipboard_read|check_url|web_fetch|web_search|bg_output)$/.test(toolName)) {
     return 'read';
   }
-  if (/^(write_file|edit_file|multi_edit|apply_patch|delete_file|move_file)$/.test(toolName)) {
+  if (/^(write_file|edit_file|multi_edit|apply_patch|delete_file|move_file|remember_fact|mail_reply|slack_send_message|calendar_create|create_task|start_coding|notification|open_url|open_app|applescript|reminder_create)$/.test(toolName)) {
     return 'write';
   }
-  if (/^(run_shell|shell|bash|terminal)$/.test(toolName)) {
+  if (/^(run_shell|shell|bash|terminal|start_static_server|stop_static_server)$/.test(toolName)) {
     return 'process';
   }
-  if (/^(web_|fetch|http_|mail_|slack_|calendar_)/.test(toolName)) {
+  if (/^(web_|fetch|http_|check_url|mail_|slack_|calendar_)/.test(toolName)) {
     return 'network';
   }
   if (/^(mcp_call|mcp__|skill|skill__|task)$/.test(toolName)) {
@@ -624,6 +657,11 @@ function normalizeApproval(value) {
   return ['never', 'suggest', 'required'].includes(text) ? text : 'required';
 }
 
+function normalizeInterruptBehavior(value) {
+  const text = String(value || '').trim();
+  return text === 'cancel' ? 'cancel' : 'block';
+}
+
 function normalizeOutputPolicy(value) {
   const text = String(value || '').trim();
   return ['inline', 'artifact', 'synthesize'].includes(text) ? text : 'inline';

package/template/wall-e/coding/user-hooks.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+
+/**
+ * User-defined lifecycle hooks for the coding agent, loaded from
+ * `<projectRoot>/.walle/hooks.json` and `~/.walle/hooks.json`.
+ *
+ * Config shape (either a bare array or `{ "hooks": [...] }`):
+ *   {
+ *     "event":      "pre_tool" | "post_tool" | "stop" | "pre_compact" | "session_start",
+ *     "matcher":    "run_shell|edit_file",   // optional regex on tool name
+ *     "command":    "./scripts/check.sh",    // shell hook: payload JSON on stdin
+ *     "js":         "./hooks/check.js",      // OR a JS module exporting async (payload) => verdict
+ *     "timeout_ms": 10000,
+ *     "failMode":   "open" | "closed"        // hook crash/timeout: continue (default) or deny
+ *   }
+ *
+ * Shell protocol: exit 0 = continue (stdout may be JSON `{updatedInput}` for
+ * pre_tool, `{reason}` for context); exit 2 = deny, with the reason on stderr
+ * (or stdout). Any other failure follows failMode.
+ *
+ * `stop` deny means "the agent may not finish yet" — the orchestrator feeds
+ * the reason back to the model and continues the loop (bounded).
+ */
+
+const USER_HOOK_EVENTS = Object.freeze(['pre_tool', 'post_tool', 'stop', 'pre_compact', 'session_start']);
+const DEFAULT_HOOK_TIMEOUT_MS = 10000;
+const DENY_EXIT_CODE = 2;
+const MAX_HOOK_OUTPUT = 1024 * 1024;
+
+function loadHookConfigs({ projectRoot = '', homeDir = os.homedir() } = {}) {
+  const hooks = [];
+  const files = [];
+  if (homeDir) files.push(path.join(homeDir, '.walle', 'hooks.json'));
+  if (projectRoot) {
+    const projectFile = path.resolve(projectRoot, '.walle', 'hooks.json');
+    if (!files.includes(projectFile)) files.push(projectFile);
+  }
+  for (const file of files) {
+    let raw;
+    try {
+      raw = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue; // missing config is the normal case
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.hooks) ? parsed.hooks : [];
+      for (const entry of entries) {
+        if (!entry || typeof entry !== 'object') continue;
+        if (!USER_HOOK_EVENTS.includes(entry.event)) continue;
+        if (!entry.command && !entry.js) continue;
+        hooks.push({ ...entry, source: file });
+      }
+    } catch (err) {
+      console.warn(`[user-hooks] Ignoring invalid hooks config ${file}: ${err.message}`);
+    }
+  }
+  return hooks;
+}
+
+class UserHooks {
+  constructor({ hooks = [], cwd = process.cwd(), env = process.env, logger = console } = {}) {
+    this.hooks = hooks;
+    this.cwd = cwd;
+    this.env = env;
+    this.logger = logger;
+  }
+
+  hasHooks(event) {
+    return this.hooks.some((hook) => hook.event === event);
+  }
+
+  _matching(event, payload = {}) {
+    return this.hooks.filter((hook) => {
+      if (hook.event !== event) return false;
+      if (!hook.matcher) return true;
+      if (!payload.tool) return true;
+      try {
+        return new RegExp(hook.matcher).test(payload.tool);
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  /**
+   * Run all matching hooks sequentially. First deny short-circuits.
+   * @returns {Promise<{decision: 'allow'|'deny', reason: string, updatedInput: object|null}>}
+   */
+  async run(event, payload = {}) {
+    const verdict = { decision: 'allow', reason: '', updatedInput: null };
+    for (const hook of this._matching(event, payload)) {
+      let outcome;
+      try {
+        outcome = hook.js
+          ? await this._runJsHook(hook, { event, ...payload })
+          : await this._runShellHook(hook, { event, ...payload });
+      } catch (err) {
+        if (hook.failMode === 'closed') {
+          return { decision: 'deny', reason: `Hook failed (failMode=closed): ${err.message}`, updatedInput: null };
+        }
+        this.logger?.warn?.(`[user-hooks] ${event} hook from ${hook.source || 'config'} failed open: ${err.message}`);
+        continue;
+      }
+      if (outcome?.decision === 'deny') {
+        return { decision: 'deny', reason: outcome.reason || 'denied by user hook', updatedInput: null };
+      }
+      if (outcome?.updatedInput && typeof outcome.updatedInput === 'object') {
+        verdict.updatedInput = outcome.updatedInput;
+      }
+    }
+    return verdict;
+  }
+
+  /** Like run() but never denies — for observational events (post_tool). */
+  async runObserved(event, payload = {}) {
+    try {
+      await this.run(event, payload);
+    } catch (err) {
+      this.logger?.warn?.(`[user-hooks] ${event} hook error ignored: ${err.message}`);
+    }
+  }
+
+  async _runJsHook(hook, payload) {
+    const base = hook.source ? path.dirname(hook.source) : this.cwd;
+    const modulePath = path.isAbsolute(hook.js) ? hook.js : path.resolve(base, hook.js);
+    const mod = require(modulePath);
+    const handler = typeof mod === 'function' ? mod : mod?.handler;
+    if (typeof handler !== 'function') throw new Error(`JS hook ${modulePath} does not export a function`);
+    const result = await withTimeout(
+      Promise.resolve(handler(payload)),
+      hook.timeout_ms || DEFAULT_HOOK_TIMEOUT_MS,
+      `JS hook ${hook.js}`
+    );
+    return normalizeVerdict(result);
+  }
+
+  _runShellHook(hook, payload) {
+    const timeout = hook.timeout_ms || DEFAULT_HOOK_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const child = execFile('/bin/sh', ['-c', hook.command], {
+        cwd: this.cwd,
+        env: { ...this.env, WALLE_HOOK_EVENT: payload.event || hook.event },
+        timeout,
+        maxBuffer: MAX_HOOK_OUTPUT,
+      }, (err, stdout, stderr) => {
+        if (err && err.code === DENY_EXIT_CODE) {
+          resolve({
+            decision: 'deny',
+            reason: String(stderr || stdout || '').trim() || `hook ${hook.command} denied`,
+          });
+          return;
+        }
+        if (err) {
+          reject(new Error(err.killed ? `hook timed out after ${timeout}ms` : (String(stderr || '').trim() || err.message)));
+          return;
+        }
+        resolve(parseShellOutput(stdout));
+      });
+      try {
+        child.stdin.write(JSON.stringify(payload));
+        child.stdin.end();
+      } catch {
+        // hook may not read stdin — fine
+      }
+    });
+  }
+}
+
+function parseShellOutput(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return { decision: 'allow' };
+  try {
+    return normalizeVerdict(JSON.parse(text));
+  } catch {
+    return { decision: 'allow' };
+  }
+}
+
+function normalizeVerdict(value) {
+  if (!value || typeof value !== 'object') return { decision: 'allow' };
+  return {
+    decision: value.decision === 'deny' ? 'deny' : 'allow',
+    reason: String(value.reason || ''),
+    updatedInput: (value.updatedInput && typeof value.updatedInput === 'object') ? value.updatedInput : null,
+  };
+}
+
+function withTimeout(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, rejectRace) => {
+      timer = setTimeout(() => rejectRace(new Error(`${label} timed out after ${ms}ms`)), ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+function createUserHooks({ projectRoot = '', cwd = '', env = process.env, logger = console } = {}) {
+  if (process.env.WALLE_USER_HOOKS === '0') return null;
+  const hooks = loadHookConfigs({ projectRoot: projectRoot || cwd });
+  if (hooks.length === 0) return null;
+  return new UserHooks({ hooks, cwd: cwd || projectRoot || process.cwd(), env, logger });
+}
+
+module.exports = {
+  UserHooks,
+  createUserHooks,
+  loadHookConfigs,
+  USER_HOOK_EVENTS,
+  DEFAULT_HOOK_TIMEOUT_MS,
+};