@bahulam/code 0.1.23 → 0.1.25

package/src/local-service/agent-relay.mjs

@@ -110,6 +110,13 @@ export class LocalAgentRelay {
     this.flushingFollowups = false;
     this.cancellationRequested = false;
     this.cancellationEventEmitted = false;
+    // Background-job nudge bookkeeping. See _onBackgroundJobFinished.
+    this._bgUnsubscribe = null;
+    this._bgNotifiedJobIds = new Set();
+    // Trace: per-call_id start-time cache for computing duration on tool_result.
+    // Keyed by call_id | request_id. Cleaned up on tool_result.
+    this._pendingToolCalls = new Map();
+    this._traceSeq = 0;
   }
 
   async listHistorySessions() {
@@ -126,6 +133,24 @@ export class LocalAgentRelay {
     return this._historySnapshot();
   }
 
+  /**
+   * Return full trace entries (unelided args/output/errors) for
+   * /api/trace/export. One entry per tool call. Pass includeTurns=true
+   * to also include user/assistant turns so exports can be correlated.
+   */
+  fullTrace({ includeTurns = false } = {}) {
+    const trace = fullTraceEntries(this.displayHistory);
+    if (!includeTurns) return trace;
+    const turns = this.displayHistory
+      .filter(e => e?.role === 'user' || e?.role === 'assistant')
+      .map(e => ({
+        role: e.role,
+        timestamp: e.timestamp || null,
+        content: typeof e.content === 'string' ? e.content : JSON.stringify(e.content ?? ''),
+      }));
+    return { turns, trace };
+  }
+
   async startNewHistory() {
     if (this.running) {
       const err = new Error('A local agent turn is already running for this workspace');
@@ -137,6 +162,8 @@ export class LocalAgentRelay {
     this.turnCount = 0;
     this.displayHistory = [];
     this.agentHistory = [];
+    this._pendingToolCalls.clear();
+    this._traceSeq = 0;
     this.jsonlWriter = null;
     if (this.client) {
       this.client.sessionId = null;
@@ -288,6 +315,7 @@ export class LocalAgentRelay {
           const data = event.data || {};
           turnHistory.addToolUse(data);
           writer.accumulateToolCall(data.call_id || data.request_id, data.tool || data.name, data.args || data.input);
+          this._traceRecordCall(data);
         }
 
         if (event.type === 'tool_done' || event.type === 'tool_result') {
@@ -299,6 +327,7 @@ export class LocalAgentRelay {
             data.success === false || data.is_error,
             data,
           );
+          this._traceRecordResult(data);
         }
 
         if (event.type === 'complete') {
@@ -471,10 +500,41 @@ export class LocalAgentRelay {
       err.code = 'BAD_REQUEST';
       throw err;
     }
+    // Promote-on-idle: if no turn is currently running, treat the
+    // follow-up as a fresh instruction and start a new turn. Fixes the
+    // "cancelled + typed continue → task ended, task wont resume" gap
+    // where the last turn was cancelled (or the last tool call was a
+    // fire-and-forget background job) and the client still routes input
+    // through the follow-up channel.
     if (!this.running || !this.client) {
-      const err = new Error('No running agent turn to follow up');
-      err.code = 'CONFLICT';
-      throw err;
+      const promotedId = `promoted-followup-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+      // Best-effort acknowledgement so panels can show "picked up where
+      // you left off" instead of a silent restart.
+      try {
+        this.emit('agent_followup_promoted', {
+          intervention_id: promotedId,
+          instruction: text.slice(0, 500),
+          reason: this.running ? 'client-not-initialized' : 'no-running-turn',
+        });
+      } catch { /* SSE failure must never block promotion */ }
+      // Fire and await runTurn; caller's HTTP handler expects a JSON
+      // reply, and we want to signal the promoted status regardless of
+      // how long the new turn takes to spin up.
+      const started = this.runTurn({ prompt: text }).catch((err) => {
+        try {
+          this.emit('agent_error', { turn_id: null, message: `promoted follow-up failed: ${err.message || String(err)}` });
+        } catch { /* ok */ }
+      });
+      // Do not block: return acknowledgement synchronously so the
+      // client can render immediately; the new turn's events stream
+      // over SSE as they normally do.
+      void started;
+      return {
+        ok: true,
+        status: 'promoted_to_new_turn',
+        intervention_id: promotedId,
+        task_id: null,
+      };
     }
 
     const item = {
@@ -532,6 +592,83 @@ export class LocalAgentRelay {
     }
   }
 
+  /**
+   * Background-task nudge — called by backgroundTasks.onExit when any
+   * shell-spawned job finishes. Filters:
+   *
+   *   - Skips jobs that declared an explicit `on_complete` target
+   *     (the caller opted into a specific trigger; nudging would be a
+   *     double dispatch).
+   *   - Skips user-killed jobs (killing signals "I'm done with it").
+   *   - Skips jobs whose cwd is outside this workspace (defensive —
+   *     lets the singleton be shared across processes without cross-talk).
+   *   - Idempotent: each job id nudges at most once.
+   *
+   * Routing:
+   *   - If a turn is running: append to pendingFollowups so the current
+   *     agent turn picks it up naturally at the next event tick.
+   *   - If idle: promote to a fresh runTurn — same path as the
+   *     followup-promote branch, so client behavior is uniform.
+   */
+  _onBackgroundJobFinished(jobDesc) {
+    if (!jobDesc || !jobDesc.id) return;
+    if (this._bgNotifiedJobIds.has(jobDesc.id)) return;
+    if (jobDesc.on_complete) return;
+    if (jobDesc.status === 'killed') return;
+    const ownRoot = this.session?.root_path || '';
+    const jobCwd = jobDesc.cwd || '';
+    if (ownRoot && jobCwd && !jobCwd.startsWith(ownRoot)) return;
+    this._bgNotifiedJobIds.add(jobDesc.id);
+
+    const instruction = this._buildBackgroundJobNudge(jobDesc);
+
+    try {
+      this.emit('agent_background_job_finished', {
+        job_id: jobDesc.id,
+        status: jobDesc.status,
+        exit_code: jobDesc.exit_code,
+        duration_s: jobDesc.duration_s,
+        command: (jobDesc.command || '').slice(0, 240),
+        will_nudge: true,
+      });
+    } catch { /* SSE failure must never block the nudge */ }
+
+    const idempotencyKey = `bg-nudge-${jobDesc.id}`;
+    if (this.running && this.client) {
+      this.pendingFollowups.push({
+        instruction,
+        role: 'user',
+        messageType: 'background_job_nudge',
+        priority: 'normal',
+        idempotencyKey,
+      });
+      // If the runtime is already draining events, flush now; else the
+      // next tool_result cycle will do it.
+      this._flushQueuedFollowups().catch(() => { /* best-effort */ });
+      return;
+    }
+    // Idle — promote a fresh turn.
+    this.runTurn({ prompt: instruction }).catch((err) => {
+      try { this.emit('agent_error', { turn_id: null, message: `bg nudge turn failed: ${err.message || String(err)}` }); }
+      catch { /* ok */ }
+    });
+  }
+
+  _buildBackgroundJobNudge(job) {
+    const tailLines = String(job.tail || '').split('\n').slice(-20).join('\n');
+    const parts = [
+      `Background job \`${job.id}\` finished (status=${job.status}, exit=${job.exit_code}, duration ${job.duration_s}s).`,
+      `Command: ${job.command}`,
+    ];
+    if (tailLines) {
+      parts.push('Recent output:\n```\n' + tailLines + '\n```');
+    } else {
+      parts.push('(no output captured)');
+    }
+    parts.push('Continue from here.');
+    return parts.join('\n\n');
+  }
+
   async _sendFollowupNow(item) {
     const result = await this.client.sendIntervention(item.instruction, {
       idempotencyKey: item.idempotencyKey,
@@ -600,6 +737,21 @@ export class LocalAgentRelay {
       process.chdir(this.session.root_path);
     }
 
+    // Background-task nudge: subscribe once so a `shell {run_in_background:true}`
+    // that finishes AFTER the user cancelled the turn (or after the turn
+    // that started it completed) doesn't die in silence. See
+    // _onBackgroundJobFinished for the routing rules.
+    if (!this._bgUnsubscribe) {
+      const { backgroundTasks } = await import('../core/background-tasks.mjs');
+      this._bgUnsubscribe = backgroundTasks.onExit((jobDesc) => {
+        try { this._onBackgroundJobFinished(jobDesc); }
+        catch (err) {
+          try { this.emit('agent_error', { turn_id: null, message: `bg nudge handler failed: ${err.message || String(err)}` }); }
+          catch { /* ok */ }
+        }
+      });
+    }
+
     const { PluginRegistry } = await import('../plugins/registry.mjs');
     const activePlugins = activePluginNamesFromSession(this.session);
     const pluginDirs = pluginScanDirsFromSession(this.session);
@@ -755,6 +907,13 @@ export class LocalAgentRelay {
   _makeWorkspaceSessionSubstrate(pluginRegistry) {
     return (agent, node, instruction, { scopedExecutor } = {}) => (async function* (relay) {
       const execContext = await relay._buildExecContext(instruction);
+      // Per-agent model override from YAML — same pattern as agents.mjs:330.
+      // If the agent definition declares a `model` field, it wins over
+      // the session default for this sub-agent's turn.
+      if (agent.model) execContext.model_override = agent.model;
+      if (agent.models && typeof agent.models === 'object' && Object.keys(agent.models).length) {
+        execContext.model_overrides = { ...(execContext.model_overrides || {}), ...agent.models };
+      }
       const slug = agent.slug || agent.command || agent.name || node?.agent_slug || node?.id || 'agent';
       execContext.sub_agent = {
         slug,
@@ -819,6 +978,68 @@ export class LocalAgentRelay {
     return lines.join('\n');
   }
 
+  // ── Trace ────────────────────────────────────────────────────────
+  // Two entry points fire for every tool: _traceRecordCall on
+  // tool_call / tool_request, _traceRecordResult on tool_result /
+  // tool_done. Together they populate displayHistory with role:'tool'
+  // rows carrying { id, ts, tool, plugin, args, status, output, error?,
+  // duration_ms, sub_agent?, call_id, parent_id?, kind }. The compact
+  // view is derived from these; the full data is written verbatim to
+  // the transcript writer for /api/trace/export.
+
+  _traceRecordCall(data) {
+    const callId = data.call_id || data.request_id || data.tool_id || `call_${++this._traceSeq}`;
+    const startTs = Date.now();
+    this._pendingToolCalls.set(callId, {
+      startTs,
+      tool: data.tool || data.name || '',
+      plugin: data.plugin || data._plugin || null,
+      args: data.args || data.input || {},
+      sub_agent: data.sub_agent || null,
+      parent_id: data.parent_id || data.parent_call_id || null,
+    });
+  }
+
+  _traceRecordResult(data) {
+    const callId = data.call_id || data._callId || data.request_id || data.id || data.tool_use_id;
+    const pending = callId ? this._pendingToolCalls.get(callId) : null;
+    if (callId) this._pendingToolCalls.delete(callId);
+
+    const startTs = pending?.startTs || Date.now();
+    const endTs = Date.now();
+    const durationMs = data.duration_ms || (endTs - startTs);
+    const isError = data.success === false || data.is_error === true || Boolean(data.error);
+
+    // Prefer the structured error envelope from normalizeToolResult if present.
+    const errEnvelope = data.error && typeof data.error === 'object' && data.error.code
+      ? {
+          code: String(data.error.code || 'UNKNOWN'),
+          message: String(data.error.message || data.output || ''),
+          ...(data.error.hint ? { hint: String(data.error.hint) } : {}),
+          ...(process.env.DEBUG && data.error.stack ? { stack: String(data.error.stack) } : {}),
+        }
+      : (isError
+          ? { code: 'UNKNOWN', message: typeof data.output === 'string' ? data.output : (data.message || 'Tool call failed.') }
+          : null);
+
+    this.displayHistory.push({
+      role: 'tool',
+      kind: isError ? 'error' : 'result',
+      tool: pending?.tool || data.tool || data.name || '',
+      plugin: pending?.plugin || data.plugin || data._plugin || null,
+      call_id: callId || null,
+      parent_id: pending?.parent_id || null,
+      sub_agent: pending?.sub_agent || data.sub_agent || null,
+      args: pending?.args || data.args || {},
+      output: data.output ?? data.result ?? data.message ?? '',
+      error: errEnvelope,
+      status: isError ? 'error' : 'ok',
+      duration_ms: durationMs,
+      timestamp: new Date(endTs).toISOString(),
+      order: this.displayHistory.length,
+    });
+  }
+
   _historySnapshot() {
     return {
       ok: true,
@@ -1033,15 +1254,73 @@ function browserMessages(history = []) {
     }));
 }
 
-function browserTraceItems(history = []) {
+// Compact trace summary for the panel — full data lives on the
+// history entry itself (available via /api/trace/export).
+//
+// Handles two entry shapes:
+//   1. Live entries pushed by _traceRecordResult (single row per round-trip,
+//      with kind: 'result'|'error', args, output, error, duration_ms).
+//   2. Resume entries built by local-store.buildResumeHistory (separate
+//      rows per tool_call and tool_result, with kind: 'call'|'result',
+//      only `content` populated).
+//
+// The `type` field preserves the historical `history_tool_<kind>` shape
+// so consumers can distinguish call vs. result vs. error rows without
+// knowing which pipeline produced them.
+export function browserTraceItems(history = []) {
+  return history
+    .filter((entry) => entry?.role === 'tool')
+    .map((entry) => {
+      const kind = entry.kind || (entry.status === 'error' ? 'error' : 'result');
+      const isLive = entry.call_id != null || entry.args !== undefined || entry.error !== undefined;
+      const base = {
+        type: `history_tool_${kind}`,
+        timestamp: entry.timestamp || null,
+        tool: entry.tool || null,
+        kind,
+      };
+      if (!isLive) {
+        // Resume entry — surface content as-is for backward compat.
+        return { ...base, content: typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content || '') };
+      }
+      return {
+        ...base,
+        id: entry.call_id || null,
+        parent_id: entry.parent_id || null,
+        plugin: entry.plugin || null,
+        status: entry.status || (kind === 'error' ? 'error' : 'ok'),
+        duration_ms: entry.duration_ms ?? null,
+        args_summary: elide(typeof entry.args === 'string' ? entry.args : JSON.stringify(entry.args ?? {}), 320),
+        output_summary: elide(typeof entry.output === 'string' ? entry.output : JSON.stringify(entry.output ?? ''), 320),
+        error: entry.error
+          ? { code: entry.error.code, message: elide(entry.error.message, 220), hint: entry.error.hint || null }
+          : null,
+        sub_agent: entry.sub_agent || null,
+      };
+    });
+}
+
+function elide(text, max = 320) {
+  const s = typeof text === 'string' ? text : JSON.stringify(text ?? '');
+  return s.length > max ? `${s.slice(0, max)}…` : s;
+}
+
+// Full trace entries (unelided) for /api/trace/export.
+export function fullTraceEntries(history = []) {
   return history
     .filter((entry) => entry?.role === 'tool')
     .map((entry) => ({
-      type: `history_tool_${entry.kind || 'event'}`,
+      id: entry.call_id || null,
+      parent_id: entry.parent_id || null,
       timestamp: entry.timestamp || null,
       tool: entry.tool || null,
-      kind: entry.kind || null,
-      content: typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content || ''),
+      plugin: entry.plugin || null,
+      status: entry.status || (entry.kind === 'error' ? 'error' : 'ok'),
+      duration_ms: entry.duration_ms ?? null,
+      args: entry.args ?? null,
+      output: entry.output ?? null,
+      error: entry.error || null,
+      sub_agent: entry.sub_agent || null,
     }));
 }
 

package/src/local-service/server.mjs

@@ -288,6 +288,19 @@ async function routeRequest({ req, res, sessionId, token, events, sseClients, em
     return;
   }
 
+  // Vendor asset: Bahulam plugin design system (CSS/JS shared across views).
+  // Served from assets/bahulam-plugin/ so every plugin workspace view can
+  // import a common design language without inlining or server-side packing.
+  if (req.method === 'GET' && url.pathname.startsWith('/vendor/bahulam-plugin/')) {
+    sendPackageAsset({
+      res,
+      root: fileURLToPath(new URL('../../assets/bahulam-plugin/', import.meta.url)),
+      pathname: url.pathname,
+      prefix: '/vendor/bahulam-plugin/',
+    });
+    return;
+  }
+
   if (req.method === 'GET' && url.pathname === '/assets/bahulam-mark.png') {
     sendBrandMark(res);
     return;
@@ -312,6 +325,30 @@ async function routeRequest({ req, res, sessionId, token, events, sseClients, em
     return;
   }
 
+  // Trace export — one JSONL line per tool call with FULL args / output /
+  // error / stack (no eliding). Pass ?turns=1 to also stream user +
+  // assistant messages (as separate lines with role="turn") for
+  // correlation.
+  if (req.method === 'GET' && url.pathname === '/api/trace/export') {
+    const relay = getAgentRelay(session);
+    const includeTurns = url.searchParams.get('turns') === '1' || url.searchParams.get('turns') === 'true';
+    const data = relay.fullTrace({ includeTurns });
+    const filename = `trace-${session.id || 'session'}-${Date.now()}.jsonl`;
+    res.writeHead(200, {
+      'Content-Type': 'application/x-ndjson; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${filename}"`,
+      'Cache-Control': 'no-store',
+    });
+    if (includeTurns) {
+      for (const t of data.turns || []) res.write(JSON.stringify({ role: 'turn', ...t }) + '\n');
+      for (const e of data.trace || []) res.write(JSON.stringify({ role: 'tool', ...e }) + '\n');
+    } else {
+      for (const e of data || []) res.write(JSON.stringify(e) + '\n');
+    }
+    res.end();
+    return;
+  }
+
   if (req.method === 'GET' && url.pathname === '/api/chat/sessions') {
     const relay = getAgentRelay(session);
     const historySessions = await relay.listHistorySessions();

package/src/orchestration/node-runner.mjs

@@ -43,7 +43,8 @@ export async function* runNode(node, agent, instruction, ctx, options = {}) {
 
   const model = node.model || effectiveAgent.model || ctx.defaultModel || null;
   const { apiKey = null, openRouterKey = null } = ctx.credentials || {};
-  if (!apiKey && !openRouterKey) {
+  const useGateway = ctx.modelTransport === 'gateway' && ctx.gatewayToken;
+  if (!useGateway && !apiKey && !openRouterKey) {
     throw new Error(
       `Cannot run node '${node.id}' locally: no model API key. ` +
       'Set ANTHROPIC_API_KEY or OPENROUTER_API_KEY, or log in and use the session substrate.',
@@ -60,8 +61,11 @@ export async function* runNode(node, agent, instruction, ctx, options = {}) {
     .filter(schema => declaredTools.has(schema.name));
 
   const localAgent = new LocalAgent({
-    apiKey,
-    openRouterKey,
+    apiKey: useGateway ? null : apiKey,
+    openRouterKey: useGateway ? null : openRouterKey,
+    gatewayUrl: useGateway ? ctx.gatewayUrl : null,
+    gatewayToken: useGateway ? ctx.gatewayToken : null,
+    sessionId: ctx.sessionId || null,
     model,
     toolExecutor: scopedExecutor,
     cwd: ctx.cwd || process.cwd(),

package/src/permissions/command-classifier.mjs

@@ -238,6 +238,24 @@ const EXACT_SAFE = new Set([
     'python --version', 'python3 --version',
 ]);
 
+/** Tools commonly invoked with -version/--version to probe the installed version.
+ *  These are pure reads (no file access, no network) and should never require
+ *  project-scoping — they probe the local system's SDK/toolchain. */
+const VERSION_PROBE_TOOLS = new Set([
+    'java', 'javac', 'python', 'python3', 'node', 'ruby', 'go', 'rustc',
+    'deno', 'bun', 'php', 'perl', 'gcc', 'clang', 'make', 'cmake', 'mvn',
+    'gradle', 'pip', 'npm', 'yarn', 'pnpm', 'cargo', 'swift', 'kotlin',
+]);
+
+/** Absolute paths to system probes that are safe to invoke for read-only
+ *  version/path queries. These live outside any project root and should not
+ *  trigger project-scope errors. */
+const SAFE_ABS_PROBE_PATHS = new Set([
+    '/usr/libexec/java_home',
+    '/usr/bin/xcode-select',
+    '/usr/bin/which',
+]);
+
 /**
  * Commands with allowed flags — allowlist approach.
  * Key: command name (or "git diff" for multi-word).
@@ -682,6 +700,23 @@ function classifySingleCommand(command) {
         return { classification: 'safe', reason: 'Echo without expansion' };
     }
 
+    // ── Version probe: <tool> -version / --version (pure OS read, no project needed) ──
+    if (VERSION_PROBE_TOOLS.has(baseCmd)) {
+        const token = tokenize(trimmed);
+        const flag = token[1] || '';
+        if (/^--?v(ersion)?$/.test(flag)) {
+            return { classification: 'safe', reason: `Version probe: ${baseCmd}` };
+        }
+    }
+
+    // ── Known system-probe absolute paths (e.g. /usr/libexec/java_home -V) ──
+    if (SAFE_ABS_PROBE_PATHS.has(baseCmd)) {
+        const rest = trimmed.slice(baseCmd.length).trim();
+        if (!rest || /^--?[a-z]/i.test(rest)) {
+            return { classification: 'safe', reason: `System probe: ${baseCmd}` };
+        }
+    }
+
     // ── Default: contained (unknown command, not explicitly blocked) ──
     return { classification: 'contained', reason: `Unknown command, defaulting to contained: ${baseCmd}` };
 }

package/src/plugins/executor.mjs

@@ -8,6 +8,7 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import path from 'path';
 import { makePluginState } from './state.mjs';
+import { normalizeToolResult } from '../core/tool-error.mjs';
 
 /**
  * Load a plugin tool handler by resolving its path relative to the plugin directory.
@@ -105,13 +106,12 @@ export async function createPluginToolExecutor(manifest, opts = {}) {
         get state() { return getState(); },
         pluginName,
       };
+      const traceId = options?._trace_id || null;
       try {
         const result = await entry.handler.call(args || {}, handlerOpts);
-        return result?.success !== false
-          ? { success: true, output: result?.output ?? result, _tool: name, _plugin: pluginName }
-          : { success: false, output: result?.output ?? String(result), _tool: name, _plugin: pluginName };
+        return normalizeToolResult({ tool: name, plugin: pluginName, traceId }, result, null);
       } catch (err) {
-        return { success: false, output: `Plugin tool error (${name}): ${err.message}`, _tool: name, _plugin: pluginName };
+        return normalizeToolResult({ tool: name, plugin: pluginName, traceId }, null, err);
       }
     },
     list: () => [...handlers.keys()],