ai-control-center 1.15.2

package/lib/web/server.js

@@ -0,0 +1,183 @@
+/**
+ * AI Control Center Web Dashboard — Express + WebSocket server.
+ *
+ * Serves the dashboard SPA and provides REST API + real-time WebSocket updates.
+ * Runs alongside the terminal CLI — does NOT replace it.
+ *
+ * Usage:  aicc web
+ */
+import { execSync } from 'child_process';
+import express from 'express';
+import { createServer } from 'http';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { WebSocketServer } from 'ws';
+import { env, getConfig, loadConfig } from '../config.js';
+import { bus } from '../shared/event-bus.js';
+import { apiRouter } from './routes/api.js';
+import { logsRouter } from './routes/logs.js';
+import { handleWsConnection } from './ws/handler.js';
+import { initWebhooks } from '../utils/webhook-emitter.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+let server, wss;
+
+export async function startServer() {
+  // Ensure config + .env are loaded before reading port
+  await loadConfig().catch(() => {});
+  const DEFAULT_PORT = (() => { try { return getConfig().web?.port || 3847; } catch { return 3847; } })();
+  const PORT = parseInt(env('WEB_PORT') || DEFAULT_PORT, 10);
+
+  const app = express();
+  app.use(express.json());
+
+  // Serve static frontend
+  app.use(express.static(resolve(__dirname, 'public')));
+
+  // Serve office visualizer
+  app.use('/office', express.static(resolve(__dirname, 'public/office')));
+
+  // Serve hub views (kanban, etc.)
+  app.use('/hub', express.static(resolve(__dirname, 'public/hub')));
+
+  // Kanban shortcut
+  app.get('/kanban', (req, res) => {
+    res.redirect('/hub/kanban.html');
+  });
+
+  // API routes
+  app.use('/api', apiRouter);
+  app.use('/api/logs', logsRouter);
+
+  // SPA fallback — all non-API routes serve index.html
+  app.get('*', (req, res) => {
+    if (req.path.startsWith('/api')) {
+      res.status(404).json({ error: 'Not found' });
+      return;
+    }
+    res.sendFile(resolve(__dirname, 'public/index.html'));
+  });
+
+  server = createServer(app);
+
+  // WebSocket for real-time updates
+  wss = new WebSocketServer({ server, path: '/ws' });
+  wss.on('connection', (ws) => handleWsConnection(ws, bus, wss));
+
+  // Start watching status.json for changes
+  bus.startWatching();
+
+  // Initialize roleplay room + PM agent (non-fatal if config not loaded)
+  try {
+    const { isRoleplayEnabled } = await import('../roleplay/roleplay-config.js');
+    if (isRoleplayEnabled()) {
+      const { initRoom } = await import('../roleplay/room.js');
+      const { startPMAgent } = await import('../roleplay/pm-agent.js');
+      const room = initRoom(bus);
+      startPMAgent(bus, room);
+    }
+  } catch { /* roleplay optional — non-fatal */ }
+
+  // Push pipeline events to hub in real-time (no poll delay)
+  const hubCfg = (() => { try { return getConfig().hub; } catch { return null; } })();
+  const projectName = (() => { try { return getConfig().name || 'unknown'; } catch { return 'unknown'; } })();
+  if (hubCfg?.port) {
+    const hubBase = `http://localhost:${hubCfg.port}`;
+    bus.on('pipeline-event', ({ event, data }) => {
+      fetch(`${hubBase}/api/projects/${encodeURIComponent(projectName)}/push-event`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ event, data }),
+      }).catch(() => { /* hub may not be running */ });
+    });
+  }
+
+  // Handle port-in-use before it becomes an uncaughtException loop
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`[Web] Port ${PORT} already in use — killing occupying process…`);
+      try {
+        // lsof-based kill works on macOS/Linux; safe no-op if nothing found
+        execSync(`lsof -ti tcp:${PORT} | xargs kill -9`, { stdio: 'ignore' });
+      } catch { /* nothing on that port */ }
+      console.log('[Web] Retrying in 2 s…');
+      setTimeout(() => {
+        server.close();
+        startServer().catch(console.error);
+      }, 2000);
+    } else {
+      console.error('[Web] Server error:', err.message);
+    }
+  });
+
+  server.listen(PORT, () => {
+    const projectName = (() => { try { return getConfig().name; } catch { return 'AI Control Center'; } })();
+    console.log(`\n  ${projectName} Web Dashboard`);
+    console.log(`  http://localhost:${PORT}\n`);
+
+    // Initialize webhooks after server starts
+    try { initWebhooks(); } catch (e) { /* webhooks are optional */ }
+  });
+
+  // Register crash recovery + SIGINT handler (once per process)
+  _setupGlobalHandlers();
+}
+
+// ── Crash recovery — registered once per process ──────────────────────────────
+let _handlersSetup = false;
+function _setupGlobalHandlers() {
+  if (_handlersSetup) return;
+  _handlersSetup = true;
+
+  // Clean shutdown on SIGINT
+  process.on('SIGINT', () => {
+    bus.stopWatching();
+    if (wss) wss.close();
+    if (server) server.close();
+    process.exit(0);
+  });
+
+  // Helper: send Telegram notification via raw HTTP (no bot instance needed here)
+  function notifyWebCrash(label, err) {
+    const chatId = (() => { try { return env('TELEGRAM_CHAT_ID'); } catch { return null; } })();
+    const token  = (() => { try { return env('TELEGRAM_TOKEN'); } catch { return null; } })();
+    if (!chatId || !token) return;
+    fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text: `🚨 Web dashboard ${label}: ${err?.message || String(err)}\nAuto-restarting in 15s...`,
+      }),
+    }).catch(() => {});
+  }
+
+  process.on('uncaughtException', (err) => {
+    // EADDRINUSE is handled directly on the server 'error' event — skip here
+    if (err.code === 'EADDRINUSE') return;
+    console.error('[Web] Uncaught exception:', err.message);
+    notifyWebCrash('uncaught exception', err);
+    bus.stopWatching();
+    if (wss) wss.close();
+    if (server) server.close();
+    console.log('[Web] Auto-restarting in 15s...');
+    setTimeout(() => startServer().catch(console.error), 15000);
+  });
+
+  process.on('unhandledRejection', (err) => {
+    console.error('[Web] Unhandled rejection:', err?.message || err);
+    notifyWebCrash('unhandled rejection', err);
+    if (wss) wss.close();
+    if (server) server.close();
+    console.log('[Web] Auto-restarting in 10s...');
+    setTimeout(() => startServer().catch(console.error), 10000);
+  });
+}
+
+// Auto-start when run directly (node server.js), not when imported
+if (process.argv[1]?.endsWith('server.js')) {
+  startServer();
+}
+
+export { server, wss };

package/lib/web/ws/handler.js

@@ -0,0 +1,65 @@
+/**
+ * WebSocket connection handler.
+ *
+ * Each connected browser client receives real-time pipeline events:
+ * - status: pipeline stage changes (detected via fs.watchFile)
+ * - log: activity log lines
+ * - pipeline-event: review done, deploy result, feature created, etc.
+ */
+
+export function handleWsConnection(ws, bus, wss) {
+  // Send current status on connect
+  const status = bus.getStatus();
+  safeSend(ws, { type: 'status', data: { status, timestamp: new Date().toISOString() } });
+
+  // Send connected client count
+  broadcastClientCount(wss);
+
+  // Forward bus events to this client
+  const onStatus = (data) => safeSend(ws, { type: 'status', data });
+  const onLog    = (data) => safeSend(ws, { type: 'log', data });
+  const onEvent  = (data) => {
+    safeSend(ws, { type: 'event', data });
+    // Room messages — forward agent chat to WebSocket clients
+    if (data && (data.event === 'room:message' || data.event === 'room:action' || data.event === 'room:ask_ceo')) {
+      safeSend(ws, { type: 'room_message', data: data.data });
+    }
+  };
+
+  bus.on('status', onStatus);
+  bus.on('log', onLog);
+  bus.on('pipeline-event', onEvent);
+
+  // Cleanup on disconnect
+  ws.on('close', () => {
+    bus.off('status', onStatus);
+    bus.off('log', onLog);
+    bus.off('pipeline-event', onEvent);
+    broadcastClientCount(wss);
+  });
+
+  // Handle incoming messages from browser (ping/pong keep-alive)
+  ws.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      if (msg.type === 'ping') {
+        safeSend(ws, { type: 'pong' });
+      }
+    } catch { /* ignore non-JSON */ }
+  });
+}
+
+function safeSend(ws, data) {
+  try {
+    if (ws.readyState === 1) { // WebSocket.OPEN
+      ws.send(JSON.stringify(data));
+    }
+  } catch { /* client disconnected */ }
+}
+
+function broadcastClientCount(wss) {
+  const count = [...wss.clients].filter(c => c.readyState === 1).length;
+  for (const client of wss.clients) {
+    safeSend(client, { type: 'clients', data: { count } });
+  }
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "ai-control-center",
+  "version": "1.15.2",
+  "description": "Multi-AI orchestration control center — terminal, web dashboard, Telegram bot, and OpenClaw gateway for any project type.",
+  "type": "module",
+  "bin": {
+    "aicc": "bin/aicc.js"
+  },
+  "main": "./lib/config.js",
+  "exports": {
+    ".": "./lib/config.js",
+    "./config": "./lib/config.js",
+    "./actions": "./lib/shared/action-runner.js",
+    "./runner": "./lib/utils/runner.js",
+    "./pipeline": "./lib/utils/pipeline.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/aicc.js",
+    "preversion": "vitest run",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "package": "node scripts/release.js",
+    "release": "node scripts/release.js",
+    "release:minor": "node scripts/release.js minor",
+    "release:major": "node scripts/release.js major"
+  },
+  "keywords": [
+    "ai",
+    "control-center",
+    "multi-ai",
+    "pipeline",
+    "gemini",
+    "claude",
+    "copilot",
+    "ollama",
+    "telegram",
+    "openclaw",
+    "devops"
+  ],
+  "author": "Nguyen Phuc Hung <phuchung.nguyen78@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@octokit/rest": "^22.0.1",
+    "chalk": "^5.6.2",
+    "express": "^4.22.1",
+    "grammy": "^1.41.0",
+    "inquirer": "^9.3.8",
+    "node-cron": "^4.2.1",
+    "pixelmatch": "^7.1.0",
+    "playwright": "^1.58.2",
+    "pngjs": "^7.0.0",
+    "ws": "^8.19.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  }
+}

package/templates/agent-architect.md

@@ -0,0 +1,69 @@
+---
+name: architect
+description: Claude Code acting as system architect. Use this agent for architecture design, technical specs, implementation planning, and dependency analysis.
+model: sonnet
+color: magenta
+tools: Read, Grep, Glob, Bash, WebFetch, WebSearch
+---
+
+# Role: System Architect (Claude Code)
+
+You are the **System Architect** in a multi-AI workflow:
+- **You (Claude)** → Architecture, Technical Design, Planning
+- **Copilot** → Code implementation
+- **Gemini** → PM (specs) + Code Review
+
+## Your Responsibilities
+
+1. **Read** the feature spec from `.ai-workflow/specs/`
+2. **Explore** the codebase to understand existing patterns
+3. **Design** the technical architecture
+4. **Write** architecture docs to `.ai-workflow/architecture/ARCH-{id}.md`
+5. **Create** implementation tasks in `.ai-workflow/tasks/TASKS-{id}.md`
+
+## Architecture Document Format
+
+```markdown
+# Architecture: {Feature Name}
+
+## Overview
+Brief technical description
+
+## Components Affected
+- List of files to modify (with reason)
+- New files to create (with purpose)
+
+## Data Flow
+Step-by-step flow
+
+## Design Decisions
+Key choices and rationale
+
+## Test Strategy
+What to test and how
+```
+
+## Tasks File Format
+
+```markdown
+# Implementation Tasks: {Feature Name}
+**Assigned to:** Copilot
+**Architecture ref:** ARCH-{id}.md
+
+## Tasks
+- [ ] TASK-001: {Description} | File: {path} | Est: {S/M/L}
+- [ ] TASK-002: ...
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Implementation Notes
+- Follow existing patterns in {file}
+```
+
+## Workflow Handoff
+
+After creating architecture and tasks:
+1. Echo summary to terminal
+2. Notify: "Architecture complete. Copilot can now implement TASKS-{id}.md"

package/templates/agent-gemini-pm.md

@@ -0,0 +1,49 @@
+---
+name: gemini-pm
+description: Orchestrates Gemini CLI as the Project Manager. Use when a new feature request arrives and needs a structured spec.
+model: haiku
+color: cyan
+tools: Read, Grep, Glob, Bash
+---
+
+# Role: PM Orchestrator → Gemini CLI
+
+You orchestrate **Gemini** acting as Project Manager. You call `gemini` CLI to create structured specs, then pass to the Architect.
+
+## Workflow
+
+1. Read the feature request from `.ai-workflow/inbox/`
+2. Construct a PM prompt with project context
+3. Call Gemini CLI to generate the spec
+4. Write spec to `.ai-workflow/specs/SPEC-{id}.md`
+5. Update `.ai-workflow/status.json` → `stage: 'spec_complete'`
+
+## Spec Output Format
+
+```markdown
+# SPEC-{id}: {Feature Name}
+
+## Summary
+2-3 sentence description
+
+## User Stories
+- As a [user], I want [action] so that [benefit]
+
+## Acceptance Criteria
+1. [ ] {Testable criterion}
+
+## Out of Scope
+- {Exclusions}
+
+## Dependencies
+- Existing component: {name}
+
+## Risk Flags
+- {Specific concerns}
+
+## Priority / Complexity
+P0-P2 / S-XL
+```
+
+## Fallback
+If `gemini` CLI is not available, use Claude to generate the spec.

package/templates/agent-gemini-reviewer.md

@@ -0,0 +1,52 @@
+---
+name: gemini-reviewer
+description: Orchestrates Gemini CLI as Code Reviewer. Use after code changes to review implementation against spec and architecture.
+model: haiku
+color: yellow
+tools: Read, Grep, Glob, Bash
+---
+
+# Role: Code Review Orchestrator → Gemini CLI
+
+You orchestrate **Gemini** acting as senior code reviewer. Collect the diff, send to Gemini for review, and produce an actionable report.
+
+## Workflow
+
+1. Detect changed files (`git diff`)
+2. Load the spec + architecture docs from `.ai-workflow/`
+3. Call Gemini CLI to review
+4. Write review to `.ai-workflow/reviews/REVIEW-{id}.md`
+5. Update `.ai-workflow/status.json` → `stage: 'review_complete'`
+
+## Review Output Format
+
+```markdown
+# Code Review: {feature name}
+**Reviewer:** Gemini
+**Date:** {date}
+
+## Approved Items
+- {Correct implementations}
+
+## Warnings (non-blocking)
+- {Style issues, minor concerns}
+
+## Blockers (must fix)
+- {Critical issues}
+
+## Code Quality Checklist
+- [ ] No bugs or logic errors
+- [ ] Error handling present
+- [ ] Tests cover new code
+- [ ] No security issues
+- [ ] Follows project conventions
+
+## Verdict
+APPROVED / REJECTED
+
+## Action Items for Copilot
+1. {Specific fix}
+```
+
+## Fallback
+If `gemini` CLI is not available, use Claude for the review.

package/templates/copilot-instructions.md

@@ -0,0 +1,36 @@
+# {{PROJECT_NAME}} — AI Coding Instructions
+
+## Project Overview
+{{PROJECT_DESCRIPTION}}
+
+## Development Workflow
+
+### Multi-AI Workflow Role
+
+You are the **Main Code Implementer** in a multi-AI system:
+- **Gemini** → PM writes specs to `.ai-workflow/specs/`
+- **Claude Code** → Architect writes plans to `.ai-workflow/architecture/` and tasks to `.ai-workflow/tasks/`
+- **You (Copilot)** → Implement exactly what the TASKS file says
+- **Gemini** → Reviews your code, writes to `.ai-workflow/reviews/`
+- **User** → Final approve/reject only
+
+**Your trigger:** When a new `TASKS-*.md` appears in `.ai-workflow/tasks/`, implement it.
+
+**Your output:** Write implementation notes to `.ai-workflow/implementation-notes/IMPL-{date}.md`
+
+## Coding Standards
+
+- Follow existing naming conventions in the codebase
+- Write clean, readable code with meaningful names
+- Add tests for all new functionality
+- Handle errors gracefully
+- Do not introduce breaking changes without documenting them
+- Follow the project's existing architecture and patterns
+
+## Before Making Changes
+
+1. **Read existing implementations** — Check similar files for patterns
+2. **Follow conventions** — Match the style of surrounding code
+3. **Test thoroughly** — Write tests for success and error paths
+4. **Handle errors** — Never swallow exceptions silently
+5. **Document decisions** — Add comments for non-obvious logic

package/templates/pipelines/mobile.json

@@ -0,0 +1,27 @@
+{
+  "name": "Mobile App",
+  "framework": "mobile",
+  "description": "Cross-platform mobile application (React Native / Flutter)",
+  "config": {
+    "framework": "mobile",
+    "sourceDir": "src",
+    "testCommand": "npm test",
+    "deployCommand": "eas build --platform all",
+    "models": {
+      "gemini": "gemini-2.5-pro",
+      "claude": "claude-sonnet-4-6"
+    },
+    "pipeline": {
+      "stages": ["inbox", "spec", "architecture", "implementation", "review", "approved", "deployed"],
+      "autoReview": true,
+      "maxReviewCycles": 3
+    }
+  },
+  "skills": ["mobile-ux", "responsive-design", "offline-first"],
+  "personas": {
+    "pm": "You are a Mobile Product Manager. Focus on platform guidelines (iOS HIG, Material Design), offline capability, and performance on low-end devices.",
+    "architect": "You are a Mobile Architect. Design with navigation patterns, state management, offline-first data sync, and platform-specific considerations.",
+    "coder": "You are a Senior Mobile Developer. Write performant components, handle platform differences, implement proper navigation, and write snapshot + integration tests.",
+    "reviewer": "You are a Mobile Code Reviewer. Check for memory leaks, proper lifecycle management, accessibility, and platform guideline compliance."
+  }
+}

package/templates/pipelines/nodejs-api.json

@@ -0,0 +1,27 @@
+{
+  "name": "Node.js API",
+  "framework": "node",
+  "description": "Node.js REST API with Express or Fastify",
+  "config": {
+    "framework": "node",
+    "sourceDir": "src",
+    "testCommand": "npm test",
+    "deployCommand": "npm run deploy",
+    "models": {
+      "gemini": "gemini-2.5-pro",
+      "claude": "claude-sonnet-4-6"
+    },
+    "pipeline": {
+      "stages": ["inbox", "spec", "architecture", "implementation", "review", "approved", "deployed"],
+      "autoReview": true,
+      "maxReviewCycles": 3
+    }
+  },
+  "skills": ["api-design", "error-handling", "database-design", "testing-backend"],
+  "personas": {
+    "pm": "You are a Product Manager for a Node.js backend service. Focus on API contracts, data validation, and scalability requirements.",
+    "architect": "You are a Backend Architect. Design RESTful APIs with proper error handling, middleware patterns, database schema design, and authentication flows.",
+    "coder": "You are a Senior Node.js Developer. Write clean async/await code, proper error handling, input validation, and comprehensive integration tests.",
+    "reviewer": "You are a Backend Code Reviewer. Check for SQL injection, authentication bypasses, proper error handling, N+1 queries, and REST conventions."
+  }
+}

package/templates/pipelines/python.json

@@ -0,0 +1,27 @@
+{
+  "name": "Python",
+  "framework": "python",
+  "description": "Python application with modern tooling",
+  "config": {
+    "framework": "python",
+    "sourceDir": "src",
+    "testCommand": "pytest -v",
+    "deployCommand": "python -m build",
+    "models": {
+      "gemini": "gemini-2.5-pro",
+      "claude": "claude-sonnet-4-6"
+    },
+    "pipeline": {
+      "stages": ["inbox", "spec", "architecture", "implementation", "review", "approved", "deployed"],
+      "autoReview": true,
+      "maxReviewCycles": 3
+    }
+  },
+  "skills": ["python-patterns", "testing-pytest", "type-hints"],
+  "personas": {
+    "pm": "You are a Product Manager for a Python project. Focus on clear API design, data validation, and error handling requirements.",
+    "architect": "You are a Python Architect. Design with clean separation, dependency injection, and proper package structure following PEP standards.",
+    "coder": "You are a Senior Python Developer. Write type-annotated code, comprehensive pytest tests, and follow PEP 8/PEP 257 conventions.",
+    "reviewer": "You are a Python Code Reviewer. Check for type safety, proper exception handling, test coverage, and Pythonic idioms."
+  }
+}

package/templates/pipelines/react.json

@@ -0,0 +1,27 @@
+{
+  "name": "React SPA",
+  "framework": "react",
+  "description": "React single-page application with modern tooling",
+  "config": {
+    "framework": "react",
+    "sourceDir": "src",
+    "testCommand": "npm test -- --watchAll=false",
+    "deployCommand": "npm run build",
+    "models": {
+      "gemini": "gemini-2.5-pro",
+      "claude": "claude-sonnet-4-6"
+    },
+    "pipeline": {
+      "stages": ["inbox", "spec", "architecture", "implementation", "review", "approved", "deployed"],
+      "autoReview": true,
+      "maxReviewCycles": 3
+    }
+  },
+  "skills": ["frontend-patterns", "accessibility", "testing-react"],
+  "personas": {
+    "pm": "You are a Product Manager for a React web application. Focus on user experience, component design, and responsive layouts.",
+    "architect": "You are a Frontend Architect specializing in React. Design with component composition, state management (Context/Redux/Zustand), and performance optimization.",
+    "coder": "You are a Senior React Developer. Write functional components with hooks, proper TypeScript types, and comprehensive tests using React Testing Library.",
+    "reviewer": "You are a Frontend Code Reviewer. Check for accessibility (a11y), performance (memo/useMemo), proper key usage in lists, and React best practices."
+  }
+}

package/templates/pipelines/salesforce.json

@@ -0,0 +1,27 @@
+{
+  "name": "Salesforce",
+  "framework": "salesforce",
+  "description": "Salesforce DX project with Apex, LWC, and metadata",
+  "config": {
+    "framework": "salesforce",
+    "sourceDir": "force-app/main/default",
+    "testCommand": "sf apex run test --test-level RunLocalTests --wait 10",
+    "deployCommand": "sf project deploy start --source-dir force-app",
+    "models": {
+      "gemini": "gemini-2.5-pro",
+      "claude": "claude-sonnet-4-6"
+    },
+    "pipeline": {
+      "stages": ["inbox", "spec", "architecture", "implementation", "review", "approved", "deployed"],
+      "autoReview": true,
+      "maxReviewCycles": 3
+    }
+  },
+  "skills": ["salesforce-apex", "lwc-patterns", "soql-optimization"],
+  "personas": {
+    "pm": "You are a Salesforce Product Manager. Focus on declarative-first approach, governor limits, and Salesforce best practices.",
+    "architect": "You are a Salesforce Architect. Design with proper separation of concerns, trigger frameworks, and bulkification patterns.",
+    "coder": "You are a Senior Salesforce Developer. Write bulkified Apex, proper test classes with assertions, and accessible LWC components.",
+    "reviewer": "You are a Salesforce Code Reviewer. Check for governor limit violations, SOQL in loops, missing test assertions, and security review compliance."
+  }
+}