forgeos 0.1.0-alpha.63 → 0.1.0-alpha.64

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

@@ -0,0 +1,199 @@
+import type { DbAdapter } from "../runtime/db/adapter.ts";
+import { AgentFabricError } from "./errors.ts";
+import { stableStringify } from "./canonical.ts";
+import type { LocalPatchEvidence } from "./local-coding-worker.ts";
+import {
+  validateLocalCodingTaskProposal,
+  type ValidatedLocalCodingTaskProposal,
+} from "./local-task-contract.ts";
+import type { Digest } from "./types.ts";
+
+const CREATE_TASKS_TABLE = `
+  CREATE TABLE IF NOT EXISTS _forge_agent_fabric_local_tasks (
+    task_id TEXT PRIMARY KEY,
+    repository_root TEXT NOT NULL,
+    proposal_digest TEXT NOT NULL UNIQUE,
+    proposal_json TEXT NOT NULL,
+    state TEXT NOT NULL CHECK (state IN ('proposed', 'rejected')),
+    created_at BIGINT NOT NULL,
+    decided_at BIGINT
+  )`;
+
+const CREATE_PATCHES_TABLE = `
+  CREATE TABLE IF NOT EXISTS _forge_agent_fabric_local_patches (
+    task_id TEXT PRIMARY KEY,
+    evidence_json TEXT NOT NULL
+  )`;
+
+const CREATE_DECISIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS _forge_agent_fabric_local_patch_decisions (
+    task_id TEXT PRIMARY KEY,
+    diff_digest TEXT NOT NULL,
+    decision TEXT NOT NULL CHECK (decision IN ('approved', 'rejected')),
+    decided_at BIGINT NOT NULL
+  )`;
+
+export interface LocalTaskRecord extends ValidatedLocalCodingTaskProposal {
+  taskId: string;
+  repositoryRoot: string;
+  state: "proposed" | "rejected";
+  createdAt: number;
+  decidedAt: number | null;
+}
+
+function taskIdFor(digest: Digest): string {
+  return `task:${digest.slice("sha256:".length)}`;
+}
+
+export class LocalTaskInbox {
+  private schemaReady?: Promise<unknown>;
+  private patchSchemaReady?: Promise<unknown>;
+  private decisionSchemaReady?: Promise<unknown>;
+
+  constructor(private readonly adapter: DbAdapter) {
+    if (adapter.kind !== "pglite") {
+      throw new AgentFabricError("AF_INVALID_STATE", "Local task inbox requires PGlite");
+    }
+  }
+
+  private async ready(): Promise<void> {
+    this.schemaReady ??= this.adapter.query(CREATE_TASKS_TABLE);
+    await this.schemaReady;
+  }
+
+  async propose(
+    input: unknown,
+    repositoryRoot: string,
+    now = Date.now(),
+  ): Promise<LocalTaskRecord> {
+    const validated = validateLocalCodingTaskProposal(input);
+    if (validated.proposal.limits.expiresAt <= now) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Local coding task has expired");
+    }
+    const taskId = taskIdFor(validated.proposalDigest);
+    await this.ready();
+    await this.adapter.query(
+      `INSERT INTO _forge_agent_fabric_local_tasks
+       (task_id, repository_root, proposal_digest, proposal_json, state, created_at)
+       VALUES ($1, $2, $3, $4, 'proposed', $5)
+       ON CONFLICT (task_id) DO NOTHING`,
+      [taskId, repositoryRoot, validated.proposalDigest,
+        JSON.stringify(validated.proposal), now],
+    );
+    const record = await this.get(taskId);
+    if (!record || record.repositoryRoot !== repositoryRoot ||
+        record.proposalDigest !== validated.proposalDigest) {
+      throw new AgentFabricError("AF_CONFLICT", "Task identity is already bound to another repository or revision");
+    }
+    return record;
+  }
+
+  async get(taskId: string): Promise<LocalTaskRecord | null> {
+    if (!/^task:[0-9a-f]{64}$/u.test(taskId)) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Invalid local task identity");
+    }
+    await this.ready();
+    const result = await this.adapter.query(
+      `SELECT task_id, repository_root, proposal_digest, proposal_json, state, created_at, decided_at
+       FROM _forge_agent_fabric_local_tasks WHERE task_id = $1`,
+      [taskId],
+    );
+    const row = result.rows[0];
+    if (!row) return null;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(String(row.proposal_json));
+    } catch {
+      throw new AgentFabricError("AF_INVALID_STATE", "Stored task proposal is not JSON");
+    }
+    const validated = validateLocalCodingTaskProposal(parsed);
+    if (row.task_id !== taskId || row.proposal_digest !== validated.proposalDigest ||
+        taskIdFor(validated.proposalDigest) !== taskId ||
+        (row.state !== "proposed" && row.state !== "rejected") ||
+        typeof row.repository_root !== "string" || !row.repository_root) {
+      throw new AgentFabricError("AF_INVALID_STATE", "Stored task proposal is inconsistent");
+    }
+    return {
+      taskId,
+      repositoryRoot: row.repository_root,
+      ...validated,
+      state: row.state,
+      createdAt: Number(row.created_at),
+      decidedAt: row.decided_at === null ? null : Number(row.decided_at),
+    };
+  }
+
+  async reject(taskId: string, expectedDigest: Digest, now = Date.now()): Promise<void> {
+    await this.ready();
+    const result = await this.adapter.query(
+      `UPDATE _forge_agent_fabric_local_tasks SET state = 'rejected', decided_at = $3
+       WHERE task_id = $1 AND proposal_digest = $2 AND state = 'proposed'`,
+      [taskId, expectedDigest, now],
+    );
+    if (result.rowCount !== 1) {
+      throw new AgentFabricError("AF_CONFLICT", "Task is stale or already reviewed");
+    }
+  }
+
+  async recordPatch(taskId: string, evidence: LocalPatchEvidence): Promise<void> {
+    await this.ready();
+    this.patchSchemaReady ??= this.adapter.query(CREATE_PATCHES_TABLE);
+    await this.patchSchemaReady;
+    const encoded = stableStringify(evidence);
+    await this.adapter.query(
+      `INSERT INTO _forge_agent_fabric_local_patches (task_id, evidence_json)
+       VALUES ($1, $2) ON CONFLICT (task_id) DO NOTHING`,
+      [taskId, encoded],
+    );
+    const stored = await this.getPatch(taskId);
+    if (!stored || stableStringify(stored) !== encoded) {
+      throw new AgentFabricError("AF_CONFLICT", "Task already has different patch evidence");
+    }
+  }
+
+  async getPatch(taskId: string): Promise<LocalPatchEvidence | null> {
+    this.patchSchemaReady ??= this.adapter.query(CREATE_PATCHES_TABLE);
+    await this.patchSchemaReady;
+    const result = await this.adapter.query(
+      `SELECT evidence_json FROM _forge_agent_fabric_local_patches WHERE task_id = $1`,
+      [taskId],
+    );
+    const encoded = result.rows[0]?.evidence_json;
+    if (typeof encoded !== "string") return null;
+    try {
+      return JSON.parse(encoded) as LocalPatchEvidence;
+    } catch {
+      throw new AgentFabricError("AF_INVALID_STATE", "Stored patch evidence is not JSON");
+    }
+  }
+
+  async recordPatchDecision(taskId: string, diffDigest: Digest, decision: "approved" | "rejected", now = Date.now()): Promise<void> {
+    const patch = await this.getPatch(taskId);
+    if (!patch || patch.diffDigest !== diffDigest) {
+      throw new AgentFabricError("AF_CONFLICT", "Patch review does not match the recorded diff");
+    }
+    this.decisionSchemaReady ??= this.adapter.query(CREATE_DECISIONS_TABLE);
+    await this.decisionSchemaReady;
+    const result = await this.adapter.query(
+      `INSERT INTO _forge_agent_fabric_local_patch_decisions (task_id, diff_digest, decision, decided_at)
+       VALUES ($1, $2, $3, $4) ON CONFLICT (task_id) DO NOTHING`,
+      [taskId, diffDigest, decision, now],
+    );
+    if (result.rowCount !== 1) {
+      throw new AgentFabricError("AF_CONFLICT", "Patch already has an owner decision");
+    }
+  }
+
+  async getPatchDecision(taskId: string): Promise<"approved" | "rejected" | null> {
+    this.decisionSchemaReady ??= this.adapter.query(CREATE_DECISIONS_TABLE);
+    await this.decisionSchemaReady;
+    const result = await this.adapter.query(
+      `SELECT decision FROM _forge_agent_fabric_local_patch_decisions WHERE task_id = $1`,
+      [taskId],
+    );
+    const decision = result.rows[0]?.decision;
+    if (decision === "approved" || decision === "rejected") return decision;
+    if (decision === undefined) return null;
+    throw new AgentFabricError("AF_INVALID_STATE", "Stored patch decision is invalid");
+  }
+}

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

@@ -0,0 +1,207 @@
+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 { AgentFabricError, isAgentFabricError } from "./errors.ts";
+import { LocalTaskService, type LocalTaskStatus } from "./local-task-service.ts";
+import { localFabricPath } from "./local-paths.ts";
+
+const MAX_REQUEST_BYTES = 40 * 1024;
+const ENDPOINT_FILENAME = "owner-endpoint.json";
+
+export type LocalTaskAction = "propose" | "status" | "review" | "run" | "review-result";
+
+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): 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 (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 === "review") return service.review(request.taskId);
+  if (action === "run") return service.run(request.taskId);
+  return service.reviewResult(request.taskId);
+}
+
+export interface LocalTaskOwnerServer {
+  repositoryRoot: string;
+  port: number;
+  close(): Promise<void>;
+}
+
+/** 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;
+  try {
+    if (readEndpoint(root)) {
+      throw new AgentFabricError("AF_CONFLICT", "A local Agent Fabric owner is already running");
+    }
+    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;
+      }
+      const action = request.url?.slice("/v1/".length) as LocalTaskAction;
+      if (request.method !== "POST" || !request.url?.startsWith("/v1/") ||
+          !["propose", "status", "review", "run", "review-result"].includes(action)) {
+        response.writeHead(404).end(JSON.stringify({ ok: false, error: "unknown_action" }));
+        return;
+      }
+      void readBody(request).then((body) => dispatch(service, action, body)).then((status) => {
+        if (!response.destroyed) response.writeHead(200).end(JSON.stringify({ ok: true, status }));
+      }).catch((error: unknown) => {
+        if (!response.destroyed) response.writeHead(isAgentFabricError(error) ? 400 : 500).end(JSON.stringify({
+          ok: false, code: isAgentFabricError(error) ? 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 new Promise<void>((resolve) => listener!.close(() => resolve()));
+        if (existsSync(path) && readFileSync(path, "utf8") === JSON.stringify(published)) unlinkSync(path);
+        if (!suppliedService) await service.close();
+      },
+    };
+  } catch (error) {
+    if (listener?.listening) await new Promise<void>((resolve) => listener!.close(() => resolve()));
+    if (!suppliedService) await service.close();
+    throw error;
+  }
+}
+
+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 === "review" || action === "review-result" ? 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;
+}