agentic-orchestrator 0.1.2 → 0.1.4

package/eslint.config.mjs

@@ -14,7 +14,8 @@ export default tseslint.config(
       '**/.aop/**',
       'agentic/features/**',
       'agentic/runtime/**',
-      '**/*.d.ts'
+      '**/*.d.ts',
+      'packages/web-dashboard/**'
     ]
   },
   js.configs.recommended,

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "agentic-orchestrator",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
+  "workspaces": [
+    "packages/*"
+  ],
   "type": "module",
   "description": "MCP-first, platform-agnostic multi-agent orchestrator control plane",
   "scripts": {
@@ -13,13 +16,18 @@
     "validate:mcp-contracts": "tsx apps/control-plane/scripts/validate-mcp-contracts.ts",
     "validate:docker-mcp": "node apps/control-plane/scripts/validate-docker-mcp-contract.mjs",
     "validate:architecture": "node apps/control-plane/scripts/validate-architecture-rules.mjs",
+    "validate:all": "npm run validate:mcp-contracts && npm run validate:docker-mcp && npm run validate:architecture",
     "lint": "eslint . --max-warnings 0",
-    "lint:fix": "npm run lint -- --fix"
+    "lint:fix": "npm run lint -- --fix",
+    "dashboard:dev": "npm run --workspace @aop/web-dashboard dev",
+    "dashboard:build": "npm run --workspace @aop/web-dashboard build",
+    "dashboard:start": "npm run --workspace @aop/web-dashboard start"
   },
   "bin": {
     "aop": "dist/apps/control-plane/cli/aop.js"
   },
   "devDependencies": {
+    "@testing-library/react": "^14.3.1",
     "@eslint/js": "^9.37.0",
     "@types/node": "^22.13.10",
     "@vitest/coverage-v8": "^3.2.4",
@@ -29,10 +37,12 @@
     "tsx": "^4.19.3",
     "typescript-eslint": "^8.46.1",
     "typescript": "^5.8.2",
+    "msw": "^2.7.0",
     "vitest": "^3.2.4"
   },
   "dependencies": {
     "ajv": "^8.17.1",
+    "chalk": "^5.4.1",
     "minimatch": "^10.0.1",
     "yaml": "^2.6.1"
   }

package/packages/web-dashboard/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.

package/packages/web-dashboard/next.config.js

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    externalDir: true
+  }
+};
+export default nextConfig;

package/packages/web-dashboard/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@aop/web-dashboard",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "next": "16.1.5",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "tailwindcss": "^3.4.17",
+    "yaml": "^2.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "typescript": "^5.4.0"
+  }
+}

package/packages/web-dashboard/src/app/api/actions/route.ts

@@ -0,0 +1,64 @@
+import { approveFeatureReview, denyFeatureReview, requestFeatureChanges } from '@/lib/orchestrator-tools';
+import { resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+interface ActionsRequest {
+  action: 'review.approve' | 'review.deny' | 'review.request_changes';
+  feature_id: string;
+  approval_token?: string;
+  reason?: string;
+  message?: string;
+  merge_strategy?: 'merge_commit' | 'squash' | 'rebase';
+  commit_message?: string;
+}
+
+export async function POST(req: Request): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as ActionsRequest;
+  if (!body.feature_id) {
+    return Response.json(
+      { ok: false, error: { code: 'feature_id_required', message: 'feature_id is required' } },
+      { status: 400 }
+    );
+  }
+
+  if (body.action === 'review.approve') {
+    if (!body.approval_token) {
+      return Response.json(
+        { ok: false, error: { code: 'approval_token_required', message: 'approval_token is required for approval' } },
+        { status: 400 }
+      );
+    }
+    const response = await approveFeatureReview(
+      body.feature_id,
+      body.approval_token,
+      body.merge_strategy ?? 'merge_commit',
+      body.commit_message,
+      repoRoot
+    );
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
+  if (body.action === 'review.deny') {
+    if (!body.reason || body.reason.trim().length === 0) {
+      return Response.json(
+        { ok: false, error: { code: 'reason_required', message: 'reason is required for deny action' } },
+        { status: 400 }
+      );
+    }
+    const response = await denyFeatureReview(body.feature_id, body.reason.trim(), repoRoot);
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
+  if (body.action === 'review.request_changes') {
+    const response = await requestFeatureChanges(body.feature_id, body.message ?? '', repoRoot);
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
+  return Response.json(
+    { ok: false, error: { code: 'unsupported_action', message: `Unsupported action: ${String(body.action)}` } },
+    { status: 400 }
+  );
+}

package/packages/web-dashboard/src/app/api/events/route.ts

@@ -0,0 +1,51 @@
+import { readDashboardStatus, resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const project = url.searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const encoder = new TextEncoder();
+  let heartbeatInterval: ReturnType<typeof setInterval> | undefined;
+  let pollInterval: ReturnType<typeof setInterval> | undefined;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send initial snapshot
+      void (async () => {
+        const payload = await readDashboardStatus(repoRoot);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'snapshot', features: payload.index, payload })}\n\n`));
+      })();
+
+      // Heartbeat every 15s
+      heartbeatInterval = setInterval(() => {
+        try { controller.enqueue(encoder.encode(': heartbeat\n\n')); }
+        catch { clearInterval(heartbeatInterval); clearInterval(pollInterval); }
+      }, 15000);
+
+      // Poll every 2s
+      pollInterval = setInterval(() => {
+        void (async () => {
+          try {
+            const payload = await readDashboardStatus(repoRoot);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'snapshot', features: payload.index, payload })}\n\n`));
+          } catch { /* ignore */ }
+        })();
+      }, 2000);
+    },
+    cancel() {
+      clearInterval(heartbeatInterval);
+      clearInterval(pollInterval);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}

package/packages/web-dashboard/src/app/api/features/[id]/checkout/route.ts

@@ -0,0 +1,256 @@
+import { execFile } from 'node:child_process';
+import { access, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { readFeatureState, resolveProjectRoot } from '@/lib/aop-client';
+
+const execFileAsync = promisify(execFile);
+
+interface CheckoutRequest {
+  stash_changes?: boolean;
+  action?: 'checkout' | 'restore';
+}
+
+interface CheckoutRestoreRecord {
+  checked_out_feature_id: string;
+  checked_out_branch: string;
+  previous_branch: string;
+  stash_ref?: string;
+  created_at: string;
+}
+
+export const dynamic = 'force-dynamic';
+
+function restoreFilePath(repoRoot: string): string {
+  return path.join(repoRoot, '.aop', 'runtime', 'checkout-restore.json');
+}
+
+async function git(repoRoot: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
+  const result = await execFileAsync('git', args, { cwd: repoRoot });
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? ''
+  };
+}
+
+async function gitTry(repoRoot: string, args: string[]): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+  try {
+    const result = await git(repoRoot, args);
+    return { ok: true, stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    const typed = error as { stdout?: string; stderr?: string };
+    return {
+      ok: false,
+      stdout: typed.stdout ?? '',
+      stderr: typed.stderr ?? ''
+    };
+  }
+}
+
+async function readRestoreRecord(repoRoot: string): Promise<CheckoutRestoreRecord | null> {
+  try {
+    const raw = await readFile(restoreFilePath(repoRoot), 'utf8');
+    return JSON.parse(raw) as CheckoutRestoreRecord;
+  } catch {
+    return null;
+  }
+}
+
+async function branchExists(repoRoot: string, branch: string): Promise<boolean> {
+  const local = await gitTry(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
+  if (local.ok) {
+    return true;
+  }
+  const remote = await gitTry(repoRoot, ['show-ref', '--verify', '--quiet', `refs/remotes/origin/${branch}`]);
+  return remote.ok;
+}
+
+async function isDirtyWorkspace(repoRoot: string): Promise<boolean> {
+  const result = await gitTry(repoRoot, ['status', '--porcelain']);
+  return result.ok && result.stdout.trim().length > 0;
+}
+
+async function mergeInProgress(repoRoot: string): Promise<boolean> {
+  try {
+    await access(path.join(repoRoot, '.git', 'MERGE_HEAD'));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function currentBranch(repoRoot: string): Promise<string> {
+  const result = await git(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  return result.stdout.trim();
+}
+
+async function checkoutFeature(repoRoot: string, featureId: string, stashChanges: boolean): Promise<Response> {
+  if (await mergeInProgress(repoRoot)) {
+    return Response.json(
+      { ok: false, error: { code: 'merge_in_progress', message: 'Cannot checkout while merge is in progress' } },
+      { status: 409 }
+    );
+  }
+
+  const existing = await readRestoreRecord(repoRoot);
+  if (existing) {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'checkout_already_active',
+          message: `Checkout already active for feature ${existing.checked_out_feature_id}; restore first`
+        }
+      },
+      { status: 409 }
+    );
+  }
+
+  const state = await readFeatureState(featureId, repoRoot);
+  if (!state) {
+    return Response.json(
+      { ok: false, error: { code: 'feature_not_found', message: `Feature ${featureId} not found` } },
+      { status: 404 }
+    );
+  }
+
+  const branch = state.branch ?? featureId;
+  if (!(await branchExists(repoRoot, branch))) {
+    return Response.json(
+      { ok: false, error: { code: 'branch_not_found', message: `Feature branch not found: ${branch}` } },
+      { status: 404 }
+    );
+  }
+
+  const worktreePath = state.worktree_path ?? path.join(repoRoot, '.worktrees', featureId);
+  try {
+    await access(worktreePath);
+  } catch {
+    return Response.json(
+      { ok: false, error: { code: 'worktree_not_found', message: `Feature worktree not found: ${worktreePath}` } },
+      { status: 404 }
+    );
+  }
+
+  const previous = await currentBranch(repoRoot);
+  let stashRef: string | undefined;
+
+  if (stashChanges && (await isDirtyWorkspace(repoRoot))) {
+    const beforeStash = await gitTry(repoRoot, ['rev-parse', '--verify', '-q', 'refs/stash']);
+    await git(repoRoot, ['stash', 'push', '-u', '-m', `aop-dashboard-checkout:${featureId}:${Date.now()}`]);
+    const afterStash = await gitTry(repoRoot, ['rev-parse', '--verify', '-q', 'refs/stash']);
+    if (afterStash.ok && (!beforeStash.ok || beforeStash.stdout.trim() !== afterStash.stdout.trim())) {
+      stashRef = afterStash.stdout.trim();
+    }
+  }
+
+  const checkoutResult = await gitTry(repoRoot, ['checkout', branch]);
+  if (!checkoutResult.ok) {
+    return Response.json(
+      { ok: false, error: { code: 'checkout_failed', message: checkoutResult.stderr.trim() || 'git checkout failed' } },
+      { status: 409 }
+    );
+  }
+
+  const record: CheckoutRestoreRecord = {
+    checked_out_feature_id: featureId,
+    checked_out_branch: branch,
+    previous_branch: previous,
+    stash_ref: stashRef,
+    created_at: new Date().toISOString()
+  };
+  const restoreFile = restoreFilePath(repoRoot);
+  await mkdir(path.dirname(restoreFile), { recursive: true });
+  await writeFile(restoreFile, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+
+  return Response.json({
+    ok: true,
+    data: {
+      feature_id: featureId,
+      branch,
+      previous_branch: previous,
+      stashed: Boolean(stashRef),
+      stash_ref: stashRef ?? null
+    }
+  });
+}
+
+async function restoreCheckout(repoRoot: string, featureId: string): Promise<Response> {
+  const saved = await readRestoreRecord(repoRoot);
+  if (!saved) {
+    return Response.json(
+      { ok: false, error: { code: 'restore_not_available', message: 'No active dashboard checkout to restore' } },
+      { status: 404 }
+    );
+  }
+
+  if (saved.checked_out_feature_id !== featureId) {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'restore_feature_mismatch',
+          message: `Active checkout belongs to ${saved.checked_out_feature_id}; restore that feature first`
+        }
+      },
+      { status: 409 }
+    );
+  }
+
+  const checkoutResult = await gitTry(repoRoot, ['checkout', saved.previous_branch]);
+  if (!checkoutResult.ok) {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'restore_checkout_failed',
+          message: checkoutResult.stderr.trim() || 'Failed to restore previous branch'
+        }
+      },
+      { status: 409 }
+    );
+  }
+
+  let stashRestored = false;
+  if (saved.stash_ref) {
+    const apply = await gitTry(repoRoot, ['stash', 'apply', '--index', saved.stash_ref]);
+    if (apply.ok) {
+      stashRestored = true;
+      await gitTry(repoRoot, ['stash', 'drop', saved.stash_ref]);
+    } else {
+      return Response.json(
+        {
+          ok: false,
+          error: {
+            code: 'stash_restore_failed',
+            message: apply.stderr.trim() || 'Failed to restore stashed changes'
+          }
+        },
+        { status: 409 }
+      );
+    }
+  }
+
+  await unlink(restoreFilePath(repoRoot)).catch(() => undefined);
+
+  return Response.json({
+    ok: true,
+    data: {
+      restored_to: saved.previous_branch,
+      stash_restored: stashRestored,
+      stash_ref: saved.stash_ref ?? null
+    }
+  });
+}
+
+export async function POST(req: Request, { params }: { params: { id: string } }): Promise<Response> {
+  const url = new URL(req.url);
+  const project = url.searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as CheckoutRequest;
+  const action = body.action ?? 'checkout';
+  if (action === 'restore') {
+    return await restoreCheckout(repoRoot, params.id);
+  }
+  return await checkoutFeature(repoRoot, params.id, body.stash_changes ?? true);
+}

package/packages/web-dashboard/src/app/api/features/[id]/diff/route.ts

@@ -0,0 +1,10 @@
+import { readFeatureDiff, resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request, { params }: { params: { id: string } }): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const diff = await readFeatureDiff(params.id, repoRoot);
+  return new Response(diff, { headers: { 'Content-Type': 'text/plain' } });
+}

package/packages/web-dashboard/src/app/api/features/[id]/evidence/[artifact]/route.ts

@@ -0,0 +1,25 @@
+import { readEvidenceArtifact, resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: { id: string; artifact: string } }
+): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const content = await readEvidenceArtifact(params.id, params.artifact, repoRoot);
+  if (content == null) {
+    return Response.json(
+      { ok: false, error: { code: 'artifact_not_found', message: `Artifact not found: ${params.artifact}` } },
+      { status: 404 }
+    );
+  }
+
+  return new Response(content, {
+    headers: {
+      'Content-Type': params.artifact.endsWith('.json') ? 'application/json' : 'text/plain',
+      'Content-Disposition': `attachment; filename="${params.artifact}"`
+    }
+  });
+}

package/packages/web-dashboard/src/app/api/features/[id]/review/route.ts

@@ -0,0 +1,63 @@
+import {
+  approveFeatureReview,
+  denyFeatureReview,
+  requestFeatureChanges
+} from '@/lib/orchestrator-tools';
+import { resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+interface ReviewRequest {
+  decision: 'approve' | 'deny' | 'request_changes';
+  approval_token?: string;
+  merge_strategy?: 'merge_commit' | 'squash' | 'rebase';
+  commit_message?: string;
+  reason?: string;
+  message?: string;
+}
+
+export async function POST(req: Request, { params }: { params: { id: string } }): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as ReviewRequest;
+
+  if (!['approve', 'deny', 'request_changes'].includes(body.decision)) {
+    return Response.json(
+      { ok: false, error: { code: 'invalid_decision', message: 'decision must be approve, deny, or request_changes' } },
+      { status: 400 }
+    );
+  }
+
+  if (body.decision === 'approve') {
+    if (!body.approval_token || body.approval_token.trim().length === 0) {
+      return Response.json(
+        { ok: false, error: { code: 'approval_token_required', message: 'approval_token is required for approve' } },
+        { status: 400 }
+      );
+    }
+
+    const response = await approveFeatureReview(
+      params.id,
+      body.approval_token.trim(),
+      body.merge_strategy ?? 'merge_commit',
+      body.commit_message,
+      repoRoot
+    );
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
+  if (body.decision === 'deny') {
+    const reason = body.reason?.trim();
+    if (!reason) {
+      return Response.json(
+        { ok: false, error: { code: 'reason_required', message: 'reason is required when decision=deny' } },
+        { status: 400 }
+      );
+    }
+    const response = await denyFeatureReview(params.id, reason, repoRoot);
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
+  const response = await requestFeatureChanges(params.id, body.message ?? '', repoRoot);
+  return Response.json(response, { status: response.ok ? 200 : 409 });
+}

package/packages/web-dashboard/src/app/api/features/[id]/route.ts

@@ -0,0 +1,16 @@
+import { readFeatureDetail, resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request, { params }: { params: { id: string } }): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const detail = await readFeatureDetail(params.id, repoRoot);
+  if (!detail) {
+    return Response.json(
+      { ok: false, error: { code: 'feature_not_found', message: `Feature ${params.id} not found` } },
+      { status: 404 }
+    );
+  }
+  return Response.json({ ok: true, data: detail });
+}

package/packages/web-dashboard/src/app/api/projects/route.ts

@@ -0,0 +1,31 @@
+import { getAopRoot } from '@/lib/aop-client';
+import { readMultiProjectConfig } from '@/lib/multi-project-config';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(): Promise<Response> {
+  const config = await readMultiProjectConfig(getAopRoot());
+  if (!config) {
+    return Response.json({
+      ok: true,
+      data: {
+        projects: [],
+        defaults: null
+      }
+    });
+  }
+
+  return Response.json({
+    ok: true,
+    data: {
+      defaults: config.defaults ?? null,
+      projects: config.projects.map((project) => ({
+        name: project.name,
+        path: project.path,
+        policy: project.policy ?? null,
+        gates: project.gates ?? null,
+        dashboard_port: project.dashboard_port ?? null
+      }))
+    }
+  });
+}

package/packages/web-dashboard/src/app/api/status/route.ts

@@ -0,0 +1,15 @@
+import { readDashboardStatus, resolveProjectRoot } from '@/lib/aop-client';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const project = url.searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const payload = await readDashboardStatus(repoRoot);
+  return Response.json({
+    ok: true,
+    data: payload,
+    timestamp: new Date().toISOString(),
+  });
+}

package/packages/web-dashboard/src/app/globals.css

@@ -0,0 +1,2 @@
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; }

package/packages/web-dashboard/src/app/layout.tsx

@@ -0,0 +1,15 @@
+import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: 'AOP Dashboard',
+  description: 'Agentic Orchestrator Dashboard',
+};
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}