agentic-factory-bridge 1.0.6 → 1.1.0

package/bridge.js

@@ -488,6 +488,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
 // ---------------------------------------------------------------------------

package/package.json

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