@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/cli/commands/config.command.js

@@ -0,0 +1,92 @@
+/**
+ * ossa config set <key> <value> | get [key] | list | unset <key>
+ * Persists to ~/.ossa/config.json. process.env overrides config file when reading.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getConfigPath, getConfigValue, setConfigValue, unsetConfigValue, listConfig, } from '../../config/cli-config.js';
+export const configCommand = new Command('config')
+    .description('Get or set OSSA CLI config (stored in ~/.ossa/config.json). Env vars override config when running commands.')
+    .configureHelp({ sortSubcommands: true });
+configCommand
+    .command('set <key> <value>')
+    .description('Set a config key (e.g. SKILLS_PATH, BLUEFLY_SKILLS_CATALOG)')
+    .action((key, value) => {
+    if (!key || !value) {
+        console.error(chalk.red('Usage: ossa config set <key> <value>'));
+        process.exit(1);
+    }
+    setConfigValue(key, value);
+    console.log(chalk.gray(`Config: ${getConfigPath()}`));
+    console.log(chalk.green(`${key}=${value}`));
+});
+configCommand
+    .command('get [key]')
+    .description('Get a config value (env overrides file). Omit key to show config path.')
+    .action((key) => {
+    if (!key) {
+        console.log(getConfigPath());
+        return;
+    }
+    const v = getConfigValue(key);
+    if (v === undefined || v === '') {
+        console.log('');
+        process.exit(1);
+    }
+    console.log(v);
+});
+configCommand
+    .command('list')
+    .description('List all keys and values stored in the config file')
+    .option('-q, --quiet', 'Only print keys')
+    .action((opts) => {
+    const data = listConfig();
+    const keys = Object.keys(data).sort();
+    if (keys.length === 0) {
+        console.log(chalk.gray('No keys in config file. Use: ossa config set SKILLS_PATH <path>'));
+        console.log(chalk.gray('Config path: ' + getConfigPath()));
+        return;
+    }
+    if (opts.quiet) {
+        keys.forEach((k) => console.log(k));
+        return;
+    }
+    console.log(chalk.gray('Config: ' + getConfigPath() + '\n'));
+    keys.forEach((k) => {
+        const val = data[k];
+        const display = val.length > 60 ? val.slice(0, 57) + '...' : val;
+        console.log(`  ${chalk.cyan(k)}=${display}`);
+    });
+});
+configCommand
+    .command('unset <key>')
+    .description('Remove a key from the config file')
+    .action((key) => {
+    const removed = unsetConfigValue(key);
+    if (removed) {
+        console.log(chalk.green(`Removed ${key}`));
+    }
+    else {
+        console.log(chalk.yellow(`Key not in config: ${key}`));
+        process.exit(1);
+    }
+});
+configCommand.addHelpText('after', `
+Known keys (you can set any key; these are commonly used):
+  SKILLS_PATH              Directory for skills add/list (e.g. /Volumes/AgentPlatform/services/marketplace/skills)
+  BLUEFLY_SKILLS_MARKETPLACE   Set to 1 to prefer marketplace skills path in MCP
+  BLUEFLY_SKILLS_CATALOG   Path to marketplace-skills-catalog.json
+  BLUEFLY_SKILLS_PATH      Alias for skills path
+  OSSA_WEBAGENTS_API_URL   OSSA UI / agent builder API base URL
+  OSSA_CONFIG_PATH         Override config file path
+  MCP_URL                  MCP server URL
+  GITLAB_URL               GitLab instance URL
+  GITLAB_TOKEN             GitLab token (prefer env for secrets)
+
+Examples:
+  ossa config set SKILLS_PATH /Volumes/AgentPlatform/services/marketplace/skills
+  ossa config get SKILLS_PATH
+  ossa config list
+  ossa config unset SKILLS_PATH
+`);
+//# sourceMappingURL=config.command.js.map

package/dist/cli/commands/daemon.command.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OSSA Daemon Command
+ * Local development daemon for Neural Forge real-time builder integration
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+import { Command } from 'commander';
+export declare const daemonCommand: Command;
+//# sourceMappingURL=daemon.command.d.ts.map

package/dist/cli/commands/daemon.command.js

@@ -0,0 +1,423 @@
+/**
+ * OSSA Daemon Command
+ * Local development daemon for Neural Forge real-time builder integration
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import * as http from 'http';
+import * as path from 'path';
+import * as url from 'url';
+import { container } from '../../di-container.js';
+import { ManifestRepository } from '../../repositories/manifest.repository.js';
+import { AuditLogService } from '../../services/daemon/audit-log.service.js';
+import { ExecutionService } from '../../services/daemon/execution.service.js';
+import { FileWatcherService } from '../../services/daemon/fs-watcher.service.js';
+import { PairingService } from '../../services/daemon/pairing.service.js';
+import { SkillAggregatorService } from '../../services/daemon/skill-aggregator.service.js';
+import { SSEEndpoints } from '../../services/daemon/sse-endpoints.js';
+import { DaemonWebSocketServer } from '../../services/daemon/ws-server.js';
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB
+export const daemonCommand = new Command('daemon')
+    .argument('[workspace]', 'Path to workspace directory', '.')
+    .option('-p, --port <port>', 'Port to bind daemon on', '4242')
+    .option('--host <host>', 'Host to bind on (127.0.0.1 for security)', '127.0.0.1')
+    .option('--no-pair', 'Disable pairing requirement (dev mode only)')
+    .option('--no-watch', 'Disable file watching')
+    .option('-v, --verbose', 'Verbose logging')
+    .description('Start Neural Forge daemon for real-time builder integration')
+    .action(async (workspace, options) => {
+    const port = parseInt(options.port || '4242', 10);
+    const host = options.host || '127.0.0.1';
+    const workspaceRoot = path.resolve(workspace);
+    const pairingEnabled = options.pair !== false;
+    // Security: never bind to 0.0.0.0
+    if (host === '0.0.0.0') {
+        console.error(chalk.red('SECURITY: Binding to 0.0.0.0 is not allowed. Use 127.0.0.1 (default) for localhost-only access.'));
+        process.exit(1);
+    }
+    if (!pairingEnabled) {
+        console.warn(chalk.yellow('WARNING: Pairing disabled (--no-pair). Any local process can connect. For development only.'));
+    }
+    try {
+        // Initialize services
+        const pairingService = container.get(PairingService);
+        const auditLog = container.get(AuditLogService);
+        const wsServer = container.get(DaemonWebSocketServer);
+        const fileWatcher = container.get(FileWatcherService);
+        const sseEndpoints = container.get(SSEEndpoints);
+        const skillAggregator = container.get(SkillAggregatorService);
+        const executionService = container.get(ExecutionService);
+        const manifestRepo = container.get(ManifestRepository);
+        // Initialize audit log
+        await auditLog.initialize();
+        const startTime = Date.now();
+        // ── Middleware helpers ──
+        /** Validate pairing token from Authorization header */
+        function authenticateRequest(req) {
+            if (!pairingEnabled)
+                return 'dev-session';
+            const auth = req.headers['authorization'];
+            if (!auth?.startsWith('Bearer '))
+                return null;
+            const token = auth.slice(7);
+            const session = pairingService.verifyToken(token);
+            return session ? session.sessionId : null;
+        }
+        /** Check origin allowlist */
+        function isAllowedOrigin(req) {
+            const origin = req.headers['origin'] || '';
+            if (!origin)
+                return true; // Same-origin requests have no Origin header
+            return pairingService.isOriginAllowed(origin);
+        }
+        /** Read request body with size limit */
+        function readBody(req) {
+            return new Promise((resolve, reject) => {
+                let body = '';
+                let size = 0;
+                req.on('data', (chunk) => {
+                    size += chunk.length;
+                    if (size > MAX_BODY_SIZE) {
+                        req.destroy();
+                        reject(new Error('Request body too large'));
+                        return;
+                    }
+                    body += chunk.toString();
+                });
+                req.on('end', () => resolve(body));
+                req.on('error', reject);
+            });
+        }
+        /** Send JSON response */
+        function json(res, status, data) {
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(data));
+        }
+        /** Send error response */
+        function error(res, status, msg) {
+            json(res, status, { error: msg, message: msg });
+        }
+        // ── HTTP Server ──
+        const server = http.createServer(async (req, res) => {
+            const parsedUrl = url.parse(req.url || '/', true);
+            const pathname = parsedUrl.pathname || '/';
+            const method = req.method || 'GET';
+            // CORS headers (restricted origins)
+            const origin = req.headers['origin'] || '';
+            if (pairingService.isOriginAllowed(origin) || !origin) {
+                res.setHeader('Access-Control-Allow-Origin', origin || '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            }
+            if (method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            // Origin check
+            if (!isAllowedOrigin(req)) {
+                error(res, 403, 'Origin not allowed');
+                return;
+            }
+            try {
+                // ── Unauthenticated routes ──
+                if (pathname === '/health' && method === 'GET') {
+                    json(res, 200, {
+                        status: 'ok',
+                        version: '0.4.0',
+                        uptime: Math.floor((Date.now() - startTime) / 1000),
+                        workspace: {
+                            path: workspaceRoot,
+                            manifestCount: fileWatcher.getFileTree().length,
+                        },
+                        activeSessions: pairingService.getActiveSessions().length,
+                    });
+                    return;
+                }
+                if (pathname === '/pair' && method === 'POST') {
+                    const body = JSON.parse(await readBody(req));
+                    const code = body?.code;
+                    if (!code || !/^\d{6}$/.test(code)) {
+                        error(res, 400, 'Invalid pairing code format');
+                        return;
+                    }
+                    const session = pairingService.pair(code, origin);
+                    if (!session) {
+                        await auditLog.log({ action: 'pair', origin, result: 'failure' });
+                        error(res, 401, 'Invalid or expired pairing code');
+                        return;
+                    }
+                    await auditLog.log({
+                        action: 'pair',
+                        origin,
+                        sessionId: session.sessionId,
+                        result: 'success',
+                    });
+                    json(res, 200, {
+                        sessionId: session.sessionId,
+                        token: session.token,
+                        expiresAt: session.expiresAt.toISOString(),
+                    });
+                    return;
+                }
+                // ── Authenticated routes ──
+                const sessionId = authenticateRequest(req);
+                if (!sessionId) {
+                    error(res, 401, 'Authentication required');
+                    return;
+                }
+                // DELETE /pair/:sessionId
+                const pairMatch = pathname.match(/^\/pair\/([^/]+)$/);
+                if (pairMatch && method === 'DELETE') {
+                    const revoked = pairingService.revokeSession(pairMatch[1]);
+                    if (revoked) {
+                        await auditLog.log({
+                            action: 'session_revoke',
+                            sessionId: pairMatch[1],
+                            result: 'success',
+                        });
+                    }
+                    json(res, revoked ? 200 : 404, { revoked });
+                    return;
+                }
+                // GET /workspace
+                if (pathname === '/workspace' && method === 'GET') {
+                    const files = fileWatcher.getFileTree();
+                    const manifests = [];
+                    for (const file of files) {
+                        if (file.path.endsWith('.ossa.yaml') || file.path.endsWith('.ossa.yml')) {
+                            try {
+                                const abs = path.join(workspaceRoot, file.path);
+                                const manifest = await manifestRepo.load(abs);
+                                manifests.push({
+                                    path: file.path,
+                                    kind: manifest.kind || 'Agent',
+                                    name: manifest.metadata?.name || path.basename(file.path),
+                                    version: manifest.metadata?.version,
+                                });
+                            }
+                            catch {
+                                // Skip invalid manifests
+                            }
+                        }
+                    }
+                    json(res, 200, { root: workspaceRoot, files, manifests });
+                    return;
+                }
+                // GET /workspace/files
+                if (pathname === '/workspace/files' && method === 'GET') {
+                    json(res, 200, { root: workspaceRoot, entries: fileWatcher.getFileTree() });
+                    return;
+                }
+                // PUT /workspace/files/:path
+                const fileMatch = pathname.match(/^\/workspace\/files\/(.+)$/);
+                if (fileMatch && method === 'PUT') {
+                    const filePath = decodeURIComponent(fileMatch[1]);
+                    if (!fileWatcher.isPathSafe(path.join(workspaceRoot, filePath))) {
+                        await auditLog.log({
+                            action: 'file_write',
+                            sessionId,
+                            path: filePath,
+                            result: 'failure',
+                            detail: 'Path traversal attempt',
+                        });
+                        error(res, 400, 'Invalid file path');
+                        return;
+                    }
+                    const body = JSON.parse(await readBody(req));
+                    const content = body?.content;
+                    if (!content) {
+                        error(res, 400, 'Content required');
+                        return;
+                    }
+                    const fs = await import('fs');
+                    const absPath = path.join(workspaceRoot, filePath);
+                    if (body.createDirectories) {
+                        fs.mkdirSync(path.dirname(absPath), { recursive: true });
+                    }
+                    fs.writeFileSync(absPath, content, 'utf-8');
+                    await auditLog.log({
+                        action: 'file_write',
+                        sessionId,
+                        path: filePath,
+                        result: 'success',
+                    });
+                    json(res, 200, { path: filePath, written: true, validated: false });
+                    return;
+                }
+                // GET /skills
+                if (pathname === '/skills' && method === 'GET') {
+                    const source = parsedUrl.query?.source;
+                    const search = parsedUrl.query?.search;
+                    let skills;
+                    if (search) {
+                        skills = await skillAggregator.search(search);
+                    }
+                    else if (source) {
+                        skills = await skillAggregator.getBySource(source);
+                    }
+                    else {
+                        skills = await skillAggregator.loadAll();
+                    }
+                    json(res, 200, { skills, sources: skillAggregator.getSourceStatus() });
+                    return;
+                }
+                // POST /skills/install
+                if (pathname === '/skills/install' && method === 'POST') {
+                    const body = JSON.parse(await readBody(req));
+                    await auditLog.log({
+                        action: 'skill_install',
+                        sessionId,
+                        path: body?.name,
+                        result: 'success',
+                    });
+                    json(res, 200, { installed: true, path: body?.targetPath || '.', files: [] });
+                    return;
+                }
+                // POST /execute
+                if (pathname === '/execute' && method === 'POST') {
+                    const body = JSON.parse(await readBody(req));
+                    const execution = await executionService.start(body.manifestPath, body.input, body.runtime);
+                    await auditLog.log({
+                        action: 'execute',
+                        sessionId,
+                        path: body.manifestPath,
+                        result: 'success',
+                    });
+                    json(res, 200, {
+                        executionId: execution.id,
+                        status: execution.status,
+                        sseUrl: `/sse/execution/${execution.id}`,
+                    });
+                    return;
+                }
+                // GET /execute/:id
+                const execGetMatch = pathname.match(/^\/execute\/([^/]+)$/);
+                if (execGetMatch && method === 'GET') {
+                    const execution = executionService.getExecution(execGetMatch[1]);
+                    if (!execution) {
+                        error(res, 404, 'Execution not found');
+                        return;
+                    }
+                    json(res, 200, execution);
+                    return;
+                }
+                // DELETE /execute/:id
+                if (execGetMatch && method === 'DELETE') {
+                    const cancelled = await executionService.cancel(execGetMatch[1]);
+                    if (cancelled) {
+                        await auditLog.log({
+                            action: 'execute_cancel',
+                            sessionId,
+                            path: execGetMatch[1],
+                            result: 'success',
+                        });
+                    }
+                    json(res, cancelled ? 200 : 404, { cancelled, executionId: execGetMatch[1] });
+                    return;
+                }
+                // SSE endpoints — pass token from Authorization header
+                const token = req.headers['authorization']?.slice(7) || parsedUrl.query?.token || '';
+                if (pathname.startsWith('/sse/execution/') && method === 'GET') {
+                    const execId = pathname.split('/').pop() || '';
+                    sseEndpoints.streamExecution(execId, res, token);
+                    return;
+                }
+                if (pathname === '/sse/workspace' && method === 'GET') {
+                    sseEndpoints.streamWorkspace(res, token);
+                    return;
+                }
+                if (pathname === '/sse/status' && method === 'GET') {
+                    sseEndpoints.streamStatus(res, token);
+                    return;
+                }
+                // 404
+                error(res, 404, `Not found: ${pathname}`);
+            }
+            catch (err) {
+                if (options.verbose) {
+                    console.error(chalk.red('[ERROR]'), err);
+                }
+                error(res, 500, err.message || 'Internal server error');
+            }
+        });
+        // Attach WebSocket server
+        wsServer.attach(server);
+        // Start file watcher
+        if (options.watch !== false) {
+            fileWatcher.start(workspaceRoot);
+            fileWatcher.onFileChange((event) => {
+                wsServer.broadcast({
+                    type: 'file_changed',
+                    id: crypto.randomUUID(),
+                    timestamp: new Date().toISOString(),
+                    payload: event,
+                    metadata: { agentId: 'daemon' },
+                });
+            });
+        }
+        // Pre-load skills
+        skillAggregator.loadAll().catch(() => {
+            // Graceful — skills load in background
+        });
+        // Start server
+        server.listen(port, host, () => {
+            console.log('');
+            console.log(chalk.blue.bold('  OSSA Neural Forge Daemon'));
+            console.log(chalk.gray('  ───────────────────────────'));
+            console.log(`  ${chalk.green('Server:')}    http://${host}:${port}`);
+            console.log(`  ${chalk.green('WebSocket:')} ws://${host}:${port}/ws`);
+            console.log(`  ${chalk.green('Workspace:')} ${workspaceRoot}`);
+            console.log(`  ${chalk.green('Watching:')}  ${options.watch !== false ? 'Yes' : 'No'}`);
+            console.log(`  ${chalk.green('Pairing:')}   ${pairingEnabled ? 'Required' : chalk.yellow('Disabled')}`);
+            if (pairingEnabled) {
+                console.log('');
+                console.log(chalk.cyan('  Pairing code:'));
+                // Display pairing code and refresh
+                const displayCode = () => {
+                    const code = pairingService.getCurrentCode();
+                    process.stdout.write(`\r  ${chalk.bgCyan.black.bold(` ${code} `)}  ${chalk.gray('(refreshes every 60s)')}`);
+                };
+                displayCode();
+                setInterval(displayCode, 1000);
+            }
+            console.log('');
+            console.log(chalk.gray('  Press Ctrl+C to stop'));
+            console.log('');
+        });
+        // Forward execution events to WebSocket clients
+        executionService.on('execution_event', (event) => {
+            wsServer.broadcast({
+                type: 'execution_output',
+                id: crypto.randomUUID(),
+                timestamp: new Date().toISOString(),
+                payload: event,
+                metadata: { agentId: 'daemon' },
+            });
+        });
+        // Graceful shutdown
+        const shutdown = () => {
+            console.log(chalk.yellow('\n  Shutting down daemon...'));
+            fileWatcher.stop();
+            wsServer.close();
+            server.close(() => {
+                console.log(chalk.green('  Daemon stopped'));
+                process.exit(0);
+            });
+            // Force exit after 5s
+            setTimeout(() => process.exit(0), 5000);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (err) {
+        console.error(chalk.red('[ERROR]'), err.message);
+        if (options.verbose && err.stack) {
+            console.error(chalk.gray(err.stack));
+        }
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=daemon.command.js.map

package/dist/cli/commands/deploy.command.js

@@ -7,6 +7,8 @@ import { Command } from 'commander';
 import { container } from '../../di-container.js';
 import { ManifestRepository } from '../../repositories/manifest.repository.js';
 import { KAgentRuntimeAdapter } from '../../sdks/kagent/runtime-adapter.js';
+import { DockerDeploymentDriver } from '../../deploy/docker-driver.js';
+import { KubernetesDeploymentDriver } from '../../deploy/k8s-driver.js';
 import { getDeployDefaults } from '../../config/defaults.js';
 export const deployCommand = new Command('deploy')
     .description('Deploy OSSA agent to specified platform(s)')
@@ -55,13 +57,23 @@ async function deployToPlatform(manifest, platform, options) {
             break;
         }
         case 'docker': {
-            console.log(chalk.yellow('  Docker deployment not yet implemented'));
-            console.log(chalk.yellow('  Use: docker build -t agent . && docker run agent'));
+            const dockerDriver = new DockerDeploymentDriver();
+            await dockerDriver.deploy(manifest, {
+                target: 'docker',
+                environment: 'default',
+                namespace: options.namespace,
+                replicas: Number(options.replicas) || 1,
+            });
             break;
         }
         case 'kubernetes': {
-            console.log(chalk.yellow('  Kubernetes deployment not yet implemented'));
-            console.log(chalk.yellow('  Use: kubectl apply -f k8s/'));
+            const k8sDriver = new KubernetesDeploymentDriver();
+            await k8sDriver.deploy(manifest, {
+                target: 'kubernetes',
+                environment: 'default',
+                namespace: options.namespace,
+                replicas: Number(options.replicas) || 1,
+            });
             break;
         }
         default:

package/dist/cli/commands/discover.js

@@ -19,7 +19,7 @@ class AgentProtocolClient {
     baseUrl;
     token;
     constructor(config) {
-        this.baseUrl = config?.baseUrl || 'https://mesh.blueflyagents.com';
+        this.baseUrl = config?.baseUrl || process.env.OSSA_REGISTRY_URL || '';
         this.token =
             config?.apiKey ||
                 process.env.AGENT_PROTOCOL_TOKEN ||

package/dist/cli/commands/ensure-uuid.command.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ossa ensure-uuid - Add metadata.uuid and metadata.machine_name to OSSA manifests
+ * so every agent gets a stable UUID and Drupal-friendly machine name (card + registry).
+ */
+import { Command } from 'commander';
+export declare const ensureUuidCommand: Command;
+//# sourceMappingURL=ensure-uuid.command.d.ts.map