@bbigbang/core 0.1.0

package/dist/services/nativeMissionWorkerBroker.js

@@ -0,0 +1,190 @@
+import { randomUUID } from 'node:crypto';
+export class NativeMissionWorkerBroker {
+    pending = new Map();
+    active = new Map();
+    nodeRegistry;
+    timeoutMs;
+    callbacks;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 15_000;
+        this.callbacks = params.callbacks ?? {};
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = callbacks;
+    }
+    runMission(nodeId, mission, options = {}) {
+        const missionDir = mission.missionDir;
+        if (!missionDir) {
+            return Promise.reject(new Error('Mission has no missionDir configured.'));
+        }
+        const requestId = options.requestId ?? randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Native mission start request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                nodeId,
+                missionId: mission.missionId,
+                featureId: options?.feature?.featureId,
+                attemptId: options.attemptId,
+                resolve,
+                reject,
+                timer,
+            });
+            const message = {
+                type: 'mission.run.request',
+                requestId,
+                missionId: mission.missionId,
+                runtimeProvider: 'bigbang_native',
+                title: mission.title,
+                prompt: options.promptOverride ?? (mission.description || mission.title),
+                workspaceRoot: mission.workspacePath,
+                missionDir,
+                modelMode: mission.modelMode,
+                orchestratorModel: mission.orchestratorModel,
+                workerModel: mission.workerModel,
+                validatorModel: mission.validatorModel,
+                ...(options.feature ?? {}),
+            };
+            const sent = this.nodeRegistry.send(nodeId, message);
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    hasActiveMission(missionId) {
+        for (const pending of this.pending.values()) {
+            if (pending.missionId === missionId)
+                return true;
+        }
+        for (const attempt of this.active.values()) {
+            if (attempt.missionId === missionId)
+                return true;
+        }
+        return false;
+    }
+    handleAccepted(msg, nodeId) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.nodeId !== nodeId || pending.missionId !== msg.missionId)
+            return null;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        const attempt = {
+            attemptId: pending.attemptId,
+            requestId: msg.requestId,
+            nodeId,
+            missionId: msg.missionId,
+            featureId: msg.featureId ?? pending.featureId ?? null,
+            missionDir: msg.missionDir,
+        };
+        this.active.set(msg.requestId, attempt);
+        pending.resolve(msg);
+        this.callbacks.onAccepted?.(attempt, msg);
+        return attempt;
+    }
+    verifyEvent(msg, nodeId) {
+        const attempt = this.active.get(msg.requestId);
+        if (!attempt || attempt.nodeId !== nodeId || attempt.missionId !== msg.missionId)
+            return null;
+        return attempt;
+    }
+    handleEvent(msg, nodeId) {
+        const attempt = this.verifyEvent(msg, nodeId);
+        if (!attempt)
+            return null;
+        this.callbacks.onEvent?.(attempt, msg);
+        return attempt;
+    }
+    handleEnd(msg, nodeId) {
+        const pending = this.pending.get(msg.requestId);
+        if (pending) {
+            this.pending.delete(msg.requestId);
+            clearTimeout(pending.timer);
+            pending.reject(new Error(msg.error ?? 'Native mission did not start.'));
+            return null;
+        }
+        const attempt = this.active.get(msg.requestId);
+        if (!attempt || attempt.nodeId !== nodeId || attempt.missionId !== msg.missionId)
+            return null;
+        this.active.delete(msg.requestId);
+        this.callbacks.onEnd?.(attempt, msg);
+        return attempt;
+    }
+    /**
+     * Send a cancellation signal to the node for an active feature attempt.
+     * Returns true if a matching active attempt was found and the cancel message
+     * was sent; false otherwise.
+     */
+    cancelFeature(requestId) {
+        const attempt = this.active.get(requestId);
+        if (!attempt)
+            return false;
+        const message = {
+            type: 'mission.run.cancel',
+            requestId: attempt.requestId,
+            missionId: attempt.missionId,
+            runtimeProvider: 'bigbang_native',
+            featureId: attempt.featureId ?? null,
+        };
+        return this.nodeRegistry.send(attempt.nodeId, message);
+    }
+    /**
+     * Cancel all active feature attempts for a mission. Returns true if at least
+     * one cancellation message was sent.
+     */
+    cancelMissionFeatures(missionId) {
+        let sent = false;
+        for (const attempt of this.active.values()) {
+            if (attempt.missionId !== missionId)
+                continue;
+            const message = {
+                type: 'mission.run.cancel',
+                requestId: attempt.requestId,
+                missionId: attempt.missionId,
+                runtimeProvider: 'bigbang_native',
+                featureId: attempt.featureId ?? null,
+            };
+            if (this.nodeRegistry.send(attempt.nodeId, message)) {
+                sent = true;
+            }
+        }
+        return sent;
+    }
+    /**
+     * Reject all pending and active attempts for a disconnected node. Pending
+     * requests are rejected directly. Active attempts are surfaced through the
+     * onEnd callback with a synthetic mission.run.end message so the orchestrator
+     * can mark the feature and mission as failed.
+     */
+    rejectNodeAttempts(nodeId, error) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            this.pending.delete(requestId);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        for (const [requestId, attempt] of this.active.entries()) {
+            if (attempt.nodeId !== nodeId)
+                continue;
+            this.active.delete(requestId);
+            const supersededAt = Date.now();
+            this.callbacks.onAttemptSuperseded?.(attempt, 'orphan_cleanup', supersededAt);
+            const endMsg = {
+                type: 'mission.run.end',
+                requestId: attempt.requestId,
+                missionId: attempt.missionId,
+                runtimeProvider: 'bigbang_native',
+                missionDir: attempt.missionDir,
+                featureId: attempt.featureId ?? undefined,
+                error: error.message,
+                reason: 'node_disconnected',
+            };
+            this.callbacks.onEnd?.(attempt, endMsg);
+        }
+    }
+}

package/dist/services/nodeRegistry.js

@@ -0,0 +1,34 @@
+export class NodeRegistry {
+    entries = new Map();
+    register(entry) {
+        this.entries.set(entry.nodeId, entry);
+    }
+    unregister(nodeId) {
+        this.entries.delete(nodeId);
+    }
+    getNode(nodeId) {
+        return this.entries.get(nodeId);
+    }
+    listNodes() {
+        return [...this.entries.values()].map(({ ws: _ws, localSend: _localSend, terminalBackendAvailable, ...rest }) => ({
+            ...rest,
+            terminalBackendAvailable: Boolean(terminalBackendAvailable),
+        }));
+    }
+    heartbeat(nodeId) {
+        const entry = this.entries.get(nodeId);
+        if (entry)
+            entry.lastSeen = Date.now();
+    }
+    send(nodeId, msg) {
+        const entry = this.entries.get(nodeId);
+        if (!entry)
+            return false;
+        if (entry.localSend)
+            return entry.localSend(msg);
+        if (!entry.ws || entry.ws.readyState !== 1 /* OPEN */)
+            return false;
+        entry.ws.send(JSON.stringify(msg));
+        return true;
+    }
+}

package/dist/services/nodeStateReconciler.js

@@ -0,0 +1,97 @@
+import { finishRun, log } from '@bbigbang/runtime-acp';
+import { releaseDreamRunLock } from './memoryService.js';
+function parseDreamAgentId(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.agentId === 'string' && parsed.agentId.trim() ? parsed.agentId.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function reconcileNodeStateOnStartup(db) {
+    const now = Date.now();
+    const offlineResult = db
+        .prepare(`UPDATE nodes SET status = 'offline', last_seen = ? WHERE status = 'online'`)
+        .run(now);
+    const failedResult = db
+        .prepare(`UPDATE conversations
+          SET status = 'failed', updated_at = ?
+        WHERE node_id IS NOT NULL
+          AND status IN ('active', 'recovering', 'awaiting_approval')`)
+        .run(now);
+    const failedWorkspaceSessionResult = db
+        .prepare(`UPDATE workspace_sessions
+          SET status = 'failed',
+              updated_at = ?,
+              last_active_at = ?
+        WHERE status IN ('active', 'queued', 'recovering', 'awaiting_approval')`)
+        .run(now, now);
+    const openRuns = db.prepare(`SELECT r.run_id as runId,
+            rdi.dispatch_mode as dispatchMode,
+            rdi.activation_metadata_json as activationMetadataJson,
+            c.agent_id as conversationAgentId
+       FROM runs r
+       LEFT JOIN run_debug_inputs rdi ON rdi.run_id = r.run_id
+       LEFT JOIN conversations c ON c.session_key = r.session_key
+      WHERE r.ended_at IS NULL`).all();
+    for (const run of openRuns) {
+        if (run.dispatchMode === 'dream') {
+            const agentId = parseDreamAgentId(run.activationMetadataJson) ?? run.conversationAgentId;
+            if (agentId)
+                releaseDreamRunLock(db, agentId);
+        }
+        finishRun(db, {
+            runId: run.runId,
+            error: 'Core restarted before run completed',
+        });
+    }
+    const backfilledAgentResult = db
+        .prepare(`UPDATE conversations
+          SET agent_id = (
+            SELECT a.agent_id
+              FROM agents a
+             WHERE a.agent_type = conversations.agent_type
+               AND a.channel_id = conversations.channel_id
+               AND (
+                 (a.node_id IS NULL AND conversations.node_id IS NULL)
+                 OR a.node_id = conversations.node_id
+               )
+               AND (
+                 (a.workspace_path IS NULL AND conversations.workspace_path IS NULL)
+                 OR a.workspace_path = conversations.workspace_path
+               )
+          )
+        WHERE agent_id IS NULL
+          AND 1 = (
+            SELECT COUNT(*)
+              FROM agents a
+             WHERE a.agent_type = conversations.agent_type
+               AND a.channel_id = conversations.channel_id
+               AND (
+                 (a.node_id IS NULL AND conversations.node_id IS NULL)
+                 OR a.node_id = conversations.node_id
+               )
+               AND (
+                 (a.workspace_path IS NULL AND conversations.workspace_path IS NULL)
+                 OR a.workspace_path = conversations.workspace_path
+               )
+          )`)
+        .run();
+    const summary = {
+        offlinedNodes: offlineResult.changes,
+        failedConversations: failedResult.changes,
+        failedWorkspaceSessions: failedWorkspaceSessionResult.changes,
+        backfilledConversationAgents: backfilledAgentResult.changes,
+        finishedRuns: openRuns.length,
+    };
+    if (summary.offlinedNodes > 0
+        || summary.failedConversations > 0
+        || summary.failedWorkspaceSessions > 0
+        || summary.backfilledConversationAgents > 0) {
+        log.warn('[startup-reconcile] reset stale runtime state on startup', summary);
+    }
+    return summary;
+}

package/dist/services/panelMediaScanner.js

@@ -0,0 +1,119 @@
+import { PANEL_MEDIA_FETCH_CONCURRENCY, PANEL_MEDIA_REMOTE_FETCH_TIMEOUT_MS, } from '@bbigbang/protocol';
+import { panelMediaDisplayTypeLimitBytes, panelMediaMimeMatchesDisplayType, panelMediaSizeCapExceededError, } from '../web/panelMediaPolicy.js';
+class Semaphore {
+    permits;
+    waiters = [];
+    constructor(permits) {
+        this.permits = permits;
+    }
+    async acquire() {
+        if (this.permits > 0) {
+            this.permits -= 1;
+            return () => this.release();
+        }
+        await new Promise((resolve) => this.waiters.push(resolve));
+        return () => this.release();
+    }
+    release() {
+        this.permits += 1;
+        const next = this.waiters.shift();
+        if (next) {
+            this.permits -= 1;
+            next();
+        }
+    }
+}
+function withTimeout(promise, ms, errorMessage) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return promise;
+    const timeout = new Promise((_, reject) => {
+        const timer = setTimeout(() => reject(new Error(errorMessage)), ms);
+        // Ensure the timer does not keep the process alive in tests.
+        timer.unref?.();
+    });
+    return Promise.race([promise, timeout]);
+}
+export function createPanelMediaScanner(workspaceBroker, options = {}) {
+    const concurrency = options.concurrency ?? PANEL_MEDIA_FETCH_CONCURRENCY;
+    const semaphore = new Semaphore(concurrency);
+    return {
+        async scan(params) {
+            const stats = { peakInFlight: 0, totalRequested: params.items.length };
+            let inFlight = 0;
+            async function scanOne(item) {
+                const release = await semaphore.acquire();
+                inFlight += 1;
+                stats.peakInFlight = Math.max(stats.peakInFlight, inFlight);
+                try {
+                    const streamResult = await withTimeout(workspaceBroker.streamExactPath(item.nodeId, item.absolutePath, {
+                        allowedRoot: item.allowedRoot,
+                    }), params.timeoutMs ?? PANEL_MEDIA_REMOTE_FETCH_TIMEOUT_MS, 'Media scan request timed out.');
+                    return validateStreamResult(item, streamResult);
+                }
+                catch (error) {
+                    const message = String(error?.message ?? error);
+                    if (message.includes('timed out')) {
+                        return {
+                            ok: false,
+                            rowIndex: item.rowIndex,
+                            slot: item.slot,
+                            statusCode: 504,
+                            error: 'Media source timed out',
+                        };
+                    }
+                    return {
+                        ok: false,
+                        rowIndex: item.rowIndex,
+                        slot: item.slot,
+                        statusCode: 502,
+                        error: message,
+                    };
+                }
+                finally {
+                    inFlight -= 1;
+                    release();
+                }
+            }
+            const promises = params.items.map((item) => scanOne(item));
+            const settled = await Promise.all(promises);
+            for (const result of settled) {
+                if (!result.ok) {
+                    return { result: { outcome: 'error', error: result }, stats };
+                }
+            }
+            return { result: { outcome: 'ok', results: settled }, stats };
+        },
+    };
+}
+function validateStreamResult(item, streamResult) {
+    if (!panelMediaMimeMatchesDisplayType(streamResult.mimeType, item.displayType)) {
+        return {
+            ok: false,
+            rowIndex: item.rowIndex,
+            slot: item.slot,
+            statusCode: 415,
+            error: item.displayType === 'img'
+                ? 'Non-image media not supported'
+                : `Media mime type does not match declared displayType ${item.displayType}`,
+        };
+    }
+    const limitBytes = panelMediaDisplayTypeLimitBytes(item.displayType);
+    if (streamResult.size > limitBytes) {
+        const capError = panelMediaSizeCapExceededError(item.displayType);
+        return {
+            ok: false,
+            rowIndex: item.rowIndex,
+            slot: item.slot,
+            statusCode: capError.statusCode,
+            error: capError.error,
+        };
+    }
+    return {
+        ok: true,
+        rowIndex: item.rowIndex,
+        slot: item.slot,
+        mimeType: streamResult.mimeType,
+        size: streamResult.size,
+        displayType: item.displayType,
+    };
+}

package/dist/services/persistentRuntimeJsonlClient.js

@@ -0,0 +1,153 @@
+import { WorkspaceToolServiceError } from './workspaceToolErrors.js';
+import { deriveTerminalRunCompletion, isJsonlEventEnvelope, isWorkspaceFileNotFoundError, normalizeStateRow, normalizeWorkspaceToolRunEventEnvelope, parseStateRowFromJsonlEvent, sleep, validateStateRowForManifest, } from './workspaceToolExecutionUtils.js';
+import { joinWorkspaceRelativePath } from './workspaceToolUploadMaterializer.js';
+const PERSISTENT_RUNTIME_LOG_POLL_MS = 250;
+const PERSISTENT_RUNTIME_ACTION_TIMEOUT_MS = 120_000;
+const PERSISTENT_RUNTIME_LOG_READ_LIMIT = 64 * 1024;
+export class PersistentRuntimeJsonlClient {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    normalizeLogDir(toolId, manifest) {
+        const raw = manifest.runtime?.logDir?.trim() || `.agent-tools-runtime/${toolId}`;
+        const normalized = raw.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+        if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../') || normalized.startsWith('/')) {
+            throw new WorkspaceToolServiceError('Tool runtime.logDir must stay inside the agent workspace.', 400);
+        }
+        return normalized;
+    }
+    buildRunLogPath(logDir, runId) {
+        return joinWorkspaceRelativePath(logDir, 'runs', `${runId}.jsonl`);
+    }
+    buildStdinRequest(params) {
+        return {
+            type: 'action',
+            runId: params.runId,
+            actionId: params.actionId,
+            params: params.actionParams,
+            toolId: params.toolId,
+            revision: params.revision,
+        };
+    }
+    stdinRequestToLine(request) {
+        return `${JSON.stringify(request)}\n`;
+    }
+    actionTimeoutMs(action) {
+        return action.maxRunSeconds ? action.maxRunSeconds * 1000 : PERSISTENT_RUNTIME_ACTION_TIMEOUT_MS;
+    }
+    async syncRunLog(params) {
+        const deadline = Date.now() + params.timeoutMs;
+        let offset = 0;
+        let pending = '';
+        let completion = null;
+        let lastReadError = null;
+        while (Date.now() <= deadline) {
+            const current = this.deps.getActiveTerminalId(params.toolId);
+            if (current !== params.terminalId) {
+                throw new WorkspaceToolServiceError('Persistent tool runtime exited before the action completed.', 502, { runId: params.runId });
+            }
+            try {
+                const file = await this.deps.readWorkspaceFile(params.agentNodeId, params.workspaceRoot, params.logPath, {
+                    scaffold: false,
+                    offset,
+                    limit: PERSISTENT_RUNTIME_LOG_READ_LIMIT,
+                });
+                lastReadError = null;
+                if (file.content) {
+                    offset = file.nextOffset ?? Math.min(file.size, offset + file.content.length);
+                    pending += file.content;
+                    const lines = pending.split('\n');
+                    pending = lines.pop() ?? '';
+                    for (const line of lines) {
+                        if (completion)
+                            break;
+                        const observed = this.processLogLine(params, line);
+                        if (observed)
+                            completion = observed;
+                    }
+                }
+                if (!completion && !file.hasMore && pending.trim()) {
+                    try {
+                        JSON.parse(pending.trim());
+                        const observed = this.processLogLine(params, pending);
+                        if (observed)
+                            completion = observed;
+                        pending = '';
+                    }
+                    catch {
+                        // The runtime may still be appending the final JSONL record.
+                    }
+                }
+                if (!file.hasMore && file.nextOffset != null) {
+                    offset = file.nextOffset;
+                }
+            }
+            catch (error) {
+                if (isWorkspaceFileNotFoundError(error)) {
+                    lastReadError = null;
+                    // The runtime may not have created the run file yet. Keep polling until the action deadline.
+                }
+                else {
+                    lastReadError = error;
+                }
+            }
+            if (completion)
+                return completion;
+            await sleep(PERSISTENT_RUNTIME_LOG_POLL_MS);
+        }
+        if (lastReadError) {
+            throw new WorkspaceToolServiceError(`Persistent tool runtime action could not read the run log: ${String(lastReadError?.message ?? lastReadError)}`, 502, { runId: params.runId });
+        }
+        const timeoutError = 'Persistent tool runtime action timed out: the runtime did not write a result/error event per protocol.';
+        params.onTimeoutEvent({
+            actionId: params.actionId,
+            timeoutMs: params.timeoutMs,
+            expectedResultPath: params.logPath,
+            error: timeoutError,
+        });
+        throw new WorkspaceToolServiceError(timeoutError, 504, { runId: params.runId });
+    }
+    processLogLine(ctx, line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return null;
+        }
+        const isEvent = isJsonlEventEnvelope(parsed);
+        const state = isEvent
+            ? parseStateRowFromJsonlEvent(parsed)
+            : normalizeStateRow(parsed, { rejectUnsupportedMediaKinds: true });
+        if (state) {
+            validateStateRowForManifest(ctx.manifest, state);
+            ctx.onStateUpdate(state);
+            return null;
+        }
+        const event = normalizeWorkspaceToolRunEventEnvelope(parsed);
+        if (!event)
+            return null;
+        ctx.onRunEvent(parsed);
+        if (event.eventType === 'result') {
+            const completion = deriveTerminalRunCompletion({ kind: 'result_event' });
+            return { ...completion, summary: event.summary };
+        }
+        if (event.eventType === 'error') {
+            const completion = deriveTerminalRunCompletion({
+                kind: 'error_event',
+                exitCode: typeof parsed.exitCode === 'number'
+                    ? parsed.exitCode
+                    : undefined,
+                signal: typeof parsed.signal === 'string'
+                    ? parsed.signal
+                    : undefined,
+            });
+            return { ...completion, summary: event.summary };
+        }
+        return null;
+    }
+}