@aion0/forge 0.5.46 → 0.5.48

package/lib/migration/runner.ts

@@ -0,0 +1,219 @@
+// HTTP runner — fires the same path against legacy + new and compares.
+// diffMode controls how comparison happens:
+//   exact = fire both, deep-equal JSON
+//   shape = fire only `next`, validate response against OpenAPI schema (legacy not needed)
+//   both  = fire both + schema validation
+
+import type { Endpoint, MigrationConfig, RunResult, SideResult } from './types';
+import { diff, validateAgainstSchema, type SchemaViolation } from './differ';
+
+function compileIgnore(patterns: string[]): RegExp[] {
+  return patterns.map(p => {
+    const body = p.startsWith('$') ? p.slice(1) : p;
+    const escaped = body
+      .replace(/\./g, '\\.')
+      .replace(/\[\*\]/g, '\\[\\d+\\]')
+      .replace(/\[(\d+)\]/g, '\\[$1\\]');
+    return new RegExp(`^\\$${escaped}$`);
+  });
+}
+import { loadOpenApi, lookup, getResponseSchema, type OpenApiDoc } from './openapi';
+
+function substitutePath(path: string, subs: Record<string, string> = {}): string {
+  return path.replace(/\{([^}]+)\}/g, (_, name) => subs[name] ?? subs.id ?? '1');
+}
+
+function buildHeaders(config: MigrationConfig): Record<string, string> {
+  const headers: Record<string, string> = { Accept: 'application/json' };
+  if (config.auth.mode === 'bearer' && config.auth.tokenEnv) {
+    const tok = process.env[config.auth.tokenEnv];
+    if (tok) headers['Authorization'] = `Bearer ${tok}`;
+  } else if (config.auth.mode === 'basic' && config.auth.username && config.auth.passwordEnv) {
+    const pw = process.env[config.auth.passwordEnv];
+    if (pw) {
+      const b64 = Buffer.from(`${config.auth.username}:${pw}`).toString('base64');
+      headers['Authorization'] = `Basic ${b64}`;
+    }
+  }
+  return headers;
+}
+
+async function fetchOne(baseUrl: string, ep: Endpoint, config: MigrationConfig, timeout: number): Promise<SideResult> {
+  const path = substitutePath(ep.path, config.pathSubstitutions);
+  const url = baseUrl.replace(/\/+$/, '') + path;
+  const start = Date.now();
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeout);
+  try {
+    const resp = await fetch(url, {
+      method: ep.method,
+      headers: buildHeaders(config),
+      signal: ctrl.signal,
+    });
+    const text = await resp.text();
+    let bodyJson: any = undefined;
+    try { bodyJson = text ? JSON.parse(text) : undefined; } catch {}
+    return {
+      url, status: resp.status, ok: resp.ok,
+      bodyExcerpt: text.slice(0, 4096),
+      bodyJson,
+      durationMs: Date.now() - start,
+    };
+  } catch (e: any) {
+    return {
+      url, status: 0, ok: false,
+      error: e?.name === 'AbortError' ? `timeout after ${timeout}ms` : (e?.message || String(e)),
+      durationMs: Date.now() - start,
+    };
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+// Convert SchemaViolation[] → DiffEntry[] so the UI can show them uniformly.
+function violationsToDiffs(vios: SchemaViolation[]): RunResult['diff'] {
+  return vios.slice(0, 50).map(v => ({
+    jsonPath: v.jsonPath,
+    legacy: v.expected,
+    next: v.actual,
+    reason: v.reason === 'missing-required' ? 'missing-in-next' :
+            v.reason === 'type-mismatch' ? 'type-mismatch' : 'value',
+  }));
+}
+
+export async function runEndpoint(ep: Endpoint, config: MigrationConfig, openApi?: OpenApiDoc | null): Promise<RunResult> {
+  const startedAt = new Date().toISOString();
+  const t0 = Date.now();
+  const mode = config.diffMode || 'exact';
+
+  let legacy: SideResult;
+  let next: SideResult;
+
+  if (mode === 'shape') {
+    // Skip legacy entirely — use a synthesized "n/a" SideResult
+    legacy = { url: '(skipped — shape mode)', status: 0, ok: true, durationMs: 0 };
+    next = await fetchOne(config.next.baseUrl, ep, config, config.healthCheck.newTimeout);
+  } else {
+    [legacy, next] = await Promise.all([
+      fetchOne(config.legacy.baseUrl, ep, config, config.healthCheck.legacyTimeout),
+      fetchOne(config.next.baseUrl, ep, config, config.healthCheck.newTimeout),
+    ]);
+  }
+
+  let match: RunResult['match'] = 'pass';
+  let errorType: string | undefined;
+  let errorMessage: string | undefined;
+  let diffEntries: RunResult['diff'];
+
+  // ── Stubbed: only the new side matters; expect 501 ──
+  if (ep.isStubbed) {
+    if (next.error) {
+      match = 'error'; errorType = 'new-unreachable'; errorMessage = next.error;
+    } else if (next.status === 501) {
+      match = 'stub-ok';
+    } else {
+      match = 'fail'; errorType = 'stub-not-501'; errorMessage = `Expected 501, got ${next.status}`;
+    }
+  }
+  // ── Shape mode: validate new against OpenAPI schema ──
+  else if (mode === 'shape') {
+    if (next.error) {
+      match = 'error'; errorType = 'new-unreachable'; errorMessage = next.error;
+    } else if (!(next.status >= 200 && next.status < 300)) {
+      match = 'fail'; errorType = 'http-status'; errorMessage = `HTTP ${next.status}`;
+    } else {
+      const schema = openApi ? getOpResponseSchema(openApi, ep) : null;
+      if (!schema) {
+        // No schema — treat as smoke pass (endpoint responded 2xx with no body check)
+        match = 'pass';
+      } else {
+        const vios = validateAgainstSchema(next.bodyJson, schema, '$', [], compileIgnore(config.ignorePaths));
+        if (vios.length > 0) {
+          match = 'fail';
+          errorType = 'schema-violation';
+          errorMessage = `${vios.length} schema violations`;
+          diffEntries = violationsToDiffs(vios);
+        }
+      }
+    }
+  }
+  // ── Exact / both: deep-equal both sides + optional schema validation ──
+  else {
+    if (legacy.error || next.error) {
+      match = 'error';
+      errorType = legacy.error ? 'legacy-unreachable' : 'new-unreachable';
+      errorMessage = legacy.error || next.error;
+    } else if (legacy.status !== next.status) {
+      match = 'fail';
+      errorType = 'http-status-mismatch';
+      errorMessage = `legacy=${legacy.status} new=${next.status}`;
+    } else {
+      const d = diff(legacy.bodyJson, next.bodyJson, config.ignorePaths, { sortArrays: true });
+      if (d.length > 0) {
+        match = 'fail';
+        errorType = 'json-diff';
+        errorMessage = `${d.length} differences`;
+        diffEntries = d.slice(0, 50);
+      }
+      // In `both` mode also run schema validation on the new side
+      if (mode === 'both' && openApi) {
+        const schema = getOpResponseSchema(openApi, ep);
+        if (schema) {
+          const vios = validateAgainstSchema(next.bodyJson, schema, '$', [], compileIgnore(config.ignorePaths));
+          if (vios.length > 0 && match === 'pass') {
+            match = 'fail';
+            errorType = 'schema-violation';
+            errorMessage = `${vios.length} schema violations`;
+            diffEntries = violationsToDiffs(vios);
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    endpointId: ep.id,
+    startedAt,
+    durationMs: Date.now() - t0,
+    legacy, next, match,
+    diff: diffEntries,
+    errorType,
+    errorMessage,
+  };
+}
+
+function getOpResponseSchema(openApi: OpenApiDoc, ep: Endpoint): any | null {
+  const op = lookup(openApi, ep.method, ep.path);
+  if (!op) return null;
+  return getResponseSchema(op, openApi);
+}
+
+export async function runEndpoints(eps: Endpoint[], config: MigrationConfig, opts: {
+  concurrency?: number;
+  onProgress?: (done: number, total: number, last: RunResult) => void;
+  projectPath?: string;
+} = {}): Promise<RunResult[]> {
+  const concurrency = Math.max(1, opts.concurrency ?? 4);
+  const results: RunResult[] = [];
+  let done = 0;
+  let i = 0;
+
+  // Load OpenAPI once for the whole batch (shape/both modes)
+  let openApi: OpenApiDoc | null = null;
+  if ((config.diffMode === 'shape' || config.diffMode === 'both') && config.endpointSource.openApiSpec && opts.projectPath) {
+    openApi = loadOpenApi(opts.projectPath, config.endpointSource.openApiSpec);
+  }
+
+  async function worker() {
+    while (true) {
+      const idx = i++;
+      if (idx >= eps.length) return;
+      const r = await runEndpoint(eps[idx], config, openApi);
+      results[idx] = r;
+      done++;
+      opts.onProgress?.(done, eps.length, r);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, eps.length) }, worker));
+  return results;
+}

package/lib/migration/store.ts

@@ -0,0 +1,89 @@
+// Per-project file storage at <project>/.forge/migration/
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import * as YAML from 'yaml';
+import type { Endpoint, MigrationConfig, RunResult, Failure } from './types';
+import { DEFAULT_CONFIG } from './types';
+
+function migrationDir(projectPath: string): string {
+  return join(projectPath, '.forge', 'migration');
+}
+function ensureDir(dir: string) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+// ── Config ──────────────────────────────────────────────
+export function loadConfig(projectPath: string): MigrationConfig {
+  const file = join(migrationDir(projectPath), 'config.yaml');
+  if (!existsSync(file)) return structuredClone(DEFAULT_CONFIG);
+  try {
+    const parsed = YAML.parse(readFileSync(file, 'utf8')) || {};
+    return { ...DEFAULT_CONFIG, ...parsed,
+      auth: { ...DEFAULT_CONFIG.auth, ...(parsed.auth || {}) },
+      healthCheck: { ...DEFAULT_CONFIG.healthCheck, ...(parsed.healthCheck || {}) },
+      endpointSource: { ...DEFAULT_CONFIG.endpointSource, ...(parsed.endpointSource || {}) },
+      pathSubstitutions: { ...DEFAULT_CONFIG.pathSubstitutions, ...(parsed.pathSubstitutions || {}) },
+    };
+  } catch {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+}
+
+export function saveConfig(projectPath: string, config: MigrationConfig): void {
+  const dir = migrationDir(projectPath);
+  ensureDir(dir);
+  writeFileSync(join(dir, 'config.yaml'), YAML.stringify(config), 'utf8');
+}
+
+// ── Endpoints ───────────────────────────────────────────
+export function loadEndpoints(projectPath: string): Endpoint[] {
+  const file = join(migrationDir(projectPath), 'endpoints.json');
+  if (!existsSync(file)) return [];
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
+}
+
+export function saveEndpoints(projectPath: string, endpoints: Endpoint[]): void {
+  const dir = migrationDir(projectPath);
+  ensureDir(dir);
+  writeFileSync(join(dir, 'endpoints.json'), JSON.stringify(endpoints, null, 2), 'utf8');
+}
+
+// ── Runs ────────────────────────────────────────────────
+export function saveRun(projectPath: string, results: RunResult[]): string {
+  const runsDir = join(migrationDir(projectPath), 'runs');
+  ensureDir(runsDir);
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = join(runsDir, `${ts}.json`);
+  writeFileSync(file, JSON.stringify(results, null, 2), 'utf8');
+  return file;
+}
+
+export function listRuns(projectPath: string): { name: string; path: string; mtime: number }[] {
+  const runsDir = join(migrationDir(projectPath), 'runs');
+  if (!existsSync(runsDir)) return [];
+  return readdirSync(runsDir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const path = join(runsDir, f);
+      return { name: f, path, mtime: 0 };
+    });
+}
+
+export function loadRun(file: string): RunResult[] {
+  if (!existsSync(file)) return [];
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
+}
+
+// ── Failures ────────────────────────────────────────────
+export function saveFailures(projectPath: string, failures: Failure[]): void {
+  const dir = join(migrationDir(projectPath), 'failures');
+  ensureDir(dir);
+  writeFileSync(join(dir, 'current.json'), JSON.stringify(failures, null, 2), 'utf8');
+}
+
+export function loadFailures(projectPath: string): Failure[] {
+  const file = join(migrationDir(projectPath), 'failures', 'current.json');
+  if (!existsSync(file)) return [];
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
+}

package/lib/migration/types.ts

@@ -0,0 +1,115 @@
+// Migration Cockpit types — API parity testing for legacy → new module migrations.
+
+export type EndpointStatus = 'pending' | 'in-progress' | 'migrated' | 'tested' | 'skip' | 'defer';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+export interface Endpoint {
+  id: string;                        // stable hash of `${method} ${path}`
+  controller: string;                // tag from OpenAPI or controller name from doc
+  file?: string;                     // legacy or migrated file path
+  method: HttpMethod;
+  path: string;                      // raw path with `{id}` style placeholders
+  status: EndpointStatus;
+  expectedHttpStatus: number;        // 200 normally, 501 for stubbed
+  isStubbed: boolean;
+  source: string;                    // primary source (OpenAPI / doc file)
+  notes?: string;
+  acceptance?: string[];
+  // OpenAPI cross-reference (when OpenAPI is the primary source)
+  operationId?: string;
+  tag?: string;
+  summary?: string;
+  hasResponseSchema?: boolean;
+  // Migration doc cross-reference
+  docFile?: string;                  // docs/migration/<X>.java.md if matched
+}
+
+export interface RunResult {
+  endpointId: string;
+  startedAt: string;
+  durationMs: number;
+  legacy: SideResult;
+  next: SideResult;
+  match: 'pass' | 'fail' | 'stub-ok' | 'error';
+  diff?: DiffEntry[];
+  errorType?: string;
+  errorMessage?: string;
+}
+
+export interface SideResult {
+  url: string;
+  status: number;
+  ok: boolean;
+  bodyExcerpt?: string;
+  bodyJson?: any;
+  error?: string;
+  durationMs: number;
+}
+
+export interface DiffEntry {
+  jsonPath: string;
+  legacy: any;
+  next: any;
+  reason: 'value' | 'missing-in-next' | 'missing-in-legacy' | 'type-mismatch';
+}
+
+export interface Failure {
+  endpointId: string;
+  controller: string;
+  method: HttpMethod;
+  path: string;
+  errorType: string;                 // e.g. "http-status-mismatch", "json-diff", "exception"
+  errorMessage: string;
+  lastSeenAt: string;
+}
+
+export interface FailureCluster {
+  errorType: string;
+  count: number;
+  controllers: { controller: string; failures: Failure[] }[];
+}
+
+export type DiffMode = 'exact' | 'shape' | 'both';
+
+export interface MigrationConfig {
+  legacy: { baseUrl: string };
+  next: { baseUrl: string; sourceDir?: string };
+  auth: {
+    mode: 'skip' | 'bearer' | 'basic';
+    tokenEnv?: string;
+    username?: string;
+    passwordEnv?: string;
+  };
+  ignorePaths: string[];
+  healthCheck: {
+    legacyTimeout: number;
+    newTimeout: number;
+    skipUnhealthy: boolean;
+  };
+  clusterMode: 'simple' | 'ai';
+  diffMode: DiffMode;                // exact = compare both sides; shape = validate new against schema; both = both
+  endpointSource: {
+    type: 'docs' | 'openapi' | 'source-scan' | 'mixed';
+    primary: string;                 // dir for per-controller docs
+    fallback?: string;               // history file
+    openApiSpec?: string;            // path to OpenAPI 3 JSON (preferred when set)
+  };
+  pathSubstitutions?: Record<string, string>; // {id} → "1" etc
+}
+
+export const DEFAULT_CONFIG: MigrationConfig = {
+  legacy: { baseUrl: 'http://localhost:8080' },
+  next: { baseUrl: 'http://localhost:9090' },
+  auth: { mode: 'skip' },
+  ignorePaths: ['$.timestamp', '$.requestId', '$.traceId'],
+  healthCheck: { legacyTimeout: 2000, newTimeout: 2000, skipUnhealthy: true },
+  clusterMode: 'simple',
+  diffMode: 'shape',
+  endpointSource: {
+    type: 'mixed',
+    primary: 'docs/migration',
+    fallback: 'docs/lead/migration-history.md',
+    openApiSpec: 'docs/fnac-rest-schema-7.6.json',
+  },
+  pathSubstitutions: { id: '1', dbid: '1', ip: '127.0.0.1', mac: '00:00:00:00:00:00' },
+};

package/lib/telegram-standalone.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env -S npx tsx
 /**
  * Standalone Telegram bot process.
  * Runs as a single process — no duplication from Next.js workers.

package/lib/terminal-standalone.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env -S npx tsx
 /**
  * Standalone terminal WebSocket server with tmux-backed persistent sessions.
  * Sessions survive browser close and app restart.

package/lib/workspace-standalone.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env -S npx tsx
 /**
  * Workspace Daemon — standalone process for managing workspace agent orchestrators.
  *

package/middleware.ts

@@ -9,10 +9,12 @@ export function middleware(req: NextRequest) {
 
   const { pathname } = req.nextUrl;
 
-  // Allow auth endpoints and static assets without login
+  // Allow auth endpoints, version probe (used by IDE plugins to detect a live
+  // server before prompting for password), and static assets without login.
   if (
     pathname.startsWith('/login') ||
     pathname.startsWith('/api/auth') ||
+    pathname === '/api/version' ||
     pathname.startsWith('/api/telegram') ||
     (pathname.startsWith('/api/workspace') && (pathname.endsWith('/smith') || pathname === '/api/workspace')) ||
     pathname.startsWith('/_next') ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.46",
+  "version": "0.5.48",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/qa/.forge/agent-context.json

@@ -0,0 +1,6 @@
+{
+  "workspaceId": "656c9e65-9d73-4cb6-a065-60d966e1fc78",
+  "agentId": "qa-1774920510930",
+  "agentLabel": "QA",
+  "forgePort": 8403
+}

package/qa/.forge/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "forge": {
+      "type": "sse",
+      "url": "http://localhost:8406/sse?workspaceId=656c9e65-9d73-4cb6-a065-60d966e1fc78&agentId=qa-1774920510930"
+    }
+  }
+}