opc-agent 1.2.1 → 1.3.0

package/dist/tools/gateway.js

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolGateway = void 0;
-// ─── Gateway Tool Wrapper ────────────────────────────────────
-class GatewayTool {
-    gateway;
-    meta;
-    name;
-    description;
-    inputSchema;
-    constructor(gateway, meta) {
-        this.gateway = gateway;
-        this.meta = meta;
-        this.name = `gateway:${meta.name}`;
-        this.description = `[Gateway] ${meta.description}`;
-        this.inputSchema = meta.inputSchema;
-    }
-    async execute(input, _context) {
-        return this.gateway.invokeTool(this.meta.name, input);
-    }
-}
-// ─── Default Tool Definitions ────────────────────────────────
-const DEFAULT_TOOL_DEFS = [
-    {
-        name: 'web-search',
-        description: 'Search the web and return results',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Search query' },
-                count: { type: 'number', description: 'Number of results (1-10)' },
-            },
-            required: ['query'],
-        },
-        available: true,
-    },
-    {
-        name: 'image-gen',
-        description: 'Generate images from text prompts',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                prompt: { type: 'string', description: 'Image generation prompt' },
-                size: { type: 'string', description: 'Image size (e.g. 1024x1024)' },
-            },
-            required: ['prompt'],
-        },
-        available: true,
-    },
-    {
-        name: 'tts',
-        description: 'Convert text to speech audio',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                text: { type: 'string', description: 'Text to synthesize' },
-                voice: { type: 'string', description: 'Voice identifier' },
-            },
-            required: ['text'],
-        },
-        available: true,
-    },
-    {
-        name: 'browser',
-        description: 'Automated browser actions — navigate, screenshot, extract content',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', description: 'Action: navigate | screenshot | extract' },
-                url: { type: 'string', description: 'Target URL' },
-                selector: { type: 'string', description: 'CSS selector for extraction' },
-            },
-            required: ['action', 'url'],
-        },
-        available: true,
-    },
-];
-// ─── ToolGateway ─────────────────────────────────────────────
-class ToolGateway {
-    config;
-    availableTools = new Map();
-    connected = false;
-    constructor(config) {
-        this.config = {
-            timeout: 30_000,
-            ...config,
-        };
-    }
-    /** Discover available tools from the gateway endpoint. */
-    async connect() {
-        if (!this.config.enabled)
-            return;
-        try {
-            const res = await fetch(`${this.config.endpoint}/tools`, {
-                headers: { Authorization: `Bearer ${this.config.apiKey}` },
-                signal: AbortSignal.timeout(this.config.timeout),
-            });
-            if (!res.ok) {
-                throw new Error(`Gateway returned ${res.status}`);
-            }
-            const data = (await res.json());
-            const enabledSet = this.config.enabledTools
-                ? new Set(this.config.enabledTools)
-                : null;
-            for (const tool of data.tools) {
-                if (!enabledSet || enabledSet.has(tool.name)) {
-                    this.availableTools.set(tool.name, tool);
-                }
-            }
-            this.connected = true;
-        }
-        catch {
-            // Auto-detect failed — fall back to default definitions
-            this.loadDefaults();
-            this.connected = false;
-        }
-    }
-    /** Load default tool definitions (used as fallback). */
-    loadDefaults() {
-        const enabledSet = this.config.enabledTools
-            ? new Set(this.config.enabledTools)
-            : null;
-        for (const def of DEFAULT_TOOL_DEFS) {
-            if (!enabledSet || enabledSet.has(def.name)) {
-                this.availableTools.set(def.name, def);
-            }
-        }
-    }
-    /** Invoke a tool through the gateway. */
-    async invokeTool(name, input) {
-        try {
-            const res = await fetch(`${this.config.endpoint}/tools/${name}/invoke`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.config.apiKey}`,
-                },
-                body: JSON.stringify({ input }),
-                signal: AbortSignal.timeout(this.config.timeout),
-            });
-            if (!res.ok) {
-                return { content: `Gateway error: HTTP ${res.status}`, isError: true };
-            }
-            const data = (await res.json());
-            if (data.error) {
-                return { content: data.error, isError: true, metadata: data.metadata };
-            }
-            return { content: data.content, metadata: data.metadata };
-        }
-        catch (err) {
-            return {
-                content: `Gateway invocation failed: ${err instanceof Error ? err.message : String(err)}`,
-                isError: true,
-            };
-        }
-    }
-    /** Get all gateway tools as MCPTool instances for registry integration. */
-    getTools() {
-        return Array.from(this.availableTools.values()).map((meta) => new GatewayTool(this, meta));
-    }
-    /** Get tool definitions (without execute). */
-    listTools() {
-        return Array.from(this.availableTools.values()).map(({ name, description, inputSchema }) => ({
-            name: `gateway:${name}`,
-            description: `[Gateway] ${description}`,
-            inputSchema,
-        }));
-    }
-    get isConnected() {
-        return this.connected;
-    }
-    get toolCount() {
-        return this.availableTools.size;
-    }
-}
-exports.ToolGateway = ToolGateway;
-//# sourceMappingURL=gateway.js.map

package/src/dtv/data.ts

@@ -1,29 +0,0 @@
-export interface DataSource {
-  readonly name: string;
-  readonly type: string;
-  read(key: string): Promise<unknown>;
-}
-
-/**
- * MRGConfig reader — read-only data layer for agents.
- * Agents can read business data but cannot modify source systems.
- */
-export class MRGConfigReader implements DataSource {
-  readonly name = 'mrg-config';
-  readonly type = 'config';
-  private data: Map<string, unknown>;
-
-  constructor(initial?: Record<string, unknown>) {
-    this.data = new Map(Object.entries(initial ?? {}));
-  }
-
-  async read(key: string): Promise<unknown> {
-    return this.data.get(key);
-  }
-
-  load(data: Record<string, unknown>): void {
-    for (const [k, v] of Object.entries(data)) {
-      this.data.set(k, v);
-    }
-  }
-}

package/src/dtv/trust.ts

@@ -1,43 +0,0 @@
-import type { TrustLevelType } from '../schema/oad';
-
-/**
- * Trust levels: sandbox → verified → certified → listed
- *
- * - sandbox:   No network, no file system, limited capabilities
- * - verified:  Identity verified, basic capabilities
- * - certified: Passed security audit, full capabilities
- * - listed:    Published in OPC marketplace
- */
-export class TrustManager {
-  private level: TrustLevelType;
-
-  constructor(level: TrustLevelType = 'sandbox') {
-    this.level = level;
-  }
-
-  getLevel(): TrustLevelType {
-    return this.level;
-  }
-
-  canAccessNetwork(): boolean {
-    return this.level !== 'sandbox';
-  }
-
-  canAccessFileSystem(): boolean {
-    return this.level === 'certified' || this.level === 'listed';
-  }
-
-  canPublish(): boolean {
-    return this.level === 'listed';
-  }
-
-  upgrade(to: TrustLevelType): void {
-    const order: TrustLevelType[] = ['sandbox', 'verified', 'certified', 'listed'];
-    const currentIdx = order.indexOf(this.level);
-    const targetIdx = order.indexOf(to);
-    if (targetIdx <= currentIdx) {
-      throw new Error(`Cannot downgrade trust from ${this.level} to ${to}`);
-    }
-    this.level = to;
-  }
-}

package/src/dtv/value.ts

@@ -1,47 +0,0 @@
-/**
- * Value tracking — metrics and ROI for agent operations.
- */
-export interface ValueMetric {
-  name: string;
-  value: number;
-  unit: string;
-  timestamp: number;
-}
-
-export class ValueTracker {
-  private metrics: Map<string, ValueMetric[]> = new Map();
-  private trackedNames: Set<string>;
-
-  constructor(metricNames: string[] = []) {
-    this.trackedNames = new Set(metricNames);
-  }
-
-  record(name: string, value: number, unit: string = ''): void {
-    if (!this.metrics.has(name)) {
-      this.metrics.set(name, []);
-    }
-    this.metrics.get(name)!.push({ name, value, unit, timestamp: Date.now() });
-  }
-
-  getMetrics(name: string): ValueMetric[] {
-    return this.metrics.get(name) ?? [];
-  }
-
-  getAverage(name: string): number {
-    const m = this.getMetrics(name);
-    if (m.length === 0) return 0;
-    return m.reduce((sum, v) => sum + v.value, 0) / m.length;
-  }
-
-  getSummary(): Record<string, { count: number; average: number; last: number }> {
-    const result: Record<string, { count: number; average: number; last: number }> = {};
-    for (const [name, values] of this.metrics) {
-      result[name] = {
-        count: values.length,
-        average: this.getAverage(name),
-        last: values[values.length - 1]?.value ?? 0,
-      };
-    }
-    return result;
-  }
-}

package/src/marketplace/index.ts

@@ -1,223 +0,0 @@
-/**
- * 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 };
-}