@bluefly/openstandardagents 0.4.5 → 0.4.8

package/dist/services/manifest/manifest-crud.service.js

@@ -0,0 +1,319 @@
+/**
+ * ManifestCrudService — Unified CRUD for all OSSA manifest kinds
+ *
+ * Extracts and consolidates logic from MCP server inline handlers
+ * and CLI commands. No TUI/HTTP dependencies.
+ */
+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 { injectable, inject } from 'inversify';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import semver from 'semver';
+import { ManifestRepository } from '../../repositories/manifest.repository.js';
+import { ValidationService } from '../validation.service.js';
+import { MigrationTransformService } from '../migration-transform.service.js';
+import { VersionDetectionService } from '../version-detection.service.js';
+import { getApiVersion } from '../../utils/version.js';
+import { scanManifests } from '../../utils/manifest-scanner.js';
+import { getDefaultAgentVersion, getDefaultAgentKind, getDefaultRoleTemplate, getDefaultDescriptionTemplate, getAgentTypeConfigs, } from '../../config/defaults.js';
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+let ManifestCrudService = class ManifestCrudService {
+    manifestRepo;
+    validationService;
+    migrationTransformService;
+    versionDetectionService;
+    constructor(manifestRepo, validationService, migrationTransformService, versionDetectionService) {
+        this.manifestRepo = manifestRepo;
+        this.validationService = validationService;
+        this.migrationTransformService = migrationTransformService;
+        this.versionDetectionService = versionDetectionService;
+    }
+    // ---- Create (scaffold) ----
+    async create(input) {
+        const outputDir = path.resolve(input.output_dir || '.agents');
+        const agentDir = path.join(outputDir, input.name);
+        if (fs.existsSync(agentDir)) {
+            throw new Error(`Directory already exists: ${agentDir}`);
+        }
+        const typeConfigs = getAgentTypeConfigs();
+        const typeConfig = typeConfigs[input.type || 'worker'] || typeConfigs.worker;
+        const manifest = {
+            apiVersion: getApiVersion(),
+            kind: getDefaultAgentKind(),
+            metadata: {
+                name: input.name,
+                version: input.version || getDefaultAgentVersion(),
+                description: input.description || getDefaultDescriptionTemplate(input.name),
+            },
+            spec: {
+                role: input.role || getDefaultRoleTemplate(input.name),
+                llm: { provider: 'openai', model: '${LLM_MODEL:-gpt-4}' },
+                tools: typeConfig.capabilityName
+                    ? [{ type: 'capability', name: typeConfig.capabilityName }]
+                    : [],
+            },
+        };
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.mkdirSync(path.join(agentDir, 'prompts'), { recursive: true });
+        fs.mkdirSync(path.join(agentDir, 'tools'), { recursive: true });
+        const manifestPath = path.join(agentDir, 'manifest.ossa.yaml');
+        await this.manifestRepo.save(manifestPath, manifest);
+        const agentsMd = `# ${input.name}\n\n${manifest.metadata?.description || ''}\n\n## Tools\n\nTBD\n\n## Usage\n\n\`\`\`bash\nossa validate .agents/${input.name}/manifest.ossa.yaml\n\`\`\`\n`;
+        fs.writeFileSync(path.join(agentDir, 'AGENTS.md'), agentsMd, 'utf8');
+        return {
+            success: true,
+            manifest_path: manifestPath,
+            agent_dir: agentDir,
+            files_created: ['manifest.ossa.yaml', 'AGENTS.md', 'prompts/', 'tools/'],
+            manifest,
+        };
+    }
+    // ---- Read ----
+    async read(filePath) {
+        return this.manifestRepo.load(path.resolve(filePath));
+    }
+    // ---- List ----
+    async list(directory, opts) {
+        const baseDir = path.resolve(directory);
+        const recursive = opts?.recursive ?? true;
+        const results = await scanManifests(baseDir, {
+            recursive,
+            includeAgentsDirs: true,
+            absolute: true,
+        });
+        const agents = results.map((r) => r.error
+            ? { name: r.name || 'unknown', path: r.path, error: r.error }
+            : {
+                name: r.name || 'unknown',
+                version: r.version,
+                path: r.path,
+                kind: r.kind,
+                apiVersion: r.apiVersion,
+                description: r.description,
+            });
+        return { count: agents.length, agents };
+    }
+    // ---- Validate ----
+    async validate(manifest, opts) {
+        const result = await this.validationService.validate(manifest, opts?.platform);
+        if (opts?.strict && result.warnings?.length) {
+            const promoted = result.warnings.map((w) => `[strict] ${w}`);
+            result.errors = [
+                ...(result.errors || []),
+                ...promoted,
+            ];
+            result.valid = !result.errors?.length;
+        }
+        return result;
+    }
+    // ---- Inspect ----
+    async inspect(filePath) {
+        const manifestPath = path.resolve(filePath);
+        const manifest = await this.manifestRepo.load(manifestPath);
+        const validation = await this.validationService.validate(manifest);
+        const fileStat = fs.statSync(manifestPath);
+        const meta = manifest.metadata;
+        const spec = manifest.spec;
+        const extensions = manifest.extensions;
+        const versionStr = meta?.version || '0.0.0';
+        const parsed = semver.parse(versionStr);
+        const specTools = spec?.tools || [];
+        const access = spec?.access;
+        const autonomy = spec?.autonomy;
+        const deployTargets = [];
+        if (extensions) {
+            if (extensions.kagent)
+                deployTargets.push('kagent');
+            if (extensions.docker)
+                deployTargets.push('docker');
+            if (extensions.kubernetes)
+                deployTargets.push('kubernetes');
+        }
+        return {
+            name: meta?.name,
+            version: versionStr,
+            version_analysis: parsed
+                ? {
+                    major: parsed.major,
+                    minor: parsed.minor,
+                    patch: parsed.patch,
+                    prerelease: parsed.prerelease,
+                }
+                : null,
+            kind: manifest.kind,
+            apiVersion: manifest.apiVersion,
+            description: meta?.description,
+            role: spec?.role
+                ? String(spec.role).substring(0, 200) +
+                    (String(spec.role).length > 200 ? '...' : '')
+                : null,
+            llm: spec?.llm || null,
+            tools: specTools.map((t) => ({ name: t.name || t.type, type: t.type })),
+            tool_count: specTools.length,
+            access_tier: access?.tier || null,
+            autonomy_level: autonomy?.level || autonomy?.humanInLoop || null,
+            deploy_targets: deployTargets,
+            has_extensions: !!extensions,
+            extension_keys: extensions ? Object.keys(extensions) : [],
+            validation: {
+                valid: validation.valid,
+                error_count: validation.errors?.length || 0,
+                warning_count: validation.warnings?.length || 0,
+            },
+            file_size_bytes: fileStat.size,
+            manifest_path: manifestPath,
+        };
+    }
+    // ---- Diff ----
+    async diff(pathA, pathB) {
+        const resolvedA = path.resolve(pathA);
+        const resolvedB = path.resolve(pathB);
+        const manifestA = await this.manifestRepo.load(resolvedA);
+        const manifestB = await this.manifestRepo.load(resolvedB);
+        const allChanges = this.deepDiff(manifestA, manifestB);
+        const breakingChanges = allChanges.filter((c) => this.isBreakingChange(c));
+        return {
+            path_a: resolvedA,
+            path_b: resolvedB,
+            name_a: manifestA.metadata?.name,
+            name_b: manifestB.metadata?.name,
+            total_changes: allChanges.length,
+            breaking_changes: breakingChanges.map((c) => `${c.path}: ${c.type}`),
+            changes: allChanges,
+            compatible: breakingChanges.length === 0,
+        };
+    }
+    // ---- Migrate ----
+    async migrate(filePath, targetVersion, outputDir) {
+        const manifestPath = path.resolve(filePath);
+        const manifest = await this.manifestRepo.load(manifestPath);
+        const detectionResult = await this.versionDetectionService.detectVersion(manifest);
+        const currentVersion = detectionResult.version || manifest.apiVersion || 'unknown';
+        const target = targetVersion || 'ossa/v0.4';
+        if (currentVersion === target || `ossa/${currentVersion}` === target) {
+            return {
+                migrated: false,
+                reason: `Already at ${target}`,
+                manifest_path: manifestPath,
+            };
+        }
+        const fromVer = currentVersion.replace(/^ossa\/v?/, '');
+        const toVer = target.replace(/^ossa\/v?/, '');
+        const transform = this.migrationTransformService.getTransform(fromVer, toVer);
+        let migrated;
+        const migrations = [];
+        if (transform) {
+            migrated = this.migrationTransformService.applyTransform(manifest, fromVer, toVer);
+            migrations.push(`${transform.description} (${fromVer} → ${toVer})`);
+            if (transform.breaking)
+                migrations.push('WARNING: This migration contains breaking changes');
+            const warnings = this.migrationTransformService.validateMigration(manifest, migrated);
+            if (warnings.length)
+                migrations.push(...warnings.map((w) => `WARN: ${w}`));
+        }
+        else {
+            migrated = JSON.parse(JSON.stringify(manifest));
+            migrated.apiVersion = target;
+            migrations.push(`apiVersion: ${currentVersion} → ${target} (no registered transform — apiVersion updated only)`);
+        }
+        if (outputDir) {
+            const outDir = path.resolve(outputDir);
+            fs.mkdirSync(outDir, { recursive: true });
+            const outPath = path.join(outDir, path.basename(manifestPath));
+            const output = yaml.dump(migrated, {
+                lineWidth: 120,
+                noRefs: true,
+            });
+            fs.writeFileSync(outPath, output, 'utf8');
+            return {
+                migrated: true,
+                from: currentVersion,
+                to: target,
+                migrations,
+                written_to: outPath,
+            };
+        }
+        return {
+            migrated: true,
+            from: currentVersion,
+            to: target,
+            migrations,
+            manifest: migrated,
+        };
+    }
+    // ---- Private: deep diff ----
+    deepDiff(obj1, obj2, prefix = '') {
+        const changes = [];
+        const allKeys = new Set([
+            ...Object.keys(obj1 || {}),
+            ...Object.keys(obj2 || {}),
+        ]);
+        for (const key of allKeys) {
+            const fieldPath = prefix ? `${prefix}.${key}` : key;
+            const val1 = obj1?.[key];
+            const val2 = obj2?.[key];
+            if (!(key in (obj1 || {}))) {
+                changes.push({ type: 'added', path: fieldPath, newValue: val2 });
+            }
+            else if (!(key in (obj2 || {}))) {
+                changes.push({ type: 'removed', path: fieldPath, oldValue: val1 });
+            }
+            else if (typeof val1 === 'object' &&
+                typeof val2 === 'object' &&
+                val1 !== null &&
+                val2 !== null &&
+                !Array.isArray(val1) &&
+                !Array.isArray(val2)) {
+                changes.push(...this.deepDiff(val1, val2, fieldPath));
+            }
+            else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
+                changes.push({
+                    type: 'modified',
+                    path: fieldPath,
+                    oldValue: val1,
+                    newValue: val2,
+                });
+            }
+        }
+        return changes;
+    }
+    isBreakingChange(change) {
+        if (change.type === 'removed')
+            return true;
+        if (change.path.includes('metadata.name') ||
+            change.path.includes('metadata.version'))
+            return true;
+        if (change.path.includes('spec.role'))
+            return true;
+        if (change.path.includes('apiVersion'))
+            return true;
+        return false;
+    }
+};
+ManifestCrudService = __decorate([
+    injectable(),
+    __param(0, inject(ManifestRepository)),
+    __param(1, inject(ValidationService)),
+    __param(2, inject(MigrationTransformService)),
+    __param(3, inject(VersionDetectionService)),
+    __metadata("design:paramtypes", [ManifestRepository,
+        ValidationService,
+        MigrationTransformService,
+        VersionDetectionService])
+], ManifestCrudService);
+export { ManifestCrudService };
+//# sourceMappingURL=manifest-crud.service.js.map

package/dist/services/mcp/bridge.service.d.ts

@@ -0,0 +1,62 @@
+/**
+ * McpBridgeService — OSSA MCP Bridge (NIST Pillar 2: Interoperability)
+ *
+ * Uses @modelcontextprotocol/sdk Client to connect to and introspect
+ * external MCP servers, then registers them in the OSSA workspace registry.
+ *
+ * SOD: This service owns MCP connectivity and registry logic only.
+ * HTTP routing lives in mcp.router.ts. CLI presentation in mcp.command.ts.
+ */
+export interface OssaMcpServerEntry {
+    name: string;
+    command?: string;
+    args?: string[];
+    url?: string;
+    transport: 'stdio' | 'sse' | 'streamable-http';
+    source: string;
+    importedAt: string;
+    tools?: string[];
+}
+export interface McpBridgeSyncResult {
+    action: 'sync';
+    source: string;
+    serversFound: number;
+    serversImported: number;
+    registryPath: string;
+    servers: OssaMcpServerEntry[];
+}
+export interface McpBridgeListResult {
+    action: 'list';
+    registryPath: string;
+    servers: OssaMcpServerEntry[];
+}
+export declare class McpBridgeService {
+    private getRegistryPath;
+    private loadRegistry;
+    private saveRegistry;
+    /**
+     * Use @modelcontextprotocol/sdk Client to connect to a stdio server and list its tools.
+     * Returns an empty array if connection fails (non-fatal — import still proceeds).
+     */
+    private discoverToolsViaSDK;
+    /**
+     * Parse an external app's MCP config JSON into normalized OSSA entries.
+     * Uses the standard `mcpServers` shape from Claude Desktop / Cursor.
+     */
+    private parseExternalConfig;
+    /**
+     * Sync an external MCP source into the OSSA workspace registry.
+     * Uses SDK Client to introspect available tools where possible.
+     */
+    sync(source: string, workspaceDir: string): Promise<McpBridgeSyncResult>;
+    list(workspaceDir: string): Promise<McpBridgeListResult>;
+    /**
+     * Policy-gate check: validates that a tool server is registered in the OSSA bridge.
+     * Future: enforce per-agent allowlist from .agents-workspace/policy/tool-allowlist.yaml
+     */
+    executeTool(agentId: string, toolName: string, workspaceDir: string): Promise<{
+        allowed: boolean;
+        reason: string;
+    }>;
+}
+//# sourceMappingURL=bridge.service.d.ts.map

package/dist/services/mcp/bridge.service.js

@@ -0,0 +1,160 @@
+/**
+ * McpBridgeService — OSSA MCP Bridge (NIST Pillar 2: Interoperability)
+ *
+ * Uses @modelcontextprotocol/sdk Client to connect to and introspect
+ * external MCP servers, then registers them in the OSSA workspace registry.
+ *
+ * SOD: This service owns MCP connectivity and registry logic only.
+ * HTTP routing lives in mcp.router.ts. CLI presentation in mcp.command.ts.
+ */
+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;
+};
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { injectable } from 'inversify';
+import yaml from 'js-yaml';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getApiVersion } from '../../utils/version.js';
+/** Known config file locations per app — no hardcoding of values, only path resolution */
+const KNOWN_CONFIG_PATHS = {
+    'claude-desktop': [
+        path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+        path.join(os.homedir(), '.config', 'claude', 'claude_desktop_config.json'),
+    ],
+    cursor: [
+        path.join(os.homedir(), '.cursor', 'mcp.json'),
+        path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'mcp.json'),
+    ],
+};
+let McpBridgeService = class McpBridgeService {
+    getRegistryPath(workspaceDir) {
+        return path.join(workspaceDir, '.agents-workspace', 'registry', 'mcp-bridge.yaml');
+    }
+    loadRegistry(workspaceDir) {
+        const registryPath = this.getRegistryPath(workspaceDir);
+        if (!fs.existsSync(registryPath))
+            return [];
+        try {
+            const content = fs.readFileSync(registryPath, 'utf8');
+            const parsed = yaml.load(content);
+            return parsed?.servers ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    saveRegistry(workspaceDir, servers) {
+        const registryPath = this.getRegistryPath(workspaceDir);
+        const registryDir = path.dirname(registryPath);
+        if (!fs.existsSync(registryDir)) {
+            fs.mkdirSync(registryDir, { recursive: true });
+        }
+        fs.writeFileSync(registryPath, yaml.dump({ generatedBy: 'ossa-mcp-bridge', apiVersion: getApiVersion(), updatedAt: new Date().toISOString(), servers }, { lineWidth: 120 }), 'utf8');
+        return registryPath;
+    }
+    /**
+     * Use @modelcontextprotocol/sdk Client to connect to a stdio server and list its tools.
+     * Returns an empty array if connection fails (non-fatal — import still proceeds).
+     */
+    async discoverToolsViaSDK(command, args) {
+        let client;
+        try {
+            const transport = new StdioClientTransport({ command, args, env: process.env });
+            client = new Client({ name: 'ossa-mcp-bridge', version: '1.0.0' }, { capabilities: {} });
+            await client.connect(transport);
+            const { tools } = await client.listTools();
+            return tools.map((t) => t.name);
+        }
+        catch {
+            // Many MCP servers require API keys or context — graceful fallback
+            return [];
+        }
+        finally {
+            if (client) {
+                try {
+                    await client.close();
+                }
+                catch { /* swallow */ }
+            }
+        }
+    }
+    /**
+     * Parse an external app's MCP config JSON into normalized OSSA entries.
+     * Uses the standard `mcpServers` shape from Claude Desktop / Cursor.
+     */
+    parseExternalConfig(configPath, source) {
+        const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        return Object.entries(raw?.mcpServers ?? {}).map(([name, cfg]) => ({
+            name,
+            command: cfg.command,
+            args: cfg.args,
+            url: cfg.url,
+            transport: cfg.transport ?? (cfg.command ? 'stdio' : 'sse'),
+        }));
+    }
+    /**
+     * Sync an external MCP source into the OSSA workspace registry.
+     * Uses SDK Client to introspect available tools where possible.
+     */
+    async sync(source, workspaceDir) {
+        const dir = path.resolve(workspaceDir);
+        const knownPaths = KNOWN_CONFIG_PATHS[source];
+        if (!knownPaths) {
+            throw new Error(`Unknown MCP source: "${source}". Supported: ${Object.keys(KNOWN_CONFIG_PATHS).join(', ')}`);
+        }
+        const configPath = knownPaths.find((p) => fs.existsSync(p));
+        if (!configPath) {
+            throw new Error(`No config found for "${source}". Looked in:\n${knownPaths.join('\n')}`);
+        }
+        const parsed = this.parseExternalConfig(configPath, source);
+        const existing = this.loadRegistry(dir);
+        const existingKeys = new Set(existing.map((s) => `${s.source}::${s.name}`));
+        const now = new Date().toISOString();
+        const newEntries = [];
+        for (const cfg of parsed) {
+            if (existingKeys.has(`${source}::${cfg.name}`))
+                continue;
+            // Use SDK to discover actual tool names from stdio servers
+            const tools = cfg.command
+                ? await this.discoverToolsViaSDK(cfg.command, cfg.args ?? [])
+                : [];
+            newEntries.push({ ...cfg, source, importedAt: now, tools });
+        }
+        const merged = [...existing, ...newEntries];
+        const registryPath = this.saveRegistry(dir, merged);
+        return { action: 'sync', source, serversFound: parsed.length, serversImported: newEntries.length, registryPath, servers: newEntries };
+    }
+    async list(workspaceDir) {
+        const dir = path.resolve(workspaceDir);
+        const servers = this.loadRegistry(dir);
+        return { action: 'list', registryPath: this.getRegistryPath(dir), servers };
+    }
+    /**
+     * Policy-gate check: validates that a tool server is registered in the OSSA bridge.
+     * Future: enforce per-agent allowlist from .agents-workspace/policy/tool-allowlist.yaml
+     */
+    async executeTool(agentId, toolName, workspaceDir) {
+        const servers = this.loadRegistry(path.resolve(workspaceDir));
+        const [serverName, method] = toolName.split('/');
+        const server = servers.find((s) => s.name === serverName);
+        if (!server) {
+            return { allowed: false, reason: `"${serverName}" not in OSSA bridge registry. Run: ossa mcp bridge sync <source>` };
+        }
+        // Verify the specific tool name if we have a tool list from SDK discovery
+        if (server.tools && server.tools.length > 0 && method && !server.tools.includes(method)) {
+            return { allowed: false, reason: `Tool "${method}" not found on server "${serverName}". Known tools: ${server.tools.join(', ')}` };
+        }
+        return { allowed: true, reason: `Agent "${agentId}" is authorized to call "${toolName}" via OSSA bridge.` };
+    }
+};
+McpBridgeService = __decorate([
+    injectable()
+], McpBridgeService);
+export { McpBridgeService };
+//# sourceMappingURL=bridge.service.js.map

package/dist/services/mcp-manifest/mcp-manifest.service.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MCPManifestService — CRUD for mcp.ossa.yaml manifests
+ */
+import { ValidationService } from '../validation.service.js';
+import type { OssaMCPServer, ValidationResult } from '../../types/index.js';
+export interface CreateMCPInput {
+    name: string;
+    version?: string;
+    description?: string;
+    transport?: 'stdio' | 'sse' | 'streamable-http';
+}
+export declare class MCPManifestService {
+    private validationService;
+    constructor(validationService: ValidationService);
+    create(input: CreateMCPInput): Promise<OssaMCPServer>;
+    read(filePath: string): Promise<OssaMCPServer>;
+    validate(manifest: unknown): Promise<ValidationResult>;
+    list(directory: string): Promise<OssaMCPServer[]>;
+}
+//# sourceMappingURL=mcp-manifest.service.d.ts.map

package/dist/services/mcp-manifest/mcp-manifest.service.js

@@ -0,0 +1,85 @@
+/**
+ * MCPManifestService — CRUD for mcp.ossa.yaml manifests
+ */
+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 { injectable, inject } from 'inversify';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import fg from 'fast-glob';
+import { ValidationService } from '../validation.service.js';
+import { safeParseYAML } from '../../utils/yaml-parser.js';
+let MCPManifestService = class MCPManifestService {
+    validationService;
+    constructor(validationService) {
+        this.validationService = validationService;
+    }
+    async create(input) {
+        const manifest = {
+            apiVersion: 'ossa/v1',
+            kind: 'MCPServer',
+            metadata: {
+                name: input.name,
+                version: input.version || '1.0.0',
+                description: input.description || `MCP Server: ${input.name}`,
+            },
+            spec: {
+                transport: (input.transport || 'stdio'),
+                tools: [],
+                resources: [],
+            },
+        };
+        return manifest;
+    }
+    async read(filePath) {
+        const content = fs.readFileSync(path.resolve(filePath), 'utf8');
+        return safeParseYAML(content);
+    }
+    async validate(manifest) {
+        return this.validationService.validate(manifest);
+    }
+    async list(directory) {
+        const dir = path.resolve(directory);
+        const patterns = [
+            '**/*.mcp.ossa.yaml',
+            '**/*.mcp.ossa.yml',
+            '**/mcp.ossa.yaml',
+        ];
+        const files = await fg(patterns, {
+            cwd: dir,
+            ignore: ['**/node_modules/**', '**/dist/**'],
+            absolute: true,
+        });
+        const servers = [];
+        for (const f of files) {
+            try {
+                const content = fs.readFileSync(f, 'utf8');
+                const parsed = safeParseYAML(content);
+                if (parsed.kind === 'MCPServer') {
+                    servers.push(parsed);
+                }
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return servers;
+    }
+};
+MCPManifestService = __decorate([
+    injectable(),
+    __param(0, inject(ValidationService)),
+    __metadata("design:paramtypes", [ValidationService])
+], MCPManifestService);
+export { MCPManifestService };
+//# sourceMappingURL=mcp-manifest.service.js.map

package/dist/services/messaging/index.js

@@ -8,7 +8,7 @@
 // Core service
 export { MessagingService } from './messaging.service.js';
 // Message broker implementations
-// FIXME: MemoryBroker is runtime concern, should be in @bluefly/agent-mesh
+// MemoryBroker is a runtime concern; prefer @bluefly/agent-mesh when available.
 // export { MemoryBroker } from './memory-broker.js';
 // Types
 export { 

package/dist/services/multi-agent/team-generator.service.d.ts

@@ -15,13 +15,20 @@ export interface GeneratedTeamFile {
     type: 'code' | 'config' | 'documentation';
     language?: string;
 }
-export type TeamTargetPlatform = 'crewai' | 'langchain' | 'openai-agents' | 'claude-code' | 'mcp' | 'npm' | 'generic';
+export type TeamTargetPlatform = 'crewai' | 'langchain' | 'openai-agents' | 'claude-code' | 'mcp' | 'npm' | 'generic' | 'custom';
 export interface TeamGeneratorOptions {
     platform: TeamTargetPlatform;
     outputDir?: string;
     includeTests?: boolean;
     includeDocumentation?: boolean;
 }
+/**
+ * Wrapper class for tests and callers that expect a service instance.
+ * Delegates to generateTeamFiles / generateSubagentFiles.
+ */
+export declare class TeamGeneratorService {
+    generate(manifest: OssaAgent, platform?: TeamTargetPlatform): GeneratedTeamFile[];
+}
 /**
  * Detects if a manifest defines a multi-agent system
  */