agentic-factory-bridge 1.0.6 → 1.2.0

package/bridge.js

@@ -57,6 +57,7 @@ const RATE_LIMITS = {
   execute: { windowMs: 60000, max: 10 },
   install: { windowMs: 3600000, max: 2 },
   register: { windowMs: 3600000, max: 3 },
+  update: { windowMs: 3600000, max: 3 },
 };
 
 // In-memory store limits
@@ -488,6 +489,351 @@ app.delete('/executions', requireBridgeAuth, (_req, res) => {
   res.json({ message: `Cleared ${count} executions` });
 });
 
+// ---------------------------------------------------------------------------
+// Agent Hub — OpenCode Agent Sync
+// ---------------------------------------------------------------------------
+
+const AGENTS_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || require('os').homedir(),
+  '.config',
+  'opencode',
+  'agents',
+);
+
+/**
+ * Validates an agent name to prevent path traversal and injection.
+ * Only allows alphanumeric chars, hyphens, and underscores.
+ */
+function sanitizeAgentName(name) {
+  if (!name || typeof name !== 'string') return null;
+  if (name.includes('..') || name.includes('/') || name.includes('\\')) return null;
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '');
+  if (!sanitized || sanitized.length === 0 || sanitized.length > 100) return null;
+  return sanitized;
+}
+
+/**
+ * Ensures the agents directory exists.
+ */
+function ensureAgentsDir() {
+  if (!fs.existsSync(AGENTS_DIR)) {
+    fs.mkdirSync(AGENTS_DIR, { recursive: true });
+  }
+  return AGENTS_DIR;
+}
+
+/**
+ * Generates an OpenCode agent .md file content from a marketplace manifest.
+ */
+function generateAgentMd(manifest) {
+  const frontmatter = {
+    description: manifest.displayName || manifest.name,
+    mode: 'subagent',
+  };
+
+  if (manifest.llmModel) {
+    frontmatter.model = manifest.llmModel;
+  }
+
+  frontmatter.tools = {
+    read: true,
+    edit: true,
+    write: true,
+    bash: true,
+    glob: true,
+    grep: true,
+    webfetch: true,
+  };
+
+  // Build YAML frontmatter manually (no dependency needed)
+  const yamlLines = ['---'];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === null || value === undefined) continue;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      yamlLines.push(`${key}:`);
+      for (const [k, v] of Object.entries(value)) {
+        yamlLines.push(`  ${k}: ${v}`);
+      }
+    } else if (typeof value === 'string') {
+      // Escape strings that contain special YAML chars
+      if (
+        value.includes(':') ||
+        value.includes('#') ||
+        value.includes("'") ||
+        value.includes('"')
+      ) {
+        yamlLines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+      } else {
+        yamlLines.push(`${key}: ${value}`);
+      }
+    } else {
+      yamlLines.push(`${key}: ${value}`);
+    }
+  }
+  yamlLines.push('---');
+  yamlLines.push('');
+
+  // Body = system prompt (agent description)
+  const body = manifest.description || `Agent: ${manifest.displayName || manifest.name}`;
+
+  // Add metadata as HTML comment (for sync tracking)
+  const meta = [
+    '',
+    `<!-- agentic-factory-sync`,
+    `  source: ${manifest.sourceUrl || 'unknown'}`,
+    `  version: ${manifest.version || '1.0.0'}`,
+    `  synced: ${new Date().toISOString()}`,
+    `  category: ${manifest.category || 'other'}`,
+    `  owner: ${manifest.owner || 'unknown'}`,
+    `  tags: ${(manifest.tags || []).join(', ')}`,
+    `-->`,
+  ];
+
+  return yamlLines.join('\n') + body + '\n' + meta.join('\n') + '\n';
+}
+
+/**
+ * Parses metadata from an existing agent .md file.
+ */
+function parseAgentMdMeta(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const meta = { version: 'unknown', source: 'unknown', syncedAt: 'unknown' };
+
+    const syncMatch = content.match(/<!-- agentic-factory-sync\s*([\s\S]*?)-->/);
+    if (syncMatch) {
+      const block = syncMatch[1];
+      const versionMatch = block.match(/version:\s*(.+)/);
+      const sourceMatch = block.match(/source:\s*(.+)/);
+      const syncedMatch = block.match(/synced:\s*(.+)/);
+      if (versionMatch) meta.version = versionMatch[1].trim();
+      if (sourceMatch) meta.source = sourceMatch[1].trim();
+      if (syncedMatch) meta.syncedAt = syncedMatch[1].trim();
+    }
+    return meta;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * GET /agents/installed — List all locally installed OpenCode agents.
+ */
+app.get('/agents/installed', (_req, res) => {
+  try {
+    ensureAgentsDir();
+    const files = fs.readdirSync(AGENTS_DIR).filter((f) => f.endsWith('.md'));
+    const agents = files.map((f) => {
+      const name = f.replace(/\.md$/, '');
+      const filePath = path.join(AGENTS_DIR, f);
+      const meta = parseAgentMdMeta(filePath) || {};
+      return {
+        name,
+        version: meta.version || 'unknown',
+        syncedAt: meta.syncedAt || 'unknown',
+        source: meta.source || 'unknown',
+      };
+    });
+    res.json({ agents, agentsDir: AGENTS_DIR });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to list agents', details: err.message });
+  }
+});
+
+/**
+ * GET /agents/:name/check — Check if a specific agent is installed locally.
+ */
+app.get('/agents/:name/check', (req, res) => {
+  const name = sanitizeAgentName(req.params.name);
+  if (!name) {
+    return res.status(400).json({ error: 'Invalid agent name' });
+  }
+  try {
+    ensureAgentsDir();
+    const filePath = path.join(AGENTS_DIR, `${name}.md`);
+    if (fs.existsSync(filePath)) {
+      const meta = parseAgentMdMeta(filePath) || {};
+      res.json({ installed: true, version: meta.version, syncedAt: meta.syncedAt });
+    } else {
+      res.json({ installed: false });
+    }
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to check agent', details: err.message });
+  }
+});
+
+/**
+ * POST /agents/install — Download manifest from marketplace API and install agent locally.
+ * Body: { name: string, marketplaceUrl?: string, agentId: string }
+ */
+app.post(
+  '/agents/install',
+  requireBridgeAuth,
+  rateLimit('install'),
+  express.json(),
+  async (req, res) => {
+    const { agentId } = req.body;
+    let { name } = req.body;
+
+    if (!agentId) {
+      return res.status(400).json({ error: 'agentId is required' });
+    }
+
+    try {
+      // Fetch manifest from marketplace API
+      const apiUrl =
+        req.body.marketplaceUrl ||
+        process.env.MARKETPLACE_API_URL ||
+        'https://atos-agentic-factory-qzwe.onrender.com/api';
+      const manifestUrl = `${apiUrl}/agents/${encodeURIComponent(agentId)}/opencode-manifest`;
+
+      const manifest = await new Promise((resolve, reject) => {
+        const urlObj = new URL(manifestUrl);
+        const client = urlObj.protocol === 'https:' ? https : http;
+        const request = client.get(manifestUrl, { timeout: 15000 }, (response) => {
+          if (response.statusCode !== 200) {
+            reject(new Error(`API returned ${response.statusCode}`));
+            return;
+          }
+          let data = '';
+          response.on('data', (chunk) => {
+            data += chunk;
+          });
+          response.on('end', () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch (e) {
+              reject(new Error('Invalid JSON response from API'));
+            }
+          });
+        });
+        request.on('error', reject);
+        request.on('timeout', () => {
+          request.destroy();
+          reject(new Error('Request timeout'));
+        });
+      });
+
+      // Use name from manifest if not provided
+      const agentName = sanitizeAgentName(name || manifest.name);
+      if (!agentName) {
+        return res.status(400).json({ error: 'Invalid agent name' });
+      }
+
+      // Generate .md file content
+      const mdContent = generateAgentMd(manifest);
+
+      // Write to agents directory
+      ensureAgentsDir();
+      const filePath = path.join(AGENTS_DIR, `${agentName}.md`);
+      fs.writeFileSync(filePath, mdContent, 'utf8');
+
+      console.log(`[Agent Hub] Installed agent: ${agentName} -> ${filePath}`);
+      res.json({
+        success: true,
+        message: `Agent "${agentName}" installed successfully`,
+        path: filePath,
+        name: agentName,
+        version: manifest.version || '1.0.0',
+      });
+    } catch (err) {
+      console.error(`[Agent Hub] Install failed:`, err.message);
+      res.status(500).json({ error: 'Failed to install agent', details: err.message });
+    }
+  },
+);
+
+/**
+ * DELETE /agents/:name — Remove a locally installed agent.
+ */
+app.delete('/agents/:name', requireBridgeAuth, (req, res) => {
+  const name = sanitizeAgentName(req.params.name);
+  if (!name) {
+    return res.status(400).json({ error: 'Invalid agent name' });
+  }
+  try {
+    const filePath = path.join(AGENTS_DIR, `${name}.md`);
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ error: `Agent "${name}" not found` });
+    }
+    fs.unlinkSync(filePath);
+    console.log(`[Agent Hub] Removed agent: ${name}`);
+    res.json({ success: true, message: `Agent "${name}" removed` });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to remove agent', details: err.message });
+  }
+});
+
+/**
+ * PUT /agents/:name/update — Re-download and update an existing agent.
+ */
+app.put('/agents/:name/update', requireBridgeAuth, async (req, res) => {
+  const name = sanitizeAgentName(req.params.name);
+  if (!name) {
+    return res.status(400).json({ error: 'Invalid agent name' });
+  }
+
+  const filePath = path.join(AGENTS_DIR, `${name}.md`);
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: `Agent "${name}" not found locally` });
+  }
+
+  // Get agentId from existing metadata or request body
+  const { agentId } = req.body || {};
+  if (!agentId) {
+    return res.status(400).json({ error: 'agentId is required for update' });
+  }
+
+  try {
+    const apiUrl =
+      req.body.marketplaceUrl ||
+      process.env.MARKETPLACE_API_URL ||
+      'https://atos-agentic-factory-qzwe.onrender.com/api';
+    const manifestUrl = `${apiUrl}/agents/${encodeURIComponent(agentId)}/opencode-manifest`;
+
+    const manifest = await new Promise((resolve, reject) => {
+      const urlObj = new URL(manifestUrl);
+      const client = urlObj.protocol === 'https:' ? https : http;
+      const request = client.get(manifestUrl, { timeout: 15000 }, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`API returned ${response.statusCode}`));
+          return;
+        }
+        let data = '';
+        response.on('data', (chunk) => {
+          data += chunk;
+        });
+        response.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error('Invalid JSON response from API'));
+          }
+        });
+      });
+      request.on('error', reject);
+      request.on('timeout', () => {
+        request.destroy();
+        reject(new Error('Request timeout'));
+      });
+    });
+
+    const mdContent = generateAgentMd(manifest);
+    fs.writeFileSync(filePath, mdContent, 'utf8');
+
+    console.log(`[Agent Hub] Updated agent: ${name}`);
+    res.json({
+      success: true,
+      message: `Agent "${name}" updated successfully`,
+      path: filePath,
+      version: manifest.version || '1.0.0',
+    });
+  } catch (err) {
+    console.error(`[Agent Hub] Update failed:`, err.message);
+    res.status(500).json({ error: 'Failed to update agent', details: err.message });
+  }
+});
+
 // ---------------------------------------------------------------------------
 // Smart Detection
 // ---------------------------------------------------------------------------
@@ -681,6 +1027,136 @@ app.post(
   },
 );
 
+// ---------------------------------------------------------------------------
+// Auto-Update
+// ---------------------------------------------------------------------------
+
+/**
+ * Check the latest version of the bridge on npm registry.
+ * Returns { current, latest, updateAvailable }.
+ */
+function checkNpmVersion() {
+  return new Promise((resolve) => {
+    const proc = spawn('npm', ['view', 'agentic-factory-bridge', 'version'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 15000,
+      shell: true,
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    proc.on('close', (code) => {
+      if (code === 0 && stdout.trim()) {
+        const latest = stdout.trim();
+        const updateAvailable = latest !== BRIDGE_VERSION;
+        resolve({ current: BRIDGE_VERSION, latest, updateAvailable });
+      } else {
+        resolve({
+          current: BRIDGE_VERSION,
+          latest: null,
+          updateAvailable: false,
+          error: stderr.trim() || 'Failed to query npm registry',
+        });
+      }
+    });
+    proc.on('error', (err) => {
+      resolve({
+        current: BRIDGE_VERSION,
+        latest: null,
+        updateAvailable: false,
+        error: err.message,
+      });
+    });
+  });
+}
+
+app.get('/check-update', async (_req, res) => {
+  try {
+    const result = await checkNpmVersion();
+    console.log(
+      `[bridge] Update check: current=${result.current}, latest=${result.latest}, updateAvailable=${result.updateAvailable}`,
+    );
+    res.json(result);
+  } catch (err) {
+    res.json({
+      current: BRIDGE_VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: err.message,
+    });
+  }
+});
+
+app.post(
+  '/self-update',
+  requireBridgeAuth,
+  rateLimit('update', RATE_LIMITS.update),
+  async (_req, res) => {
+    console.log('[bridge] Self-update: installing latest version via npm...');
+    try {
+      const installResult = await new Promise((resolve, reject) => {
+        const proc = spawn('npm', ['install', '-g', 'agentic-factory-bridge@latest'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          timeout: 120000,
+          shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+          stdout += data.toString();
+          console.log(`[bridge] npm update stdout: ${data.toString().trim()}`);
+        });
+        proc.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+          if (code === 0) resolve({ success: true, stdout, stderr });
+          else
+            reject(
+              new Error(
+                `npm install -g agentic-factory-bridge@latest failed with code ${code}: ${stderr || stdout}`,
+              ),
+            );
+        });
+        proc.on('error', (err) => {
+          reject(new Error(`Failed to spawn npm: ${err.message}`));
+        });
+      });
+
+      // Check new version
+      const versionCheck = await checkNpmVersion();
+
+      res.json({
+        success: true,
+        message: 'Bridge updated successfully. Restart the bridge to apply.',
+        previousVersion: BRIDGE_VERSION,
+        newVersion: versionCheck.latest || 'unknown',
+        restartRequired: true,
+      });
+
+      // Auto-restart after 2 seconds to let the response be sent
+      console.log('[bridge] Update complete. Restarting in 2 seconds...');
+      setTimeout(() => {
+        process.exit(0); // Exit — systemd/pm2/npm script will restart, or user restarts manually
+      }, 2000);
+    } catch (err) {
+      console.error(`[bridge] Self-update error: ${err.message}`);
+      res.status(500).json({
+        success: false,
+        message: `Update failed: ${err.message}`,
+        previousVersion: BRIDGE_VERSION,
+        newVersion: null,
+        restartRequired: false,
+      });
+    }
+  },
+);
+
 // ---------------------------------------------------------------------------
 // Start server
 // ---------------------------------------------------------------------------
@@ -711,4 +1187,17 @@ app.listen(PORT, '127.0.0.1', () => {
     console.log(`  Bridge secret: ${BRIDGE_SECRET.substring(0, 16)}...`);
     console.log('');
   }
+
+  // Startup update check (non-blocking)
+  checkNpmVersion().then((result) => {
+    if (result.updateAvailable) {
+      console.log('  +----------------------------------------------+');
+      console.log(`  |   [!] Update available: v${result.latest.padEnd(21)}|`);
+      console.log(`  |       Current: v${BRIDGE_VERSION.padEnd(29)}|`);
+      console.log('  |       Run: npm update -g agentic-factory-bridge |');
+      console.log('  |       Or update from the marketplace UI      |');
+      console.log('  +----------------------------------------------+');
+      console.log('');
+    }
+  });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-factory-bridge",
-  "version": "1.0.6",
+  "version": "1.2.0",
   "description": "Local bridge for Atos Agentic Factory — connects the marketplace to OpenCode CLI on your machine",
   "main": "bridge.js",
   "bin": {