@bbigbang/core 0.1.0

package/dist/services/agentRuntimeCleanupBroker.js

@@ -0,0 +1,62 @@
+import { randomUUID } from 'node:crypto';
+export class AgentRuntimeCleanupBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 15_000;
+    }
+    cleanupAgentRuntime(params) {
+        const hostKeys = [...new Set(params.hostKeys.filter(Boolean))];
+        const sessionKeys = [...new Set((params.sessionKeys ?? []).filter(Boolean))];
+        if (hostKeys.length === 0 && sessionKeys.length === 0)
+            return Promise.resolve();
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Agent runtime cleanup timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                nodeId: params.nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(params.nodeId, {
+                type: 'agent.cleanup.request',
+                requestId,
+                agentId: params.agentId,
+                hostKeys,
+                ...(sessionKeys.length > 0 ? { sessionKeys } : {}),
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleCleanupResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.ok) {
+            pending.reject(new Error(msg.error ?? 'Agent runtime cleanup failed.'));
+            return;
+        }
+        pending.resolve();
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.pending.delete(requestId);
+        }
+    }
+}

package/dist/services/agentSkillsBroker.js

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+export class AgentSkillsBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 5_000;
+    }
+    listSkills(nodeId, skillRoots, params, skillPath) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Skill request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'list',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'skills.list.request',
+                requestId,
+                skillRoots,
+                path: skillPath ?? null,
+                agentType: params?.agentType,
+                workspaceRoot: params?.workspaceRoot ?? null,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    readSkillFile(nodeId, skillRoots, params, skillPath) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Skill request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                kind: 'read',
+                nodeId,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'skills.read.request',
+                requestId,
+                skillRoots,
+                path: skillPath,
+                agentType: params.agentType,
+                workspaceRoot: params.workspaceRoot ?? null,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleSkillsListResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'list')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.skills || !msg.entries) {
+            pending.reject(new Error(formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            path: msg.path ?? null,
+            roots: msg.roots,
+            skills: msg.skills,
+            entries: msg.entries,
+        });
+    }
+    handleSkillsReadResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || msg.content === undefined || !msg.mimeType || msg.size === undefined) {
+            pending.reject(new Error(formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            path: msg.path,
+            content: msg.content,
+            mimeType: msg.mimeType,
+            size: msg.size,
+            modifiedAt: msg.modifiedAt ?? null,
+        });
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.pending.delete(requestId);
+        }
+    }
+}
+function formatErrorMessage(errorCode, error) {
+    if (errorCode) {
+        return `${errorCode}:${error ?? 'skill request failed'}`;
+    }
+    return error ?? 'skill request failed';
+}

package/dist/services/agentSkillsService.js

@@ -0,0 +1,83 @@
+export class AgentSkillsServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class AgentSkillsService {
+    getAgentById;
+    broker;
+    constructor(params) {
+        this.getAgentById = params.getAgentById;
+        this.broker = params.broker;
+    }
+    async listSkills(agentId, skillPath) {
+        const agent = this.getAgentById(agentId);
+        if (!agent)
+            throw new AgentSkillsServiceError(404, 'Agent not found.');
+        if (!agent.nodeId)
+            throw new AgentSkillsServiceError(409, 'Agent is not assigned to a remote node.');
+        const skillRoots = normalizeSkillRoots(agent.skillRoots);
+        if (skillRoots.length === 0) {
+            throw new AgentSkillsServiceError(409, 'Agent has no skill roots configured.');
+        }
+        try {
+            return await this.broker.listSkills(agent.nodeId, skillRoots, {
+                agentType: agent.agentType,
+                workspaceRoot: agent.workspacePath ?? null,
+            }, skillPath ?? null);
+        }
+        catch (error) {
+            throw mapSkillError(error);
+        }
+    }
+    async readSkillFile(agentId, skillPath) {
+        const agent = this.getAgentById(agentId);
+        if (!agent)
+            throw new AgentSkillsServiceError(404, 'Agent not found.');
+        if (!agent.nodeId)
+            throw new AgentSkillsServiceError(409, 'Agent is not assigned to a remote node.');
+        const skillRoots = normalizeSkillRoots(agent.skillRoots);
+        if (skillRoots.length === 0) {
+            throw new AgentSkillsServiceError(409, 'Agent has no skill roots configured.');
+        }
+        try {
+            return await this.broker.readSkillFile(agent.nodeId, skillRoots, {
+                agentType: agent.agentType,
+                workspaceRoot: agent.workspacePath ?? null,
+            }, skillPath);
+        }
+        catch (error) {
+            throw mapSkillError(error);
+        }
+    }
+}
+function normalizeSkillRoots(skillRoots) {
+    return (skillRoots ?? []).map((value) => value.trim()).filter(Boolean);
+}
+function mapSkillError(error) {
+    const message = String(error?.message ?? error);
+    if (message === 'Agent node is offline.') {
+        return new AgentSkillsServiceError(409, message);
+    }
+    if (message === 'Skill request timed out.') {
+        return new AgentSkillsServiceError(504, message);
+    }
+    if (message.startsWith('not_found:')) {
+        return new AgentSkillsServiceError(404, message.slice('not_found:'.length));
+    }
+    if (message.startsWith('path_outside_workspace:')) {
+        return new AgentSkillsServiceError(400, message.slice('path_outside_workspace:'.length));
+    }
+    if (message.startsWith('binary_file:')) {
+        return new AgentSkillsServiceError(415, message.slice('binary_file:'.length));
+    }
+    if (message.startsWith('file_too_large:')) {
+        return new AgentSkillsServiceError(413, message.slice('file_too_large:'.length));
+    }
+    if (message.startsWith('not_directory:') || message.startsWith('not_file:')) {
+        return new AgentSkillsServiceError(400, message.slice(message.indexOf(':') + 1));
+    }
+    return new AgentSkillsServiceError(500, message);
+}