forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/agent-fabric/local-task-server.ts

@@ -0,0 +1,374 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import type { AddressInfo } from "node:net";
+import { dirname } from "node:path";
+import { MANAGED_RUN_ACTIONS, ManagedRunError, type ManagedRunAction } from "./managed-run-contract.ts";
+import type { ManagedRunService } from "./managed-run-service.ts";
+import { AttachedTaskService } from "./attached-task-service.ts";
+import { AttachedTaskError } from "./attached-task-contract.ts";
+import { AgentFabricError, isAgentFabricError } from "./errors.ts";
+import { LocalTaskService, type LocalTaskStatus } from "./local-task-service.ts";
+import type { LocalMemoryEntry } from "./local-intelligence.ts";
+import { localFabricPath } from "./local-paths.ts";
+import { applyFabricProfile } from "./project-profile.ts";
+import { ProgramRunService, PROGRAM_RUN_ACTIONS, type ProgramRunAction } from "./program-service.ts";
+import { ProgramError } from "./program-contract.ts";
+
+const MAX_REQUEST_BYTES = 40 * 1024;
+const ENDPOINT_FILENAME = "owner-endpoint.json";
+
+export { MANAGED_RUN_ACTIONS, type ManagedRunAction };
+export { PROGRAM_RUN_ACTIONS, type ProgramRunAction };
+export function isProgramRunAction(action: unknown): action is ProgramRunAction {
+  return typeof action === "string" && (PROGRAM_RUN_ACTIONS as readonly string[]).includes(action);
+}
+export function isManagedRunAction(action: unknown): action is ManagedRunAction {
+  return typeof action === "string" && (MANAGED_RUN_ACTIONS as readonly string[]).includes(action);
+}
+
+export const ATTACHED_TASK_ACTIONS = ["attached-propose", "attached-status", "attached-context", "attached-attach", "attached-assign", "attached-attempt", "attached-prepare-review", "attached-submit-review", "attached-record-verification", "attached-cover", "workflow-plan", "workflow-next", "workflow-claim", "workflow-result", "workflow-replan", "workflow-reconcile", "workflow-recover"] as const;
+export type AttachedTaskAction = typeof ATTACHED_TASK_ACTIONS[number];
+export function isAttachedTaskAction(action: unknown): action is AttachedTaskAction {
+  return typeof action === "string" && (ATTACHED_TASK_ACTIONS as readonly string[]).includes(action);
+}
+export function isAttachedTaskRead(action: AttachedTaskAction): boolean {
+  return action === "attached-status" || action === "attached-context" || action === "workflow-next";
+}
+
+export type LocalTaskAction = "propose" | "status" | "evidence" | "review" | "run" | "cancel" | "reconcile" | "verify" | "recover-verification" | "review-result";
+export type LocalMemoryAction = "memory-add" | "memory-list" | "memory-delete";
+export type LocalMemoryResult = LocalMemoryEntry | readonly LocalMemoryEntry[] | { deleted: boolean };
+
+interface OwnerEndpoint {
+  schemaVersion: 1;
+  repositoryRoot: string;
+  pid: number;
+  port: number;
+  token: string;
+}
+
+function endpointPath(repositoryRoot: string): string {
+  return localFabricPath(repositoryRoot, ENDPOINT_FILENAME);
+}
+
+function processIsAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+function readEndpoint(repositoryRoot: string, pruneStale = true): OwnerEndpoint | null {
+  const path = endpointPath(repositoryRoot);
+  if (!existsSync(path)) return null;
+  if (lstatSync(path).isSymbolicLink()) {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner endpoint is a symbolic link");
+  }
+  const bytes = readFileSync(path);
+  if (bytes.length > 2_048) throw new AgentFabricError("AF_INVALID_STATE", "Local owner endpoint is oversized");
+  let value: unknown;
+  try { value = JSON.parse(bytes.toString("utf8")); } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner endpoint is invalid JSON");
+  }
+  const item = value as Partial<OwnerEndpoint>;
+  if (!item || item.schemaVersion !== 1 || item.repositoryRoot !== repositoryRoot ||
+      !Number.isSafeInteger(item.pid) || (item.pid ?? 0) <= 0 ||
+      !Number.isSafeInteger(item.port) || (item.port ?? 0) < 1 || (item.port ?? 0) > 65535 ||
+      typeof item.token !== "string" || !/^[0-9a-f]{64}$/u.test(item.token)) {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner endpoint is inconsistent");
+  }
+  if (!processIsAlive(item.pid!)) {
+    // A killed owner cannot hold PGlite. Remove only the exact endpoint bytes
+    // read above; a replacement means another owner is starting.
+    if (pruneStale && readFileSync(path).equals(bytes)) unlinkSync(path);
+    return null;
+  }
+  return item as OwnerEndpoint;
+}
+
+function authorized(request: IncomingMessage, endpoint: OwnerEndpoint): boolean {
+  const supplied = request.headers.authorization;
+  const expected = `Bearer ${endpoint.token}`;
+  return request.headers.origin === undefined &&
+    request.headers.host === `127.0.0.1:${endpoint.port}` &&
+    typeof supplied === "string" && supplied.length === expected.length &&
+    timingSafeEqual(Buffer.from(supplied), Buffer.from(expected));
+}
+
+async function readBody(request: IncomingMessage): Promise<Record<string, unknown>> {
+  if (request.headers["content-type"] !== "application/json") {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner request must be JSON");
+  }
+  let bytes = 0;
+  const chunks: Buffer[] = [];
+  for await (const chunk of request) {
+    const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    bytes += part.length;
+    if (bytes > MAX_REQUEST_BYTES) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Local owner request exceeds 40 KiB");
+    }
+    chunks.push(part);
+  }
+  let value: unknown;
+  try { value = JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner request is invalid JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner request is not an object");
+  }
+  return value as Record<string, unknown>;
+}
+
+async function dispatch(service: LocalTaskService, action: LocalTaskAction, request: Record<string, unknown>): Promise<LocalTaskStatus> {
+  const keys = Object.keys(request).sort().join(",");
+  if (action === "propose") {
+    if (keys !== "proposal") throw new AgentFabricError("AF_INVALID_STATE", "Proposal request has unexpected fields");
+    return service.propose(request.proposal);
+  }
+  if (keys !== "taskId" || typeof request.taskId !== "string") {
+    throw new AgentFabricError("AF_INVALID_STATE", "Task request requires only taskId");
+  }
+  if (action === "status") return service.status(request.taskId);
+  if (action === "evidence") return service.evidence(request.taskId);
+  if (action === "review") return service.review(request.taskId);
+  if (action === "run") return service.run(request.taskId);
+  if (action === "cancel") return service.cancel(request.taskId);
+  if (action === "reconcile") return service.reconcile(request.taskId);
+  if (action === "verify") return service.verify(request.taskId);
+  if (action === "recover-verification") return service.recoverVerification(request.taskId);
+  return service.reviewResult(request.taskId);
+}
+
+function dispatchMemory(service: LocalTaskService, action: LocalMemoryAction, request: Record<string, unknown>): LocalMemoryResult {
+  if (action === "memory-add") return service.rememberMemory(request);
+  if (action === "memory-list") return service.listMemory(request);
+  if (Object.keys(request).join(",") !== "id") {
+    throw new AgentFabricError("AF_INVALID_STATE", "Memory deletion requires only id");
+  }
+  return { deleted: service.forgetMemory(request.id) };
+}
+
+export interface LocalTaskOwnerServer {
+  repositoryRoot: string;
+  port: number;
+  close(): Promise<void>;
+}
+
+/** Authenticated and read-only. Endpoint secrets never leave this module. */
+export async function probeLocalOwner(repositoryRoot: string): Promise<{ repositoryRoot: string; pid: number; port: number } | null> {
+  const endpoint = readEndpoint(realpathSync(repositoryRoot), false);
+  if (!endpoint) return null;
+  const request = (action: string, body: object) => fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, {
+    method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(2000),
+  });
+  const response = await request("owner-health", {});
+  if (response.ok) {
+    const health = await response.json() as { ok?: boolean; repositoryRoot?: string; pid?: number };
+    if (!health.ok || health.repositoryRoot !== endpoint.repositoryRoot || health.pid !== endpoint.pid) throw new Error("Agent Fabric owner identity does not match its endpoint");
+  } else {
+    // Owners started before portable integration already expose this read-only action.
+    if (response.status !== 404) throw new Error("Agent Fabric owner health check failed");
+    const legacy = await request("run-status", { runId: "fabric-owner-health-probe" });
+    const value = await legacy.json() as { code?: string };
+    if (legacy.status !== 400 || value.code !== "AF_RUN_NOT_FOUND") throw new Error("Agent Fabric owner cannot be authenticated; inspect it before restarting");
+  }
+  return { repositoryRoot: endpoint.repositoryRoot, pid: endpoint.pid, port: endpoint.port };
+}
+
+/** One PGlite owner shared by CLI clients and the read/proposal MCP adapter. */
+export async function serveLocalTasks(
+  repositoryRoot: string,
+  suppliedService?: LocalTaskService,
+): Promise<LocalTaskOwnerServer> {
+  const service = suppliedService ?? await LocalTaskService.open(repositoryRoot);
+  const root = service.repositoryRoot;
+  if (root !== realpathSync(repositoryRoot)) {
+    if (!suppliedService) await service.close();
+    throw new AgentFabricError("AF_INVALID_STATE", "Local owner service belongs to another repository");
+  }
+  const path = endpointPath(root);
+  let listener: ReturnType<typeof createServer> | undefined;
+  let published: OwnerEndpoint | undefined;
+  let attachedService: AttachedTaskService | undefined;
+  let managedService: ManagedRunService | undefined;
+  let programService: ProgramRunService | undefined;
+  try {
+    if (readEndpoint(root)) {
+      throw new AgentFabricError("AF_CONFLICT", "A local Agent Fabric owner is already running");
+    }
+    attachedService = await AttachedTaskService.open(root);
+    const { ManagedRunService: ManagedService } = await import("./managed-run-service.ts");
+    managedService = await ManagedService.open(root);
+    programService = await ProgramRunService.open(root);
+    const token = randomBytes(32).toString("hex");
+    listener = createServer((request, response: ServerResponse) => {
+      response.setHeader("Content-Type", "application/json; charset=utf-8");
+      response.setHeader("Cache-Control", "no-store");
+      if (!published || !authorized(request, published)) {
+        response.writeHead(403).end(JSON.stringify({ ok: false, error: "unauthorized" }));
+        return;
+      }
+      if (request.method === "POST" && request.url === "/v1/owner-health") {
+        response.writeHead(200).end(JSON.stringify({ ok: true, repositoryRoot: root, pid: process.pid }));
+        return;
+      }
+      const action = request.url?.slice("/v1/".length) as LocalTaskAction | LocalMemoryAction | AttachedTaskAction | ManagedRunAction | ProgramRunAction;
+      if (request.method !== "POST" || !request.url?.startsWith("/v1/") ||
+          (!isProgramRunAction(action) && !isAttachedTaskAction(action) && !isManagedRunAction(action) && !["propose", "status", "evidence", "review", "run", "cancel", "reconcile", "verify", "recover-verification", "review-result", "memory-add", "memory-list", "memory-delete"].includes(action))) {
+        response.writeHead(404).end(JSON.stringify({ ok: false, error: "unknown_action" }));
+        return;
+      }
+      void readBody(request).then(async (body) => {
+        if (isProgramRunAction(action)) return { status: await programService!.execute(action, body) };
+        if (isManagedRunAction(action)) return { status: await managedService!.execute(action, body) };
+        if (isAttachedTaskAction(action)) return { status: await attachedService!.execute(action as Parameters<AttachedTaskService["execute"]>[0], body) };
+        if (action.startsWith("memory-")) return { memory: dispatchMemory(service, action as LocalMemoryAction, body) };
+        return { status: await dispatch(service, action as LocalTaskAction, body) };
+      }).then((result) => {
+        if (!response.destroyed) response.writeHead(200).end(JSON.stringify({ ok: true, ...result }));
+      }).catch((error: unknown) => {
+        if (!response.destroyed) response.writeHead(isAgentFabricError(error) || error instanceof AttachedTaskError || error instanceof ManagedRunError || error instanceof ProgramError ? 400 : 500).end(JSON.stringify({
+          ok: false, code: isAgentFabricError(error) || error instanceof AttachedTaskError || error instanceof ManagedRunError || error instanceof ProgramError ? error.code : "AF_INVALID_STATE",
+          error: error instanceof Error ? error.message : "Local owner request failed",
+        }));
+      });
+    });
+    await new Promise<void>((resolve, reject) => {
+      listener!.once("error", reject);
+      listener!.listen(0, "127.0.0.1", resolve);
+    });
+    const port = (listener.address() as AddressInfo).port;
+    published = { schemaVersion: 1, repositoryRoot: root, pid: process.pid, port, token };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(published), { flag: "wx", mode: 0o600 });
+    let closed = false;
+    return {
+      repositoryRoot: root, port,
+      async close() {
+        if (closed) return;
+        closed = true;
+        await programService?.close();
+        try { await managedService?.close(); }
+        finally {
+          await new Promise<void>((resolve) => listener!.close(() => resolve()));
+          if (existsSync(path) && readFileSync(path, "utf8") === JSON.stringify(published)) unlinkSync(path);
+          try { await attachedService?.close(); }
+          finally { if (!suppliedService) await service.close(); }
+        }
+      },
+    };
+  } catch (error) {
+    await programService?.close();
+    try { await managedService?.close(); }
+    finally {
+      if (listener?.listening) await new Promise<void>((resolve) => listener!.close(() => resolve()));
+      try { await attachedService?.close(); }
+      finally { if (!suppliedService) await service.close(); }
+    }
+    throw error;
+  }
+}
+
+export async function requestLocalMemory(repositoryRoot: string, action: LocalMemoryAction,
+  body: Record<string, unknown>): Promise<LocalMemoryResult | null> {
+  const endpoint = readEndpoint(repositoryRoot);
+  if (!endpoint) return null;
+  let response: Response;
+  try {
+    response = await fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, {
+      method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(10_000),
+    });
+  } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local Agent Fabric owner is unreachable; restart it before retrying");
+  }
+  if (response.status >= 300) {
+    const result = await response.json().catch(() => ({})) as { error?: string };
+    throw new AgentFabricError("AF_INVALID_STATE", result.error ?? "Local memory request failed");
+  }
+  const result = await response.json() as { ok?: boolean; memory?: LocalMemoryResult };
+  if (!result.ok || result.memory === undefined) throw new AgentFabricError("AF_INVALID_STATE", "Local owner returned no memory result");
+  return result.memory;
+}
+
+export async function requestLocalTask(
+  repositoryRoot: string,
+  action: LocalTaskAction,
+  body: Record<string, unknown>,
+): Promise<LocalTaskStatus | null> {
+  const endpoint = readEndpoint(repositoryRoot);
+  if (!endpoint) return null;
+  let response: Response;
+  try {
+    response = await fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, {
+      method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body), redirect: "manual",
+      signal: AbortSignal.timeout(action === "run" ? 130_000 : action === "verify" ? 250_000 :
+        action === "review" || action === "review-result" || action === "recover-verification" ? 310_000 : 10_000),
+    });
+  } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local Agent Fabric owner is unreachable; restart it before retrying");
+  }
+  if (response.status >= 300) {
+    const result = await response.json().catch(() => ({})) as { code?: string; error?: string };
+    throw new AgentFabricError("AF_INVALID_STATE", result.error ?? "Local owner request failed");
+  }
+  const result = await response.json() as { ok?: boolean; status?: LocalTaskStatus };
+  if (!result.ok || !result.status) throw new AgentFabricError("AF_INVALID_STATE", "Local owner returned no task status");
+  return result.status;
+}
+
+/** Accompanied tasks always share the running owner; there is no direct-store fallback. */
+export async function requestAttachedTask(repositoryRoot: string, action: AttachedTaskAction,
+  body: Record<string, unknown>): Promise<unknown> {
+  if (!isAttachedTaskAction(action)) throw new AgentFabricError("AF_INVALID_STATE", "Unknown accompanied task action");
+  const endpoint = readEndpoint(realpathSync(repositoryRoot));
+  if (!endpoint) throw new AgentFabricError("AF_INVALID_STATE", "Agent Fabric local owner is not running; start forge fabric serve");
+  let response: Response;
+  try {
+    response = await fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, {
+      method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(30_000),
+    });
+  } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local Agent Fabric owner is unreachable; restart it before retrying");
+  }
+  const result = await response.json() as { ok?: boolean; code?: string; error?: string; status?: unknown };
+  if (!response.ok || !result.ok) throw new AttachedTaskError(result.code ?? "AF_INVALID_STATE", result.error ?? "Accompanied task request failed");
+  if (result.status === undefined) throw new AgentFabricError("AF_INVALID_STATE", "Local owner returned no accompanied task result");
+  return result.status;
+}
+
+/** Managed runs always use the single authenticated owner, including bounded event waits. */
+export async function requestManagedRun(repositoryRoot: string, action: ManagedRunAction,
+  body: Record<string, unknown>): Promise<unknown> {
+  if (!isManagedRunAction(action)) throw new AgentFabricError("AF_INVALID_STATE", "Unknown managed run action");
+  if (action === "run-start") body = await applyFabricProfile(repositoryRoot, body);
+  const endpoint = readEndpoint(realpathSync(repositoryRoot));
+  if (!endpoint) throw new AgentFabricError("AF_INVALID_STATE", "Agent Fabric local owner is not running; start forge fabric serve");
+  let response: Response;
+  try {
+    response = await fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, {
+      method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(action === "run-wait" ? 35_000 : 30_000),
+    });
+  } catch {
+    throw new AgentFabricError("AF_INVALID_STATE", "Local Agent Fabric owner is unreachable; restart it before retrying");
+  }
+  const result = await response.json() as { ok?: boolean; code?: string; error?: string; status?: unknown };
+  if (!response.ok || !result.ok) throw new ManagedRunError(result.code ?? "AF_INVALID_STATE", result.error ?? "Managed run request failed");
+  if (result.status === undefined) throw new AgentFabricError("AF_INVALID_STATE", "Local owner returned no managed run result");
+  return result.status;
+}
+
+/** V2 shares the authenticated owner; no direct-store fallback or worker-side registry changes. */
+export async function requestProgramRun(repositoryRoot: string, action: ProgramRunAction, body: Record<string, unknown>): Promise<unknown> {
+  if (!isProgramRunAction(action)) throw new ProgramError("AF_PROGRAM_INVALID", "Unknown program action");
+  const endpoint = readEndpoint(realpathSync(repositoryRoot));
+  if (!endpoint) throw new ProgramError("AF_PROGRAM_OWNER", "Start forge fabric ensure-owner before using program workflows");
+  const response = await fetch(`http://127.0.0.1:${endpoint.port}/v1/${action}`, { method: "POST", headers: { Authorization: `Bearer ${endpoint.token}`, "Content-Type": "application/json" }, body: JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(action === "program-wait" ? 35000 : 120000) });
+  const result = await response.json() as { ok?: boolean; code?: string; error?: string; status?: unknown };
+  if (!response.ok || !result.ok) throw new ProgramError(result.code ?? "AF_PROGRAM_OWNER", result.error ?? "Program request failed");
+  return result.status;
+}