@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/services/daemon/skill-aggregator.service.js

@@ -0,0 +1,252 @@
+/**
+ * Skill Aggregator Service
+ * Aggregates skills from 4 sources (local, built-in, GitHub, registry)
+ * into a unified catalog for the daemon API.
+ * In-memory TTL cache (5 min). Graceful per-source failure handling.
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import fg from 'fast-glob';
+import { injectable } from 'inversify';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { safeParseYAML } from '../../utils/yaml-parser.js';
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const BUILTIN_SKILLS = [
+    { name: 'web-search', source: 'builtin', description: 'Search the web for information', tags: ['search', 'web'] },
+    { name: 'code-review', source: 'builtin', description: 'Review code for quality, security, and best practices', tags: ['code', 'review', 'quality'] },
+    { name: 'text-summary', source: 'builtin', description: 'Summarize text content into concise form', tags: ['text', 'summary', 'nlp'] },
+    { name: 'data-analysis', source: 'builtin', description: 'Analyze structured and unstructured data', tags: ['data', 'analysis', 'statistics'] },
+    { name: 'image-generation', source: 'builtin', description: 'Generate images from text descriptions', tags: ['image', 'generation', 'creative'] },
+    { name: 'translation', source: 'builtin', description: 'Translate text between languages', tags: ['translation', 'language', 'nlp'] },
+    { name: 'file-management', source: 'builtin', description: 'Read, write, and manage files in the workspace', tags: ['file', 'io', 'workspace'] },
+    { name: 'api-integration', source: 'builtin', description: 'Integrate with external REST and GraphQL APIs', tags: ['api', 'integration', 'http'] },
+    { name: 'database-query', source: 'builtin', description: 'Query and manage database connections', tags: ['database', 'sql', 'query'] },
+    { name: 'monitoring', source: 'builtin', description: 'Monitor system health, metrics, and alerts', tags: ['monitoring', 'observability', 'health'] },
+    { name: 'testing', source: 'builtin', description: 'Run and manage test suites', tags: ['testing', 'quality', 'ci'] },
+    { name: 'documentation', source: 'builtin', description: 'Generate and maintain documentation', tags: ['docs', 'documentation', 'writing'] },
+];
+let SkillAggregatorService = class SkillAggregatorService {
+    cache = new Map();
+    sourceStatuses = new Map();
+    workspacePath = process.cwd();
+    constructor() {
+        for (const name of ['local', 'builtin', 'github', 'registry']) {
+            this.sourceStatuses.set(name, { name, status: 'pending', count: 0 });
+        }
+    }
+    /**
+     * Set the workspace root for local skill scanning.
+     */
+    setWorkspacePath(dir) {
+        this.workspacePath = path.resolve(dir);
+    }
+    /**
+     * Load skills from all 4 sources. Uses cache if fresh.
+     */
+    async loadAll() {
+        const sources = ['local', 'builtin', 'github', 'registry'];
+        const results = await Promise.all(sources.map((s) => this.loadSource(s)));
+        return results.flat();
+    }
+    /**
+     * Load skills from a single source. Uses cache if fresh.
+     */
+    async loadSource(source) {
+        const cached = this.cache.get(source);
+        if (cached && Date.now() - cached.loadedAt < CACHE_TTL_MS) {
+            return cached.skills;
+        }
+        let skills = [];
+        try {
+            switch (source) {
+                case 'local':
+                    skills = await this.loadLocal();
+                    break;
+                case 'builtin':
+                    skills = this.loadBuiltin();
+                    break;
+                case 'github':
+                    skills = await this.loadGitHub();
+                    break;
+                case 'registry':
+                    skills = await this.loadRegistry();
+                    break;
+                default:
+                    return [];
+            }
+            const now = Date.now();
+            this.cache.set(source, { skills, loadedAt: now });
+            this.sourceStatuses.set(source, {
+                name: source,
+                status: 'loaded',
+                count: skills.length,
+                lastLoaded: new Date(now).toISOString(),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[skill-aggregator] ${source} failed: ${msg}\n`);
+            this.sourceStatuses.set(source, {
+                name: source,
+                status: 'error',
+                count: 0,
+                error: msg,
+            });
+            // Return stale cache if available
+            if (cached)
+                return cached.skills;
+        }
+        return skills;
+    }
+    /**
+     * Search skills by query string (matches name, description, tags).
+     */
+    async search(query) {
+        const all = await this.loadAll();
+        const q = query.toLowerCase();
+        return all.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q) ||
+            s.tags?.some((t) => t.toLowerCase().includes(q)) ||
+            s.capabilities?.some((c) => c.toLowerCase().includes(q)));
+    }
+    /**
+     * Get skills filtered by source.
+     */
+    async getBySource(source) {
+        return this.loadSource(source);
+    }
+    /**
+     * Force refresh one or all sources (clears cache).
+     */
+    async refresh(source) {
+        if (source) {
+            this.cache.delete(source);
+            await this.loadSource(source);
+        }
+        else {
+            this.cache.clear();
+            await this.loadAll();
+        }
+    }
+    /**
+     * Get status of all sources.
+     */
+    getSourceStatus() {
+        return Array.from(this.sourceStatuses.values()).map(({ name, status, count, lastLoaded }) => ({
+            name,
+            status,
+            count,
+            lastLoaded,
+        }));
+    }
+    // --- Private loaders ---
+    async loadLocal() {
+        const patterns = ['**/*.skill.yaml', '**/*.skill.yml', '**/SKILL.md'];
+        const ignorePatterns = ['**/node_modules/**', '**/dist/**', '**/.git/**', '**/coverage/**'];
+        const files = await fg(patterns, {
+            cwd: this.workspacePath,
+            ignore: ignorePatterns,
+            absolute: true,
+        });
+        const skills = [];
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                if (file.endsWith('.md')) {
+                    // SKILL.md — extract name from first heading, rest is description
+                    const lines = content.split('\n');
+                    const heading = lines.find((l) => l.startsWith('#'));
+                    const name = heading ? heading.replace(/^#+\s*/, '').trim() : path.basename(path.dirname(file));
+                    const description = lines
+                        .filter((l) => !l.startsWith('#') && l.trim())
+                        .slice(0, 3)
+                        .join(' ')
+                        .trim();
+                    skills.push({ name, source: 'local', description: description || 'Local skill', manifest: content });
+                }
+                else {
+                    // YAML skill file
+                    const parsed = safeParseYAML(content);
+                    const meta = parsed?.metadata;
+                    skills.push({
+                        name: meta?.name || path.basename(file, path.extname(file)).replace('.skill', ''),
+                        source: 'local',
+                        description: meta?.description || parsed?.description || 'Local skill',
+                        version: meta?.version || undefined,
+                        capabilities: Array.isArray(parsed?.capabilities) ? parsed.capabilities : undefined,
+                        tags: Array.isArray(parsed?.tags) ? parsed.tags : undefined,
+                        manifest: parsed,
+                    });
+                }
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return skills;
+    }
+    loadBuiltin() {
+        return [...BUILTIN_SKILLS];
+    }
+    async loadGitHub() {
+        const url = 'https://api.github.com/repos/anthropics/skills/contents/';
+        const response = await fetch(url, {
+            headers: { Accept: 'application/vnd.github.v3+json', 'User-Agent': 'ossa-daemon' },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) {
+            if (response.status === 403 || response.status === 429) {
+                throw new Error(`GitHub rate limited (${response.status})`);
+            }
+            throw new Error(`GitHub API returned ${response.status}`);
+        }
+        const items = (await response.json());
+        const skills = [];
+        for (const item of items) {
+            if (item.type === 'dir') {
+                skills.push({
+                    name: item.name,
+                    source: 'github',
+                    description: `GitHub skill: ${item.name}`,
+                    tags: ['github', 'community'],
+                });
+            }
+        }
+        return skills;
+    }
+    async loadRegistry() {
+        const url = 'https://openstandardagents.org/api/skills';
+        const response = await fetch(url, {
+            headers: { Accept: 'application/json', 'User-Agent': 'ossa-daemon' },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) {
+            throw new Error(`Registry returned ${response.status}`);
+        }
+        const data = (await response.json());
+        return data.map((item) => ({
+            name: item.name || 'unknown',
+            source: 'registry',
+            description: item.description || 'Registry skill',
+            version: item.version || undefined,
+            capabilities: Array.isArray(item.capabilities) ? item.capabilities : undefined,
+            tags: Array.isArray(item.tags) ? item.tags : undefined,
+        }));
+    }
+};
+SkillAggregatorService = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], SkillAggregatorService);
+export { SkillAggregatorService };
+//# sourceMappingURL=skill-aggregator.service.js.map

package/dist/services/daemon/sse-endpoints.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Daemon SSE Endpoints
+ * Server-Sent Events handlers for Neural Forge browser clients.
+ * Streams real-time execution output, workspace changes, and daemon status.
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+import type http from 'http';
+import { PairingService } from './pairing.service.js';
+/** Execution event types streamed during agent runs */
+export type ExecutionEventKind = 'stdout' | 'stderr' | 'tool_call' | 'tool_result' | 'completion' | 'error';
+/** Payload for execution stream events */
+export interface ExecutionEventPayload {
+    executionId: string;
+    kind: ExecutionEventKind;
+    data: string;
+    timestamp: string;
+}
+/** Payload for workspace file change events */
+export interface WorkspaceChangePayload {
+    path: string;
+    event: 'add' | 'change' | 'unlink';
+    timestamp: string;
+}
+/** Payload for daemon status heartbeat */
+export interface DaemonStatusPayload {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    uptime: number;
+    memoryUsageMB: number;
+    activeConnections: number;
+    timestamp: string;
+}
+export declare class SSEEndpoints {
+    private readonly pairing;
+    private readonly startTime;
+    private activeConnections;
+    /** Event subscribers keyed by execution ID */
+    private readonly executionListeners;
+    /** Workspace change subscribers */
+    private readonly workspaceListeners;
+    constructor(pairing: PairingService);
+    /**
+     * Stream agent execution output (stdout, stderr, tool calls, completion).
+     * Client connects to /sse/execution/:id?token=<pairing-token>
+     */
+    streamExecution(executionId: string, res: http.ServerResponse, token: string): void;
+    /**
+     * Stream workspace file change events.
+     * Client connects to /sse/workspace?token=<pairing-token>
+     */
+    streamWorkspace(res: http.ServerResponse, token: string): void;
+    /**
+     * Stream daemon health metrics every 5 seconds.
+     * Client connects to /sse/status?token=<pairing-token>
+     */
+    streamStatus(res: http.ServerResponse, token: string): void;
+    /** Push an execution event to all listeners for the given execution ID */
+    publishExecutionEvent(executionId: string, payload: ExecutionEventPayload): void;
+    /** Push a workspace change event to all listeners */
+    publishWorkspaceChange(payload: WorkspaceChangePayload): void;
+    /** Validate pairing token; sends 401 and returns false if invalid */
+    private authenticate;
+    /** Write SSE headers and bump connection counter */
+    private initSSE;
+    /** Write a single SSE frame to the response */
+    private sendEvent;
+}
+//# sourceMappingURL=sse-endpoints.d.ts.map

package/dist/services/daemon/sse-endpoints.js

@@ -0,0 +1,176 @@
+/**
+ * Daemon SSE Endpoints
+ * Server-Sent Events handlers for Neural Forge browser clients.
+ * Streams real-time execution output, workspace changes, and daemon status.
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { randomUUID } from 'crypto';
+import { injectable, inject } from 'inversify';
+import { PairingService } from './pairing.service.js';
+const SSE_HEADERS = {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+};
+const STATUS_INTERVAL_MS = 5_000;
+let SSEEndpoints = class SSEEndpoints {
+    pairing;
+    startTime = Date.now();
+    activeConnections = 0;
+    /** Event subscribers keyed by execution ID */
+    executionListeners = new Map();
+    /** Workspace change subscribers */
+    workspaceListeners = new Set();
+    constructor(pairing) {
+        this.pairing = pairing;
+    }
+    /**
+     * Stream agent execution output (stdout, stderr, tool calls, completion).
+     * Client connects to /sse/execution/:id?token=<pairing-token>
+     */
+    streamExecution(executionId, res, token) {
+        if (!this.authenticate(token, res))
+            return;
+        this.initSSE(res);
+        const listener = (payload) => {
+            this.sendEvent(res, {
+                type: 'message',
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                payload,
+                metadata: {
+                    agentId: 'daemon',
+                    streamId: executionId,
+                },
+            });
+            if (payload.kind === 'completion' || payload.kind === 'error') {
+                res.end();
+            }
+        };
+        if (!this.executionListeners.has(executionId)) {
+            this.executionListeners.set(executionId, new Set());
+        }
+        this.executionListeners.get(executionId).add(listener);
+        res.on('close', () => {
+            this.executionListeners.get(executionId)?.delete(listener);
+            if (this.executionListeners.get(executionId)?.size === 0) {
+                this.executionListeners.delete(executionId);
+            }
+            this.activeConnections--;
+        });
+    }
+    /**
+     * Stream workspace file change events.
+     * Client connects to /sse/workspace?token=<pairing-token>
+     */
+    streamWorkspace(res, token) {
+        if (!this.authenticate(token, res))
+            return;
+        this.initSSE(res);
+        const listener = (payload) => {
+            this.sendEvent(res, {
+                type: 'message',
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                payload,
+                metadata: {
+                    agentId: 'daemon',
+                },
+            });
+        };
+        this.workspaceListeners.add(listener);
+        res.on('close', () => {
+            this.workspaceListeners.delete(listener);
+            this.activeConnections--;
+        });
+    }
+    /**
+     * Stream daemon health metrics every 5 seconds.
+     * Client connects to /sse/status?token=<pairing-token>
+     */
+    streamStatus(res, token) {
+        if (!this.authenticate(token, res))
+            return;
+        this.initSSE(res);
+        const interval = setInterval(() => {
+            const mem = process.memoryUsage();
+            const payload = {
+                status: 'healthy',
+                uptime: Math.floor((Date.now() - this.startTime) / 1000),
+                memoryUsageMB: Math.round(mem.heapUsed / 1024 / 1024),
+                activeConnections: this.activeConnections,
+                timestamp: new Date().toISOString(),
+            };
+            this.sendEvent(res, {
+                type: 'status',
+                id: randomUUID(),
+                timestamp: payload.timestamp,
+                payload,
+                metadata: {
+                    agentId: 'daemon',
+                },
+            });
+        }, STATUS_INTERVAL_MS);
+        res.on('close', () => {
+            clearInterval(interval);
+            this.activeConnections--;
+        });
+    }
+    // -- Internal publish methods for other daemon services --
+    /** Push an execution event to all listeners for the given execution ID */
+    publishExecutionEvent(executionId, payload) {
+        const listeners = this.executionListeners.get(executionId);
+        if (listeners) {
+            for (const fn of listeners) {
+                fn(payload);
+            }
+        }
+    }
+    /** Push a workspace change event to all listeners */
+    publishWorkspaceChange(payload) {
+        for (const fn of this.workspaceListeners) {
+            fn(payload);
+        }
+    }
+    // -- Private helpers --
+    /** Validate pairing token; sends 401 and returns false if invalid */
+    authenticate(token, res) {
+        if (!token || !this.pairing.verifyToken(token)) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid or missing pairing token' }));
+            return false;
+        }
+        return true;
+    }
+    /** Write SSE headers and bump connection counter */
+    initSSE(res) {
+        res.writeHead(200, SSE_HEADERS);
+        this.activeConnections++;
+    }
+    /** Write a single SSE frame to the response */
+    sendEvent(res, event) {
+        if (res.writableEnded)
+            return;
+        res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\nid: ${event.id}\n\n`);
+    }
+};
+SSEEndpoints = __decorate([
+    injectable(),
+    __param(0, inject(PairingService)),
+    __metadata("design:paramtypes", [PairingService])
+], SSEEndpoints);
+export { SSEEndpoints };
+//# sourceMappingURL=sse-endpoints.js.map

package/dist/services/daemon/ws-server.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Daemon WebSocket Server
+ * Server-side WebSocket for Neural Forge browser clients.
+ * Binds to 127.0.0.1 only (NIST SP 800-204B).
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+import type http from 'http';
+import type { WebSocketEvent } from '../../transports/websocket.js';
+/**
+ * Extended event types for daemon-specific communication
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+export type DaemonEventType = 'message' | 'capability_call' | 'status_update' | 'error' | 'ack' | 'ping' | 'pong' | 'register' | 'file_changed' | 'manifest_updated' | 'execution_output' | 'workspace_state' | 'skill_catalog' | 'validation_result';
+export declare class DaemonWebSocketServer {
+    private wss;
+    private sessions;
+    private pingInterval;
+    /**
+     * Attach to an existing HTTP server for WebSocket upgrade.
+     * Binds to 127.0.0.1 only -- never 0.0.0.0.
+     */
+    attach(server: http.Server): void;
+    /**
+     * Broadcast event to all authenticated clients
+     */
+    broadcast(event: WebSocketEvent): void;
+    /**
+     * Send event to a specific session
+     */
+    sendToSession(sessionId: string, event: WebSocketEvent): void;
+    /**
+     * List connected session IDs
+     */
+    getConnectedSessions(): string[];
+    /**
+     * Graceful shutdown -- close all connections and stop the server
+     */
+    close(): void;
+    /**
+     * Handle a new WebSocket connection after upgrade
+     */
+    private handleConnection;
+    /**
+     * Handle incoming message with rate limiting and size validation
+     */
+    private handleMessage;
+    /**
+     * Check and update rate limit for a session
+     */
+    private checkRateLimit;
+    /**
+     * Send an error event to a client
+     */
+    private sendError;
+    /**
+     * Send a WebSocket event to a client
+     */
+    private sendEvent;
+    /**
+     * Periodic ping to detect dead connections
+     */
+    private startPingInterval;
+}
+//# sourceMappingURL=ws-server.d.ts.map