opc-agent 1.4.0 → 1.4.1

package/src/marketplace/index.ts

@@ -0,0 +1,223 @@
+/**
+ * Agent Marketplace - Package, publish, and install agents
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { execSync } from 'child_process';
+
+export interface AgentManifest {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  license: string;
+  oadVersion: string;
+  channels: string[];
+  skills: string[];
+  files: string[];
+  checksum: string;
+  publishedAt: string;
+  homepage?: string;
+  repository?: string;
+  tags?: string[];
+}
+
+export interface PublishOptions {
+  oadPath: string;
+  outputDir?: string;
+  includeKnowledge?: boolean;
+}
+
+export interface InstallOptions {
+  source: string; // local path or URL
+  targetDir?: string;
+}
+
+function computeChecksum(filePath: string): string {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+export async function publishAgent(options: PublishOptions): Promise<{ archivePath: string; manifest: AgentManifest }> {
+  const { oadPath, outputDir = '.', includeKnowledge = false } = options;
+  const absOad = path.resolve(oadPath);
+  const baseDir = path.dirname(absOad);
+
+  if (!fs.existsSync(absOad)) {
+    throw new Error(`OAD file not found: ${absOad}`);
+  }
+
+  // Dynamic import yaml
+  const yaml = await import('js-yaml');
+  const oadContent = fs.readFileSync(absOad, 'utf-8');
+  const oad = yaml.load(oadContent) as any;
+
+  const name = oad.metadata?.name ?? 'unnamed-agent';
+  const version = oad.metadata?.version ?? '0.0.0';
+  const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+
+  // Collect files to package
+  const filesToPack: { rel: string; abs: string }[] = [
+    { rel: path.basename(absOad), abs: absOad },
+  ];
+
+  // Include common files
+  const extras = ['.env.example', 'README.md', 'package.json'];
+  for (const f of extras) {
+    const fp = path.join(baseDir, f);
+    if (fs.existsSync(fp)) {
+      filesToPack.push({ rel: f, abs: fp });
+    }
+  }
+
+  // Include knowledge base if requested
+  if (includeKnowledge) {
+    const kbFile = path.join(baseDir, '.opc-knowledge.json');
+    if (fs.existsSync(kbFile)) {
+      filesToPack.push({ rel: '.opc-knowledge.json', abs: kbFile });
+    }
+  }
+
+  // Include prompts directory if exists
+  const promptsDir = path.join(baseDir, 'prompts');
+  if (fs.existsSync(promptsDir) && fs.statSync(promptsDir).isDirectory()) {
+    const promptFiles = fs.readdirSync(promptsDir);
+    for (const pf of promptFiles) {
+      filesToPack.push({ rel: `prompts/${pf}`, abs: path.join(promptsDir, pf) });
+    }
+  }
+
+  // Build manifest
+  const manifest: AgentManifest = {
+    name: safeName,
+    version,
+    description: oad.metadata?.description ?? '',
+    author: oad.metadata?.author ?? '',
+    license: oad.metadata?.license ?? 'Apache-2.0',
+    oadVersion: 'opc/v1',
+    channels: (oad.spec?.channels ?? []).map((c: any) => c.type),
+    skills: (oad.spec?.skills ?? []).map((s: any) => s.name),
+    files: filesToPack.map(f => f.rel),
+    checksum: '',
+    publishedAt: new Date().toISOString(),
+    tags: oad.metadata?.marketplace?.tags,
+  };
+
+  // Create staging directory
+  const stageDir = path.join(outputDir, `.opc-stage-${safeName}`);
+  fs.mkdirSync(stageDir, { recursive: true });
+
+  for (const f of filesToPack) {
+    const dest = path.join(stageDir, f.rel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(f.abs, dest);
+  }
+
+  // Write manifest
+  fs.writeFileSync(path.join(stageDir, 'opc-manifest.json'), JSON.stringify(manifest, null, 2));
+
+  // Create tar.gz
+  const archiveName = `${safeName}-${version}.tar.gz`;
+  const archivePath = path.join(outputDir, archiveName);
+
+  try {
+    execSync(`tar -czf "${archivePath}" -C "${stageDir}" .`, { stdio: 'pipe' });
+  } catch {
+    // Fallback: just zip the directory content list
+    // On Windows without tar, create a simple zip-like package
+    const packageData = {
+      manifest,
+      files: filesToPack.map(f => ({
+        path: f.rel,
+        content: fs.readFileSync(f.abs, 'utf-8'),
+      })),
+    };
+    fs.writeFileSync(
+      archivePath.replace('.tar.gz', '.opc.json'),
+      JSON.stringify(packageData, null, 2),
+    );
+  }
+
+  // Compute checksum
+  if (fs.existsSync(archivePath)) {
+    manifest.checksum = computeChecksum(archivePath);
+  }
+
+  // Cleanup staging
+  fs.rmSync(stageDir, { recursive: true, force: true });
+
+  // Write final manifest
+  fs.writeFileSync(
+    path.join(outputDir, 'opc-manifest.json'),
+    JSON.stringify(manifest, null, 2),
+  );
+
+  return { archivePath: fs.existsSync(archivePath) ? archivePath : archivePath.replace('.tar.gz', '.opc.json'), manifest };
+}
+
+export async function installAgent(options: InstallOptions): Promise<{ dir: string; manifest: AgentManifest }> {
+  const { source, targetDir } = options;
+  const absSource = path.resolve(source);
+
+  if (!fs.existsSync(absSource)) {
+    throw new Error(`Package not found: ${absSource}`);
+  }
+
+  let manifest: AgentManifest;
+  let installDir: string;
+
+  if (absSource.endsWith('.opc.json')) {
+    // JSON package format
+    const pkg = JSON.parse(fs.readFileSync(absSource, 'utf-8'));
+    manifest = pkg.manifest;
+    installDir = targetDir ?? path.join('.', manifest.name);
+    fs.mkdirSync(installDir, { recursive: true });
+
+    for (const f of pkg.files) {
+      const dest = path.join(installDir, f.path);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.writeFileSync(dest, f.content, 'utf-8');
+    }
+    fs.writeFileSync(path.join(installDir, 'opc-manifest.json'), JSON.stringify(manifest, null, 2));
+  } else {
+    // tar.gz format
+    const tmpDir = path.join(path.dirname(absSource), '.opc-extract-tmp');
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+      execSync(`tar -xzf "${absSource}" -C "${tmpDir}"`, { stdio: 'pipe' });
+    } catch {
+      throw new Error('Failed to extract package. Ensure tar is available.');
+    }
+
+    const manifestPath = path.join(tmpDir, 'opc-manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      throw new Error('Invalid package: missing opc-manifest.json');
+    }
+
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    installDir = targetDir ?? path.join('.', manifest.name);
+
+    // Move files
+    fs.mkdirSync(installDir, { recursive: true });
+    const copyRecursive = (src: string, dest: string) => {
+      const entries = fs.readdirSync(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+          fs.mkdirSync(destPath, { recursive: true });
+          copyRecursive(srcPath, destPath);
+        } else {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    };
+    copyRecursive(tmpDir, installDir);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+
+  return { dir: installDir, manifest };
+}

package/src/memory/cloud-storage.ts

@@ -0,0 +1,217 @@
+// ─── Cloud Memory Backend ────────────────────────────────────
+// Fetch-based cloud storage for S3, GCS, and Azure Blob — no SDK deps.
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export interface CloudStorageConfig {
+  provider: 's3' | 'gcs' | 'azure-blob';
+  bucket: string;
+  prefix?: string;
+  credentials?: {
+    accessKey?: string;
+    secretKey?: string;
+    region?: string;
+  };
+  syncIntervalMs?: number;
+}
+
+/** Simple memory backend interface for cloud storage */
+export interface CloudMemoryBackendInterface {
+  upload(key: string, data: Buffer | string): Promise<string>;
+  download(key: string): Promise<Buffer | null>;
+  list(prefix?: string): Promise<string[]>;
+  delete(key: string): Promise<boolean>;
+}
+
+export class CloudMemoryBackend implements CloudMemoryBackendInterface {
+  private config: CloudStorageConfig;
+  private effectivePrefix: string;
+
+  constructor(config: CloudStorageConfig) {
+    this.config = config;
+    this.effectivePrefix = config.prefix ? config.prefix.replace(/\/$/, '') + '/' : '';
+  }
+
+  /** Upload data to cloud storage, returns the object URL */
+  async upload(key: string, data: Buffer | string): Promise<string> {
+    const fullKey = this.effectivePrefix + key;
+    const body = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
+    const url = this.buildUrl(fullKey);
+
+    const headers = await this.buildHeaders('PUT', fullKey, body);
+    const resp = await fetch(url, { method: 'PUT', headers, body });
+
+    if (!resp.ok) {
+      throw new Error(`Cloud upload failed [${resp.status}]: ${await resp.text()}`);
+    }
+    return url;
+  }
+
+  /** Download an object by key. Returns null if not found. */
+  async download(key: string): Promise<Buffer | null> {
+    const fullKey = this.effectivePrefix + key;
+    const url = this.buildUrl(fullKey);
+    const headers = await this.buildHeaders('GET', fullKey);
+
+    const resp = await fetch(url, { method: 'GET', headers });
+    if (resp.status === 404) return null;
+    if (!resp.ok) {
+      throw new Error(`Cloud download failed [${resp.status}]: ${await resp.text()}`);
+    }
+    const ab = await resp.arrayBuffer();
+    return Buffer.from(ab);
+  }
+
+  /** List object keys under a prefix */
+  async list(prefix?: string): Promise<string[]> {
+    const fullPrefix = this.effectivePrefix + (prefix ?? '');
+
+    if (this.config.provider === 's3') {
+      const listUrl = this.buildBucketUrl() + `?list-type=2&prefix=${encodeURIComponent(fullPrefix)}`;
+      const headers = await this.buildHeaders('GET', '');
+      const resp = await fetch(listUrl, { method: 'GET', headers });
+      if (!resp.ok) return [];
+      const text = await resp.text();
+      // Simple XML key extraction
+      const keys: string[] = [];
+      const regex = /<Key>([^<]+)<\/Key>/g;
+      let match: RegExpExecArray | null;
+      while ((match = regex.exec(text)) !== null) {
+        keys.push(match[1]);
+      }
+      return keys;
+    }
+
+    if (this.config.provider === 'gcs') {
+      const listUrl = `https://storage.googleapis.com/storage/v1/b/${this.config.bucket}/o?prefix=${encodeURIComponent(fullPrefix)}`;
+      const headers = await this.buildHeaders('GET', '');
+      const resp = await fetch(listUrl, { method: 'GET', headers });
+      if (!resp.ok) return [];
+      const json = await resp.json() as { items?: { name: string }[] };
+      return (json.items ?? []).map((i) => i.name);
+    }
+
+    // azure-blob
+    const listUrl = this.buildBucketUrl() + `?restype=container&comp=list&prefix=${encodeURIComponent(fullPrefix)}`;
+    const headers = await this.buildHeaders('GET', '');
+    const resp = await fetch(listUrl, { method: 'GET', headers });
+    if (!resp.ok) return [];
+    const text = await resp.text();
+    const keys: string[] = [];
+    const regex = /<Name>([^<]+)<\/Name>/g;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(text)) !== null) {
+      keys.push(match[1]);
+    }
+    return keys;
+  }
+
+  /** Delete an object by key */
+  async delete(key: string): Promise<boolean> {
+    const fullKey = this.effectivePrefix + key;
+    const url = this.buildUrl(fullKey);
+    const headers = await this.buildHeaders('DELETE', fullKey);
+    const resp = await fetch(url, { method: 'DELETE', headers });
+    return resp.ok || resp.status === 204;
+  }
+
+  /** Sync a local directory with the cloud bucket prefix */
+  async sync(localDir: string): Promise<{ uploaded: number; downloaded: number }> {
+    let uploaded = 0;
+    let downloaded = 0;
+
+    // Upload local files
+    if (fs.existsSync(localDir)) {
+      const files = fs.readdirSync(localDir);
+      for (const file of files) {
+        const filePath = path.join(localDir, file);
+        if (fs.statSync(filePath).isFile()) {
+          const data = fs.readFileSync(filePath);
+          await this.upload(file, data);
+          uploaded++;
+        }
+      }
+    }
+
+    // Download remote files not present locally
+    const remoteKeys = await this.list();
+    for (const key of remoteKeys) {
+      const baseName = key.replace(this.effectivePrefix, '');
+      if (!baseName || baseName.includes('/')) continue;
+      const localPath = path.join(localDir, baseName);
+      if (!fs.existsSync(localPath)) {
+        const data = await this.download(baseName);
+        if (data) {
+          fs.mkdirSync(localDir, { recursive: true });
+          fs.writeFileSync(localPath, data);
+          downloaded++;
+        }
+      }
+    }
+
+    return { uploaded, downloaded };
+  }
+
+  // ─── Internal helpers ──────────────────────────────────────
+
+  private buildUrl(key: string): string {
+    switch (this.config.provider) {
+      case 's3': {
+        const region = this.config.credentials?.region ?? 'us-east-1';
+        return `https://${this.config.bucket}.s3.${region}.amazonaws.com/${key}`;
+      }
+      case 'gcs':
+        return `https://storage.googleapis.com/${this.config.bucket}/${key}`;
+      case 'azure-blob':
+        return `https://${this.config.bucket}.blob.core.windows.net/${key}`;
+    }
+  }
+
+  private buildBucketUrl(): string {
+    switch (this.config.provider) {
+      case 's3': {
+        const region = this.config.credentials?.region ?? 'us-east-1';
+        return `https://${this.config.bucket}.s3.${region}.amazonaws.com`;
+      }
+      case 'gcs':
+        return `https://storage.googleapis.com/${this.config.bucket}`;
+      case 'azure-blob':
+        return `https://${this.config.bucket}.blob.core.windows.net`;
+    }
+  }
+
+  private async buildHeaders(
+    method: string,
+    key: string,
+    body?: Buffer,
+  ): Promise<Record<string, string>> {
+    const headers: Record<string, string> = {};
+
+    if (this.config.provider === 's3' && this.config.credentials?.accessKey) {
+      // Simplified AWS Signature v4 — date + authorization placeholder
+      const date = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
+      const dateShort = date.slice(0, 8);
+      const region = this.config.credentials.region ?? 'us-east-1';
+      headers['x-amz-date'] = date;
+      headers['x-amz-content-sha256'] = body
+        ? crypto.createHash('sha256').update(body).digest('hex')
+        : 'UNSIGNED-PAYLOAD';
+      // Real v4 signing would go here; keeping header structure correct
+      headers['Authorization'] = `AWS4-HMAC-SHA256 Credential=${this.config.credentials.accessKey}/${dateShort}/${region}/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=placeholder`;
+    }
+
+    if (this.config.provider === 'gcs' && this.config.credentials?.accessKey) {
+      headers['Authorization'] = `Bearer ${this.config.credentials.accessKey}`;
+    }
+
+    if (this.config.provider === 'azure-blob' && this.config.credentials?.accessKey) {
+      headers['x-ms-version'] = '2021-08-06';
+      headers['x-ms-date'] = new Date().toUTCString();
+      headers['Authorization'] = `SharedKey ${this.config.credentials.accessKey}`;
+    }
+
+    return headers;
+  }
+}

package/src/memory/deepbrain.ts

@@ -1,108 +1,108 @@
-import type { Message, MemoryStore } from '../core/types';
-import { InMemoryStore } from './index';
-
-/**
- * DeepBrain-backed memory store for long-term semantic memory.
- * Falls back to InMemoryStore if deepbrain package is not installed.
- */
-export interface DeepBrainClient {
-  store(collection: string, id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
-  search(collection: string, query: string, limit?: number): Promise<Array<{ id: string; content: string; score: number }>>;
-  delete(collection: string, id?: string): Promise<void>;
-}
-
-export class DeepBrainMemoryStore implements MemoryStore {
-  private fallback: InMemoryStore;
-  private client: DeepBrainClient | null = null;
-  private collection: string;
-  private ready: Promise<boolean>;
-
-  constructor(options: { collection?: string; config?: Record<string, unknown> } = {}) {
-    this.fallback = new InMemoryStore();
-    this.collection = options.collection ?? 'agent-memory';
-    this.ready = this.initClient(options.config);
-  }
-
-  private async initClient(config?: Record<string, unknown>): Promise<boolean> {
-    try {
-      // @ts-ignore - dynamic optional dependency
-      const deepbrain = await import(/* webpackIgnore: true */ 'deepbrain');
-      this.client = (deepbrain as any).createClient?.(config) ?? (deepbrain as any).default?.createClient?.(config);
-      if (!this.client) {
-        console.warn('[DeepBrainMemory] Could not create client, using in-memory fallback');
-        return false;
-      }
-      return true;
-    } catch {
-      console.warn('[DeepBrainMemory] deepbrain package not found, using in-memory fallback');
-      return false;
-    }
-  }
-
-  async get(key: string): Promise<unknown> {
-    await this.ready;
-    if (this.client) {
-      try {
-        const results = await this.client.search(this.collection, key, 1);
-        return results[0]?.content;
-      } catch {
-        return this.fallback.get(key);
-      }
-    }
-    return this.fallback.get(key);
-  }
-
-  async set(key: string, value: unknown): Promise<void> {
-    await this.ready;
-    if (this.client) {
-      try {
-        await this.client.store(this.collection, key, JSON.stringify(value));
-        return;
-      } catch { /* fallback */ }
-    }
-    return this.fallback.set(key, value);
-  }
-
-  async getConversation(sessionId: string): Promise<Message[]> {
-    return this.fallback.getConversation(sessionId);
-  }
-
-  async addMessage(sessionId: string, message: Message): Promise<void> {
-    await this.fallback.addMessage(sessionId, message);
-    // Also store in DeepBrain for semantic search
-    await this.ready;
-    if (this.client && message.role === 'user') {
-      try {
-        await this.client.store(this.collection, message.id, message.content, {
-          sessionId,
-          role: message.role,
-          timestamp: message.timestamp,
-        });
-      } catch { /* non-critical */ }
-    }
-  }
-
-  async clear(sessionId?: string): Promise<void> {
-    await this.fallback.clear(sessionId);
-    if (this.client && !sessionId) {
-      try { await this.client.delete(this.collection); } catch { /* ignore */ }
-    }
-  }
-
-  /**
-   * Semantic search over stored memories.
-   */
-  async semanticSearch(query: string, limit: number = 5): Promise<Array<{ id: string; content: string; score: number }>> {
-    await this.ready;
-    if (this.client) {
-      try {
-        return await this.client.search(this.collection, query, limit);
-      } catch { return []; }
-    }
-    return [];
-  }
-
-  isDeepBrainAvailable(): Promise<boolean> {
-    return this.ready;
-  }
-}
+import type { Message, MemoryStore } from '../core/types';
+import { InMemoryStore } from './index';
+
+/**
+ * DeepBrain-backed memory store for long-term semantic memory.
+ * Falls back to InMemoryStore if deepbrain package is not installed.
+ */
+export interface DeepBrainClient {
+  store(collection: string, id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
+  search(collection: string, query: string, limit?: number): Promise<Array<{ id: string; content: string; score: number }>>;
+  delete(collection: string, id?: string): Promise<void>;
+}
+
+export class DeepBrainMemoryStore implements MemoryStore {
+  private fallback: InMemoryStore;
+  private client: DeepBrainClient | null = null;
+  private collection: string;
+  private ready: Promise<boolean>;
+
+  constructor(options: { collection?: string; config?: Record<string, unknown> } = {}) {
+    this.fallback = new InMemoryStore();
+    this.collection = options.collection ?? 'agent-memory';
+    this.ready = this.initClient(options.config);
+  }
+
+  private async initClient(config?: Record<string, unknown>): Promise<boolean> {
+    try {
+      // @ts-ignore - dynamic optional dependency
+      const deepbrain = await import(/* webpackIgnore: true */ 'deepbrain');
+      this.client = (deepbrain as any).createClient?.(config) ?? (deepbrain as any).default?.createClient?.(config);
+      if (!this.client) {
+        console.warn('[DeepBrainMemory] Could not create client, using in-memory fallback');
+        return false;
+      }
+      return true;
+    } catch {
+      console.warn('[DeepBrainMemory] deepbrain package not found, using in-memory fallback');
+      return false;
+    }
+  }
+
+  async get(key: string): Promise<unknown> {
+    await this.ready;
+    if (this.client) {
+      try {
+        const results = await this.client.search(this.collection, key, 1);
+        return results[0]?.content;
+      } catch {
+        return this.fallback.get(key);
+      }
+    }
+    return this.fallback.get(key);
+  }
+
+  async set(key: string, value: unknown): Promise<void> {
+    await this.ready;
+    if (this.client) {
+      try {
+        await this.client.store(this.collection, key, JSON.stringify(value));
+        return;
+      } catch { /* fallback */ }
+    }
+    return this.fallback.set(key, value);
+  }
+
+  async getConversation(sessionId: string): Promise<Message[]> {
+    return this.fallback.getConversation(sessionId);
+  }
+
+  async addMessage(sessionId: string, message: Message): Promise<void> {
+    await this.fallback.addMessage(sessionId, message);
+    // Also store in DeepBrain for semantic search
+    await this.ready;
+    if (this.client && message.role === 'user') {
+      try {
+        await this.client.store(this.collection, message.id, message.content, {
+          sessionId,
+          role: message.role,
+          timestamp: message.timestamp,
+        });
+      } catch { /* non-critical */ }
+    }
+  }
+
+  async clear(sessionId?: string): Promise<void> {
+    await this.fallback.clear(sessionId);
+    if (this.client && !sessionId) {
+      try { await this.client.delete(this.collection); } catch { /* ignore */ }
+    }
+  }
+
+  /**
+   * Semantic search over stored memories.
+   */
+  async semanticSearch(query: string, limit: number = 5): Promise<Array<{ id: string; content: string; score: number }>> {
+    await this.ready;
+    if (this.client) {
+      try {
+        return await this.client.search(this.collection, query, limit);
+      } catch { return []; }
+    }
+    return [];
+  }
+
+  isDeepBrainAvailable(): Promise<boolean> {
+    return this.ready;
+  }
+}