@bahulam/code 0.1.2 → 0.1.3

package/src/core/tool-executor.mjs

@@ -24,9 +24,11 @@ import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
+import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import * as crypto from 'node:crypto';
 import { execSync } from 'node:child_process';
 
 /**
@@ -43,6 +45,35 @@ export function createToolExecutor({
     hookRunner = null,
     interactionHandler = null,
 } = {}) {
+    // Cross-session memory cache. Ships in getAgentContext() on every turn,
+    // so we need it to be byte-identical when the underlying disk file hasn't
+    // changed — otherwise the backend's prompt cache invalidates on every
+    // ExecuteRequest.
+    //
+    // Strategy: mtime-driven cache. Read the mtimes of the global +
+    // project memory files; if unchanged since the last call, return the
+    // cached snapshot. The `remember` tool writes to disk directly, which
+    // bumps mtime and forces a reload on the next getAgentContext() call.
+    //
+    // Self-heal ~/.bahulam/ once at construction; loadDiskMemory() also
+    // guards it, but doing it here means the first read is a plain fs stat
+    // rather than a mkdir round-trip.
+    try { ensureBahulamDir('global'); } catch { /* ignore */ }
+    let _memoryCache = null; // { key: string, facts: Fact[], digest: string }
+    function _readMemorySnapshot() {
+        const gPath = globalMemoryPath();
+        const pPath = projectMemoryPath(process.cwd());
+        const gStat = fs.existsSync(gPath) ? fs.statSync(gPath).mtimeMs : 0;
+        const pStat = fs.existsSync(pPath) ? fs.statSync(pPath).mtimeMs : 0;
+        const key = `${gStat}|${pStat}|${process.cwd()}`;
+        if (_memoryCache && _memoryCache.key === key) return _memoryCache;
+        const facts = loadDiskMemory(process.cwd());
+        const digest = crypto.createHash('sha256')
+            .update(JSON.stringify(facts.map(f => [f.fact_id, f.content, f.updated_at])))
+            .digest('hex').slice(0, 16);
+        _memoryCache = { key, facts, digest };
+        return _memoryCache;
+    }
     const occRegistry = createToolRegistry();
     const skillTool = occRegistry.get('Skill');
     if (skillTool) skillTool._skillsLoader = skillsLoader;
@@ -898,7 +929,7 @@ export function createToolExecutor({
 
             const observationTimeout = args.timeout == null && isLikelyLongRunningCommand(args.command);
             const effectiveTimeout = observationTimeout ? longRunningObservationTimeoutMs() : args.timeout;
-            const result = await occRegistry.call('Bash', {
+            const result = await occRegistry.call('shell', {
                 command: args.command,
                 timeout: effectiveTimeout,
                 description: args.description || `Run: ${(args.command || '').slice(0, 50)}`,
@@ -985,7 +1016,7 @@ export function createToolExecutor({
                         } catch { /* let Read handle the error */ }
                     }
 
-                    const result = await occRegistry.call('Read', {
+                    const result = await occRegistry.call('read_file', {
                         file_path: filePath,
                         offset,
                         limit,
@@ -1027,14 +1058,14 @@ export function createToolExecutor({
             // OCC Write requires Read first for existing files — handle gracefully
             try {
                 if (fs.existsSync(filePath)) {
-                    await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                    await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
                 }
             } catch { /* file may not exist yet */ }
             // Checkpoint before overwrite so /undo can restore the previous content.
             if (checkpoints && fs.existsSync(filePath)) {
                 try { checkpoints.save(filePath); } catch { /* best effort */ }
             }
-            const result = await occRegistry.call('Write', {
+            const result = await occRegistry.call('write_file', {
                 file_path: filePath,
                 content: args.content,
             });
@@ -1092,11 +1123,11 @@ export function createToolExecutor({
                     // Read first if exists (OCC Write requirement)
                     try {
                         if (fs.existsSync(filePath)) {
-                            await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                            await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
                         }
                     } catch { /* file may not exist yet */ }
 
-                    await occRegistry.call('Write', { file_path: filePath, content });
+                    await occRegistry.call('write_file', { file_path: filePath, content });
                     const after = readTextIfExists(filePath);
                     diffs.push(buildResultFileDiff(filePath, before, after));
                     updateProjectIndex(filePath);
@@ -1145,7 +1176,7 @@ export function createToolExecutor({
             }
             // OCC Edit requires Read first
             try {
-                await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
             } catch { /* best effort */ }
 
             // Checkpoint before edit so /undo can restore the previous content.
@@ -1155,10 +1186,10 @@ export function createToolExecutor({
 
             let result;
             try {
-                result = await occRegistry.call('Edit', {
+                result = await occRegistry.call('edit_file', {
                     file_path: filePath,
-                    old_string: args.search,
-                    new_string: args.replace,
+                    search: args.search,
+                    replace: args.replace,
                     replace_all: args.replace_all || false,
                 });
             } catch (editErr) {
@@ -1239,7 +1270,7 @@ print('OK: replaced')
                             _format: 'tree',
                         };
                     }
-                    const result = await occRegistry.call('Glob', {
+                    const result = await occRegistry.call('list_files', {
                         pattern: args.pattern || '**/*',
                         path: searchPath,
                     });
@@ -1343,7 +1374,7 @@ print('OK: replaced')
                     { query, path: searchPath, mode: 'glob' },
                     { generation: _readOnlyCacheGeneration },
                     async () => {
-                        const result = await occRegistry.call('Glob', {
+                        const result = await occRegistry.call('list_files', {
                             pattern: query,
                             path: searchPath,
                         });
@@ -1364,7 +1395,7 @@ print('OK: replaced')
                 { query, path: searchPath, mode: 'grep' },
                 { generation: _readOnlyCacheGeneration },
                 async () => {
-                    const result = await occRegistry.call('Grep', {
+                    const result = await occRegistry.call('search_code', {
                         pattern: query,
                         path: searchPath,
                         output_mode: 'content',
@@ -1521,7 +1552,7 @@ print('OK: replaced')
                     else if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) cmd = 'cargo build';
                     else return { success: false, output: 'No build system detected', _tool: 'validate_build' };
                 }
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: Math.min(args.timeout || 120_000, 600_000),
                     description: `Validate build: ${cmd.slice(0, 80)}`,
@@ -1571,7 +1602,7 @@ print('OK: replaced')
                 else if (['.js', '.mjs', '.ts', '.tsx'].includes(ext)) cmd = `npx eslint "${filePath}" 2>&1 || true`;
                 else return { success: true, issues: [], message: 'No linter for this file type', _tool: 'lint_check' };
 
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: 30_000,
                     description: `Lint: ${path.basename(filePath)}`,
@@ -1595,7 +1626,7 @@ print('OK: replaced')
                 throwIfAborted(options.signal);
                 const cmd = args.command || 'npm test';
                 const cwd = await commandCwd(args);
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: Math.min(args.timeout || 120_000, 600_000),
                     description: `Run tests: ${cmd.slice(0, 80)}`,
@@ -2197,10 +2228,19 @@ print('OK: replaced')
 
         getAgentContext() {
             const global = projectRegistry.getGlobalContext();
+            const mem = _readMemorySnapshot();
             return {
                 identity: global.identity,
                 preferences: global.preferences,
                 global_skills: skillsLoader.list(),
+                // Cross-session memory read from disk (CLI-only source of truth).
+                // Backend prefers this over the Supabase agent_memory table when
+                // ctx.agent_ctx.source === 'cli'. `memory_digest` is a stable
+                // sha256 prefix so the backend can hash-compare without
+                // re-serializing — helps keep the prompt cacheable when memory
+                // hasn't changed between turns.
+                memory_facts: mem.facts,
+                memory_digest: mem.digest,
                 available_agents: listLocalAgents(process.cwd()).map(agent => ({
                     slug: agent.slug,
                     name: agent.name,

package/src/daemon/approval-store.mjs

@@ -0,0 +1,253 @@
+/**
+ *   — Pending-approval registry + timeout policy.
+ *
+ * Bridges the two paths that can answer an approval request:
+ *
+ *   1. Local TTY  — the existing approval.mjs prompt (arrow keys, dock).
+ *   2. Remote     — a socket attach client (or later, mobile via relay)
+ *                    sending an `approve` / `deny` command with an apr_id.
+ *
+ * Both race the same promise. Whichever resolves first wins; the loser's
+ * resolver becomes a no-op. Cleanup on either resolution.
+ *
+ * Also owns the timeout policy from PRD §6.7:
+ *   - `hold`         : never times out (default; safe for attended sessions)
+ *   - `deny <sec>`   : auto-deny after N seconds if nobody has answered
+ *   - `allow <sec>`  : auto-approve — gated behind the existing
+ *                       `--dangerously-skip-permissions` opt-in, checked
+ *                       by the caller (this module doesn't enforce it).
+ *
+ * NOT in this module:
+ *   - The dispatch that turns a `check()` call into an `approval_required`
+ *     event. That's an intercept wrapper wired at the ApprovalManager
+ *     call sites (see attach-approval-bridge below).
+ *   - The socket-server side — `socket-server.mjs` already parses
+ *     `approve`/`deny` commands; the daemon wiring passes them here.
+ */
+
+import { randomBytes } from 'node:crypto';
+
+/** Approvals we're waiting on. Key: apr_id → { resolve, sourceType, timer } */
+const _pending = new Map();
+
+/** Default timeout policy: never expires. Change via setTimeoutPolicy(). */
+let _policy = { mode: 'hold', durationMs: 0 };
+
+// ── policy ────────────────────────────────────────────────────────────
+
+/**
+ * Set the session-level timeout policy for pending approvals.
+ * @param {{mode: 'hold'|'deny'|'allow', durationSec?: number}} p
+ */
+export function setTimeoutPolicy(p) {
+  const mode = p?.mode || 'hold';
+  const durationMs = Math.max(0, Number(p?.durationSec || 0)) * 1000;
+  _policy = { mode, durationMs };
+  return { mode, durationMs };
+}
+
+export function getTimeoutPolicy() {
+  return { ..._policy };
+}
+
+// ── registry ──────────────────────────────────────────────────────────
+
+/**
+ * Register a new pending approval. Returns { apr_id, race } where
+ *
+ *   race       — a Promise<{decision, decided_by, note}> that resolves
+ *                when ANY source (local TTY, socket, timeout) answers.
+ *   cancel(id) — called after another source has already resolved to
+ *                mark this pending entry as consumed and clean up the
+ *                timer. Idempotent.
+ *
+ * The caller (typically the approval manager intercept) also races this
+ * against the local TTY prompt. When the TTY prompt resolves, the caller
+ * should call `cancel(apr_id)` so a late socket `approve` becomes a
+ * no-op instead of getting an "unknown apr_id" error.
+ *
+ * @param {object} meta
+ * @param {string} meta.kind             tool name / classifier tag
+ * @param {string} meta.subject          human-readable one-liner
+ * @param {number} [meta.expiresAtMs]    caller-provided override; otherwise
+ *                                        we compute from the active policy.
+ */
+export function registerPending(meta = {}) {
+  const apr_id = `apr_${Date.now().toString(36)}_${randomBytes(4).toString('hex')}`;
+  let resolve;
+  const race = new Promise(r => { resolve = r; });
+
+  const entry = {
+    apr_id,
+    kind: meta.kind || 'unknown',
+    subject: meta.subject || '',
+    resolve,
+    consumed: false,
+    timer: null,
+  };
+  _pending.set(apr_id, entry);
+
+  // Wire policy timeout — only if a duration was set AND a mode that
+  // implies an automatic decision. `hold` never schedules a timer.
+  const policy = getTimeoutPolicy();
+  if (policy.mode !== 'hold' && policy.durationMs > 0) {
+    entry.timer = setTimeout(() => {
+      if (entry.consumed) return;
+      entry.consumed = true;
+      _pending.delete(apr_id);
+      resolve({
+        decision: policy.mode === 'allow' ? 'approve' : 'deny',
+        decided_by: 'timeout',
+        note: `timeout:${policy.mode}:${policy.durationMs}ms`,
+      });
+    }, policy.durationMs);
+    if (typeof entry.timer.unref === 'function') entry.timer.unref();
+  }
+
+  return {
+    apr_id,
+    race,
+    cancel() {
+      if (entry.consumed) return;
+      entry.consumed = true;
+      _pending.delete(apr_id);
+      if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
+    },
+    expiresAt: policy.mode !== 'hold' && policy.durationMs > 0
+      ? new Date(Date.now() + policy.durationMs).toISOString()
+      : null,
+  };
+}
+
+/**
+ * Called by the socket server's approve/deny handlers. Resolves the
+ * pending approval with the given decision. Returns true if the
+ * apr_id existed and was resolved; false if unknown or already consumed.
+ *
+ * @param {'approve'|'deny'} decision
+ * @param {string} apr_id
+ * @param {string} decided_by  attach_id of the answering client
+ * @param {string} [note]
+ */
+export function resolvePending(decision, apr_id, decided_by, note = '') {
+  const entry = _pending.get(apr_id);
+  if (!entry || entry.consumed) return false;
+  entry.consumed = true;
+  _pending.delete(apr_id);
+  if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
+  entry.resolve({ decision, decided_by, note });
+  return true;
+}
+
+/**
+ * Introspection — used by the socket server's `attach_joined` replay
+ * ( follow-up) and by `bahulam status` to show pending approvals.
+ */
+export function listPending() {
+  return Array.from(_pending.values(), e => ({
+    apr_id: e.apr_id,
+    kind: e.kind,
+    subject: e.subject,
+  }));
+}
+
+/**
+ * Clean up all pending approvals (session end, daemon shutdown). Every
+ * pending entry gets a synthetic `deny` decision so no `check()` call
+ * hangs forever.
+ */
+export function shutdownAllPending(reason = 'shutdown') {
+  for (const entry of Array.from(_pending.values())) {
+    if (entry.consumed) continue;
+    entry.consumed = true;
+    if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
+    entry.resolve({ decision: 'deny', decided_by: 'shutdown', note: reason });
+  }
+  _pending.clear();
+}
+
+// ── intercept helper for ApprovalManager ─────────────────────────────
+
+/**
+ * Wrap an ApprovalManager.check() call so that:
+ *   (a) an approval_required event is emitted (broadcast to attaches),
+ *   (b) a socket approve/deny can resolve the check before the TTY does.
+ *
+ * Usage in repl.mjs ( wiring):
+ *
+ *     const orig = approval.check.bind(approval);
+ *     approval.check = (tool, args, req, ctx) =>
+ *       interceptApproval(orig, { tool, args, req, ctx, sessionId, emit });
+ *
+ * `emit(event)` is the caller's hook that writes the approval_required
+ * event to the daemon event log (tap) so it also fans out to sockets.
+ * We do the emission here rather than inside registerPending so the
+ * store stays transport-agnostic.
+ */
+export async function interceptApproval(origCheck, { tool, args, req, ctx, sessionId, emit } = {}) {
+  const pending = registerPending({ kind: tool, subject: _subjectFromArgs(tool, args) });
+  const eventData = {
+    apr_id: pending.apr_id,
+    kind: tool,
+    subject: _subjectFromArgs(tool, args),
+    expires_at: pending.expiresAt,
+  };
+  if (typeof emit === 'function') {
+    try { emit('approval_required', eventData); } catch { /* never blocks approval */ }
+  }
+
+  // Race the local TTY prompt against the remote resolution promise.
+  // Whichever resolves first wins; cancel the other.
+  const local = origCheck(tool, args, req, ctx).then(v => ({ __src: 'local', v }));
+  const remote = pending.race.then(v => ({ __src: 'remote', v }));
+
+  const first = await Promise.race([local, remote]);
+  pending.cancel();
+
+  if (first.__src === 'local') {
+    // TTY already answered; nothing else to do. Emit approval_decided so
+    // remote watchers see the outcome.
+    if (typeof emit === 'function') {
+      try {
+        emit('approval_decided', {
+          apr_id: pending.apr_id,
+          decision: first.v?.approved ? 'approve' : 'deny',
+          decided_by: 'local_tty',
+        });
+      } catch { /* ignore */ }
+    }
+    return first.v;
+  }
+
+  // Remote answered. Build the same shape ApprovalManager.check() returns
+  // so the caller (stream-client's tool_request handler) doesn't need to
+  // care where the decision came from.
+  if (typeof emit === 'function') {
+    try {
+      emit('approval_decided', {
+        apr_id: pending.apr_id,
+        decision: first.v.decision,
+        decided_by: first.v.decided_by,
+        note: first.v.note,
+      });
+    } catch { /* ignore */ }
+  }
+  return {
+    approved: first.v.decision === 'approve',
+    tier: 'destructive',  // remote answers always treated as an explicit tier decision
+    reason: first.v.note || `Decided remotely by ${first.v.decided_by}`,
+    remoteDecision: true,
+  };
+}
+
+// ── helpers ──────────────────────────────────────────────────────────
+
+function _subjectFromArgs(tool, args) {
+  if (!args || typeof args !== 'object') return tool;
+  // Best-effort short summary of the most common tool args.
+  if (typeof args.command === 'string') return `${tool}: ${args.command.slice(0, 120)}`;
+  if (typeof args.cmd === 'string')     return `${tool}: ${args.cmd.slice(0, 120)}`;
+  if (typeof args.path === 'string')    return `${tool}: ${args.path}`;
+  if (typeof args.file_path === 'string') return `${tool}: ${args.file_path}`;
+  return tool;
+}