opc-agent 2.0.0 → 2.0.1

package/src/protocols/mcp/server.ts

@@ -0,0 +1,262 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'http';
+import { createInterface } from 'readline';
+import type {
+  MCPServerConfig, MCPServerToolDefinition, MCPResourceDefinition,
+  MCPPromptDefinition, JsonRpcRequest, JsonRpcResponse,
+} from './types';
+import { MCP_ERRORS } from './types';
+
+export class MCPServer {
+  private config: MCPServerConfig;
+  private tools: Map<string, MCPServerToolDefinition> = new Map();
+  private resources: Map<string, MCPResourceDefinition> = new Map();
+  private prompts: Map<string, MCPPromptDefinition> = new Map();
+  private sseClients: Set<ServerResponse> = new Set();
+  private httpServer: ReturnType<typeof createServer> | null = null;
+
+  constructor(config: MCPServerConfig) {
+    this.config = config;
+    for (const t of config.tools ?? []) this.addTool(t);
+    for (const r of config.resources ?? []) this.addResource(r);
+    for (const p of config.prompts ?? []) this.addPrompt(p);
+  }
+
+  addTool(tool: MCPServerToolDefinition): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  removeTool(name: string): void {
+    this.tools.delete(name);
+  }
+
+  addResource(resource: MCPResourceDefinition): void {
+    this.resources.set(resource.uri, resource);
+  }
+
+  removeResource(uri: string): void {
+    this.resources.delete(uri);
+  }
+
+  addPrompt(prompt: MCPPromptDefinition): void {
+    this.prompts.set(prompt.name, prompt);
+  }
+
+  getToolCount(): number { return this.tools.size; }
+  getResourceCount(): number { return this.resources.size; }
+  getPromptCount(): number { return this.prompts.size; }
+  getConnectedClients(): number { return this.sseClients.size; }
+
+  /** Serve over stdio — one JSON-RPC message per line */
+  async serveStdio(): Promise<void> {
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on('line', async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed) as JsonRpcRequest;
+        const response = await this.handleMessage(msg);
+        if (response) {
+          process.stdout.write(JSON.stringify(response) + '\n');
+        }
+      } catch {
+        const err: JsonRpcResponse = {
+          jsonrpc: '2.0', id: null,
+          error: MCP_ERRORS.PARSE_ERROR,
+        };
+        process.stdout.write(JSON.stringify(err) + '\n');
+      }
+    });
+  }
+
+  /** Serve over HTTP + SSE */
+  async serveHTTP(port: number): Promise<void> {
+    this.httpServer = createServer((req, res) => this.handleHTTP(req, res));
+    return new Promise((resolve) => {
+      this.httpServer!.listen(port, () => resolve());
+    });
+  }
+
+  /** Mount on existing HTTP server at a path prefix */
+  mount(server: any, path = '/mcp'): void {
+    const orig = server.listeners('request')[0] as any;
+    server.removeAllListeners('request');
+    server.on('request', (req: IncomingMessage, res: ServerResponse) => {
+      if (req.url?.startsWith(path)) {
+        // Rewrite URL to strip prefix
+        req.url = req.url.slice(path.length) || '/';
+        this.handleHTTP(req, res);
+      } else if (orig) {
+        orig(req, res);
+      }
+    });
+  }
+
+  stop(): void {
+    this.httpServer?.close();
+    for (const client of this.sseClients) {
+      client.end();
+    }
+    this.sseClients.clear();
+  }
+
+  private handleHTTP(req: IncomingMessage, res: ServerResponse): void {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+
+    if (url.pathname === '/sse' && req.method === 'GET') {
+      // SSE endpoint
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      });
+      this.sseClients.add(res);
+      // Send endpoint info
+      res.write(`data: ${JSON.stringify({ type: 'endpoint', url: '/message' })}\n\n`);
+      req.on('close', () => this.sseClients.delete(res));
+      return;
+    }
+
+    if (url.pathname === '/message' && req.method === 'POST') {
+      let body = '';
+      req.on('data', (chunk) => { body += chunk; });
+      req.on('end', async () => {
+        try {
+          const msg = JSON.parse(body) as JsonRpcRequest;
+          const response = await this.handleMessage(msg);
+          if (response) {
+            // Send via SSE to all clients
+            for (const client of this.sseClients) {
+              client.write(`data: ${JSON.stringify(response)}\n\n`);
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(response));
+          } else {
+            res.writeHead(202);
+            res.end();
+          }
+        } catch {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: MCP_ERRORS.PARSE_ERROR }));
+        }
+      });
+      return;
+    }
+
+    res.writeHead(404);
+    res.end('Not Found');
+  }
+
+  async handleMessage(msg: JsonRpcRequest): Promise<JsonRpcResponse | null> {
+    // Notifications (no id) don't get responses
+    if (msg.id === undefined) return null;
+
+    const id = msg.id;
+    try {
+      switch (msg.method) {
+        case 'initialize':
+          return this.rpcResult(id, {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+              tools: this.tools.size > 0 ? { listChanged: true } : undefined,
+              resources: this.resources.size > 0 ? { subscribe: false, listChanged: true } : undefined,
+              prompts: this.prompts.size > 0 ? { listChanged: true } : undefined,
+            },
+            serverInfo: { name: this.config.name, version: this.config.version },
+          });
+
+        case 'tools/list':
+          return this.rpcResult(id, {
+            tools: Array.from(this.tools.values()).map(t => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema,
+            })),
+          });
+
+        case 'tools/call': {
+          const { name, arguments: args } = msg.params ?? {};
+          const tool = this.tools.get(name);
+          if (!tool) return this.rpcError(id, MCP_ERRORS.TOOL_NOT_FOUND);
+          // Validate required fields
+          const schema = tool.inputSchema;
+          if (schema?.required && Array.isArray(schema.required)) {
+            for (const field of schema.required) {
+              if (args?.[field] === undefined) {
+                return this.rpcError(id, { code: -32602, message: `Missing required parameter: ${field}` });
+              }
+            }
+          }
+          try {
+            const result = await tool.handler(args ?? {});
+            return this.rpcResult(id, {
+              content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
+            });
+          } catch (err: any) {
+            return this.rpcResult(id, {
+              content: [{ type: 'text', text: err.message || 'Tool execution failed' }],
+              isError: true,
+            });
+          }
+        }
+
+        case 'resources/list':
+          return this.rpcResult(id, {
+            resources: Array.from(this.resources.values()).map(r => ({
+              uri: r.uri, name: r.name, description: r.description, mimeType: r.mimeType,
+            })),
+          });
+
+        case 'resources/read': {
+          const { uri } = msg.params ?? {};
+          const resource = this.resources.get(uri);
+          if (!resource) return this.rpcError(id, MCP_ERRORS.RESOURCE_NOT_FOUND);
+          const content = await resource.handler();
+          return this.rpcResult(id, {
+            contents: [{ uri, mimeType: resource.mimeType || 'text/plain', text: content }],
+          });
+        }
+
+        case 'prompts/list':
+          return this.rpcResult(id, {
+            prompts: Array.from(this.prompts.values()).map(p => ({
+              name: p.name, description: p.description,
+              arguments: p.arguments,
+            })),
+          });
+
+        case 'prompts/get': {
+          const { name, arguments: promptArgs } = msg.params ?? {};
+          const prompt = this.prompts.get(name);
+          if (!prompt) return this.rpcError(id, MCP_ERRORS.PROMPT_NOT_FOUND);
+          const messages = prompt.handler
+            ? await prompt.handler(promptArgs ?? {})
+            : [{ role: 'user' as const, content: { type: 'text' as const, text: prompt.description || '' } }];
+          return this.rpcResult(id, { description: prompt.description, messages });
+        }
+
+        default:
+          return this.rpcError(id, MCP_ERRORS.METHOD_NOT_FOUND);
+      }
+    } catch (err: any) {
+      return this.rpcError(id, { ...MCP_ERRORS.INTERNAL_ERROR, data: err.message });
+    }
+  }
+
+  private rpcResult(id: number | string, result: any): JsonRpcResponse {
+    return { jsonrpc: '2.0', id, result };
+  }
+
+  private rpcError(id: number | string, error: { code: number; message: string; data?: any }): JsonRpcResponse {
+    return { jsonrpc: '2.0', id, error };
+  }
+}

package/src/protocols/mcp/types.ts

@@ -0,0 +1,69 @@
+/**
+ * MCP Server types — JSON-RPC 2.0 based Model Context Protocol
+ */
+
+export interface MCPServerConfig {
+  name: string;
+  version: string;
+  tools?: MCPServerToolDefinition[];
+  resources?: MCPResourceDefinition[];
+  prompts?: MCPPromptDefinition[];
+}
+
+export interface MCPServerToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: Record<string, any>;
+  handler: (args: any) => Promise<any>;
+}
+
+export interface MCPResourceDefinition {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+  handler: () => Promise<string>;
+}
+
+export interface MCPPromptDefinition {
+  name: string;
+  description?: string;
+  arguments?: MCPPromptArgument[];
+  handler?: (args: Record<string, string>) => Promise<MCPPromptMessage[]>;
+}
+
+export interface MCPPromptArgument {
+  name: string;
+  description?: string;
+  required?: boolean;
+}
+
+export interface MCPPromptMessage {
+  role: 'user' | 'assistant';
+  content: { type: 'text'; text: string };
+}
+
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id?: number | string;
+  method: string;
+  params?: any;
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number | string | null;
+  result?: any;
+  error?: { code: number; message: string; data?: any };
+}
+
+export const MCP_ERRORS = {
+  PARSE_ERROR: { code: -32700, message: 'Parse error' },
+  INVALID_REQUEST: { code: -32600, message: 'Invalid Request' },
+  METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },
+  INVALID_PARAMS: { code: -32602, message: 'Invalid params' },
+  INTERNAL_ERROR: { code: -32603, message: 'Internal error' },
+  TOOL_NOT_FOUND: { code: -32001, message: 'Tool not found' },
+  RESOURCE_NOT_FOUND: { code: -32002, message: 'Resource not found' },
+  PROMPT_NOT_FOUND: { code: -32003, message: 'Prompt not found' },
+} as const;

package/src/publish/index.ts

@@ -0,0 +1,376 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as yaml from 'js-yaml';
+import { execSync } from 'child_process';
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface PackageManifest {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  license: string;
+  agent: {
+    model: string;
+    provider: string;
+    channels: string[];
+    skills: string[];
+    tools: string[];
+  };
+  files: string[];
+  checksum: string;
+  createdAt: string;
+}
+
+export interface PublishOptions {
+  dryRun?: boolean;
+  registry?: string;
+  tag?: string;
+  access?: 'public' | 'private';
+}
+
+// ─── Ignore patterns ────────────────────────────────────────
+
+const DEFAULT_IGNORE = [
+  'node_modules',
+  '.git',
+  '.env',
+  '.opc',
+  '*.log',
+  'dist',
+  '.DS_Store',
+  'Thumbs.db',
+];
+
+function loadIgnorePatterns(dir: string): string[] {
+  const opcIgnore = path.join(dir, '.opcignore');
+  const gitIgnore = path.join(dir, '.gitignore');
+
+  let lines: string[] = [];
+  if (fs.existsSync(opcIgnore)) {
+    lines = fs.readFileSync(opcIgnore, 'utf-8').split('\n');
+  } else if (fs.existsSync(gitIgnore)) {
+    lines = fs.readFileSync(gitIgnore, 'utf-8').split('\n');
+  }
+
+  const patterns = lines
+    .map(l => l.trim())
+    .filter(l => l && !l.startsWith('#'));
+
+  // Merge with defaults (deduplicate)
+  const all = new Set([...DEFAULT_IGNORE, ...patterns]);
+  return Array.from(all);
+}
+
+function matchesPattern(filePath: string, pattern: string): boolean {
+  // Normalize separators
+  const normalized = filePath.replace(/\\/g, '/');
+  const p = pattern.replace(/\\/g, '/').replace(/\/$/, '');
+
+  // Exact directory/file match
+  if (normalized === p || normalized.startsWith(p + '/')) return true;
+
+  // Basename match (e.g. ".env" matches any ".env" at any depth)
+  const basename = path.basename(normalized);
+  if (basename === p) return true;
+
+  // Simple glob: *.ext
+  if (p.startsWith('*.')) {
+    const ext = p.slice(1); // e.g. ".log"
+    if (basename.endsWith(ext)) return true;
+  }
+
+  // Directory at any depth: "tests/" pattern
+  const segments = normalized.split('/');
+  if (segments.includes(p)) return true;
+
+  return false;
+}
+
+function isIgnored(filePath: string, patterns: string[]): boolean {
+  return patterns.some(p => matchesPattern(filePath, p));
+}
+
+// ─── File walker ────────────────────────────────────────────
+
+function walkDir(dir: string, base: string, patterns: string[]): string[] {
+  const results: string[] = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const rel = path.join(base, entry.name).replace(/\\/g, '/');
+    if (isIgnored(rel, patterns)) continue;
+
+    if (entry.isDirectory()) {
+      results.push(...walkDir(path.join(dir, entry.name), rel, patterns));
+    } else if (entry.isFile()) {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+
+// ─── AgentPackager ──────────────────────────────────────────
+
+export class AgentPackager {
+  async validate(dir: string): Promise<{ valid: boolean; errors: string[]; warnings: string[] }> {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Required files
+    if (!fs.existsSync(path.join(dir, 'agent.yaml'))) {
+      errors.push('Missing agent.yaml');
+    }
+    if (!fs.existsSync(path.join(dir, 'package.json'))) {
+      errors.push('Missing package.json');
+    }
+
+    // Recommended files
+    if (!fs.existsSync(path.join(dir, 'SOUL.md'))) {
+      warnings.push('Missing SOUL.md (recommended)');
+    }
+    if (!fs.existsSync(path.join(dir, 'README.md'))) {
+      warnings.push('Missing README.md');
+    }
+
+    // Validate agent.yaml content if it exists
+    if (fs.existsSync(path.join(dir, 'agent.yaml'))) {
+      try {
+        const raw = fs.readFileSync(path.join(dir, 'agent.yaml'), 'utf-8');
+        const config = yaml.load(raw) as any;
+
+        if (!config?.metadata?.name) {
+          errors.push('agent.yaml: missing metadata.name');
+        } else {
+          const name = config.metadata.name;
+          if (name !== name.toLowerCase()) {
+            errors.push('agent.yaml: metadata.name must be lowercase');
+          }
+          if (/\s/.test(name)) {
+            errors.push('agent.yaml: metadata.name must not contain spaces');
+          }
+        }
+
+        if (!config?.metadata?.version) {
+          errors.push('agent.yaml: missing metadata.version');
+        } else {
+          const ver = config.metadata.version;
+          if (!/^\d+\.\d+\.\d+/.test(ver)) {
+            errors.push(`agent.yaml: invalid version format "${ver}" (expected semver)`);
+          }
+        }
+      } catch (e) {
+        errors.push(`agent.yaml: invalid YAML — ${e instanceof Error ? e.message : e}`);
+      }
+    }
+
+    // Validate package.json
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      try {
+        JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+      } catch {
+        errors.push('package.json: invalid JSON');
+      }
+    }
+
+    return { valid: errors.length === 0, errors, warnings };
+  }
+
+  async listFiles(dir: string): Promise<string[]> {
+    const patterns = loadIgnorePatterns(dir);
+    return walkDir(dir, '', patterns);
+  }
+
+  async pack(dir: string): Promise<{ path: string; manifest: PackageManifest }> {
+    // 1. Validate
+    const validation = await this.validate(dir);
+    if (!validation.valid) {
+      throw new Error(`Validation failed:\n  ${validation.errors.join('\n  ')}`);
+    }
+
+    // 2. Read configs
+    const agentYaml = yaml.load(fs.readFileSync(path.join(dir, 'agent.yaml'), 'utf-8')) as any;
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+
+    const meta = agentYaml.metadata ?? {};
+    const spec = agentYaml.spec ?? {};
+
+    // 3. Collect files
+    const files = await this.listFiles(dir);
+
+    // 4. Create manifest
+    const manifest: PackageManifest = {
+      name: meta.name ?? pkgJson.name ?? 'unknown',
+      version: meta.version ?? pkgJson.version ?? '0.0.0',
+      description: meta.description ?? pkgJson.description ?? '',
+      author: meta.author ?? pkgJson.author ?? '',
+      license: meta.license ?? pkgJson.license ?? 'UNLICENSED',
+      agent: {
+        model: spec.model ?? '',
+        provider: spec.provider?.default ?? '',
+        channels: (spec.channels ?? []).map((c: any) => c.type ?? String(c)),
+        skills: (spec.skills ?? []).map((s: any) => s.name ?? String(s)),
+        tools: (spec.tools ?? []).map((t: any) => t.name ?? String(t)),
+      },
+      files,
+      checksum: '', // computed after tarball
+      createdAt: new Date().toISOString(),
+    };
+
+    // Write manifest into dir temporarily
+    const manifestPath = path.join(dir, 'manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    // 5. Create tarball
+    const tarName = `${manifest.name}-${manifest.version}.opc.tgz`;
+    const outputPath = path.resolve(dir, '..', tarName);
+
+    // Include manifest.json in file list
+    const allFiles = ['manifest.json', ...files];
+
+    try {
+      // Try using system tar
+      const fileListPath = path.join(dir, '.opc-filelist');
+      fs.writeFileSync(fileListPath, allFiles.join('\n'));
+
+      execSync(
+        `tar czf "${outputPath}" -C "${dir}" -T "${fileListPath}"`,
+        { stdio: 'pipe' },
+      );
+
+      // Cleanup temp files
+      try { fs.unlinkSync(fileListPath); } catch { /* ignore */ }
+    } catch {
+      // Fallback: use node zlib + simple tar via exec
+      // On Windows, try PowerShell Compress-Archive as .zip then rename
+      try {
+        const tempZip = outputPath.replace('.tgz', '.zip');
+        const absFiles = allFiles.map(f => `"${path.join(dir, f)}"`).join(',');
+        execSync(
+          `powershell -NoProfile -Command "Compress-Archive -Path ${absFiles} -DestinationPath '${tempZip}' -Force"`,
+          { stdio: 'pipe' },
+        );
+        // Rename .zip to .tgz (not ideal but functional)
+        if (fs.existsSync(tempZip)) {
+          fs.renameSync(tempZip, outputPath);
+        }
+      } catch (e2) {
+        // Last resort: create a simple tar-like archive manually
+        // Bundle all files as a JSON + base64 archive
+        const archive: Record<string, string> = {};
+        for (const f of allFiles) {
+          const content = fs.readFileSync(path.join(dir, f));
+          archive[f] = content.toString('base64');
+        }
+        const archiveJson = JSON.stringify(archive);
+        const { gzipSync } = require('zlib');
+        const compressed = gzipSync(Buffer.from(archiveJson));
+        fs.writeFileSync(outputPath, compressed);
+      }
+    }
+
+    // Cleanup manifest from source dir
+    try { fs.unlinkSync(manifestPath); } catch { /* ignore */ }
+
+    // 6. Calculate checksum
+    const fileBuffer = fs.readFileSync(outputPath);
+    manifest.checksum = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+
+    return { path: outputPath, manifest };
+  }
+}
+
+// ─── AgentPublisher ─────────────────────────────────────────
+
+export class AgentPublisher {
+  async publish(
+    packagePath: string,
+    manifest: PackageManifest,
+    options: PublishOptions = {},
+  ): Promise<{ success: boolean; url?: string }> {
+    const tag = options.tag ?? 'latest';
+    const access = options.access ?? 'public';
+    const registry = options.registry ?? 'https://registry.npmjs.org';
+
+    if (options.dryRun) {
+      console.log('\n📦 Dry run — would publish:\n');
+      console.log(`  Name:      ${manifest.name}`);
+      console.log(`  Version:   ${manifest.version}`);
+      console.log(`  Tag:       ${tag}`);
+      console.log(`  Access:    ${access}`);
+      console.log(`  Registry:  ${registry}`);
+      console.log(`  Files:     ${manifest.files.length}`);
+      console.log(`  Checksum:  ${manifest.checksum}`);
+      console.log(`  Package:   ${packagePath}`);
+      console.log();
+      return { success: true };
+    }
+
+    // For now: placeholder — future OPC registry integration
+    console.log(`\n📦 Publishing ${manifest.name}@${manifest.version} (tag: ${tag})...`);
+    console.log(`   Registry: ${registry}`);
+    console.log(`   Package:  ${packagePath}`);
+    console.log(`   Checksum: ${manifest.checksum}`);
+
+    // Future: actual npm publish or OPC registry API call
+    // execSync(`npm publish "${packagePath}" --tag ${tag} --access ${access}`, { stdio: 'inherit' });
+
+    console.log(`\n✅ Published ${manifest.name}@${manifest.version}`);
+    return {
+      success: true,
+      url: `${registry}/${manifest.name}`,
+    };
+  }
+}
+
+// ─── AgentInstaller ─────────────────────────────────────────
+
+export class AgentInstaller {
+  async install(source: string, targetDir: string): Promise<void> {
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    if (source.endsWith('.opc.tgz')) {
+      // Extract tarball
+      if (!fs.existsSync(source)) {
+        throw new Error(`Package not found: ${source}`);
+      }
+
+      try {
+        // Try system tar
+        execSync(`tar xzf "${source}" -C "${targetDir}"`, { stdio: 'pipe' });
+      } catch {
+        // Fallback: try reading as gzipped JSON archive
+        const { gunzipSync } = require('zlib');
+        const compressed = fs.readFileSync(source);
+        try {
+          const decompressed = gunzipSync(compressed);
+          const archive = JSON.parse(decompressed.toString());
+          for (const [filePath, base64Content] of Object.entries(archive)) {
+            const fullPath = path.join(targetDir, filePath);
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, Buffer.from(base64Content as string, 'base64'));
+          }
+        } catch {
+          throw new Error('Failed to extract package — unsupported archive format');
+        }
+      }
+
+      // Verify manifest
+      const manifestPath = path.join(targetDir, 'manifest.json');
+      if (fs.existsSync(manifestPath)) {
+        const manifest: PackageManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        console.log(`✅ Installed ${manifest.name}@${manifest.version}`);
+      } else {
+        console.log('✅ Extracted package (no manifest found)');
+      }
+    } else {
+      // npm install
+      console.log(`📦 Installing from npm: ${source}`);
+      execSync(`npm install "${source}"`, { cwd: targetDir, stdio: 'inherit' });
+    }
+  }
+}