@bluefly/openstandardagents 0.4.4 → 0.4.6

package/dist/services/audit.js

@@ -4,23 +4,39 @@
  * Scans directories for OSSA agent manifests and validates their health.
  * Implements the OSSA Audit API specification.
  */
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import Ajv from 'ajv';
+import { API_VERSION, SCHEMA_PATH, SPEC_VERSION } from '../version.js';
 export class AgentAuditService {
     ajv;
     ossaSchema;
+    validate;
     constructor() {
-        this.ajv = new Ajv({ allErrors: true, strict: false });
-        // Load OSSA schema (would load from schema directory)
-        this.ossaSchema = null; // TODO: Load actual schema
+        // Initialize Ajv validator with formats support
+        this.ajv = new Ajv({
+            allErrors: true,
+            strict: false,
+            validateFormats: true,
+        });
+        addFormats(this.ajv);
+        // Load OSSA v0.4 schema
+        const schemaPath = path.resolve(process.cwd(), SCHEMA_PATH);
+        if (!fs.existsSync(schemaPath)) {
+            throw new Error(`OSSA schema not found at ${schemaPath}`);
+        }
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        this.ossaSchema = JSON.parse(schemaContent);
+        // Compile schema and store validator
+        this.validate = this.ajv.compile(this.ossaSchema);
     }
     /**
      * Scan directory and audit all agents
      */
     async scanAndAudit(options) {
-        const { path: scanPath, recursive = true, validationLevel = 'full', specVersion = '0.3.5', includeExamples = false, } = options;
+        const { path: scanPath, recursive = true, validationLevel = 'full', specVersion = SPEC_VERSION, includeExamples = false, } = options;
         // Find all agent directories
         const agentDirs = this.findAgentDirectories(scanPath, recursive);
         // Audit each agent
@@ -103,8 +119,10 @@ export class AgentAuditService {
         // Extract basic info
         health.name = manifest.metadata?.name || manifest.name;
         // Validate against OSSA schema
+        let manifestValid = false;
         if (validationLevel === 'full' || validationLevel === 'strict') {
             const validationResult = this.validateManifest(manifest);
+            manifestValid = validationResult.valid;
             health.manifestValid = validationResult.valid;
             health.validationErrors = validationResult.errors;
             if (!validationResult.valid) {
@@ -114,31 +132,31 @@ export class AgentAuditService {
                     message: `Manifest does not conform to OSSA spec: ${validationResult.errors.length} errors`,
                 });
             }
+            // Check schema version if valid
+            if (manifestValid) {
+                const versionIssue = this.checkSchemaVersion(manifest);
+                if (versionIssue) {
+                    health.issues.push(versionIssue);
+                }
+            }
         }
         else {
             health.manifestValid = true; // Skip validation in basic mode
+            manifestValid = true;
         }
-        // Count capabilities, tools, triggers
+        // Count capabilities, tools, triggers (capabilities are legacy/workflow-specific)
         health.capabilitiesCount =
             manifest.spec?.capabilities?.length || manifest.capabilities?.length || 0;
         health.toolsCount =
             manifest.spec?.tools?.length || manifest.tools?.length || 0;
         health.triggersCount =
             manifest.spec?.triggers?.length || manifest.triggers?.length || 0;
-        // Check for missing sections
-        if (health.capabilitiesCount === 0) {
-            health.issues.push({
-                severity: 'warning',
-                code: 'NO_CAPABILITIES',
-                message: 'Agent has no capabilities defined',
-                field: 'spec.capabilities',
-            });
-        }
-        if (health.toolsCount === 0) {
+        // Check for missing tools (optional warning, not required for v0.4)
+        if (health.toolsCount === 0 && manifest.kind === 'Agent') {
             health.issues.push({
-                severity: 'warning',
+                severity: 'info',
                 code: 'NO_TOOLS',
-                message: 'Agent has no tools defined',
+                message: 'Agent has no tools defined (optional)',
                 field: 'spec.tools',
             });
         }
@@ -183,43 +201,55 @@ export class AgentAuditService {
         return dirs;
     }
     /**
-     * Validate manifest against OSSA schema
+     * Validate manifest against OSSA schema using Ajv
      */
     validateManifest(manifest) {
-        // TODO: Implement actual schema validation using ajv
-        // For now, do basic checks
-        const errors = [];
-        if (!manifest.metadata && !manifest.name) {
-            errors.push({
-                path: '/metadata/name',
-                message: 'Agent name is required',
-            });
+        const valid = this.validate(manifest);
+        if (!valid && this.validate.errors) {
+            const errors = this.validate.errors.map((err) => ({
+                path: err.instancePath || '/',
+                message: err.message || 'Validation error',
+            }));
+            return { valid: false, errors };
         }
-        if (!manifest.spec && !manifest.capabilities) {
-            errors.push({
-                path: '/spec',
-                message: 'Agent spec is required',
-            });
+        return { valid: true, errors: [] };
+    }
+    /**
+     * Check schema version and warn if outdated
+     */
+    checkSchemaVersion(manifest) {
+        const apiVersion = manifest.apiVersion;
+        if (!apiVersion) {
+            return {
+                severity: 'error',
+                code: 'MISSING_API_VERSION',
+                message: 'Manifest missing apiVersion field',
+                field: 'apiVersion',
+            };
         }
-        return {
-            valid: errors.length === 0,
-            errors,
-        };
+        // Compare with current API version
+        if (apiVersion !== API_VERSION) {
+            return {
+                severity: 'warning',
+                code: 'VERSION_MISMATCH',
+                message: `Manifest uses ${apiVersion}, current is ${API_VERSION}`,
+                field: 'apiVersion',
+            };
+        }
+        return null;
     }
     /**
      * Calculate health score (0-100)
+     * v0.4 schema no longer requires capabilities, so scoring is adjusted
      */
     calculateHealthScore(health) {
         let score = 0;
         // Manifest exists: 30 points
         if (health.manifestExists)
             score += 30;
-        // Manifest valid: 30 points
+        // Manifest valid: 50 points (increased importance in v0.4)
         if (health.manifestValid)
-            score += 30;
-        // Has capabilities: 20 points
-        if (health.capabilitiesCount > 0)
-            score += 20;
+            score += 50;
         // Has tools: 10 points
         if (health.toolsCount > 0)
             score += 10;

package/dist/services/codegen/generators/vscode.generator.js

@@ -132,8 +132,8 @@ let VSCodeGenerator = class VSCodeGenerator {
         // Replace 'v0.x.x' default values
         updated = updated.replace(/['"]v\d+\.\d+\.\d+['"]/g, (match) => {
             // Only replace if it looks like an OSSA version
-            if (match.includes('v0.3') || match.includes('v0.2')) {
-                // apiVersion is "ossa/v0.3.3", so .replace('ossa/', '') gives "v0.3.3"
+            if (match.includes('v0.')) {
+                // apiVersion is "ossa/v0.4.6", so .replace('ossa/', '') gives "v0.4.6"
                 return `'${apiVersion.replace('ossa/', '')}'`;
             }
             return match;

package/dist/services/conformance/profile-loader.service.js

@@ -36,7 +36,7 @@ let ConformanceProfileLoader = class ConformanceProfileLoader {
             // Strategy 4: From openstandardagents directory
             join(process.cwd(), 'openstandardagents/spec/v0.3/conformance/profiles'),
             // Strategy 5: Absolute path from repo root (CI environments)
-            '/builds/blueflyio/ossa/openstandardagents/spec/v0.3/conformance/profiles',
+            join(process.env.CI_PROJECT_DIR || '/builds', 'spec/v0.3/conformance/profiles'),
         ];
         for (const path of strategies) {
             if (existsSync(path)) {

package/dist/services/convert/convert.service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ConvertService — Wraps adapter toConfig() for platform conversion
+ *
+ * Thin layer over the adapter registry, callable from CLI, REST, and MCP.
+ */
+import type { OssaAgent } from '../../types/index.js';
+export interface ConvertInput {
+    manifest: OssaAgent;
+    target: string;
+    output_dir?: string;
+}
+export interface ConvertResult {
+    target: string;
+    filename: string;
+    content: Record<string, unknown>;
+    written_to?: string;
+}
+export declare class ConvertService {
+    constructor();
+    convert(input: ConvertInput): Promise<ConvertResult>;
+    listTargets(): Array<{
+        id: string;
+        name: string;
+    }>;
+}
+//# sourceMappingURL=convert.service.d.ts.map

package/dist/services/convert/convert.service.js

@@ -0,0 +1,72 @@
+/**
+ * ConvertService — Wraps adapter toConfig() for platform conversion
+ *
+ * Thin layer over the adapter registry, callable from CLI, REST, and MCP.
+ */
+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 { injectable } from 'inversify';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { initializeAdapters, registry as adapterRegistry, } from '../../adapters/index.js';
+let ConvertService = class ConvertService {
+    constructor() {
+        initializeAdapters();
+    }
+    async convert(input) {
+        const adapter = adapterRegistry.getAdapter(input.target);
+        if (!adapter) {
+            throw new Error(`Unknown target: ${input.target}`);
+        }
+        const result = await adapter.toConfig(input.manifest);
+        const converted = result.config;
+        const filename = result.filename;
+        if (input.output_dir) {
+            const outDir = path.resolve(input.output_dir);
+            fs.mkdirSync(outDir, { recursive: true });
+            const outPath = path.join(outDir, filename);
+            const multiRes = converted;
+            let content;
+            if (multiRes._ossa_multi_resource && Array.isArray(multiRes.resources)) {
+                content = multiRes.resources
+                    .map((r) => yaml.dump(r, { lineWidth: 120, noRefs: true }))
+                    .join('---\n');
+            }
+            else if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
+                content = yaml.dump(converted, { lineWidth: 120, noRefs: true });
+            }
+            else {
+                content = JSON.stringify(converted, null, 2);
+            }
+            fs.writeFileSync(outPath, content, 'utf8');
+            return {
+                target: input.target,
+                filename,
+                content: converted,
+                written_to: outPath,
+            };
+        }
+        return { target: input.target, filename, content: converted };
+    }
+    listTargets() {
+        const adapters = adapterRegistry.getAdapterInfo();
+        return adapters.map((a) => ({
+            id: a.platform,
+            name: a.displayName || a.platform,
+        }));
+    }
+};
+ConvertService = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], ConvertService);
+export { ConvertService };
+//# sourceMappingURL=convert.service.js.map

package/dist/services/daemon/audit-log.service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Daemon Audit Log Service
+ * NIST-compliant audit logging for all daemon operations.
+ * Writes JSONL to ~/.ossa/daemon-audit.jsonl for security auditing.
+ * Non-blocking writes — never slows down the daemon.
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+export type AuditAction = 'pair' | 'connect' | 'disconnect' | 'file_write' | 'file_read' | 'execute' | 'execute_cancel' | 'skill_install' | 'session_revoke';
+export interface AuditEntry {
+    ts: string;
+    action: AuditAction;
+    origin?: string;
+    sessionId?: string;
+    path?: string;
+    result: 'success' | 'failure' | 'error';
+    detail?: string;
+}
+export declare class AuditLogService {
+    private initialized;
+    /**
+     * Ensure ~/.ossa/ directory exists.
+     * Safe to call multiple times.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Append an audit entry to the JSONL log.
+     * Non-blocking: fires and forgets the write, logging errors to stderr.
+     */
+    log(entry: Omit<AuditEntry, 'ts'>): Promise<void>;
+    /**
+     * Read the most recent audit entries.
+     * Reads from the end of the file for efficiency.
+     */
+    getRecentEntries(count?: number): Promise<AuditEntry[]>;
+}
+//# sourceMappingURL=audit-log.service.d.ts.map

package/dist/services/daemon/audit-log.service.js

@@ -0,0 +1,79 @@
+/**
+ * Daemon Audit Log Service
+ * NIST-compliant audit logging for all daemon operations.
+ * Writes JSONL to ~/.ossa/daemon-audit.jsonl for security auditing.
+ * Non-blocking writes — never slows down the daemon.
+ *
+ * @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;
+};
+import { appendFile, mkdir, readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { injectable } from 'inversify';
+const OSSA_DIR = join(homedir(), '.ossa');
+const AUDIT_LOG_PATH = join(OSSA_DIR, 'daemon-audit.jsonl');
+const DEFAULT_RECENT_COUNT = 50;
+let AuditLogService = class AuditLogService {
+    initialized = false;
+    /**
+     * Ensure ~/.ossa/ directory exists.
+     * Safe to call multiple times.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        await mkdir(OSSA_DIR, { recursive: true });
+        this.initialized = true;
+    }
+    /**
+     * Append an audit entry to the JSONL log.
+     * Non-blocking: fires and forgets the write, logging errors to stderr.
+     */
+    async log(entry) {
+        const record = {
+            ts: new Date().toISOString(),
+            ...entry,
+        };
+        const line = JSON.stringify(record) + '\n';
+        try {
+            await this.initialize();
+            await appendFile(AUDIT_LOG_PATH, line, 'utf-8');
+        }
+        catch (err) {
+            // Never crash the daemon — log to stderr and continue
+            process.stderr.write(`[audit-log] write failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    /**
+     * Read the most recent audit entries.
+     * Reads from the end of the file for efficiency.
+     */
+    async getRecentEntries(count = DEFAULT_RECENT_COUNT) {
+        try {
+            await this.initialize();
+            const content = await readFile(AUDIT_LOG_PATH, 'utf-8');
+            const lines = content.trim().split('\n').filter(Boolean);
+            const recent = lines.slice(-count);
+            return recent.map((line) => JSON.parse(line));
+        }
+        catch (err) {
+            // File doesn't exist yet or read error — return empty
+            if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+                return [];
+            }
+            process.stderr.write(`[audit-log] read failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            return [];
+        }
+    }
+};
+AuditLogService = __decorate([
+    injectable()
+], AuditLogService);
+export { AuditLogService };
+//# sourceMappingURL=audit-log.service.js.map

package/dist/services/daemon/execution.service.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Daemon Execution Service
+ * Manages agent execution within the daemon process.
+ * Extends the run command logic with concurrent execution tracking,
+ * event streaming, timeout, and cancellation support.
+ *
+ * Keys are read from local .env — NEVER sent over WebSocket.
+ * Max 3 concurrent executions to prevent resource exhaustion.
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+import { EventEmitter } from 'events';
+/**
+ * Supported LLM runtime adapters
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+export type RuntimeAdapter = 'openai' | 'anthropic' | 'azure' | 'bedrock' | 'claude' | 'gemini' | 'mistral' | 'ollama';
+/**
+ * Execution state
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+export interface Execution {
+    id: string;
+    manifestPath: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    startedAt: Date;
+    completedAt?: Date;
+    output?: unknown;
+    error?: string;
+}
+/**
+ * Event emitted during execution
+ *
+ * @experimental This feature is experimental and may change without notice.
+ */
+export interface ExecutionEvent {
+    type: 'stdout' | 'stderr' | 'tool_call' | 'tool_result' | 'completion' | 'error';
+    executionId: string;
+    data: string;
+    timestamp: string;
+}
+export declare class ExecutionService extends EventEmitter {
+    private executions;
+    private abortControllers;
+    private timeoutTimers;
+    /**
+     * Start an agent execution.
+     * Loads manifest, validates, selects runtime adapter, and runs.
+     */
+    start(manifestPath: string, input?: unknown, runtime?: string, timeoutMs?: number): Promise<Execution>;
+    /**
+     * Cancel a running execution
+     */
+    cancel(executionId: string): Promise<boolean>;
+    /**
+     * Get execution by ID
+     */
+    getExecution(executionId: string): Execution | undefined;
+    /**
+     * Get all currently running executions
+     */
+    getRunningExecutions(): Execution[];
+    /**
+     * Register a callback for execution events on a specific execution
+     */
+    onExecutionEvent(executionId: string, callback: (event: ExecutionEvent) => void): void;
+    /**
+     * Get list of supported runtime adapters
+     */
+    getSupportedRuntimes(): RuntimeAdapter[];
+    /**
+     * Execute the agent — load manifest, create adapter, run chat
+     */
+    private runExecution;
+    /**
+     * Create the appropriate runtime adapter
+     * Currently OpenAI and Anthropic are fully implemented.
+     * Others return null (stub — adapters exist in src/services/runtime/).
+     */
+    private createAdapter;
+    /**
+     * Wrap adapter tool execution to emit tool_call / tool_result events.
+     * Monkey-patches the adapter's executeTool if accessible, otherwise
+     * relies on verbose output. This is a best-effort approach since
+     * the adapters don't expose a hook interface yet.
+     */
+    private wrapToolEvents;
+    /**
+     * Handle execution timeout
+     */
+    private handleTimeout;
+    /**
+     * Mark an execution as completed/failed/cancelled and emit events
+     */
+    private completeExecution;
+    /**
+     * Emit an execution event
+     */
+    private emitEvent;
+}
+//# sourceMappingURL=execution.service.d.ts.map