agentgate 0.3.2 → 0.5.0

package/src/routes/queue.js

@@ -1,5 +1,8 @@
 import { Router } from 'express';
-import { createQueueEntry, getQueueEntry, getAccountCredentials, listQueueEntriesBySubmitter } from '../lib/db.js';
+import { createQueueEntry, getQueueEntry, getAccountCredentials, listQueueEntriesBySubmitter, updateQueueStatus, getSharedQueueVisibility, listAllQueueEntries, getAgentWithdrawEnabled, checkServiceAccess, checkBypassAuth, addQueueWarning, getQueueWarnings } from '../lib/db.js';
+import { notifyAgentQueueWarning } from '../lib/agentNotifier.js';
+import { emitCountUpdate, emitEvent } from '../lib/socketManager.js';
+import { executeQueueEntry } from '../lib/queueExecutor.js';
 
 const router = Router();
 
@@ -11,7 +14,7 @@ const VALID_METHODS = ['POST', 'PUT', 'PATCH', 'DELETE'];
 
 // Submit a batch of write requests for approval
 // POST /api/queue/:service/:accountName/submit
-router.post('/:service/:accountName/submit', (req, res) => {
+router.post('/:service/:accountName/submit', async (req, res) => {
   try {
     const { service, accountName } = req.params;
     const { requests, comment } = req.body;
@@ -33,6 +36,19 @@ router.post('/:service/:accountName/submit', (req, res) => {
       });
     }
 
+    // Check service access
+    const agentName = req.apiKeyInfo?.name;
+    if (agentName) {
+      const access = checkServiceAccess(service, accountName, agentName);
+      if (!access.allowed) {
+        return res.status(403).json({
+          error: `Agent '${agentName}' does not have access to service '${service}/${accountName}'`,
+          reason: access.reason
+        });
+      }
+    }
+
+
     // Validate requests array
     if (!Array.isArray(requests) || requests.length === 0) {
       return res.status(400).json({
@@ -66,9 +82,45 @@ router.post('/:service/:accountName/submit', (req, res) => {
     // Get the API key name for audit trail
     const submittedBy = req.apiKeyInfo?.name || 'unknown';
 
+    // Check if agent has bypass_auth enabled for this service
+    const hasBypass = agentName && checkBypassAuth(service, accountName, agentName);
+
     // Create the queue entry
     const entry = createQueueEntry(service, accountName, requests, comment, submittedBy);
 
+    // If bypass enabled, execute immediately
+    if (hasBypass) {
+      try {
+        updateQueueStatus(entry.id, 'approved');
+        await executeQueueEntry({ ...entry, status: 'approved' });
+        const updatedEntry = getQueueEntry(entry.id);
+        
+        emitCountUpdate();
+        
+        return res.status(200).json({
+          id: entry.id,
+          status: updatedEntry.status,
+          message: 'Request executed immediately (bypass_auth enabled)',
+          bypassed: true,
+          results: updatedEntry.results
+        });
+      } catch (err) {
+        updateQueueStatus(entry.id, 'failed', { results: [{ error: err.message }] });
+        emitCountUpdate();
+        
+        return res.status(500).json({
+          id: entry.id,
+          status: 'failed',
+          message: 'Bypass execution failed',
+          bypassed: true,
+          error: err.message
+        });
+      }
+    }
+
+    // Emit real-time update
+    emitCountUpdate();
+
     res.status(201).json({
       id: entry.id,
       status: entry.status,
@@ -88,10 +140,14 @@ router.post('/:service/:accountName/submit', (req, res) => {
 router.get('/list', (req, res) => {
   try {
     const submittedBy = req.apiKeyInfo?.name || 'unknown';
-    const entries = listQueueEntriesBySubmitter(submittedBy);
+    const sharedVisibility = getSharedQueueVisibility();
+    const entries = sharedVisibility 
+      ? listAllQueueEntries() 
+      : listQueueEntriesBySubmitter(submittedBy);
 
     res.json({
       count: entries.length,
+      shared_visibility: sharedVisibility,
       entries: entries
     });
   } catch (error) {
@@ -115,10 +171,14 @@ router.get('/:service/:accountName/list', (req, res) => {
       });
     }
 
-    const entries = listQueueEntriesBySubmitter(submittedBy, service, accountName);
+    const sharedVisibility = getSharedQueueVisibility();
+    const entries = sharedVisibility 
+      ? listAllQueueEntries(service, accountName) 
+      : listQueueEntriesBySubmitter(submittedBy, service, accountName);
 
     res.json({
       count: entries.length,
+      shared_visibility: sharedVisibility,
       entries: entries
     });
   } catch (error) {
@@ -183,4 +243,178 @@ router.get('/:service/:accountName/status/:id', (req, res) => {
   }
 });
 
+
+// Withdraw a pending queue item (agent can only withdraw their own submissions)
+// DELETE /api/queue/:service/:accountName/status/:id
+router.delete('/:service/:accountName/status/:id', (req, res) => {
+  try {
+    // Check if withdraw is enabled
+    if (!getAgentWithdrawEnabled()) {
+      return res.status(403).json({
+        error: 'Disabled',
+        message: 'Agent withdraw is not enabled. Ask admin to enable agent_withdraw_enabled setting.'
+      });
+    }
+
+    const { id } = req.params;
+    const agentName = req.apiKeyInfo?.name || 'unknown'; // Set by auth middleware
+
+    const entry = getQueueEntry(id);
+
+    if (!entry) {
+      return res.status(404).json({
+        error: 'Not found',
+        message: 'Queue entry not found'
+      });
+    }
+
+    // Verify the requesting agent is the submitter
+    if (entry.submitted_by !== agentName) {
+      return res.status(403).json({
+        error: 'Forbidden',
+        message: 'You can only withdraw your own submissions'
+      });
+    }
+
+    // Only allow withdrawal of pending items
+    if (entry.status !== 'pending') {
+      return res.status(400).json({
+        error: 'Cannot withdraw',
+        message: `Cannot withdraw entry with status "${entry.status}". Only pending items can be withdrawn.`
+      });
+    }
+
+    // Get optional reason from request body
+    const { reason } = req.body || {};
+
+    // Update status to withdrawn (with optional reason)
+    updateQueueStatus(id, 'withdrawn', { 
+      reviewed_at: new Date().toISOString().replace('T', ' ').replace('Z', ''),
+      rejection_reason: reason || null
+    });
+
+    // Emit real-time update
+    emitCountUpdate();
+
+    res.json({
+      success: true,
+      message: 'Queue entry withdrawn',
+      id: id,
+      reason: reason || null
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to withdraw',
+      message: error.message
+    });
+  }
+});
+
+// Add a warning to a queue item (peer review)
+// POST /api/queue/:service/:accountName/:id/warn
+router.post('/:service/:accountName/:id/warn', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { message } = req.body;
+    const agentName = req.apiKeyInfo?.name;
+
+    if (!agentName) {
+      return res.status(401).json({
+        error: 'Unauthorized',
+        message: 'Agent authentication required'
+      });
+    }
+
+    if (!message || typeof message !== 'string' || message.trim().length === 0) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'Warning message is required'
+      });
+    }
+
+    const entry = getQueueEntry(id);
+
+    if (!entry) {
+      return res.status(404).json({
+        error: 'Not found',
+        message: 'Queue entry not found'
+      });
+    }
+
+    // Only allow warnings on pending items
+    if (entry.status !== 'pending') {
+      return res.status(400).json({
+        error: 'Cannot warn',
+        message: `Cannot add warning to entry with status "${entry.status}". Only pending items can be warned.`
+      });
+    }
+
+    // Cannot warn your own items (should withdraw instead)
+    if (entry.submitted_by === agentName) {
+      return res.status(403).json({
+        error: 'Forbidden',
+        message: 'Cannot warn your own submission. Use withdraw instead.'
+      });
+    }
+
+    // Add the warning
+    const warningId = addQueueWarning(id, agentName, message.trim());
+
+    // Notify the submitting agent
+    if (entry.submitted_by) {
+      notifyAgentQueueWarning(entry, agentName, message.trim()).catch(err => {
+        console.error('Failed to notify agent of warning:', err.message);
+      });
+    }
+
+    // Emit socket event for real-time UI update
+    const warnings = getQueueWarnings(id);
+    emitEvent('queueItemUpdate', {
+      id,
+      type: 'warning_added',
+      warningCount: warnings.length,
+      warnings
+    });
+
+    res.json({
+      success: true,
+      message: 'Warning added',
+      warning_id: warningId,
+      queue_id: id
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to add warning',
+      message: error.message
+    });
+  }
+});
+
+// Get warnings for a queue item
+// GET /api/queue/:service/:accountName/:id/warnings
+router.get('/:service/:accountName/:id/warnings', (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    const entry = getQueueEntry(id);
+    if (!entry) {
+      return res.status(404).json({
+        error: 'Not found',
+        message: 'Queue entry not found'
+      });
+    }
+
+    const warnings = getQueueWarnings(id);
+    res.json({ warnings });
+
+  } catch (error) {
+    res.status(500).json({
+      error: 'Failed to get warnings',
+      message: error.message
+    });
+  }
+});
+
 export default router;

package/src/routes/services.js

@@ -0,0 +1,87 @@
+import { Router } from 'express';
+import {
+  listServicesWithAccess,
+  checkServiceAccess,
+  checkBypassAuth
+} from '../lib/db.js';
+
+const router = Router();
+
+// GET /api/services - List services with access info (filtered by agent access)
+// Includes bypass_auth status for the calling agent
+router.get('/', (req, res) => {
+  const agentName = req.apiKeyInfo?.name;
+  const allServices = listServicesWithAccess();
+  
+  // Filter to only show services the agent has access to
+  // And include bypass_auth status for this agent
+  const accessibleServices = allServices
+    .filter(svc => {
+      const access = checkServiceAccess(svc.service, svc.account_name, agentName);
+      return access.allowed;
+    })
+    .map(svc => ({
+      ...svc,
+      bypass_auth: agentName ? checkBypassAuth(svc.service, svc.account_name, agentName) : false
+    }));
+  
+  res.json({ services: accessibleServices });
+});
+
+// GET /api/services/:service/:account/access - Get YOUR access info for a service/account
+// SECURITY: Only returns the calling agent's own access info, NOT other agents
+router.get('/:service/:account/access', (req, res) => {
+  const { service, account } = req.params;
+  const agentName = req.apiKeyInfo?.name;
+  
+  // Check if agent has access to this service
+  const accessCheck = checkServiceAccess(service, account, agentName);
+  if (!accessCheck.allowed) {
+    return res.status(403).json({
+      error: `You do not have access to ${service}/${account}`,
+      reason: accessCheck.reason
+    });
+  }
+  
+  // SECURITY FIX: Only return the calling agent's own access info
+  // Do NOT return the full agent list (that would leak other agents' info)
+  const agentBypass = agentName ? checkBypassAuth(service, account, agentName) : false;
+  
+  res.json({
+    service,
+    account_name: account,
+    your_access: {
+      allowed: true,
+      bypass_auth: agentBypass
+    }
+  });
+});
+
+// NOTE: Configuration endpoints (PUT access mode, POST agents, PUT bypass) 
+// have been REMOVED from the API for security.
+// All access configuration must be done through the Admin UI at /ui/access
+// which requires admin authentication.
+
+// GET /api/services/:service/:account/access/agents/:agentName/bypass - Check bypass_auth (read-only)
+// Agents can check their own bypass status
+router.get('/:service/:account/access/agents/:agentName/bypass', (req, res) => {
+  const { service, account, agentName } = req.params;
+  const callingAgent = req.apiKeyInfo?.name;
+  
+  // Agents can only check their own bypass status
+  if (callingAgent && callingAgent.toLowerCase() !== agentName.toLowerCase()) {
+    return res.status(403).json({ 
+      error: 'You can only check your own bypass status'
+    });
+  }
+  
+  const hasBypass = checkBypassAuth(service, account, agentName);
+  res.json({ 
+    service,
+    account,
+    agent: agentName,
+    bypass_auth: hasBypass
+  });
+});
+
+export default router;

package/src/routes/ui/access.js

@@ -0,0 +1,290 @@
+// Service Access Control routes
+import { Router } from 'express';
+import {
+  listServicesWithAccess,
+  listApiKeys,
+  getServiceAccess,
+  setServiceAccessMode,
+  setServiceAgentAccess,
+  setBypassAuth,
+  checkBypassAuth
+} from '../../lib/db.js';
+import { escapeHtml, simpleNavHeader, socketScript, localizeScript, renderAvatar } from './shared.js';
+
+const router = Router();
+
+// Access Control page
+router.get('/', (req, res) => {
+  const services = listServicesWithAccess();
+  const agents = listApiKeys();
+  res.send(renderAccessPage(services, agents));
+});
+
+// Update access mode for a service
+router.post('/:service/:account/mode', (req, res) => {
+  const { service, account } = req.params;
+  const { mode } = req.body;
+  const wantsJson = req.headers.accept?.includes('application/json');
+  
+  try {
+    setServiceAccessMode(service, account, mode);
+    if (wantsJson) {
+      return res.json({ success: true, mode });
+    }
+    res.redirect('/ui/access');
+  } catch (err) {
+    if (wantsJson) {
+      return res.status(400).json({ error: err.message });
+    }
+    res.status(400).send(err.message);
+  }
+});
+
+// Toggle agent access for a service
+router.post('/:service/:account/agent/:agentName', (req, res) => {
+  const { service, account, agentName } = req.params;
+  const { allowed, bypass_auth } = req.body;
+  const wantsJson = req.headers.accept?.includes('application/json');
+  
+  // Update access
+  setServiceAgentAccess(service, account, agentName, allowed !== 'false', bypass_auth === 'true');
+  
+  if (wantsJson) {
+    return res.json({ success: true });
+  }
+  res.redirect('/ui/access');
+});
+
+// Toggle bypass_auth for an agent
+router.post('/:service/:account/agent/:agentName/bypass', (req, res) => {
+  const { service, account, agentName } = req.params;
+  const { enabled } = req.body;
+  const wantsJson = req.headers.accept?.includes('application/json');
+  
+  setBypassAuth(service, account, agentName, enabled === 'true' || enabled === true);
+  
+  if (wantsJson) {
+    const hasBypass = checkBypassAuth(service, account, agentName);
+    return res.json({ success: true, bypass_auth: hasBypass });
+  }
+  res.redirect('/ui/access');
+});
+
+function renderAccessPage(services, agents) {
+  const renderServiceCard = (svc) => {
+    const access = getServiceAccess(svc.service, svc.account_name);
+    const agentRows = agents.map(agent => {
+      const agentAccess = access.agents.find(a => a.name.toLowerCase() === agent.name.toLowerCase());
+      const isAllowed = agentAccess ? agentAccess.allowed : (access.access_mode === 'all');
+      const hasBypass = agentAccess?.bypass_auth || false;
+      
+      return `
+        <tr class="agent-row" data-service="${escapeHtml(svc.service)}" data-account="${escapeHtml(svc.account_name)}" data-agent="${escapeHtml(agent.name)}">
+          <td>
+            <div class="agent-with-avatar">
+              ${renderAvatar(agent.name, { size: 28 })}
+              <span>${escapeHtml(agent.name)}</span>
+            </div>
+          </td>
+          <td>
+            <label class="toggle">
+              <input type="checkbox" class="access-toggle" ${isAllowed ? 'checked' : ''}>
+              <span class="toggle-slider"></span>
+            </label>
+          </td>
+          <td>
+            <label class="toggle ${!isAllowed ? 'disabled' : ''}">
+              <input type="checkbox" class="bypass-toggle" ${hasBypass ? 'checked' : ''} ${!isAllowed ? 'disabled' : ''}>
+              <span class="toggle-slider bypass"></span>
+            </label>
+            ${hasBypass ? '<span class="bypass-badge">⚡ Bypass</span>' : ''}
+          </td>
+        </tr>
+      `;
+    }).join('');
+    
+    return `
+      <div class="card service-card" data-service="${escapeHtml(svc.service)}" data-account="${escapeHtml(svc.account_name)}">
+        <div class="service-header">
+          <h3>${escapeHtml(svc.service)} / ${escapeHtml(svc.account_name)}</h3>
+          <select class="mode-select" data-service="${escapeHtml(svc.service)}" data-account="${escapeHtml(svc.account_name)}">
+            <option value="all" ${access.access_mode === 'all' ? 'selected' : ''}>All agents</option>
+            <option value="allowlist" ${access.access_mode === 'allowlist' ? 'selected' : ''}>Allowlist only</option>
+            <option value="none" ${access.access_mode === 'none' ? 'selected' : ''}>No agents</option>
+          </select>
+        </div>
+        
+        <table class="access-table">
+          <thead>
+            <tr>
+              <th>Agent</th>
+              <th>Access</th>
+              <th>Bypass Queue</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${agentRows}
+          </tbody>
+        </table>
+      </div>
+    `;
+  };
+  
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>agentgate - Access Control</title>
+  <link rel="icon" type="image/svg+xml" href="/public/favicon.svg">
+  <link rel="stylesheet" href="/public/style.css">
+  <script src="/socket.io/socket.io.js"></script>
+  <style>
+    .service-card { margin-bottom: 24px; }
+    .service-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 16px; }
+    .service-header h3 { margin: 0; }
+    .mode-select { padding: 8px 12px; border-radius: 6px; background: #1f2937; border: 1px solid #374151; color: #f3f4f6; cursor: pointer; }
+    .mode-select:focus { border-color: #6366f1; outline: none; }
+    
+    .access-table { width: 100%; border-collapse: collapse; }
+    .access-table th, .access-table td { padding: 12px; text-align: left; border-bottom: 1px solid #374151; }
+    .access-table th { font-weight: 600; color: #9ca3af; font-size: 14px; }
+    
+    .agent-with-avatar { display: flex; align-items: center; gap: 10px; }
+    
+    /* Toggle switch */
+    .toggle { position: relative; display: inline-block; width: 44px; height: 24px; }
+    .toggle.disabled { opacity: 0.5; pointer-events: none; }
+    .toggle input { opacity: 0; width: 0; height: 0; }
+    .toggle-slider { position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0; background-color: #374151; transition: 0.3s; border-radius: 24px; }
+    .toggle-slider:before { position: absolute; content: ""; height: 18px; width: 18px; left: 3px; bottom: 3px; background-color: white; transition: 0.3s; border-radius: 50%; }
+    .toggle input:checked + .toggle-slider { background-color: #10b981; }
+    .toggle input:checked + .toggle-slider.bypass { background-color: #f59e0b; }
+    .toggle input:checked + .toggle-slider:before { transform: translateX(20px); }
+    
+    .bypass-badge { font-size: 11px; background: rgba(245, 158, 11, 0.2); color: #fbbf24; padding: 2px 8px; border-radius: 10px; margin-left: 8px; }
+    
+    .no-services { text-align: center; padding: 40px; color: #9ca3af; }
+    
+    .info-box { background: rgba(59, 130, 246, 0.1); border: 1px solid rgba(59, 130, 246, 0.3); border-radius: 8px; padding: 16px; margin-bottom: 24px; }
+    .info-box h4 { margin: 0 0 8px 0; color: #60a5fa; }
+    .info-box p { margin: 0; color: #9ca3af; font-size: 14px; }
+    .info-box ul { margin: 8px 0 0 0; padding-left: 20px; color: #9ca3af; font-size: 14px; }
+  </style>
+</head>
+<body>
+  <div>
+    ${simpleNavHeader()}
+  </div>
+  
+  <div class="info-box">
+    <h4>🔐 Service Access Control</h4>
+    <p>Manage which agents can access which services, and enable queue bypass for trusted agents.</p>
+    <ul>
+      <li><strong>Access</strong> - Whether the agent can use this service</li>
+      <li><strong>Bypass Queue</strong> - Skip approval queue and execute immediately (⚡ use with caution!)</li>
+    </ul>
+  </div>
+  
+  ${services.length === 0 ? `
+    <div class="card no-services">
+      <p>No services configured yet.</p>
+      <p>Connect a service (GitHub, Bluesky, etc.) from the <a href="/ui">home page</a> to manage access.</p>
+    </div>
+  ` : services.map(renderServiceCard).join('')}
+  
+  <script>
+    // Mode select change
+    document.querySelectorAll('.mode-select').forEach(select => {
+      select.addEventListener('change', async function() {
+        const service = this.dataset.service;
+        const account = this.dataset.account;
+        const mode = this.value;
+        const originalValue = this.dataset.originalMode || this.value;
+        
+        try {
+          const res = await fetch('/ui/access/' + encodeURIComponent(service) + '/' + encodeURIComponent(account) + '/mode', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+            body: JSON.stringify({ mode: mode })
+          });
+          if (!res.ok) throw new Error('Failed to update mode');
+          this.dataset.originalMode = mode;
+        } catch (err) {
+          console.error('Failed to update mode:', err);
+          this.value = originalValue; // Revert on error
+        }
+      });
+    });
+    
+    // Access toggle
+    document.querySelectorAll('.access-toggle').forEach(toggle => {
+      toggle.addEventListener('change', async function() {
+        const row = this.closest('.agent-row');
+        const service = row.dataset.service;
+        const account = row.dataset.account;
+        const agent = row.dataset.agent;
+        const allowed = this.checked;
+        
+        // Also get bypass status
+        const bypassToggle = row.querySelector('.bypass-toggle');
+        const bypass = bypassToggle ? bypassToggle.checked : false;
+        
+        // Enable/disable bypass toggle based on access
+        if (bypassToggle) {
+          bypassToggle.disabled = !allowed;
+          bypassToggle.closest('.toggle').classList.toggle('disabled', !allowed);
+        }
+        
+        try {
+          await fetch('/ui/access/' + encodeURIComponent(service) + '/' + encodeURIComponent(account) + '/agent/' + encodeURIComponent(agent), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+            body: JSON.stringify({ allowed: allowed.toString(), bypass_auth: bypass.toString() })
+          });
+        } catch (err) {
+          console.error('Failed to update access:', err);
+          this.checked = !allowed; // Revert on error
+        }
+      });
+    });
+    
+    // Bypass toggle
+    document.querySelectorAll('.bypass-toggle').forEach(toggle => {
+      toggle.addEventListener('change', async function() {
+        const row = this.closest('.agent-row');
+        const service = row.dataset.service;
+        const account = row.dataset.account;
+        const agent = row.dataset.agent;
+        const enabled = this.checked;
+        
+        // Update badge
+        const badge = row.querySelector('.bypass-badge');
+        if (enabled && !badge) {
+          const td = this.closest('td');
+          const span = document.createElement('span');
+          span.className = 'bypass-badge';
+          span.textContent = '⚡ Bypass';
+          td.appendChild(span);
+        } else if (!enabled && badge) {
+          badge.remove();
+        }
+        
+        try {
+          await fetch('/ui/access/' + encodeURIComponent(service) + '/' + encodeURIComponent(account) + '/agent/' + encodeURIComponent(agent) + '/bypass', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+            body: JSON.stringify({ enabled: enabled })
+          });
+        } catch (err) {
+          console.error('Failed to update bypass:', err);
+          this.checked = !enabled; // Revert on error
+        }
+      });
+    });
+  </script>
+${socketScript()}
+${localizeScript()}
+</body>
+</html>`;
+}
+
+export default router;