@bahulam/code 0.1.1 → 0.1.3

package/src/core/headless.mjs

@@ -17,6 +17,19 @@ import { buildWorkScope, promptProjectRoots } from './work-scope.mjs';
 import { persistProjectArtifacts } from './project-artifacts.mjs';
 import { TarangAuth } from '../auth/tarang-auth.mjs';
 import { ApprovalManager } from './approval.mjs';
+// daemon wiring — headless (and `bahulam daemonize`) also starts the socket
+// server + relay bridge when eventlog is enabled. Without this the daemon
+// is invisible to attach clients and to paired mobile devices.
+import { tapSseEvent, registerBroadcaster } from '../daemon/event-tap.mjs';
+import { startSocketServer } from '../daemon/socket-server.mjs';
+import { resolvePending } from '../daemon/approval-store.mjs';
+import { startRelayBridge } from '../daemon/relay-client.mjs';
+import { loadRemoteConfig } from '../commands/remote.mjs';
+import { writeSessionMeta } from './event-log.mjs';
+import { daemonSessionDir } from './paths.mjs';
+import { publishSessionDirectory, markSessionClosed } from '../daemon/session-publisher.mjs';
+import * as fsSync from 'node:fs';
+import * as pathSync from 'node:path';
 import {
     appendVisionAnalysisToInstruction,
     prepareImageAttachments,
@@ -174,6 +187,9 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     const subAgents = [];       // { type, model, duration_s, tool_calls, success }
     let stagnationCount = 0;
     let usage = {};             // { input_tokens, output_tokens, cache_read, cache_write }
+    // daemon wiring — one-shot per headless invocation.
+    let prd092Started = false;
+    let currentSessionId = null;
 
     try {
         for await (const event of client.execute(instruction, execContext)) {
@@ -305,7 +321,110 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
                 // Surface session_id in the JSONL so multi-turn harnesses can
                 // capture it from turn N and forward on turn N+1 (via TARANG_SESSION_ID).
                 if (data?.session_id) emit({ type: 'session_info', session_id: data.session_id });
+
+                // — same daemon wiring the interactive REPL does on
+                // session_info: start the socket server so attach clients can
+                // connect, tap events, and (if remote is enabled) dial the
+                // relay so mobile can see the session. Gated by env var, one-
+                // shot per process, fire-and-forget so a wire failure never
+                // interrupts the turn.
+                const _sid = data?.session_id;
+                if (
+                    _sid &&
+                    process.env.BAHULAM_DAEMON_EVENTLOG === '1' &&
+                    !prd092Started
+                ) {
+                    prd092Started = true;
+                    (async () => {
+                        try {
+                            const server = await startSocketServer({
+                                sessionId: _sid,
+                                onCommand: {
+                                    approve: async (payload, attachId) => resolvePending('approve', payload?.apr_id, attachId, payload?.note),
+                                    deny: async (payload, attachId) => resolvePending('deny', payload?.apr_id, attachId, payload?.note),
+                                    interrupt: async () => { try { if (typeof client?.cancel === 'function') client.cancel(); } catch {} },
+                                    send_message: async () => { /* Slice C follow-up */ },
+                                },
+                            });
+                            registerBroadcaster(evt => server.broadcastEvent(evt));
+
+                            // Write meta.json + daemon.pid so `bahulam list` /
+                            // `bahulam stop` and the mobile session directory
+                            // can find this session.
+                            try {
+                                await writeSessionMeta({
+                                    sessionId: _sid,
+                                    meta: {
+                                        cwd: process.cwd(),
+                                        model: options.model || null,
+                                        pid: process.pid,
+                                        sock_path: server.sockPath,
+                                        opened_at: new Date().toISOString(),
+                                        headless: true,
+                                    },
+                                });
+                                fsSync.writeFileSync(
+                                    pathSync.join(daemonSessionDir(_sid), 'daemon.pid'),
+                                    String(process.pid),
+                                    { mode: 0o600 },
+                                );
+                            } catch (err) {
+                                try { process.stderr.write(`[prd-092] meta/pid write: ${err.message}\n`); } catch {}
+                            }
+
+                            // Slice M — publish to session_directory so mobile
+                            // can list this session even before/after the
+                            // relay handshake. Fire-and-forget; a failure
+                            // here doesn't affect anything else.
+                            try {
+                                publishSessionDirectory({
+                                    sessionId: _sid,
+                                    token: creds.token,
+                                    cwd: process.cwd(),
+                                    model: options.model || null,
+                                    status: 'running',
+                                }).catch(() => {});
+                            } catch { /* silent */ }
+
+                            // Optional relay dial (Slice H) — only when the
+                            // user opted in via `bahulam remote enable`.
+                            try {
+                                const remoteCfg = loadRemoteConfig();
+                                if (remoteCfg?.enabled) {
+                                    startRelayBridge({
+                                        sessionId: _sid,
+                                        remoteConfig: remoteCfg,
+                                        registerBroadcaster,
+                                        onCommand: {
+                                            approve: async (payload, attachId) => resolvePending('approve', payload?.apr_id, attachId, payload?.note),
+                                            deny: async (payload, attachId) => resolvePending('deny', payload?.apr_id, attachId, payload?.note),
+                                            interrupt: async () => { try { if (typeof client?.cancel === 'function') client.cancel(); } catch {} },
+                                            send_message: async () => { /* Slice C follow-up */ },
+                                        },
+                                    });
+                                }
+                            } catch (err) {
+                                try { process.stderr.write(`[prd-092] relay bridge: ${err.message}\n`); } catch {}
+                            }
+                        } catch (err) {
+                            try { process.stderr.write(`[prd-092] socket server: ${err.message}\n`); } catch {}
+                        }
+                    })();
+                }
+                // Tap this event too, so the very first frame lands in the
+                // event log (before broadcasters are registered).
+                if (_sid && process.env.BAHULAM_DAEMON_EVENTLOG === '1') {
+                    tapSseEvent({ type: 'session_info', data }, { sessionId: _sid });
+                }
+            } else if (process.env.BAHULAM_DAEMON_EVENTLOG === '1') {
+                // Tap every other event too, matching the REPL's for-await tap.
+                // sessionId is populated once session_info has landed.
+                if (currentSessionId) {
+                    tapSseEvent(event, { sessionId: currentSessionId });
+                }
             }
+            // Track current session id for the tap.
+            if (type === 'session_info' && data?.session_id) currentSessionId = data.session_id;
 
             if (type === 'complete') {
                 if (data?.rate_limit) rateLimit = data.rate_limit;
@@ -456,5 +575,84 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
         process.stderr.write(`\n--- Response ---\n${finalContent.slice(0, 2000)}\n`);
     }
 
+    // — DAEMON_HOLD mode.
+    //   BAHULAM_DAEMON_HOLD=1                   keep alive forever
+    //   BAHULAM_DAEMON_HOLD=<seconds>           keep alive for N seconds
+    //   BAHULAM_DAEMON_SPAWNED=1 (implicit)     hold with a default TTL if
+    //                                            HOLD not explicitly set
+    //
+    // When held, we DO NOT exit after agent_complete. The socket server and
+    // relay bridge (started earlier by the session_info wiring) stay up so
+    // attach clients and paired mobile devices can still see the session,
+    // reconnect, replay events from disk, and — once send_message is wired
+    // — kick off follow-up turns without spinning up a fresh daemon.
+    //
+    // Exit signals honored: SIGTERM (from `bahulam stop <id>`), SIGINT
+    // (Ctrl-C from a foreground shell), the TTL timer, and the idle-exit
+    // policy from §6.6 (30-min default with no attach).
+    if (prd092Started) {
+        const hold = process.env.BAHULAM_DAEMON_HOLD;
+        const spawned = process.env.BAHULAM_DAEMON_SPAWNED === '1';
+        const holdMode = hold != null || spawned;
+        if (holdMode) {
+            // Slice M — mark idle in the session directory so the mobile
+            // list shows the session as available-but-not-active.
+            try {
+                publishSessionDirectory({
+                    sessionId: currentSessionId,
+                    token: creds.token,
+                    cwd: process.cwd(),
+                    model: options.model || null,
+                    status: 'idle',
+                }).catch(() => {});
+            } catch { /* silent */ }
+
+            const ttlSec = _resolveHoldTtl(hold, spawned);
+            const banner = ttlSec === Infinity ? 'until stopped' : `for ${ttlSec}s`;
+            log(`[prd-092] daemon holding ${banner}. Attach: bahulam attach ${currentSessionId || '<id>'}`);
+            await _blockUntilStop(ttlSec);
+            log('[prd-092] daemon exiting (hold expired or signal received)');
+        }
+        // Whether held or not, mark the session closed in the directory
+        // so mobile doesn't list a gone-forever daemon as "idle" forever.
+        try {
+            await markSessionClosed({ sessionId: currentSessionId, token: creds.token });
+        } catch { /* silent */ }
+    }
+
     process.exit(0);
 }
+
+// ── daemon-hold helpers ─────────────────────────────────────
+
+/**
+ * How long to hold. Explicit HOLD wins; else spawned-default is 30min
+ * (§6.6 idle_ttl). Infinity for "1" or "true".
+ */
+function _resolveHoldTtl(holdEnv, spawned) {
+  if (holdEnv === '1' || holdEnv === 'true') return Infinity;
+  if (holdEnv != null && holdEnv !== '') {
+    const n = Number(holdEnv);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  if (spawned) return 30 * 60;  // §6.6 default idle_ttl
+  return 60;                     // defensive fallback
+}
+
+/**
+ * Await SIGTERM/SIGINT or the TTL. Resolves without an error either way —
+ * the caller then falls through to process.exit(0) so bahulam stop looks
+ * like a clean shutdown, not a crash.
+ */
+function _blockUntilStop(ttlSec) {
+  return new Promise(resolve => {
+    let done = false;
+    const _done = () => { if (done) return; done = true; resolve(); };
+    process.once('SIGTERM', _done);
+    process.once('SIGINT', _done);
+    if (ttlSec !== Infinity) {
+      const t = setTimeout(_done, ttlSec * 1000);
+      if (typeof t.unref === 'function') t.unref();
+    }
+  });
+}

package/src/core/loop.mjs

@@ -0,0 +1,276 @@
+/**
+ * Thin Agent Loop — iterates turns against /v1/agent/* gateway endpoints.
+ *
+ * PRD-091 §6.2-6.3: CLI owns iteration. Gateway owns LLM calls,
+ * prompt assembly, memory management, and sub-agent orchestration.
+ *
+ * This loop replaces local-agent.mjs's direct LLM calls with a
+ * POST /v1/agent/turn to the gateway. Everything else — tool dispatch,
+ * message accumulation, event shapes — matches the existing patterns
+ * the REPL already consumes.
+ *
+ * Usage (replacing client.execute()):
+ *   const { createAgentLoop } = await import('../core/loop.mjs');
+ *   for await (const event of createAgentLoop({
+ *     sessionId: 'sess_...',
+ *     messages: session.agentHistory,
+ *     toolExecutor: executor,
+ *     gatewayFetch: (body) => fetch(`${GATEWAY_URL}/v1/agent/turn`, { ... }),
+ *   })) {
+ *     // same event types as client.execute() / LocalAgent.execute()
+ *   }
+ */
+
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+const MAX_TURNS = 999;
+
+// ── Auth / URL discovery ────────────────────────────────────────────────
+// Same precedence as bundled-runtime.mjs::_readCliToken so gateway calls
+// use the SAME credential the user's login saved. Kept inline here so
+// loop.mjs stays importable without pulling the bundled-runtime module.
+function _readCliToken() {
+    if (process.env.BAHULAM_API_KEY) return process.env.BAHULAM_API_KEY;
+    if (process.env.BAHULAM_CLI_TOKEN) return process.env.BAHULAM_CLI_TOKEN;
+    if (process.env.B0_TOKEN) return process.env.B0_TOKEN;
+    try {
+        const raw = fs.readFileSync(path.join(os.homedir(), '.bahulam', 'config.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        return (parsed && typeof parsed.token === 'string' && parsed.token.trim()) || null;
+    } catch {
+        return null;
+    }
+}
+
+function _gatewayUrl() {
+    return (process.env.BAHULAM_GATEWAY_URL || 'https://gateway.bahulam.ai/v1').replace(/\/+$/, '');
+}
+
+/**
+ * Create a session on the gateway. Returns the session config the loop
+ * uses on every subsequent /v1/agent/turn (server-owned prompt +
+ * tool_schemas + model). Called ONCE per REPL session before iterating.
+ */
+export async function createGatewaySession({
+    workspace = 'kepler-code',
+    model = process.env.BAHULAM_MODEL || undefined,
+    token = _readCliToken(),
+    gateway = _gatewayUrl(),
+} = {}) {
+    if (!token) {
+        throw new Error(
+            'Not logged in — set BAHULAM_API_KEY or run `bahulam login` first.',
+        );
+    }
+    const base = gateway.endsWith('/v1') ? gateway.slice(0, -3) : gateway;
+    const res = await fetch(`${base}/v1/agent/session`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+            'X-Bahulam-User-Id': process.env.BAHULAM_USER_ID || 'cli-user',
+            'X-Bahulam-Tier': process.env.BAHULAM_TIER || 'free',
+        },
+        body: JSON.stringify({ workspace, ...(model ? { model } : {}) }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`session create failed (HTTP ${res.status}): ${text.slice(0, 300)}`);
+    }
+    return res.json();  // { session_id, workspace, prompt, tool_schemas, model, expires_at, ... }
+}
+
+/**
+ * Execute one turn against /v1/chat/completions (the standard OpenAI-shape
+ * gateway endpoint). This reuses the existing metering, entitlement, and
+ * provider translation the gateway already does for BYOK — we don't need
+ * a new /v1/agent/turn endpoint. Session config (prompt + tools + model)
+ * comes from createGatewaySession() once, then every turn just posts
+ * standard OpenAI messages + tools + model.
+ *
+ * The `session` param carries { prompt, tool_schemas, model } from
+ * createGatewaySession. We inject them into the request server prefers
+ * client to send explicitly so per-tier gating on the gateway side
+ * still works (gateway decides what a caller may use; client just
+ * echoes what it received).
+ */
+async function _callGateway({ session, messages }) {
+    const token = _readCliToken();
+    if (!token) throw new Error('Missing gateway token (BAHULAM_API_KEY / bahulam login).');
+    const base = _gatewayUrl();
+    // Support both `<host>` and `<host>/v1` in BAHULAM_GATEWAY_URL.
+    const url = base.endsWith('/v1')
+        ? `${base}/chat/completions`
+        : `${base}/v1/chat/completions`;
+
+    // Strip Bahulam-specific metadata from tool schemas before sending
+    // — server also strips defensively, but keep the wire clean.
+    const tools = (session.tool_schemas || []).map(t => ({
+        type: t.type || 'function',
+        function: t.function,
+    }));
+
+    const body = {
+        model: session.model,
+        messages,   // OpenAI-shape end-to-end — {role, content} or
+                    // assistant.tool_calls + tool.tool_call_id
+        ...(tools.length ? { tools, tool_choice: 'auto' } : {}),
+        temperature: 0.0,
+        stream: false,
+    };
+
+    const t0 = performance.now();
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+            'X-Bahulam-User-Id': process.env.BAHULAM_USER_ID || 'cli-user',
+            'X-Bahulam-Tier': process.env.BAHULAM_TIER || 'free',
+        },
+        body: JSON.stringify(body),
+    });
+    const roundTripMs = performance.now() - t0;
+
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`chat/completions failed (HTTP ${res.status}): ${text.slice(0, 400)}`);
+    }
+    const data = await res.json();
+    const choice = (data.choices || [{}])[0];
+    return {
+        message: choice.message || {},   // OpenAI assistant message shape
+        finish_reason: choice.finish_reason,
+        usage: data.usage || {},
+        timing_ms: { roundTrip: Math.round(roundTripMs * 10) / 10 },
+    };
+}
+
+/**
+ * Create an async generator that iterates turns against the gateway.
+ *
+ * Uses standard OpenAI /v1/chat/completions shape throughout — the same
+ * shape the gateway already speaks to upstream providers. No custom
+ * content-block conversion, no /v1/agent/turn endpoint needed.
+ *
+ * @param {Object} opts
+ * @param {Object} opts.session           - From createGatewaySession()
+ *                                          { session_id, prompt, tool_schemas, model, ... }
+ * @param {Array}  opts.messages          - Conversation history (mutated across turns).
+ *                                          Caller seeds with [{role:'user', content:input}].
+ * @param {Object} opts.toolExecutor      - From createToolExecutor() — .execute(name, input)
+ * @param {Function} [opts.gatewayFetch]  - Override for testing
+ * @param {number}  [opts.maxTurns]       - Max iterations (default 999)
+ * @yields {Object} Events matching the REPL event protocol
+ */
+export async function* createAgentLoop({
+    session,
+    messages,
+    toolExecutor,
+    gatewayFetch = _callGateway,
+    maxTurns = MAX_TURNS,
+} = {}) {
+    let toolCount = 0;
+    const startTime = Date.now();
+    let usage = { input_tokens: 0, output_tokens: 0 };
+
+    // Prepend the workspace system prompt if not already present. The
+    // messages array (caller-owned) may accumulate across REPL turns,
+    // so only inject once.
+    if (session?.prompt && !messages.some(m => m.role === 'system')) {
+        messages.unshift({ role: 'system', content: session.prompt });
+    }
+
+    for (let i = 0; i < maxTurns; i++) {
+        // ── Call gateway (/v1/chat/completions) ─────────────────────
+        const turn = await gatewayFetch({ session, messages });
+        const asst = turn.message || {};
+        usage = {
+            input_tokens: (usage.input_tokens || 0) + (turn.usage?.prompt_tokens || 0),
+            output_tokens: (usage.output_tokens || 0) + (turn.usage?.completion_tokens || 0),
+        };
+
+        // ── Push assistant response into message history (OpenAI shape)
+        // content=null when tool_calls exist (OpenAI protocol requirement),
+        // else the text string.
+        const openAiAsst = { role: 'assistant' };
+        if (asst.tool_calls && asst.tool_calls.length > 0) {
+            openAiAsst.content = asst.content ?? null;
+            openAiAsst.tool_calls = asst.tool_calls;
+        } else {
+            openAiAsst.content = asst.content ?? '';
+        }
+        messages.push(openAiAsst);
+
+        // ── Yield text content ──────────────────────────────────────
+        if (typeof asst.content === 'string' && asst.content) {
+            yield { type: 'content', data: { text: asst.content } };
+        }
+
+        // ── Handle tool calls ───────────────────────────────────────
+        const toolCalls = asst.tool_calls || [];
+        if (toolCalls.length > 0) {
+            for (const tc of toolCalls) {
+                const id = tc.id;
+                const name = tc.function?.name || '';
+                let input = {};
+                try { input = JSON.parse(tc.function?.arguments || '{}'); }
+                catch { input = { _raw: tc.function?.arguments }; }
+
+                yield { type: 'tool_call', data: { call_id: id, tool: name, args: input } };
+
+                // Execute locally via the existing tool executor
+                let result;
+                try {
+                    result = await toolExecutor.execute(name, input || {});
+                } catch (err) {
+                    result = { success: false, output: `Error: ${err.message}` };
+                }
+
+                yield { type: 'tool_done', data: { tool: name, duration_ms: 0 } };
+                toolCount++;
+
+                // Push tool response as a role='tool' message (OpenAI shape).
+                // tool_call_id links it to the assistant's tool_calls[i].id.
+                // MUST push one message per tool_call in the SAME order as
+                // the assistant's tool_calls, or OpenAI rejects the next
+                // turn with "tool_call_ids did not have response messages".
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: typeof result.output === 'string'
+                        ? result.output
+                        : JSON.stringify(result.output ?? result),
+                });
+            }
+            // Loop continues to next iteration
+        } else {
+            // ── No tool calls → turn is done ────────────────────────
+            const duration = (Date.now() - startTime) / 1000;
+            yield {
+                type: 'complete',
+                data: {
+                    summary: 'Done',
+                    changes: toolCount,
+                    duration_s: duration,
+                    usage,
+                },
+            };
+            return;
+        }
+    }
+
+    // Max turns reached
+    yield { type: 'error', data: { message: `Max turns (${maxTurns}) reached.`, fatal: false } };
+    yield {
+        type: 'complete',
+        data: {
+            summary: 'Aborted (max turns)',
+            changes: toolCount,
+            duration_s: (Date.now() - startTime) / 1000,
+            usage,
+        },
+    };
+}