@bahulam/code 0.1.5 → 0.1.7

package/src/core/stream-client.mjs

@@ -76,6 +76,23 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function envMs(name, fallback) {
+    const raw = Number(process.env[name] || fallback);
+    return Number.isFinite(raw) && raw > 0 ? raw : fallback;
+}
+
+function transportDebugEnabled() {
+    const raw = String(process.env.BAHULAM_TRANSPORT_DEBUG || '').toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
+function transportDebug(message, data = {}) {
+    if (!transportDebugEnabled()) return;
+    try {
+        process.stderr.write(`[transport] ${message} ${JSON.stringify(data)}\n`);
+    } catch {}
+}
+
 // Full jitter around the scheduled delay: pick a value in [delay*0.5, delay*1.5].
 // Spreads out reconnect storms so N clients dropping simultaneously don't
 // synchronize their retries. Clamped to the same 30s ceiling as the base delay.
@@ -223,6 +240,7 @@ export class TarangStreamClient {
     async *execute(instruction, context = {}, messages = null) {
         this._cancelled = false;
         this.currentTaskId = null;
+        this._firstEventTimedOut = false;
 
         // Bundled mode: spawn the local Python runtime on first turn.
         // After this, this.baseUrl points at http://127.0.0.1:<random-port>
@@ -233,6 +251,7 @@ export class TarangStreamClient {
         const body = { instruction, context };
         if (messages && messages.length > 0) body.messages = messages;
         if (this.sessionId) body.session_id = this.sessionId;
+        const requestId = `cli-${_uuidLike()}`;
 
         // daemon cache-guard hook. If BAHULAM_CAPTURE_REQUEST is set to a file
         // path, serialize the exact body that would go to /api/execute, write
@@ -260,6 +279,8 @@ export class TarangStreamClient {
         const headers = this._headers({
             'Accept': 'text/event-stream',
             'Content-Type': 'application/json',
+            'X-Bahulam-Request-ID': requestId,
+            'X-Request-ID': requestId,
         });
 
         // Abort controller so cancel() can break out of a stalled reader
@@ -268,6 +289,21 @@ export class TarangStreamClient {
         this._toolAbort = new AbortController();
 
         let response;
+        let connectTimedOut = false;
+        const connectTimeoutMs = envMs('BAHULAM_EXECUTE_CONNECT_TIMEOUT_MS', 60_000);
+        const connectStarted = Date.now();
+        const connectTimer = setTimeout(() => {
+            connectTimedOut = true;
+            try { this._abort.abort(); } catch {}
+        }, connectTimeoutMs);
+        transportDebug('execute.start', {
+            request_id: requestId,
+            url,
+            mode: this.mode,
+            session_id: this.sessionId || null,
+            messages: Array.isArray(messages) ? messages.length : 0,
+            body_bytes: Buffer.byteLength(JSON.stringify(body), 'utf8'),
+        });
         try {
             response = await fetch(url, {
                 method: 'POST',
@@ -276,15 +312,39 @@ export class TarangStreamClient {
                 signal: this._abort.signal,
             });
         } catch (err) {
+            clearTimeout(connectTimer);
             if (err.name === 'AbortError') {
+                if (connectTimedOut) {
+                    const message = `Backend did not accept /api/execute within ${Math.round(connectTimeoutMs / 1000)}s (request ${requestId}).`;
+                    transportDebug('execute.connect_timeout', {
+                        request_id: requestId,
+                        ms: Date.now() - connectStarted,
+                    });
+                    yield { type: EVENT_TYPES.ERROR, data: { message, request_id: requestId, fatal: true } };
+                }
                 return;
             }
-            yield { type: EVENT_TYPES.ERROR, data: { message: `Network error: ${err.message}. Check your connection or use --local mode.`, fatal: true } };
+            transportDebug('execute.network_error', {
+                request_id: requestId,
+                ms: Date.now() - connectStarted,
+                error: err.message,
+                code: err?.cause?.code || err?.code || '',
+            });
+            yield { type: EVENT_TYPES.ERROR, data: { message: `Network error: ${err.message}. Check your connection or use --local mode.`, request_id: requestId, fatal: true } };
             return;
         }
+        clearTimeout(connectTimer);
+        const responseRequestId = response.headers.get('x-request-id') || requestId;
+        transportDebug('execute.response', {
+            request_id: responseRequestId,
+            status: response.status,
+            ok: response.ok,
+            ms: Date.now() - connectStarted,
+            task_id: response.headers.get('x-task-id') || null,
+        });
 
         if (response.status === 401) {
-            yield { type: EVENT_TYPES.ERROR, data: { message: 'Authentication failed. Run `bahulam login` to re-authenticate.', fatal: true } };
+            yield { type: EVENT_TYPES.ERROR, data: { message: 'Authentication failed. Run `bahulam login` to re-authenticate.', request_id: responseRequestId, fatal: true } };
             return;
         }
         if (response.status === 429) {
@@ -305,6 +365,7 @@ export class TarangStreamClient {
                     rate_limit: detail?.rate_limit || null,
                     action: detail?.action || null,
                     pricing_url: normalizeBillingBrandCopy(detail?.pricing_url || null),
+                    request_id: responseRequestId,
                     fatal: true,
                 },
             };
@@ -312,7 +373,7 @@ export class TarangStreamClient {
         }
         if (!response.ok) {
             const text = await response.text().catch(() => 'Unknown error');
-            yield { type: EVENT_TYPES.ERROR, data: { message: `Backend error ${response.status}: ${text}`, fatal: true } };
+            yield { type: EVENT_TYPES.ERROR, data: { message: `Backend error ${response.status}: ${text}`, request_id: responseRequestId, fatal: true } };
             return;
         }
 
@@ -322,6 +383,17 @@ export class TarangStreamClient {
             if (this._cancelled) {
                 return;
             }
+            if (this._firstEventTimedOut) {
+                yield {
+                    type: EVENT_TYPES.ERROR,
+                    data: {
+                        message: `Backend opened the stream but sent no SSE events within ${Math.round(envMs('BAHULAM_FIRST_EVENT_TIMEOUT_MS', 60_000) / 1000)}s (request ${responseRequestId}).`,
+                        request_id: responseRequestId,
+                        fatal: true,
+                    },
+                };
+                return;
+            }
             yield* this._reconnectAfterDrop(err);
         }
     }
@@ -330,18 +402,37 @@ export class TarangStreamClient {
         const taskId = response.headers.get('X-Task-ID');
         if (taskId) this.currentTaskId = taskId;
 
-        for await (const parsed of this._parseSSE(response)) {
-            if (this._cancelled) return;
-            await this._waitIfPaused();
-            if (this._cancelled) return;
+        let sawFirstEvent = false;
+        const firstEventTimeoutMs = envMs('BAHULAM_FIRST_EVENT_TIMEOUT_MS', 60_000);
+        const firstEventTimer = setTimeout(() => {
+            if (sawFirstEvent || this._cancelled) return;
+            this._firstEventTimedOut = true;
+            try { this._abort?.abort(); } catch {}
+        }, firstEventTimeoutMs);
+        try {
+            for await (const parsed of this._parseSSE(response)) {
+                if (!sawFirstEvent) {
+                    sawFirstEvent = true;
+                    clearTimeout(firstEventTimer);
+                    transportDebug('execute.first_event', {
+                        task_id: this.currentTaskId || null,
+                        event: parsed.event || null,
+                    });
+                }
+                if (this._cancelled) return;
+                await this._waitIfPaused();
+                if (this._cancelled) return;
 
-            if (parsed.id != null) this.lastEventId = parsed.id;
-            if (parsed.retry != null) this.retryDelayMs = parsed.retry;
-            if (parsed.data?.task_id) this.currentTaskId = parsed.data.task_id;
+                if (parsed.id != null) this.lastEventId = parsed.id;
+                if (parsed.retry != null) this.retryDelayMs = parsed.retry;
+                if (parsed.data?.task_id) this.currentTaskId = parsed.data.task_id;
 
-            for await (const event of this._handleStreamEvent(parsed)) {
-                yield event;
+                for await (const event of this._handleStreamEvent(parsed)) {
+                    yield event;
+                }
             }
+        } finally {
+            clearTimeout(firstEventTimer);
         }
     }
 
@@ -729,7 +820,7 @@ export class TarangStreamClient {
             tool,
             args || {},
             true,
-            { risk, reason },
+            { risk, reason, tool_id, call_id: tool_id, request_id: tool_id },
         );
 
         // Map ApprovalManager decision to framework scope
@@ -839,9 +930,10 @@ export class TarangStreamClient {
     }
 
     /**
-     * Submit a live-steering follow-up on the current running task (PRD-081 §5.2).
-     * Unlike resume(), this does NOT pause/unpause — the text is queued and
-     * delivered at the next tool boundary.
+     * Submit a live-steering user follow-up on the current running task
+     * (PRD-081 §5.2). Unlike resume(), this does NOT pause/unpause — the text
+     * is queued and delivered at the next tool boundary as a high-priority user
+     * intervention, never as a tool call.
      *
      * Returns a status object; callers should NOT swallow errors:
      *   { status: 'accepted', interventionId }        — queued on backend, SSE ack forthcoming
@@ -855,6 +947,7 @@ export class TarangStreamClient {
      * @param {string} [opts.idempotencyKey]  Optional client-generated id.
      *                                        Auto-generated when omitted; pass the same key
      *                                        for retries to stay idempotent.
+     * @param {string} [opts.priority]        User-message priority metadata.
      */
     async sendIntervention(instruction, opts = {}) {
         if (!this.currentTaskId) {
@@ -876,6 +969,9 @@ export class TarangStreamClient {
                     body: JSON.stringify({
                         instruction: text,
                         intervention_id: interventionId,
+                        role: 'user',
+                        message_type: 'user_intervention',
+                        priority: opts.priority || 'high',
                     }),
                 },
             );

package/src/core/tool-executor.mjs

@@ -19,12 +19,14 @@ import { SkillsLoader } from '../skills/loader.mjs';
 import { createAgentFile, listLocalAgents, syncAgentsToBackend } from '../agents/scaffold.mjs';
 import { createWorkflowFile, listLocalWorkflows, WORKFLOW_SYNC_ENDPOINT, slugifyWorkflowName } from '../agents/workflow_scaffold.mjs';
 import { TarangAuth } from '../auth/tarang-auth.mjs';
+import { detectImageFile } from './attachments.mjs';
 import { streamResponse } from './streaming.mjs';
 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 { resolveLintCommand } from './lint-resolver.mjs';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
@@ -44,6 +46,8 @@ export function createToolExecutor({
     checkpoints = null,
     hookRunner = null,
     interactionHandler = null,
+    onAutoRegisterStart = null,
+    onAutoRegisterDone = 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
@@ -94,9 +98,19 @@ export function createToolExecutor({
     // for the current directory to be usable — the user chose to be here.
     // Opt out via BAHULAM_SKIP_AUTO_REGISTER=true for tests or headless
     // scripts that want a truly empty registry.
+    let autoRegisterPromise = Promise.resolve(null);
     if (process.env.BAHULAM_SKIP_AUTO_REGISTER !== 'true') {
-        projectRegistry.register(process.cwd(), { bypassProjectMarkers: true })
-            .catch(() => { /* silent — model can register explicitly */ });
+        const autoRegisterRoot = process.cwd();
+        try { onAutoRegisterStart?.(autoRegisterRoot); } catch { /* status hooks are best-effort */ }
+        autoRegisterPromise = projectRegistry.register(autoRegisterRoot, { bypassProjectMarkers: true })
+            .then((result) => {
+                try { onAutoRegisterDone?.(null, result); } catch { /* status hooks are best-effort */ }
+                return result;
+            })
+            .catch((err) => {
+                try { onAutoRegisterDone?.(err, null); } catch { /* status hooks are best-effort */ }
+                return null;
+            });
     }
     let _searchCodeUsed = false; // tracks if search_code was called (for read_file nudge)
     let _readOnlyCacheGeneration = 0;
@@ -475,15 +489,6 @@ export function createToolExecutor({
 
     // ── Auto-lint after file writes ────────────────────────────
 
-    const LINT_COMMANDS = {
-        '.py':  (file) => `python3 -m py_compile "${file}" 2>&1`,
-        '.js':  (file) => `npx eslint --no-eslintrc --rule '{}' "${file}" 2>&1 || true`,
-        '.ts':  (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.tsx': (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.go':  (file) => `go vet "${file}" 2>&1`,
-        '.rs':  (file) => `rustfmt --check "${file}" 2>&1`,
-    };
-
     // tsc --pretty and eslint emit ANSI codes (including background-red
     // highlights) which bleed when our renderer slices the first 80 chars.
     // Strip color codes so the stored lint string is always plain text.
@@ -491,15 +496,19 @@ export function createToolExecutor({
     function stripAnsi(s) { return String(s || '').replace(ANSI_RE, ''); }
 
     function autoLint(filePath) {
-        const ext = path.extname(filePath);
-        const cmdFn = LINT_COMMANDS[ext];
-        if (!cmdFn) return null;
+        const project = projectRegistry.projectForPath(filePath);
+        const lint = resolveLintCommand(filePath, {
+            projectRoot: project?.resource?.root || projectRootFor(filePath),
+            projectCommands: project?.resource?.commands || {},
+            allowProjectScript: false,
+        });
+        if (!lint?.command) return null;
 
         try {
-            const output = execSync(cmdFn(filePath), {
+            const output = execSync(lint.command, {
                 encoding: 'utf-8',
                 timeout: 15_000,
-                cwd: process.cwd(),
+                cwd: lint.cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', TERM: 'dumb' },
             });
@@ -683,6 +692,52 @@ export function createToolExecutor({
             };
         },
 
+        analyze_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('analyze_image');
+            if (!tool) {
+                return { success: false, output: 'analyze_image tool is not registered in the CLI.', _tool: 'analyze_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'analyze_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || result?.summary || JSON.stringify(result),
+                    ...result,
+                    _tool: 'analyze_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'analyze_image' };
+            }
+        },
+
+        generate_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('generate_image');
+            if (!tool) {
+                return { success: false, output: 'generate_image tool is not registered in the CLI.', _tool: 'generate_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'generate_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || JSON.stringify(result),
+                    ...result,
+                    _tool: 'generate_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'generate_image' };
+            }
+        },
+
         // 0b. read_attachment → chunked text extraction from a local document.
         // Backend registers the schema; execution happens client-side because
         // only the CLI has the user's filesystem. Supports the `path` mode
@@ -722,6 +777,17 @@ export function createToolExecutor({
                 return { success: false, output: String(err?.message || err), _tool: 'read_attachment' };
             }
 
+            const imageInfo = detectImageFile(abs);
+            if (imageInfo) {
+                return {
+                    success: false,
+                    output: `This file is an image (${imageInfo.mime_type}). read_attachment only extracts text documents. Use analyze_image with a specific question. If analyze_image already failed, report that vision error directly instead of retrying this image with read_attachment.`,
+                    _tool: 'read_attachment',
+                    _path: abs,
+                    _mime: imageInfo.mime_type,
+                };
+            }
+
             const { extractFromPath } = await import('../context/prose-chunker.mjs');
             let mime, chunks;
             try {
@@ -735,7 +801,7 @@ export function createToolExecutor({
             if (!chunks.length) {
                 return {
                     success: false,
-                    output: `Unsupported or empty file (mime=${mime}). Supported: pdf, txt, md/mdx, csv, tsv, json, yaml, toml, html, log, rst. For CSV/Excel analysis use read_table; for images use analyze_image.`,
+                    output: `Unsupported or empty file (mime=${mime}). Supported text: pdf, txt, md/mdx, ipynb, csv, tsv, json, yaml, toml, xml, html, log, rst, sql, sh, .env, .ini, Dockerfile, .gitignore — plus any file whose first 8KB is valid UTF-8 (auto-sniffed). For CSV/Excel analysis use read_table; for images use analyze_image. If analyze_image already failed for this file, report that vision error directly instead of retrying with read_attachment.`,
                     _tool: 'read_attachment',
                 };
             }
@@ -954,10 +1020,12 @@ export function createToolExecutor({
                     filteredLines: rawOutput.split('\n').length,
                 }
                 : filterOutput(rawOutput, args.command, success);
+            const agentOutput = observationTimeout && timedOut ? filtered.output : rawOutput;
 
             return {
                 success,
-                output: filtered.output,
+                output: agentOutput,
+                output_preview: filtered.output,
                 exit_code: exitCode,
                 _tool: 'shell',
                 _classification: args._classification,
@@ -1596,24 +1664,44 @@ print('OK: replaced')
             try {
                 throwIfAborted(options.signal);
                 const filePath = await resolvePath(args.file_path || args.path, args);
-                const ext = path.extname(filePath);
-                let cmd;
-                if (ext === '.py') cmd = `python3 -m ruff check "${filePath}" 2>&1 || true`;
-                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 project = projectRegistry.projectForPath(filePath);
+                const lint = resolveLintCommand(filePath, {
+                    projectRoot: project?.resource?.root || projectRootFor(filePath),
+                    projectCommands: project?.resource?.commands || {},
+                    allowProjectScript: true,
+                });
+                if (!lint?.command) {
+                    return {
+                        success: true,
+                        issues: [],
+                        message: 'No project-aware linter for this path or file type',
+                        _tool: 'lint_check',
+                    };
+                }
 
-                const output = await occRegistry.call('shell', {
-                    command: cmd,
+                const shellResult = await executeToolWithHooks('shell', {
+                    command: lint.command,
                     timeout: 30_000,
-                    description: `Lint: ${path.basename(filePath)}`,
-                    cwd: projectRootFor(filePath),
-                    signal: options.signal,
-                });
-                const rawOutput = typeof output === 'string' ? output : String(output);
+                    description: `Lint: ${path.basename(filePath)} (${lint.source})`,
+                    cwd: lint.cwd,
+                }, options);
+                const rawOutput = typeof shellResult?.output === 'string'
+                    ? shellResult.output
+                    : (typeof shellResult === 'string' ? shellResult : String(shellResult));
                 if (/^Error:\s*Command cancelled by user/i.test(rawOutput)) {
                     return { success: false, output: 'Cancelled by user', _cancelled: true, _tool: 'lint_check' };
                 }
-                return { success: true, output: rawOutput, issues: rawOutput.split('\n').filter(Boolean), _tool: 'lint_check' };
+                const normalizedOutput = rawOutput === '(no output)' ? '' : rawOutput;
+                return {
+                    success: true,
+                    output: normalizedOutput || 'No lint issues found.',
+                    command: lint.command,
+                    cwd: lint.cwd,
+                    language: lint.language,
+                    lint_source: lint.source,
+                    issues: normalizedOutput.split('\n').filter(Boolean),
+                    _tool: 'lint_check',
+                };
             } catch (err) {
                 if (isAbortError(err) || options.signal?.aborted) return cancelledToolResult('lint_check');
                 return { success: false, output: err.message, _tool: 'lint_check' };
@@ -2203,6 +2291,10 @@ print('OK: replaced')
             return projectRegistry.resources();
         },
 
+        waitForAutoRegister() {
+            return autoRegisterPromise;
+        },
+
         async registerProjectRoots(roots, { forceRefresh = false } = {}) {
             const results = [];
             const seen = new Set();