@bbigbang/core 0.1.0

package/dist/web/routes/memory.js

@@ -0,0 +1,258 @@
+import { MemoryServiceError, createMemoryEdge, createMemoryNode, deleteMemoryEdge, deleteMemoryNode, getMemoryGraph, listMemoryEdges, listMemoryNodes, updateDreamWatermark, updateMemoryNode, } from '../../services/memoryService.js';
+const MEMORY_NETWORK_DISABLED_ERROR = 'Memory Network is not enabled for this agent';
+function accessMemoryNetwork(conversationManager, agentId, notFoundError = 'Agent not found') {
+    const agent = conversationManager.getAgent(agentId);
+    if (!agent) {
+        return { allowed: false, statusCode: 404, body: { error: notFoundError } };
+    }
+    if (!agent.memoryNetworkEnabled) {
+        return { allowed: false, statusCode: 403, body: { error: MEMORY_NETWORK_DISABLED_ERROR } };
+    }
+    return { allowed: true, agent };
+}
+function denyMemoryNetworkAccess(reply, access) {
+    reply.code(access.statusCode);
+    return access.body;
+}
+function handleMemoryError(reply, error) {
+    if (error instanceof MemoryServiceError) {
+        reply.code(error.statusCode);
+        return { error: error.message };
+    }
+    reply.code(500);
+    return { error: String(error?.message ?? error) };
+}
+export function registerAgentMemoryInternalRoutes(app, db, conversationManager) {
+    app.post('/api/internal/agent/:agentId/memory/nodes', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const body = req.body ?? {};
+        if (!body.topic?.trim() || !body.summary?.trim() || !body.category?.trim()) {
+            reply.code(400);
+            return { error: 'topic, summary, and category are required' };
+        }
+        try {
+            return createMemoryNode(db, {
+                agentId: req.params.agentId,
+                topic: body.topic,
+                summary: body.summary,
+                category: body.category,
+                importance: body.importance,
+                sourceMessageId: body.sourceMessageId,
+                sourceSnippet: body.sourceSnippet,
+                status: body.status,
+            });
+        }
+        catch (error) {
+            return handleMemoryError(reply, error);
+        }
+    });
+    app.get('/api/internal/agent/:agentId/memory/nodes', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const since = req.query.since ? Number(req.query.since) : undefined;
+        return {
+            nodes: listMemoryNodes(db, {
+                agentId: req.params.agentId,
+                category: req.query.category,
+                status: req.query.status,
+                since: Number.isFinite(since) ? since : undefined,
+                query: req.query.query,
+            }),
+        };
+    });
+    app.patch('/api/internal/agent/:agentId/memory/nodes/:nodeId', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        try {
+            return updateMemoryNode(db, req.params.agentId, req.params.nodeId, req.body ?? {});
+        }
+        catch (error) {
+            return handleMemoryError(reply, error);
+        }
+    });
+    app.delete('/api/internal/agent/:agentId/memory/nodes/:nodeId', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const deleted = deleteMemoryNode(db, req.params.agentId, req.params.nodeId);
+        if (!deleted) {
+            reply.code(404);
+            return { error: 'Memory node not found' };
+        }
+        return { ok: true };
+    });
+    app.post('/api/internal/agent/:agentId/memory/edges', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const body = req.body ?? {};
+        if (!body.sourceNodeId?.trim() || !body.targetNodeId?.trim() || !body.relation?.trim()) {
+            reply.code(400);
+            return { error: 'sourceNodeId, targetNodeId, and relation are required' };
+        }
+        try {
+            return createMemoryEdge(db, {
+                agentId: req.params.agentId,
+                sourceNodeId: body.sourceNodeId,
+                targetNodeId: body.targetNodeId,
+                relation: body.relation,
+                strength: body.strength,
+            });
+        }
+        catch (error) {
+            return handleMemoryError(reply, error);
+        }
+    });
+    app.get('/api/internal/agent/:agentId/memory/edges', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        return {
+            edges: listMemoryEdges(db, {
+                agentId: req.params.agentId,
+                nodeId: req.query.node,
+            }),
+        };
+    });
+    app.delete('/api/internal/agent/:agentId/memory/edges/:edgeId', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const deleted = deleteMemoryEdge(db, req.params.agentId, req.params.edgeId);
+        if (!deleted) {
+            reply.code(404);
+            return { error: 'Memory edge not found' };
+        }
+        return { ok: true };
+    });
+    app.get('/api/internal/agent/:agentId/memory/graph', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        return getMemoryGraph(db, req.params.agentId);
+    });
+    app.post('/api/internal/agent/:agentId/memory/dream-watermark', async (req, reply) => {
+        const seq = req.body?.seq;
+        if (seq == null || !Number.isFinite(seq)) {
+            reply.code(400);
+            return { error: 'seq is required' };
+        }
+        const access = accessMemoryNetwork(conversationManager, req.params.agentId);
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        const agent = access.agent;
+        const runId = typeof req.body?.runId === 'string' ? req.body.runId.trim() : '';
+        let activitySince = agent.lastDreamAt ?? (Date.now() - 30 * 60 * 1000);
+        if (runId) {
+            const run = db.prepare(`SELECT r.started_at as startedAt
+           FROM runs r
+           JOIN run_debug_inputs rdi ON rdi.run_id = r.run_id
+           JOIN conversations c ON c.session_key = r.session_key
+          WHERE r.run_id = ?
+            AND c.agent_id = ?
+            AND rdi.dispatch_mode = 'dream'
+          LIMIT 1`).get(runId, req.params.agentId);
+            if (!run) {
+                reply.code(404);
+                return { error: 'Dream run not found for agent' };
+            }
+            if (run?.startedAt != null) {
+                activitySince = run.startedAt;
+            }
+        }
+        try {
+            return updateDreamWatermark(db, req.params.agentId, seq, {
+                requireMemoryActivitySince: activitySince,
+            });
+        }
+        catch (error) {
+            return handleMemoryError(reply, error);
+        }
+    });
+}
+export function registerDreamDispatchRoute(app, conversationManager, requireAdmin) {
+    app.post('/api/agents/:id/dream/dispatch', async (req, reply) => {
+        if (!requireAdmin(req, reply))
+            return { error: 'Admin access required' };
+        const agent = conversationManager.getAgent(req.params.id);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        if (!agent.memoryNetworkEnabled) {
+            reply.code(403);
+            return { error: 'Memory Network is not enabled for this agent' };
+        }
+        if (!agent.dreamEnabled) {
+            reply.code(403);
+            return { error: 'Dream is not enabled for this agent' };
+        }
+        if (!agent.nodeId) {
+            reply.code(409);
+            return { error: 'Agent has no node' };
+        }
+        try {
+            return await conversationManager.dispatchDream(req.params.id);
+        }
+        catch (error) {
+            reply.code(409);
+            return { error: String(error?.message ?? error) };
+        }
+    });
+}
+export function registerAgentMemoryPublicRoutes(app, db, conversationManager, requireAgentAccess) {
+    app.get('/api/agents/:id/memory/nodes', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.id, 'Not found');
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        if (!requireAgentAccess(req, reply, req.params.id))
+            return { error: 'Access denied' };
+        return {
+            nodes: listMemoryNodes(db, {
+                agentId: req.params.id,
+                category: req.query.category,
+                status: req.query.status,
+                query: req.query.query,
+            }),
+        };
+    });
+    app.get('/api/agents/:id/memory/graph', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.id, 'Not found');
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        if (!requireAgentAccess(req, reply, req.params.id))
+            return { error: 'Access denied' };
+        return getMemoryGraph(db, req.params.id);
+    });
+    app.patch('/api/agents/:id/memory/nodes/:nodeId', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.id, 'Not found');
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        if (!requireAgentAccess(req, reply, req.params.id))
+            return { error: 'Access denied' };
+        try {
+            const node = updateMemoryNode(db, req.params.id, req.params.nodeId, req.body ?? {});
+            return node;
+        }
+        catch (error) {
+            return handleMemoryError(reply, error);
+        }
+    });
+    app.delete('/api/agents/:id/memory/nodes/:nodeId', async (req, reply) => {
+        const access = accessMemoryNetwork(conversationManager, req.params.id, 'Not found');
+        if (!access.allowed)
+            return denyMemoryNetworkAccess(reply, access);
+        if (!requireAgentAccess(req, reply, req.params.id))
+            return { error: 'Access denied' };
+        const deleted = deleteMemoryNode(db, req.params.id, req.params.nodeId);
+        if (!deleted) {
+            reply.code(404);
+            return { error: 'Memory node not found' };
+        }
+        return { ok: true };
+    });
+}

package/dist/web/routes/selfState.js

@@ -0,0 +1,171 @@
+import { buildAgentGlobalSnapshot, buildAgentSelfStateReport, collectAgentSelfState } from '../agentSelfState.js';
+import { buildAgentRuntimePresenceReport, collectAgentRuntimePresence } from '../agentRuntimePresence.js';
+import { AgentVisibility } from '../agentVisibility.js';
+import { buildConversationSummaryRecords, buildConversationSurfaceResponse, getConversationSummary, listConversationSummariesForAgent, } from '../conversationSummaries.js';
+import { resolveChannelFromTarget } from '../conversationTargets.js';
+import { buildContextBundle } from '../contextBundleResolver.js';
+export function registerAgentSelfStateRoutes(app, db, conversationManager) {
+    const visibility = new AgentVisibility(db);
+    app.get('/api/internal/agent/:agentId/self-state', async (req, reply) => {
+        const { agentId } = req.params;
+        const agent = conversationManager.getAgent(agentId);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        const conversationId = typeof req.query.conversationId === 'string' ? req.query.conversationId.trim() : '';
+        if (conversationId && !visibility.canSeeConversation(agent, conversationId)) {
+            reply.code(400);
+            return { error: 'conversationId does not belong to this agent' };
+        }
+        const state = collectAgentSelfState(db, agent, {
+            conversationId: conversationId || null,
+        });
+        const conversationSummaries = buildConversationSummaryRecords(db, agent, state.conversations);
+        const conversationContexts = Object.fromEntries(conversationSummaries.map((conversation) => [
+            conversation.conversationId,
+            visibility.sanitizeSummaryForSelfState(agent, conversation.summary),
+        ]));
+        const conversationSummaryById = new Map(conversationSummaries.map((conversation) => [conversation.conversationId, conversation]));
+        const currentContext = conversationId ? (conversationContexts[conversationId] ?? null) : null;
+        const conversations = state.conversations.map((conversation) => {
+            const summary = conversationSummaryById.get(conversation.conversationId);
+            return {
+                ...conversation,
+                context: conversationContexts[conversation.conversationId] ?? summary?.summary ?? null,
+                summaryUpdatedAt: summary?.summaryUpdatedAt ?? conversation.updatedAt,
+                summaryText: summary?.summaryText ?? null,
+            };
+        });
+        const runtimePresence = collectAgentRuntimePresence(db, conversationManager, agent, {
+            conversationId: conversationId || null,
+        });
+        return {
+            ...state,
+            currentContext,
+            conversations,
+            runtimePresence,
+            snapshotText: buildAgentGlobalSnapshot(state),
+            reportText: `${buildAgentSelfStateReport(state, {
+                currentContext,
+                conversationContexts,
+            })}
+
+${buildAgentRuntimePresenceReport(runtimePresence)}`,
+        };
+    });
+    app.get('/api/internal/agent/:agentId/runtime-presence', async (req, reply) => {
+        const { agentId } = req.params;
+        const agent = conversationManager.getAgent(agentId);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        const conversationId = typeof req.query.conversationId === 'string' ? req.query.conversationId.trim() : '';
+        if (conversationId && !visibility.canSeeConversation(agent, conversationId)) {
+            reply.code(400);
+            return { error: 'conversationId does not belong to this agent' };
+        }
+        const presence = collectAgentRuntimePresence(db, conversationManager, agent, {
+            conversationId: conversationId || null,
+        });
+        return {
+            ...presence,
+            reportText: buildAgentRuntimePresenceReport(presence),
+        };
+    });
+    app.get('/api/internal/agent/:agentId/my-conversations', async (req, reply) => {
+        const { agentId } = req.params;
+        const agent = conversationManager.getAgent(agentId);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        const requestedStatus = (req.query.status ?? 'all').trim();
+        if (!['all', 'idle', 'queued', 'active', 'recovering', 'awaiting_approval', 'failed'].includes(requestedStatus)) {
+            reply.code(400);
+            return { error: `Invalid status: ${req.query.status}` };
+        }
+        const conversations = listConversationSummariesForAgent(db, agent, { status: requestedStatus });
+        return {
+            conversations: conversations.map((conversation) => buildConversationSurfaceResponse(conversation, {
+                contextKey: 'context',
+            })),
+        };
+    });
+    app.get('/api/internal/agent/:agentId/conversation-summary', async (req, reply) => {
+        const { agentId } = req.params;
+        const agent = conversationManager.getAgent(agentId);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        const conversationId = typeof req.query.conversation_id === 'string' ? req.query.conversation_id.trim() : '';
+        const target = typeof req.query.target === 'string' ? req.query.target.trim() : '';
+        if (!conversationId && !target) {
+            reply.code(400);
+            return { error: 'conversation_id or target is required' };
+        }
+        let resolvedConversationId = conversationId || null;
+        if (!resolvedConversationId && target.startsWith('#')) {
+            const channelId = resolveChannelFromTarget(target, db);
+            if (!channelId) {
+                reply.code(404);
+                return { error: 'Target channel not found' };
+            }
+            if (visibility.resolveVisibleChannelId(agent, target) === null) {
+                reply.code(403);
+                return { error: 'Agent is not a member of this channel' };
+            }
+        }
+        if (!resolvedConversationId && target) {
+            resolvedConversationId = visibility.resolveReadableConversationId(agent, target);
+        }
+        if (!resolvedConversationId) {
+            reply.code(404);
+            return { error: 'Conversation not found for the requested target' };
+        }
+        if (!visibility.canSeeConversation(agent, resolvedConversationId)) {
+            reply.code(404);
+            return { error: 'Conversation not found' };
+        }
+        const summary = getConversationSummary(db, agent, resolvedConversationId);
+        if (!summary) {
+            reply.code(404);
+            return { error: 'Conversation summary unavailable' };
+        }
+        return {
+            conversation: buildConversationSurfaceResponse(summary, {
+                contextKey: 'context',
+                includeReportText: true,
+            }),
+        };
+    });
+    app.post('/api/internal/agent/:agentId/context-bundle', async (req, reply) => {
+        const { agentId } = req.params;
+        const agent = conversationManager.getAgent(agentId);
+        if (!agent) {
+            reply.code(404);
+            return { error: 'Agent not found' };
+        }
+        const conversationId = typeof req.body?.conversationId === 'string' ? req.body.conversationId.trim() : '';
+        if (!conversationId) {
+            reply.code(400);
+            return { error: 'conversationId is required' };
+        }
+        if (!visibility.canSeeConversation(agent, conversationId)) {
+            reply.code(400);
+            return { error: 'conversationId does not belong to this agent' };
+        }
+        const bundle = buildContextBundle(db, agent, conversationId, {
+            maxSurfaces: req.body?.maxSurfaces,
+            maxTasks: req.body?.maxTasks,
+            maxHandoffs: req.body?.maxHandoffs,
+        });
+        if (!bundle) {
+            reply.code(404);
+            return { error: 'Context bundle unavailable' };
+        }
+        return { bundle };
+    });
+}

package/dist/web/routes/workspace.js

@@ -0,0 +1,154 @@
+import { AgentWorkspaceServiceError, mapAgentWorkspaceError } from '../../services/agentWorkspaceService.js';
+function normalizeWorkspaceQueryPath(rawPath) {
+    if (!rawPath)
+        return '';
+    return rawPath.replace(/^\/+/, '');
+}
+function normalizeRequiredWorkspacePath(rawPath) {
+    const trimmed = normalizeWorkspaceQueryPath(rawPath);
+    if (!trimmed)
+        throw new AgentWorkspaceServiceError(400, 'path is required');
+    return trimmed;
+}
+function ensureAgentWorkspace(conversationManager, agentId) {
+    const agent = conversationManager.getAgent(agentId);
+    if (!agent) {
+        throw new AgentWorkspaceServiceError(404, 'Agent not found');
+    }
+    if (!agent.nodeId) {
+        throw new AgentWorkspaceServiceError(409, 'Agent is not assigned to a remote node.');
+    }
+    if (!agent.workspacePath) {
+        throw new AgentWorkspaceServiceError(409, 'Agent has no workspace configured.');
+    }
+    return {
+        agentId: agent.agentId,
+        nodeId: agent.nodeId,
+        workspacePath: agent.workspacePath,
+    };
+}
+function mapInspectError(error) {
+    const message = String(error?.message ?? error);
+    if (message === 'Agent node is offline.' || message.startsWith('Agent node disconnected:')) {
+        return new AgentWorkspaceServiceError(409, message);
+    }
+    if (message === 'Workspace inspect request timed out.') {
+        return new AgentWorkspaceServiceError(504, message);
+    }
+    if (message === 'Workspace root not found.') {
+        return new AgentWorkspaceServiceError(404, message);
+    }
+    if (message === 'Workspace root is not a directory.') {
+        return new AgentWorkspaceServiceError(400, message);
+    }
+    return new AgentWorkspaceServiceError(500, message);
+}
+function buildWorkspaceInspectReport(params) {
+    const lines = [
+        '[Workspace inspect]',
+        `node: ${params.nodeId}`,
+        `workspace_root: ${params.workspaceRoot}`,
+        `git: ${params.inspect.isGit ? 'yes' : 'no'} | kind=${params.inspect.workspaceKind} | branch=${params.inspect.branchName ?? 'none'}`,
+    ];
+    if (params.inspect.repoRoot)
+        lines.push(`repo_root: ${params.inspect.repoRoot}`);
+    if (params.inspect.remoteUrl)
+        lines.push(`remote: ${params.inspect.remoteUrl}`);
+    return lines.join('\n');
+}
+function normalizeQueryString(primary, fallback) {
+    const raw = typeof primary === 'string' && primary.trim()
+        ? primary
+        : typeof fallback === 'string' && fallback.trim()
+            ? fallback
+            : '';
+    return raw.trim() || undefined;
+}
+function resolveWorkspaceRunBypassId(params) {
+    const runId = normalizeQueryString(params.query.runId, params.query.run_id);
+    const conversationId = normalizeQueryString(params.query.conversationId, params.query.conversation_id);
+    if (!runId || !conversationId)
+        return undefined;
+    const conversation = params.conversationManager.getConversation(conversationId);
+    if (!conversation || conversation.agentId !== params.agentId)
+        return undefined;
+    const row = params.db.prepare(`SELECT r.run_id as runId
+       FROM runs r
+       JOIN conversations c ON c.session_key = r.session_key
+      WHERE r.run_id = ?
+        AND c.id = ?
+        AND c.agent_id = ?
+        AND r.ended_at IS NULL
+      LIMIT 1`).get(runId, conversationId, params.agentId);
+    return row?.runId || undefined;
+}
+export function registerAgentWorkspaceRoutes(app, db, conversationManager, workspaceBroker, inspectBroker) {
+    app.get('/api/internal/agent/:agentId/workspace-inspect', async (req, reply) => {
+        try {
+            const target = ensureAgentWorkspace(conversationManager, req.params.agentId);
+            const inspect = inspectBroker
+                ? await inspectBroker.inspectWorkspace(target.nodeId, target.workspacePath)
+                : {
+                    workspaceRoot: target.workspacePath,
+                    isGit: false,
+                    repoRoot: null,
+                    workspaceKind: 'directory',
+                    branchName: null,
+                    remoteUrl: null,
+                };
+            return {
+                nodeId: target.nodeId,
+                workspaceRoot: target.workspacePath,
+                inspect,
+                reportText: buildWorkspaceInspectReport({
+                    nodeId: target.nodeId,
+                    workspaceRoot: target.workspacePath,
+                    inspect,
+                }),
+            };
+        }
+        catch (error) {
+            const mapped = error instanceof AgentWorkspaceServiceError ? error : mapInspectError(error);
+            reply.code(mapped.statusCode);
+            return { error: mapped.message };
+        }
+    });
+    app.get('/api/internal/agent/:agentId/workspace-tree', async (req, reply) => {
+        try {
+            const target = ensureAgentWorkspace(conversationManager, req.params.agentId);
+            return await workspaceBroker.listDirectory(target.nodeId, target.workspacePath, normalizeWorkspaceQueryPath(req.query.path), {
+                scaffold: false,
+                runId: resolveWorkspaceRunBypassId({
+                    db,
+                    conversationManager,
+                    agentId: target.agentId,
+                    query: req.query,
+                }),
+            });
+        }
+        catch (error) {
+            const mapped = error instanceof AgentWorkspaceServiceError ? error : mapAgentWorkspaceError(error);
+            reply.code(mapped.statusCode);
+            return { error: mapped.message };
+        }
+    });
+    app.get('/api/internal/agent/:agentId/workspace-file', async (req, reply) => {
+        try {
+            const target = ensureAgentWorkspace(conversationManager, req.params.agentId);
+            return await workspaceBroker.readFile(target.nodeId, target.workspacePath, normalizeRequiredWorkspacePath(req.query.path), {
+                scaffold: false,
+                runId: resolveWorkspaceRunBypassId({
+                    db,
+                    conversationManager,
+                    agentId: target.agentId,
+                    query: req.query,
+                }),
+            });
+        }
+        catch (error) {
+            const mapped = error instanceof AgentWorkspaceServiceError ? error : mapAgentWorkspaceError(error);
+            reply.code(mapped.statusCode);
+            return { error: mapped.message };
+        }
+    });
+}