@bbigbang/core 0.1.0

package/dist/main.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { config as loadDotenv } from 'dotenv';
+import { acquireProcessLock, openDb, migrate, log } from '@bbigbang/runtime-acp';
+import { resolveGatewayHomeDir, loadConfig } from './config.js';
+import { ConversationManager } from './web/conversationManager.js';
+import { startServer } from './web/server.js';
+import { NodeRegistry } from './services/nodeRegistry.js';
+import { AgentWorkspaceBroker } from './services/agentWorkspaceBroker.js';
+import { CodexAppServerBroker } from './services/codexAppServerBroker.js';
+import { AgentRuntimeCleanupBroker } from './services/agentRuntimeCleanupBroker.js';
+import { reconcileNodeStateOnStartup } from './services/nodeStateReconciler.js';
+import { hasAdminUser, createInviteToken } from './services/auth.js';
+loadDotenv({
+    path: path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..', '.env'),
+});
+async function main() {
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        console.log('Usage: bigbang-core');
+        return;
+    }
+    const gatewayHome = resolveGatewayHomeDir();
+    const lock = acquireProcessLock(path.join(gatewayHome, 'gateway.lock'));
+    const cleanup = () => {
+        lock.release();
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        cleanup();
+        process.exit(0);
+    });
+    const config = await loadConfig({ interactiveBootstrap: true });
+    const db = openDb(config.dbPath);
+    migrate(db);
+    reconcileNodeStateOnStartup(db);
+    // On first startup with no admin user, generate an invite token and print it
+    if (!hasAdminUser(db)) {
+        const invite = createInviteToken(db);
+        const inviteUrl = `http://localhost:${config.webPort}/?invite=${invite.token}`;
+        log.info('');
+        log.info('═══════════════════════════════════════════════════');
+        log.info('  No admin account found. Complete initial setup:');
+        log.info(`  ${inviteUrl}`);
+        log.info(`  Token expires in 24 hours.`);
+        log.info('═══════════════════════════════════════════════════');
+        log.info('');
+    }
+    const nodeRegistry = new NodeRegistry();
+    const workspaceBroker = new AgentWorkspaceBroker({ nodeRegistry });
+    const codexAppServerBroker = new CodexAppServerBroker({ nodeRegistry });
+    const agentRuntimeCleanupBroker = new AgentRuntimeCleanupBroker({ nodeRegistry });
+    const manager = new ConversationManager({
+        db,
+        config,
+        nodeRegistry,
+        codexAppServerBroker,
+        agentRuntimeCleanupBroker,
+    });
+    manager.start();
+    await startServer({
+        port: config.webPort,
+        host: config.webHost,
+        conversationManager: manager,
+        db,
+        nodeRegistry,
+        workspaceBroker,
+        codexAppServerBroker,
+        agentRuntimeCleanupBroker,
+    });
+    log.info('agent-node started', {
+        port: config.webPort,
+        host: config.webHost,
+        workspaceRoot: config.workspaceRoot,
+        dbPath: path.resolve(config.dbPath),
+    });
+    const shutdown = () => {
+        log.warn('Shutting down...');
+        manager.close();
+        db.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+await main();

package/dist/nodeEventHistory.js

@@ -0,0 +1,206 @@
+export const MAX_SAFE_NODE_EVENT_PAYLOAD_BYTES = 512 * 1024;
+export const MAX_NODE_EVENT_FIELD_PREVIEW_CHARS = 8 * 1024;
+function buildNodeEventTypeExpression() {
+    return `CASE
+    WHEN json_valid(payload_json) THEN json_extract(payload_json, '$.type')
+    ELSE NULL
+  END`;
+}
+function buildNodeEventByteLengthExpression() {
+    return `length(CAST(payload_json AS BLOB))`;
+}
+function buildExactJsonExtract(path) {
+    return `CASE
+    WHEN json_valid(payload_json) THEN json_extract(payload_json, '${path}')
+    ELSE NULL
+  END`;
+}
+function parseProjectedStructuredValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return value;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function toOptionalNumber(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function materializeProjectedNodeEvent(row) {
+    switch (row.type) {
+        case 'content.delta':
+            return typeof row.text === 'string'
+                ? { type: 'content.delta', text: row.text }
+                : null;
+        case 'activity.delta':
+            return typeof row.text === 'string'
+                ? { type: 'activity.delta', text: row.text }
+                : null;
+        case 'thinking.delta':
+            return typeof row.text === 'string'
+                ? { type: 'thinking.delta', text: row.text }
+                : null;
+        case 'plan.update':
+            return typeof row.title === 'string'
+                ? {
+                    type: 'plan.update',
+                    title: row.title,
+                    ...(typeof row.detail === 'string' ? { detail: row.detail } : {}),
+                    ...(typeof row.eventCreatedAt === 'number' ? { createdAt: row.eventCreatedAt } : {}),
+                }
+                : null;
+        case 'task.update':
+            return typeof row.title === 'string'
+                ? {
+                    type: 'task.update',
+                    title: row.title,
+                    ...(typeof row.detail === 'string' ? { detail: row.detail } : {}),
+                    ...(typeof row.eventCreatedAt === 'number' ? { createdAt: row.eventCreatedAt } : {}),
+                }
+                : null;
+        case 'tool.call':
+            return typeof row.toolCallId === 'string' && typeof row.name === 'string'
+                ? {
+                    type: 'tool.call',
+                    toolCallId: row.toolCallId,
+                    name: row.name,
+                    input: parseProjectedStructuredValue(row.inputJson),
+                    ...(typeof row.status === 'string' ? { status: row.status } : {}),
+                    ...(typeof row.startedAt === 'number' ? { startedAt: row.startedAt } : {}),
+                }
+                : null;
+        case 'tool.result':
+            return typeof row.toolCallId === 'string'
+                ? {
+                    type: 'tool.result',
+                    toolCallId: row.toolCallId,
+                    output: row.output ?? '',
+                    ...(row.error == null ? {} : { error: Boolean(row.error) }),
+                    ...(typeof row.status === 'string' ? { status: row.status } : {}),
+                    ...(typeof row.endedAt === 'number' ? { endedAt: row.endedAt } : {}),
+                }
+                : null;
+        case 'run.usage':
+            const inputTokens = toOptionalNumber(row.inputTokens);
+            const cachedInputTokens = toOptionalNumber(row.cachedInputTokens);
+            const outputTokens = toOptionalNumber(row.outputTokens);
+            const reasoningOutputTokens = toOptionalNumber(row.reasoningOutputTokens);
+            const totalTokens = toOptionalNumber(row.totalTokens);
+            const currentInputTokens = toOptionalNumber(row.currentInputTokens);
+            const currentCachedInputTokens = toOptionalNumber(row.currentCachedInputTokens);
+            const modelContextWindow = toOptionalNumber(row.modelContextWindow);
+            const createdAt = toOptionalNumber(row.eventCreatedAt);
+            return {
+                type: 'run.usage',
+                ...(inputTokens !== undefined ? { inputTokens } : {}),
+                ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+                ...(outputTokens !== undefined ? { outputTokens } : {}),
+                ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+                ...(totalTokens !== undefined ? { totalTokens } : {}),
+                ...(currentInputTokens !== undefined ? { currentInputTokens } : {}),
+                ...(currentCachedInputTokens !== undefined ? { currentCachedInputTokens } : {}),
+                ...(modelContextWindow !== undefined ? { modelContextWindow } : {}),
+                ...(createdAt !== undefined ? { createdAt } : {}),
+            };
+        case 'runtime.compact':
+            return typeof row.threadId === 'string' && typeof row.turnId === 'string' && typeof row.eventKey === 'string'
+                ? {
+                    type: 'runtime.compact',
+                    threadId: row.threadId,
+                    turnId: row.turnId,
+                    ...(typeof row.itemId === 'string' ? { itemId: row.itemId } : {}),
+                    source: row.source === 'raw_response_item' || row.source === 'thread_item'
+                        ? row.source
+                        : 'thread_compacted',
+                    eventKey: row.eventKey,
+                    ...(typeof row.eventCreatedAt === 'number' ? { createdAt: row.eventCreatedAt } : {}),
+                }
+                : null;
+        case 'run.steer.result':
+            return typeof row.requestId === 'string' && typeof row.eventRunId === 'string' && row.ok !== null
+                ? {
+                    type: 'run.steer.result',
+                    requestId: row.requestId,
+                    runId: row.eventRunId,
+                    ok: Boolean(row.ok),
+                    ...(typeof row.errorText === 'string' ? { error: row.errorText } : {}),
+                    ...(typeof row.eventCreatedAt === 'number' ? { createdAt: row.eventCreatedAt } : {}),
+                }
+                : null;
+        default:
+            return null;
+    }
+}
+export function* iterateParsedNodeEvents(db, params) {
+    if (params.types.length === 0)
+        return;
+    const typeExpr = buildNodeEventTypeExpression();
+    const byteLengthExpr = buildNodeEventByteLengthExpression();
+    const maxPayloadBytes = params.maxPayloadBytes ?? MAX_SAFE_NODE_EVENT_PAYLOAD_BYTES;
+    const previewingExtract = (path) => `CASE
+    WHEN ${byteLengthExpr} <= ${maxPayloadBytes} THEN ${buildExactJsonExtract(path)}
+    WHEN NOT json_valid(payload_json) THEN NULL
+    WHEN json_extract(payload_json, '${path}') IS NULL THEN NULL
+    WHEN length(CAST(json_extract(payload_json, '${path}') AS BLOB)) <= ${MAX_NODE_EVENT_FIELD_PREVIEW_CHARS}
+      THEN json_extract(payload_json, '${path}')
+    WHEN typeof(json_extract(payload_json, '${path}')) = 'text'
+      THEN substr(json_extract(payload_json, '${path}'), 1, ${MAX_NODE_EVENT_FIELD_PREVIEW_CHARS}) || '... [truncated]'
+    ELSE substr(CAST(json_extract(payload_json, '${path}') AS TEXT), 1, ${MAX_NODE_EVENT_FIELD_PREVIEW_CHARS}) || '... [truncated]'
+  END`;
+    const placeholders = params.types.map(() => '?').join(', ');
+    const rows = db.prepare(`SELECT seq,
+            created_at as createdAt,
+            ${byteLengthExpr} as payloadBytes,
+            ${typeExpr} as type,
+            ${previewingExtract('$.text')} as text,
+            ${previewingExtract('$.title')} as title,
+            ${previewingExtract('$.detail')} as detail,
+            ${buildExactJsonExtract('$.toolCallId')} as toolCallId,
+            ${buildExactJsonExtract('$.requestId')} as requestId,
+            ${buildExactJsonExtract('$.runId')} as eventRunId,
+            ${previewingExtract('$.name')} as name,
+            ${previewingExtract('$.input')} as inputJson,
+            ${previewingExtract('$.output')} as output,
+            ${buildExactJsonExtract('$.error')} as error,
+            ${previewingExtract('$.error')} as errorText,
+            ${buildExactJsonExtract('$.ok')} as ok,
+            ${buildExactJsonExtract('$.status')} as status,
+            ${buildExactJsonExtract('$.startedAt')} as startedAt,
+            ${buildExactJsonExtract('$.endedAt')} as endedAt,
+            ${buildExactJsonExtract('$.createdAt')} as eventCreatedAt,
+            ${buildExactJsonExtract('$.inputTokens')} as inputTokens,
+            ${buildExactJsonExtract('$.cachedInputTokens')} as cachedInputTokens,
+            ${buildExactJsonExtract('$.outputTokens')} as outputTokens,
+            ${buildExactJsonExtract('$.reasoningOutputTokens')} as reasoningOutputTokens,
+            ${buildExactJsonExtract('$.totalTokens')} as totalTokens,
+            ${buildExactJsonExtract('$.currentInputTokens')} as currentInputTokens,
+            ${buildExactJsonExtract('$.currentCachedInputTokens')} as currentCachedInputTokens,
+            ${buildExactJsonExtract('$.modelContextWindow')} as modelContextWindow,
+            ${buildExactJsonExtract('$.threadId')} as threadId,
+            ${buildExactJsonExtract('$.turnId')} as turnId,
+            ${buildExactJsonExtract('$.itemId')} as itemId,
+            ${buildExactJsonExtract('$.source')} as source,
+            ${buildExactJsonExtract('$.eventKey')} as eventKey
+       FROM events
+      WHERE run_id = ?
+        AND method = 'node/event'
+        AND ${typeExpr} IN (${placeholders})
+      ORDER BY seq ASC`).iterate(params.runId, ...params.types);
+    for (const row of rows) {
+        const event = materializeProjectedNodeEvent(row);
+        yield {
+            seq: row.seq,
+            createdAt: row.createdAt,
+            payloadBytes: row.payloadBytes,
+            event,
+            skippedOversize: row.payloadBytes > maxPayloadBytes,
+        };
+    }
+}

package/dist/scheduler/dreamLogic.js

@@ -0,0 +1,50 @@
+const BEIJING_OFFSET_MS = 8 * 60 * 60 * 1000;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+export function parseDreamScheduleHourMinute(schedule) {
+    const match = /^(\d{1,2}):(\d{2})$/.exec(schedule.trim());
+    if (!match)
+        return null;
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    if (!Number.isInteger(hour) || !Number.isInteger(minute))
+        return null;
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        return null;
+    return { hour, minute };
+}
+export function getBeijingDateParts(nowMs) {
+    const beijing = new Date(nowMs + BEIJING_OFFSET_MS);
+    return {
+        year: beijing.getUTCFullYear(),
+        month: beijing.getUTCMonth(),
+        day: beijing.getUTCDate(),
+        hour: beijing.getUTCHours(),
+        minute: beijing.getUTCMinutes(),
+    };
+}
+export function isDreamScheduleDue(schedule, nowMs, lastDreamAt) {
+    const parsed = parseDreamScheduleHourMinute(schedule);
+    if (!parsed)
+        return false;
+    const beijing = getBeijingDateParts(nowMs);
+    const scheduleMinutes = parsed.hour * 60 + parsed.minute;
+    const nowMinutes = beijing.hour * 60 + beijing.minute;
+    if (nowMinutes < scheduleMinutes)
+        return false;
+    if (lastDreamAt == null)
+        return true;
+    if (nowMs - lastDreamAt < ONE_DAY_MS)
+        return false;
+    const lastBeijing = getBeijingDateParts(lastDreamAt);
+    const sameBeijingDay = lastBeijing.year === beijing.year
+        && lastBeijing.month === beijing.month
+        && lastBeijing.day === beijing.day;
+    return !sameBeijingDay;
+}
+export function shouldTriggerDream(params) {
+    if (!params.dreamEnabled)
+        return false;
+    if (!isDreamScheduleDue(params.dreamSchedule, params.nowMs, params.lastDreamAt))
+        return false;
+    return params.newMessageCount >= Math.max(1, params.dreamMinMessages);
+}

package/dist/scheduler/dreamScheduler.js

@@ -0,0 +1,65 @@
+import { log } from '@bbigbang/runtime-acp';
+import { countAgentMessagesSinceSeq } from '../services/memoryService.js';
+import { shouldTriggerDream } from './dreamLogic.js';
+export function startDreamScheduler(params) {
+    const intervalMs = params.intervalMs ?? 60_000;
+    const inFlight = new Set();
+    const tick = async () => {
+        const nowMs = Date.now();
+        const agents = params.db.prepare(`SELECT agent_id as agentId,
+              memory_network_enabled as memoryNetworkEnabled,
+              dream_enabled as dreamEnabled,
+              dream_schedule as dreamSchedule,
+              dream_min_messages as dreamMinMessages,
+              last_dream_at as lastDreamAt,
+              last_dream_seq as lastDreamSeq,
+              node_id as nodeId,
+              dream_run_in_progress_at as dreamRunInProgressAt
+         FROM agents
+        WHERE deleted_at IS NULL
+          AND COALESCE(agent_role, 'user') = 'user'
+          AND memory_network_enabled = 1
+          AND dream_enabled = 1
+          AND node_id IS NOT NULL
+          AND (dream_run_in_progress_at IS NULL OR dream_run_in_progress_at < ?)`).all(nowMs - 30 * 60 * 1000);
+        for (const agent of agents) {
+            if (inFlight.has(agent.agentId))
+                continue;
+            const newMessageCount = countAgentMessagesSinceSeq(params.db, agent.agentId, agent.lastDreamSeq);
+            const eligible = shouldTriggerDream({
+                dreamEnabled: agent.dreamEnabled === 1,
+                dreamSchedule: agent.dreamSchedule ?? '02:00',
+                dreamMinMessages: agent.dreamMinMessages ?? 5,
+                lastDreamAt: agent.lastDreamAt,
+                newMessageCount,
+                nowMs,
+            });
+            if (!eligible)
+                continue;
+            inFlight.add(agent.agentId);
+            try {
+                log.info('[dream-scheduler] triggering dream', {
+                    agentId: agent.agentId,
+                    newMessageCount,
+                });
+                await params.dispatchDream(agent.agentId);
+            }
+            catch (error) {
+                log.warn('[dream-scheduler] dream dispatch failed', {
+                    agentId: agent.agentId,
+                    error: String(error?.message ?? error),
+                });
+            }
+            finally {
+                inFlight.delete(agent.agentId);
+            }
+        }
+    };
+    const timer = setInterval(() => {
+        void tick();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        stop: () => clearInterval(timer),
+    };
+}