ai-control-center 1.15.2

package/lib/agents/payment-agent.js

@@ -0,0 +1,116 @@
+/**
+ * Payment Agent — Routes payment-related implementation requests
+ * to the correct provider skill template.
+ *
+ * This agent does NOT process payments itself. It:
+ * 1. Detects payment intent from user request
+ * 2. Selects the correct provider template (Stripe, PayOS, etc.)
+ * 3. Injects the payment skill into the implementation prompt
+ * 4. Passes to the standard impl stage
+ *
+ * This keeps payment logic in skills (templates), not in code.
+ */
+
+import { getConfig } from '../config.js';
+import { logActivity } from '../utils/activity-log.js';
+import { injectSkills } from '../utils/skill-loader.js';
+
+const PROVIDER_TEMPLATES = {
+  stripe:  'skill-payment-stripe.md',
+  payos:   'skill-payment-payos.md',
+  momo:    'skill-payment-momo.md',
+  vnpay:   'skill-payment-vnpay.md',
+  zalopay: 'skill-payment-zalopay.md',
+};
+
+/**
+ * Detect if a feature request involves payment.
+ * Also exported as isPaymentRelated for backwards compatibility.
+ */
+export function detectPaymentIntent(description) {
+  const paymentKeywords = [
+    'payment', 'checkout', 'stripe', 'payos', 'momo', 'vnpay', 'zalopay',
+    'subscription', 'billing', 'invoice', 'cart', 'purchase', 'buy',
+    'credit card', 'debit card', 'wallet', 'refund', 'pricing',
+    'plan', 'upgrade', 'downgrade', 'trial',
+    'thanh toán', 'mua hàng', 'giỏ hàng', 'đơn hàng',  // Vietnamese
+  ];
+
+  const lower = (description || '').toLowerCase();
+  return paymentKeywords.some(kw => lower.includes(kw));
+}
+
+// Backwards-compatible alias
+export const isPaymentRelated = detectPaymentIntent;
+
+/**
+ * Get payment context for the implementation prompt.
+ */
+export function getPaymentContext(config) {
+  const cfg = config || getConfig();
+  const provider = cfg.payment?.provider || 'stripe';
+  const sandbox  = cfg.payment?.sandbox !== false; // default true
+
+  return {
+    provider,
+    sandbox,
+    template: PROVIDER_TEMPLATES[provider] || PROVIDER_TEMPLATES.stripe,
+    envVars: getPaymentEnvVars(provider),
+  };
+}
+
+function getPaymentEnvVars(provider) {
+  switch (provider) {
+    case 'stripe':
+      return {
+        secretKey:      process.env.STRIPE_SECRET_KEY,
+        publishableKey: process.env.STRIPE_PUBLISHABLE_KEY,
+        webhookSecret:  process.env.STRIPE_WEBHOOK_SECRET,
+      };
+    case 'payos':
+      return {
+        clientId:    process.env.PAYOS_CLIENT_ID,
+        apiKey:      process.env.PAYOS_API_KEY,
+        checksumKey: process.env.PAYOS_CHECKSUM_KEY,
+      };
+    default:
+      return {};
+  }
+}
+
+/**
+ * Build payment-aware implementation prompt.
+ * Called by action-runner.js when payment intent is detected.
+ */
+export async function buildPaymentPrompt(originalPrompt, description) {
+  const config = getConfig();
+  const ctx = getPaymentContext(config);
+
+  let paymentSkill = '';
+  try {
+    paymentSkill = await injectSkills('', 'payment');
+  } catch { /* skill may not exist */ }
+
+  const hasKeys = Object.values(ctx.envVars).some(v => !!v);
+  const keyWarning = hasKeys
+    ? ''
+    : `\nWARNING: No ${ctx.provider} API keys found in environment. Implement with placeholder env vars and document required keys.\n`;
+
+  return `${paymentSkill}
+
+## Payment Provider: ${ctx.provider} (${ctx.sandbox ? 'SANDBOX' : 'PRODUCTION'})
+${keyWarning}
+
+## Rules for Payment Implementation
+- ALWAYS use sandbox/test mode keys in development
+- NEVER log or store raw card numbers
+- ALWAYS validate webhook signatures
+- ALWAYS use idempotency keys for payment creation
+- Handle these states: pending, succeeded, failed, refunded
+- Create a /webhooks/${ctx.provider} endpoint for async payment events
+- Store payment records in your database with: paymentId, amount, currency, status, provider, createdAt
+
+---
+
+${originalPrompt}`;
+}

package/lib/agents/suggestion-agent.js

@@ -0,0 +1,88 @@
+/**
+ * Suggestion Agent — Proactively suggests new features when the pipeline is idle.
+ *
+ * Analyzes:
+ * - QA history (recurring failures -> suggest fixes)
+ * - Current routes (missing features typical for the app type)
+ * - Activity logs (patterns of user friction)
+ *
+ * Triggered by:
+ * - PM Agent idle timer (configurable, default 60 min)
+ * - Manual /suggest command
+ *
+ * Output:
+ * - Posts suggestions to Virtual Office room
+ * - Creates .ai-workflow/feature-suggestions/SUGGEST-{date}.json
+ * - Optionally creates feature inbox items
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { getConfig } from '../config.js';
+import { getWorkflowDir } from '../utils/pipeline.js';
+import { logActivity } from '../utils/activity-log.js';
+import { analyzeQAHistory, analyzeActivityLogs } from '../utils/ux-analyzer.js';
+import { injectSkills } from '../utils/skill-loader.js';
+import { runAI } from '../utils/runner.js';
+
+const SUGGESTION_DIR = () => resolve(getWorkflowDir(), 'feature-suggestions');
+
+export async function runSuggestionAgent(options = {}) {
+  const config = getConfig();
+
+  if (!config.suggestion?.enabled) {
+    logActivity('SUGGEST', 'Suggestion agent disabled', 'info');
+    return { skipped: true };
+  }
+
+  logActivity('SUGGEST', 'Running suggestion analysis', 'info');
+
+  const qaAnalysis  = analyzeQAHistory();
+  const logAnalysis = analyzeActivityLogs();
+
+  const contextParts = [];
+
+  if (qaAnalysis) {
+    contextParts.push(`## QA Analysis (last ${qaAnalysis.totalReports} runs)
+Average pass rate: ${qaAnalysis.avgPassRate}%
+Recurring failures: ${JSON.stringify(qaAnalysis.recurringFailures)}
+Recurring warnings: ${JSON.stringify(qaAnalysis.recurringWarnings)}
+Current routes: ${qaAnalysis.testedRoutes.join(', ')}`);
+  }
+
+  if (logAnalysis) {
+    contextParts.push(`## Activity Log Patterns
+Total error lines: ${logAnalysis.totalErrorLines}
+Sample errors: ${logAnalysis.sampleErrors.slice(0, 5).join('\n')}`);
+  }
+
+  contextParts.push(`## Project
+Name: ${config.name}
+Description: ${config.description || 'Not specified'}
+Framework: ${config.framework || 'Not specified'}`);
+
+  const skill  = injectSkills('', 'suggestion');
+  const prompt = `${skill}\n\n${contextParts.join('\n\n')}\n\nGenerate exactly 3 feature suggestions as JSON array.`;
+
+  const raw = await runAI(prompt, { weight: 'light' });
+
+  let suggestions = [];
+  try {
+    const jsonMatch = raw.match(/\[[\s\S]*\]/);
+    if (jsonMatch) suggestions = JSON.parse(jsonMatch[0]);
+  } catch {
+    logActivity('SUGGEST', 'Failed to parse suggestion JSON, using raw output', 'warn');
+    suggestions = [{ title: 'AI suggestion', description: raw.slice(0, 200), priority: 'medium', effort: 'medium' }];
+  }
+
+  // Save to disk
+  const dir = SUGGESTION_DIR();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const filePath  = resolve(dir, `SUGGEST-${timestamp}.json`);
+  writeFileSync(filePath, JSON.stringify({ timestamp, suggestions, qaAnalysis }, null, 2));
+
+  logActivity('SUGGEST', `Generated ${suggestions.length} suggestions`, 'success');
+
+  return { success: true, suggestions, filePath };
+}

package/lib/cli.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+/**
+ * AI Control Center CLI — thin wrapper around action-runner.js.
+ *
+ * Used by OpenClaw's bash tool to execute pipeline actions.
+ * Each command prints JSON to stdout for the AI to parse.
+ *
+ * Usage:
+ *   node cli.js status
+ *   node cli.js feature "Add user auth" --mode auto --type feature
+ *   node cli.js deploy --test-level RunLocalTests
+ *   node cli.js approve
+ *   node cli.js reject "Missing error handling"
+ *   node cli.js review
+ *   node cli.js logs --lines 30
+ *   node cli.js health
+ *   node cli.js cleanup
+ *   node cli.js autopilot
+ *   node cli.js reset
+ *   node cli.js files <subdir>
+ *   node cli.js read <subdir> <filename>
+ *   node cli.js ai-status
+ *   node cli.js ask "How does authentication work?"
+ */
+import * as actions from './shared/action-runner.js';
+import { logActivity } from './utils/activity-log.js';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function parseFlag(flag, defaultValue) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return defaultValue;
+  return args[idx + 1] || defaultValue;
+}
+
+function out(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+async function main() {
+  switch (command) {
+
+    case 'status':
+      out(actions.getStatusData());
+      break;
+
+    case 'health':
+      out(await actions.getHealthData());
+      break;
+
+    case 'ai-status':
+      out(await actions.getAIProviderStatus());
+      break;
+
+    case 'feature': {
+      const desc = args[1];
+      const mode = parseFlag('--mode', 'manual');
+      const type = parseFlag('--type', 'feature');
+      out(await actions.runNewFeature(desc, mode, type));
+      break;
+    }
+
+    case 'approve':
+      out(await actions.runApprove());
+      break;
+
+    case 'reject': {
+      const reason = args[1] || 'Rejected via OpenClaw';
+      out(await actions.runReject(reason));
+      break;
+    }
+
+    case 'deploy': {
+      const testLevel = parseFlag('--test-level', 'NoTestRun');
+      out(await actions.runDeploy(testLevel));
+      break;
+    }
+
+    case 'review': {
+      const review = actions.getLatestReview();
+      out(review || { found: false });
+      break;
+    }
+
+    case 'logs': {
+      const lines = parseInt(parseFlag('--lines', '30'), 10);
+      out(actions.getLogsData(lines));
+      break;
+    }
+
+    case 'cleanup':
+      out(await actions.runCleanup());
+      break;
+
+    case 'autopilot':
+      out(actions.toggleAutoPilot());
+      break;
+
+    case 'reset':
+      out(actions.runReset());
+      break;
+
+    case 'files': {
+      const subdir = args[1];
+      if (!subdir) { out({ error: 'Usage: cli.js files <subdir>' }); break; }
+      out(actions.listFiles(subdir));
+      break;
+    }
+
+    case 'read': {
+      const subdir = args[1];
+      const name = args[2];
+      if (!subdir || !name) { out({ error: 'Usage: cli.js read <subdir> <filename>' }); break; }
+      const content = actions.readFile(subdir, name);
+      out(content !== null ? { name, content } : { error: 'File not found' });
+      break;
+    }
+
+    case 'ask': {
+      const question = args[1];
+      if (!question) { out({ error: 'Usage: cli.js ask "your question"' }); break; }
+      const result = await actions.askAI(question);
+      out(typeof result === 'string' ? { answer: result } : result);
+      break;
+    }
+
+    case 'assign': {
+      const url  = args[1];
+      const goal = args.slice(2).join(' ');
+      if (!url || !goal) {
+        out({ error: 'Usage: cli.js assign <url> <goal>' });
+        break;
+      }
+      const { assignProjectAction } = await import('./actions/assign-project.js');
+      const assignResult = await assignProjectAction({ url, goal });
+      out(assignResult);
+
+      // Auto-kick browser QA if assignment succeeded and browserQA is enabled
+      if (assignResult.success) {
+        const { getConfig } = await import('./config.js');
+        const cfg = getConfig();
+        const { bus } = await import('./shared/event-bus.js');
+
+        if (cfg.browserQA?.enabled) {
+          logActivity('ASSIGN', 'Auto-starting Browser QA...', 'info');
+          try {
+            const { browserTestAction } = await import('./actions/browser-test.js');
+            const qaResult = await browserTestAction({ featureId: assignResult.projectId, config: cfg });
+            out({ browserQA: qaResult.report?.summary || { skipped: qaResult.skipped, error: qaResult.error } });
+
+            // Notify channels about QA results
+            if (qaResult.report?.summary) {
+              const s = qaResult.report.summary;
+              const authNote = s.authGated ? `\n🔒 ${s.authGated} route(s) need elevated permissions (skipped)` : '';
+              bus.emitEvent('qa_report_ready', {
+                message: `🔍 <b>Browser QA complete</b>\n📊 ${s.passed}/${s.testedRoutes || s.totalRoutes} routes passed (${s.passRate}%)${s.failed > 0 ? `\n❌ ${s.failed} failed route(s)` : '\n✅ All routes healthy'}${authNote}`,
+                projectId: assignResult.projectId,
+                summary: s,
+              });
+            }
+
+            // If QA found bugs, auto-trigger bugfix
+            if (qaResult.needsBugfix && qaResult.report) {
+              const failCount = qaResult.failCount;
+              logActivity('ASSIGN', `QA found ${failCount} issue(s) — starting bugfix loop`, 'info');
+              bus.emitEvent('bugfix_loop_start', {
+                message: `🔧 <b>Starting bugfix loop</b> — ${failCount} issue(s) found, up to ${cfg.browserQA?.maxBugfixCycles || 3} cycles`,
+                projectId: assignResult.projectId,
+                failCount,
+                maxCycles: cfg.browserQA?.maxBugfixCycles || 3,
+              });
+
+              const { fixBugAction } = await import('./actions/fix-bug.js');
+              const maxCycles = cfg.browserQA?.maxBugfixCycles || 3;
+              for (let cycle = 1; cycle <= maxCycles; cycle++) {
+                logActivity('BUGFIX', `Bug-fix cycle ${cycle}/${maxCycles}`, 'info');
+                bus.emitEvent('bugfix_cycle_start', {
+                  message: `🔄 <b>Bugfix cycle ${cycle}/${maxCycles}</b> — AI is analyzing and fixing issues...`,
+                  cycle, maxCycles, projectId: assignResult.projectId,
+                });
+
+                const fixResult = await fixBugAction({ featureId: assignResult.projectId, fromQA: true });
+
+                // Check if the AI pipeline actually ran successfully
+                if (fixResult && !fixResult.success) {
+                  logActivity('BUGFIX', `Pipeline failed: ${fixResult.error || 'unknown error'}`, 'error');
+                  bus.emitEvent('bugfix_loop_complete', {
+                    message: `⚠️ <b>Bugfix pipeline failed</b> — ${fixResult.error || 'AI provider unavailable'}.\nCheck that Claude Code, Copilot, or Gemini CLI is installed and authenticated.`,
+                    cycle, maxCycles, projectId: assignResult.projectId,
+                    success: false, error: fixResult.error,
+                  });
+                  out({ bugfix: { success: false, cycles: cycle, error: fixResult.error } });
+                  break;
+                }
+
+                // Re-run QA to verify fixes
+                bus.emitEvent('bugfix_retest', {
+                  message: `🧪 Re-running Browser QA to verify fixes (cycle ${cycle}/${maxCycles})...`,
+                  cycle, maxCycles, projectId: assignResult.projectId,
+                });
+                const reQA = await browserTestAction({ featureId: assignResult.projectId, config: cfg });
+
+                if (!reQA.needsBugfix || reQA.failCount === 0) {
+                  logActivity('BUGFIX', `All bugs fixed after ${cycle} cycle(s)`, 'success');
+                  bus.emitEvent('bugfix_loop_complete', {
+                    message: `✅ <b>All bugs fixed!</b> Took ${cycle} cycle(s). All ${reQA.report?.summary?.totalRoutes || '?'} routes passing.`,
+                    cycle, maxCycles, projectId: assignResult.projectId, success: true,
+                  });
+                  out({ bugfix: { success: true, cycles: cycle } });
+                  break;
+                }
+
+                if (cycle === maxCycles) {
+                  logActivity('BUGFIX', `Exhausted ${maxCycles} bugfix cycles — escalating`, 'error');
+                  bus.emitEvent('bugfix_loop_complete', {
+                    message: `⚠️ <b>Bugfix exhausted</b> — ${reQA.failCount} issue(s) remain after ${maxCycles} cycles. Needs manual attention.`,
+                    cycle, maxCycles, projectId: assignResult.projectId,
+                    success: false, remainingFails: reQA.failCount,
+                  });
+                  out({ bugfix: { success: false, cycles: maxCycles, remainingFails: reQA.failCount } });
+                }
+              }
+            }
+          } catch (qaErr) {
+            logActivity('ASSIGN', `Browser QA failed: ${qaErr.message}`, 'error');
+            bus.emitEvent('stage_error', {
+              stage: 'browser-qa', error: qaErr.message,
+              message: `💥 <b>Browser QA crashed:</b> ${qaErr.message.slice(0, 200)}`,
+            });
+            out({ browserQA: { error: qaErr.message } });
+          }
+        }
+      }
+      break;
+    }
+
+    case 'suggest': {
+      const { runSuggestionAgent } = await import('./agents/suggestion-agent.js');
+      out(await runSuggestionAgent());
+      break;
+    }
+
+    case 'threads': {
+      const { getOpenThreads, getAllThreads } = await import('./roleplay/discussion-threads.js');
+      const showAll = args.includes('--all');
+      out(showAll ? getAllThreads() : getOpenThreads());
+      break;
+    }
+
+    case 'browser-test':
+    case 'qa': {
+      const result = await actions.runBrowserQA();
+      if (result.skipped) {
+        out({ skipped: true, message: 'Browser QA is disabled. Enable in aicc.config.js: browserQA.enabled = true' });
+      } else {
+        out(result.report?.summary || result);
+      }
+      break;
+    }
+
+    case 'events': {
+      // Stream pipeline events as NDJSON (one JSON object per line)
+      const { bus } = await import('./shared/event-bus.js');
+      bus.startWatching();
+
+      const write = (type, data) => {
+        process.stdout.write(JSON.stringify({ type, ...data, timestamp: new Date().toISOString() }) + '\n');
+      };
+
+      bus.on('status', (data) => write('status', data));
+      bus.on('pipeline-event', (data) => write('pipeline-event', data));
+      bus.on('log', (data) => write('log', data));
+
+      write('connected', { message: 'Streaming pipeline events (Ctrl+C to stop)' });
+
+      // Keep process alive
+      process.on('SIGINT', () => {
+        bus.stopWatching();
+        process.exit(0);
+      });
+      // Block — don't exit main()
+      await new Promise(() => {});
+      break;
+    }
+
+    default:
+      out({
+        error: `Unknown command: ${command || '(none)'}`,
+        commands: [
+          'status', 'health', 'ai-status', 'feature', 'approve', 'reject',
+          'deploy', 'review', 'logs', 'cleanup', 'autopilot', 'reset',
+          'files', 'read', 'ask', 'events',
+        ],
+      });
+      process.exitCode = 1;
+  }
+}
+
+main().catch(err => {
+  out({ error: err.message });
+  process.exitCode = 1;
+});