@aion0/forge 0.5.48 → 0.5.50

package/lib/task-manager.ts

@@ -119,6 +119,116 @@ export function listTasks(status?: TaskStatus): Task[] {
   return rows.map(rowToTask);
 }
 
+// Slim list — omits the heavy fields (log / git_diff / result_summary) so the
+// task list view doesn't pull megabytes of JSON for tasks with long sessions.
+// Callers that need the full body should fetch /api/tasks/[id] on demand.
+export function listTasksLite(status?: TaskStatus): Task[] {
+  const SLIM_COLS = `
+    id, project_name, project_path, prompt, mode, status, priority,
+    conversation_id, watch_config, git_branch, cost_usd, error, agent,
+    created_at, started_at, completed_at, scheduled_at,
+    length(log) AS log_size,
+    CASE WHEN result_summary IS NULL THEN NULL ELSE substr(result_summary, 1, 1024) END AS result_summary,
+    CASE WHEN git_diff IS NULL THEN 0 ELSE 1 END AS has_git_diff
+  `;
+  let query = `SELECT ${SLIM_COLS} FROM tasks`;
+  const params: string[] = [];
+  if (status) {
+    query += ' WHERE status = ?';
+    params.push(status);
+  }
+  query += ' ORDER BY created_at DESC';
+  const rows = db().prepare(query).all(...params) as any[];
+  return rows.map(r => rowToLiteTask(r));
+}
+
+// Slice the log without parsing the whole JSON in JS — sqlite JSON1's
+// json_each walks the array and we LIMIT/OFFSET in SQL. For a 1.6 MB log
+// with 238 entries this returns just the requested ~100 in milliseconds.
+export function getTaskLogSlice(id: string, opts: { offset?: number; limit?: number; truncate?: number } = {}):
+  { entries: (TaskLogEntry & { _truncated?: number; _index?: number })[]; total: number } {
+  const totalRow = db().prepare(
+    `SELECT COALESCE(json_array_length(log), 0) AS n FROM tasks WHERE id = ?`
+  ).get(id) as { n: number } | undefined;
+  const total = totalRow?.n ?? 0;
+  if (total === 0) return { entries: [], total: 0 };
+
+  const limit = Math.max(1, Math.min(opts.limit ?? 200, 2000));
+  const offset = Math.max(0, opts.offset ?? Math.max(0, total - limit));
+  const truncate = opts.truncate ?? 8192;   // per-entry content cap; 0 = no cap
+  const rows = db().prepare(
+    `SELECT json_each.key AS idx, value FROM tasks, json_each(tasks.log)
+     WHERE tasks.id = ?
+     ORDER BY json_each.key
+     LIMIT ? OFFSET ?`
+  ).all(id, limit, offset) as { idx: number; value: string }[];
+
+  const entries = rows.map(r => {
+    let entry: TaskLogEntry & { _truncated?: number; _index?: number };
+    try { entry = JSON.parse(r.value); }
+    catch { entry = { type: 'system', content: '<unparseable entry>' } as any; }
+    entry._index = r.idx;
+    if (truncate > 0 && typeof entry.content === 'string' && entry.content.length > truncate) {
+      const fullLen = entry.content.length;
+      entry.content = entry.content.slice(0, truncate);
+      entry._truncated = fullLen;
+    }
+    return entry;
+  });
+  return { entries, total };
+}
+
+// Single entry by index — used to "show full" a previously truncated entry.
+export function getTaskLogEntry(id: string, index: number): TaskLogEntry | null {
+  const row = db().prepare(
+    `SELECT value FROM tasks, json_each(tasks.log)
+     WHERE tasks.id = ? AND json_each.key = ?`
+  ).get(id, index) as { value: string } | undefined;
+  if (!row) return null;
+  try { return JSON.parse(row.value); } catch { return null; }
+}
+
+// Fetch only the heavy fields by id (used when the client needs them after
+// having gotten the lite list earlier).
+export function getTaskBody(id: string): { resultSummary?: string; gitDiff?: string; error?: string } | null {
+  const row = db().prepare(
+    `SELECT result_summary, git_diff, error FROM tasks WHERE id = ?`
+  ).get(id) as any;
+  if (!row) return null;
+  return {
+    resultSummary: row.result_summary || undefined,
+    gitDiff: row.git_diff || undefined,
+    error: row.error || undefined,
+  };
+}
+
+function rowToLiteTask(row: any): Task {
+  return {
+    id: row.id,
+    projectName: row.project_name,
+    projectPath: row.project_path,
+    prompt: row.prompt,
+    mode: row.mode || 'prompt',
+    status: row.status,
+    priority: row.priority,
+    conversationId: row.conversation_id || undefined,
+    watchConfig: row.watch_config ? JSON.parse(row.watch_config) : undefined,
+    log: [],                                              // slim — fetch detail separately
+    resultSummary: row.result_summary || undefined,      // first 1KB only
+    gitDiff: undefined,                                   // not loaded
+    gitBranch: row.git_branch || undefined,
+    costUSD: row.cost_usd || undefined,
+    error: row.error || undefined,
+    createdAt: toIsoUTC(row.created_at) ?? row.created_at,
+    startedAt: toIsoUTC(row.started_at) ?? undefined,
+    completedAt: toIsoUTC(row.completed_at) ?? undefined,
+    scheduledAt: toIsoUTC(row.scheduled_at) ?? undefined,
+    agent: row.agent || undefined,
+    logSize: row.log_size || 0,
+    hasGitDiff: !!row.has_git_diff,
+  } as Task;
+}
+
 export function cancelTask(id: string): boolean {
   const task = getTask(id);
   if (!task) return false;

package/lib/terminal-standalone.ts

@@ -209,6 +209,7 @@ function cleanupOrphanedSessions() {
   for (const s of sessions) {
     if (s.attached) continue;
     if (s.name.startsWith(`${SESSION_PREFIX}forge-`)) continue; // workspace agent session — managed by orchestrator
+    if (s.name.startsWith('mw-craft-')) continue;               // craft session — managed by craft loader
     if (knownSessions.has(s.name)) continue; // saved in terminal state — preserve
     const clients = sessionClients.get(s.name)?.size ?? 0;
     if (clients === 0) {

package/next.config.ts

@@ -10,7 +10,7 @@ const localIPs = Object.values(networkInterfaces())
   .map(i => i!.address);
 
 const nextConfig: NextConfig = {
-  serverExternalPackages: ['better-sqlite3'],
+  serverExternalPackages: ['better-sqlite3', 'esbuild'],
   allowedDevOrigins: localIPs,
   async rewrites() {
     return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.48",
+  "version": "0.5.50",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -41,6 +41,7 @@
     "@xyflow/react": "^12.10.1",
     "ai": "^6.0.116",
     "better-sqlite3": "^12.6.2",
+    "esbuild": "^0.27.3",
     "next": "^16.2.1",
     "next-auth": "5.0.0-beta.30",
     "node-pty": "1.0.0",

package/src/types/index.ts

@@ -109,6 +109,10 @@ export interface Task {
   startedAt?: string;
   completedAt?: string;
   scheduledAt?: string;
+  agent?: string;
+  // Lite-list metadata: present in /api/tasks responses, undefined in detail
+  logSize?: number;
+  hasGitDiff?: boolean;
 }
 
 export interface TaskLogEntry {
@@ -117,6 +121,9 @@ export interface TaskLogEntry {
   content: string;
   tool?: string;
   timestamp: string;
+  // Slice-API metadata (server adds these when serving a truncated chunk)
+  _index?: number;
+  _truncated?: number;   // original content.length before truncation
 }
 
 export interface AppConfig {

package/tsconfig.json

@@ -25,6 +25,12 @@
     "paths": {
       "@/*": [
         "./*"
+      ],
+      "@forge/craft": [
+        "./lib/craft-sdk/client.tsx"
+      ],
+      "@forge/craft/server": [
+        "./lib/craft-sdk/server.ts"
       ]
     }
   },

package/app/api/migration/config/route.ts

@@ -1,19 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadConfig, saveConfig } from '@/lib/migration/store';
-import type { MigrationConfig } from '@/lib/migration/types';
-
-// GET /api/migration/config?projectPath=...
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  return NextResponse.json(loadConfig(projectPath));
-}
-
-// POST /api/migration/config — body: { projectPath, config }
-export async function POST(req: Request) {
-  const { projectPath, config } = await req.json() as { projectPath: string; config: MigrationConfig };
-  if (!projectPath || !config) return NextResponse.json({ error: 'projectPath + config required' }, { status: 400 });
-  saveConfig(projectPath, config);
-  return NextResponse.json({ ok: true });
-}

package/app/api/migration/discover/route.ts

@@ -1,26 +0,0 @@
-import { NextResponse } from 'next/server';
-import { discoverEndpoints } from '@/lib/migration/discoverer';
-import { loadConfig, saveEndpoints, loadEndpoints } from '@/lib/migration/store';
-
-// GET /api/migration/discover?projectPath=...  → return cached endpoints
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  return NextResponse.json({ endpoints: loadEndpoints(projectPath) });
-}
-
-// POST /api/migration/discover — body: { projectPath } → re-scan docs
-export async function POST(req: Request) {
-  const { projectPath } = await req.json() as { projectPath: string };
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  const config = loadConfig(projectPath);
-  const result = discoverEndpoints(projectPath, config);
-  saveEndpoints(projectPath, result.endpoints);
-  return NextResponse.json({
-    endpoints: result.endpoints,
-    warnings: result.warnings,
-    sources: result.sources,
-    total: result.endpoints.length,
-  });
-}

package/app/api/migration/failures/route.ts

@@ -1,35 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadFailures } from '@/lib/migration/store';
-import type { Failure, FailureCluster } from '@/lib/migration/types';
-
-function cluster(failures: Failure[]): FailureCluster[] {
-  const byType = new Map<string, Map<string, Failure[]>>();
-  for (const f of failures) {
-    let m = byType.get(f.errorType);
-    if (!m) { m = new Map(); byType.set(f.errorType, m); }
-    let arr = m.get(f.controller);
-    if (!arr) { arr = []; m.set(f.controller, arr); }
-    arr.push(f);
-  }
-  const out: FailureCluster[] = [];
-  for (const [errorType, ctrlMap] of byType) {
-    const controllers = [...ctrlMap.entries()].map(([controller, failures]) => ({ controller, failures }));
-    controllers.sort((a, b) => b.failures.length - a.failures.length);
-    out.push({
-      errorType,
-      count: controllers.reduce((sum, c) => sum + c.failures.length, 0),
-      controllers,
-    });
-  }
-  out.sort((a, b) => b.count - a.count);
-  return out;
-}
-
-// GET /api/migration/failures?projectPath=...
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  const failures = loadFailures(projectPath);
-  return NextResponse.json({ failures, clusters: cluster(failures) });
-}

package/app/api/migration/fix/route.ts

@@ -1,82 +0,0 @@
-import { NextResponse } from 'next/server';
-import { execSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { writeFileSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { loadEndpoints } from '@/lib/migration/store';
-import { createTask } from '@/lib/task-manager';
-import type { Failure } from '@/lib/migration/types';
-
-interface FixRequest {
-  projectPath: string;
-  projectName?: string;
-  mode: 'inject' | 'task';
-  endpointIds?: string[];           // single or batch
-  failures?: Failure[];             // optional pre-clustered failures
-  sessionName?: string;             // tmux session for inject mode
-  customPrompt?: string;
-}
-
-function buildPrompt(eps: any[], failures?: Failure[], custom?: string): string {
-  const lines: string[] = [];
-  lines.push('# API parity fix request');
-  lines.push('');
-  lines.push('The following endpoints in the new web-server module produce results that differ from the legacy module. The legacy code MUST NOT be changed — fix the new module so its output matches.');
-  lines.push('');
-  if (failures && failures.length > 0) {
-    lines.push('## Failures');
-    for (const f of failures) {
-      lines.push(`- \`${f.method} ${f.path}\` (${f.controller}) — ${f.errorType}: ${f.errorMessage}`);
-    }
-  } else if (eps.length > 0) {
-    lines.push('## Endpoints');
-    for (const e of eps) {
-      lines.push(`- \`${e.method} ${e.path}\` — controller: ${e.controller}, status: ${e.status}${e.notes ? `, notes: ${e.notes}` : ''}`);
-    }
-  }
-  lines.push('');
-  lines.push('## Approach');
-  lines.push('1. Read .forge/migration/runs/*.json for the latest run output and diffs.');
-  lines.push('2. Identify the controller class in the new web-server module.');
-  lines.push('3. Compare to the legacy implementation — focus on response shape, status codes, field names.');
-  lines.push('4. Apply minimal fix; do not change unrelated code.');
-  lines.push('5. Re-run the migration cockpit batch test for these endpoints.');
-  if (custom) {
-    lines.push('');
-    lines.push('## Additional context');
-    lines.push(custom);
-  }
-  return lines.join('\n');
-}
-
-export async function POST(req: Request) {
-  const body = await req.json() as FixRequest;
-  const { projectPath, projectName, mode, endpointIds, failures, sessionName, customPrompt } = body;
-  if (!projectPath || !mode) return NextResponse.json({ error: 'projectPath + mode required' }, { status: 400 });
-
-  const all = loadEndpoints(projectPath);
-  const ids = new Set(endpointIds || []);
-  const eps = ids.size > 0 ? all.filter(e => ids.has(e.id)) : [];
-  const prompt = buildPrompt(eps, failures, customPrompt);
-
-  if (mode === 'task') {
-    const name = projectName || projectPath.split('/').filter(Boolean).pop() || 'project';
-    const task = createTask({ projectName: name, projectPath, prompt });
-    return NextResponse.json({ ok: true, mode: 'task', taskId: task.id });
-  }
-
-  if (mode === 'inject') {
-    if (!sessionName) return NextResponse.json({ error: 'sessionName required for inject mode' }, { status: 400 });
-    try {
-      const buf = join(tmpdir(), `forge-migration-fix-${Date.now()}.txt`);
-      writeFileSync(buf, prompt);
-      execSync(`tmux load-buffer -t "${sessionName}" "${buf}" && tmux paste-buffer -t "${sessionName}" && sleep 0.2 && tmux send-keys -t "${sessionName}" Enter`, { timeout: 5000 });
-      try { unlinkSync(buf); } catch {}
-      return NextResponse.json({ ok: true, mode: 'inject', sessionName });
-    } catch (e: any) {
-      return NextResponse.json({ error: e?.message || String(e) }, { status: 500 });
-    }
-  }
-
-  return NextResponse.json({ error: 'invalid mode' }, { status: 400 });
-}

package/app/api/migration/run/route.ts

@@ -1,22 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadConfig, loadEndpoints, saveRun } from '@/lib/migration/store';
-import { runEndpoint } from '@/lib/migration/runner';
-import { loadOpenApi } from '@/lib/migration/openapi';
-
-// POST /api/migration/run — body: { projectPath, endpointId }
-export async function POST(req: Request) {
-  const { projectPath, endpointId } = await req.json() as { projectPath: string; endpointId: string };
-  if (!projectPath || !endpointId) return NextResponse.json({ error: 'projectPath + endpointId required' }, { status: 400 });
-
-  const eps = loadEndpoints(projectPath);
-  const ep = eps.find(e => e.id === endpointId);
-  if (!ep) return NextResponse.json({ error: 'endpoint not found' }, { status: 404 });
-
-  const config = loadConfig(projectPath);
-  const openApi = config.endpointSource.openApiSpec
-    ? loadOpenApi(projectPath, config.endpointSource.openApiSpec)
-    : null;
-  const result = await runEndpoint(ep, config, openApi);
-  saveRun(projectPath, [result]);
-  return NextResponse.json(result);
-}

package/app/api/migration/run-batch/route.ts

@@ -1,86 +0,0 @@
-import { loadConfig, loadEndpoints, saveRun, saveFailures } from '@/lib/migration/store';
-import { runEndpoints } from '@/lib/migration/runner';
-import type { Endpoint, RunResult, Failure } from '@/lib/migration/types';
-
-export const dynamic = 'force-dynamic';
-
-// POST /api/migration/run-batch — body: { projectPath, endpointIds?, onlyStatus?, concurrency? }
-// Returns SSE stream with progress and final result.
-export async function POST(req: Request) {
-  const { projectPath, endpointIds, onlyStatus, concurrency } = await req.json() as {
-    projectPath: string;
-    endpointIds?: string[];
-    onlyStatus?: string[];
-    concurrency?: number;
-  };
-  if (!projectPath) return new Response(JSON.stringify({ error: 'projectPath required' }), { status: 400 });
-
-  const config = loadConfig(projectPath);
-  const all = loadEndpoints(projectPath);
-  let toRun: Endpoint[] = all;
-  if (endpointIds && endpointIds.length > 0) {
-    const ids = new Set(endpointIds);
-    toRun = all.filter(e => ids.has(e.id));
-  } else if (onlyStatus && onlyStatus.length > 0) {
-    const s = new Set(onlyStatus);
-    toRun = all.filter(e => s.has(e.status));
-  }
-
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    async start(controller) {
-      const send = (event: string, data: any) => {
-        controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
-      };
-      send('start', { total: toRun.length });
-
-      try {
-        const results = await runEndpoints(toRun, config, {
-          concurrency: concurrency ?? 4,
-          projectPath,
-          onProgress: (done, total, last) => {
-            send('progress', { done, total, result: last });
-          },
-        });
-        saveRun(projectPath, results);
-
-        const failures: Failure[] = results
-          .filter(r => r.match === 'fail' || r.match === 'error')
-          .map(r => {
-            const ep = toRun.find(e => e.id === r.endpointId)!;
-            return {
-              endpointId: r.endpointId,
-              controller: ep.controller,
-              method: ep.method,
-              path: ep.path,
-              errorType: r.errorType || 'unknown',
-              errorMessage: r.errorMessage || '',
-              lastSeenAt: r.startedAt,
-            };
-          });
-        saveFailures(projectPath, failures);
-
-        send('done', {
-          total: results.length,
-          pass: results.filter(r => r.match === 'pass').length,
-          fail: results.filter(r => r.match === 'fail').length,
-          stubOk: results.filter(r => r.match === 'stub-ok').length,
-          error: results.filter(r => r.match === 'error').length,
-          failures: failures.length,
-        });
-      } catch (e: any) {
-        send('error', { message: e?.message || String(e) });
-      } finally {
-        controller.close();
-      }
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
-  });
-}