@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/project-team-store.js

@@ -0,0 +1,234 @@
+import { randomBytes } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { CODEFLOW_HOME } from "./config.js";
+import { PT_LIMITS, validateTeamDocument } from "./project-team-model.js";
+import { repositoryIdentity } from "./repository-identity.js";
+class ProjectTeamConflict extends Error {
+  status = 409;
+}
+class ProjectTeamStore {
+  constructor(directory = join(CODEFLOW_HOME, "project-teams")) {
+    this.directory = directory;
+  }
+  teams = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  listeners = /* @__PURE__ */ new Set();
+  faults = /* @__PURE__ */ new Map();
+  loaded = false;
+  feature;
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  publish(team) {
+    this.teams.set(team.id, structuredClone(team));
+    this.notify();
+  }
+  async load() {
+    const files = await readdir(this.directory).catch((e) => {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    });
+    this.teams.clear();
+    this.faults.clear();
+    this.feature = void 0;
+    try {
+      const file = await open(join(this.directory, "settings.json"), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      let raw;
+      try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size > 4096) throw new Error("Standing teams settings exceed their regular-file bound");
+        const buffer = Buffer.alloc(4097);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > 4096) throw new Error("Standing teams settings grew beyond their limit");
+        raw = JSON.parse(buffer.subarray(0, bytesRead).toString());
+      } finally {
+        await file.close();
+      }
+      if (!raw || raw.version !== 1 || typeof raw.enabled !== "boolean" || !Number.isSafeInteger(raw.revision) || raw.revision < 1 || Object.keys(raw).some((key) => !["version", "enabled", "revision"].includes(key))) throw new Error("Invalid Standing teams setting");
+      this.feature = raw;
+    } catch (error) {
+      if (error.code !== "ENOENT") this.faults.set("settings", error.message);
+    }
+    for (const name of files.filter((f) => /^pt-[a-f0-9]{24}\.json$/.test(f))) {
+      try {
+        const file = await open(join(this.directory, name), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        let value;
+        try {
+          const stat = await file.stat();
+          if (!stat.isFile() || stat.size > PT_LIMITS.bytes) throw new Error("Team file exceeds its regular-file bound");
+          const buffer = Buffer.alloc(PT_LIMITS.bytes + 1);
+          const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+          if (bytesRead > PT_LIMITS.bytes) throw new Error("Team file grew beyond its limit");
+          value = JSON.parse(buffer.subarray(0, bytesRead).toString());
+        } finally {
+          await file.close();
+        }
+        const team = validateTeamDocument(value);
+        if (`${team.id}.json` !== name) throw new Error("Team identity differs from filename");
+        this.teams.set(team.id, team);
+      } catch (error) {
+        this.faults.set(name.slice(0, -5), error.message);
+      }
+    }
+    const owners = /* @__PURE__ */ new Map();
+    for (const team of this.teams.values()) if (team.status !== "archived") {
+      try {
+        const identity = await repositoryIdentity(team.repo);
+        if (team.repositoryId && team.repositoryId !== identity) throw new Error("Repository metadata was replaced; inspect ownership before dispatch");
+        if (!team.repositoryId) {
+          team.repositoryId = identity;
+          team.revision++;
+          team.updatedAt = Date.now();
+          await this.save(team);
+        }
+        owners.set(identity, [...owners.get(identity) ?? [], team.id]);
+      } catch (error) {
+        this.faults.set(team.id, error.message);
+        this.teams.delete(team.id);
+      }
+    }
+    for (const ids of owners.values()) if (ids.length > 1) for (const id of ids) {
+      this.faults.set(id, "Multiple active teams claim this repository; resolve ownership before dispatch");
+      this.teams.delete(id);
+    }
+    this.loaded = true;
+  }
+  configuration(defaultEnabled) {
+    if (!this.loaded || this.faults.has("settings") || this.faults.has("storage")) return { enabled: false, revision: 0, source: "unavailable" };
+    return { enabled: this.feature?.enabled ?? defaultEnabled, revision: this.feature?.revision ?? 0, source: this.feature ? "saved" : "default" };
+  }
+  setEnabled(enabled, revision) {
+    return this.serialized(async () => {
+      if (!this.loaded || this.faults.has("settings") || this.faults.has("storage")) throw new Error("Repair Standing teams settings before changing them");
+      if (revision !== (this.feature?.revision ?? 0)) throw new ProjectTeamConflict("Standing teams settings changed. Reload before trying again.");
+      const next = { version: 1, enabled, revision: revision + 1 };
+      await mkdir(this.directory, { recursive: true, mode: 448 });
+      const temporary = join(this.directory, `.settings-${randomBytes(6).toString("hex")}.tmp`);
+      try {
+        const file = await open(temporary, "wx", 384);
+        try {
+          await file.writeFile(JSON.stringify(next));
+          await file.sync();
+        } finally {
+          await file.close();
+        }
+        await rename(temporary, join(this.directory, "settings.json"));
+        if (process.platform !== "win32") {
+          const directory = await open(this.directory, "r");
+          try {
+            await directory.sync();
+          } finally {
+            await directory.close();
+          }
+        }
+        this.feature = next;
+        for (const listener of this.listeners) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      } finally {
+        await rm(temporary, { force: true }).catch(() => void 0);
+      }
+    });
+  }
+  list() {
+    return [...this.teams.values()].map((t) => structuredClone(t));
+  }
+  get(id) {
+    const error = this.faults.get(id);
+    if (error) throw new Error(`Standing team storage is unavailable: ${error}`);
+    const team = this.teams.get(id);
+    if (!team) throw Object.assign(new Error("Project team not found"), { status: 404 });
+    return structuredClone(team);
+  }
+  serialized(fn) {
+    const result = this.queue.then(fn);
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async flush() {
+    await this.queue;
+  }
+  create(team) {
+    return this.serialized(async () => {
+      if (!this.loaded) throw new Error("Load project team storage before writing");
+      if (this.faults.size) throw new Error("Repair damaged team records before creating teams; repository ownership cannot be determined");
+      const existing = this.teams.get(team.id);
+      if (existing) {
+        if (existing.operations[0]?.hash !== team.operations[0]?.hash) throw new ProjectTeamConflict("Operation ID was reused with different content");
+        return structuredClone(existing);
+      }
+      team = structuredClone(team);
+      team.repositoryId = await repositoryIdentity(team.repo);
+      if ([...this.teams.values()].some((t) => t.status !== "archived" && (t.repo === team.repo || t.repositoryId === team.repositoryId))) throw new ProjectTeamConflict("This repository already has a standing team (including its linked worktrees)");
+      await this.save(team);
+      this.publish(team);
+      return structuredClone(team);
+    });
+  }
+  change(id, expected, operation, update) {
+    return this.serialized(async () => {
+      if (!this.loaded) throw new Error("Load project team storage before writing");
+      const team = this.get(id);
+      const previous = operation && team.operations.find((o) => o.id === operation.id);
+      if (previous) {
+        if (previous.hash !== operation.hash) throw new ProjectTeamConflict("Operation ID was reused with different content");
+        return team;
+      }
+      if (expected !== void 0 && expected !== team.revision) throw new ProjectTeamConflict("This team changed. Reload before acting.");
+      update(team);
+      team.revision++;
+      team.updatedAt = Date.now();
+      if (operation) team.operations.push({ ...operation, at: team.updatedAt });
+      await this.save(team);
+      this.publish(team);
+      return structuredClone(team);
+    });
+  }
+  async save(team) {
+    validateTeamDocument(team);
+    const data = JSON.stringify(team);
+    if (Buffer.byteLength(data) > PT_LIMITS.bytes) throw new Error("Standing team history exceeds its storage limit");
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const temporary = join(this.directory, `.${team.id}-${randomBytes(6).toString("hex")}.tmp`);
+    try {
+      const handle = await open(temporary, "wx", 384);
+      try {
+        await handle.writeFile(data);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temporary, join(this.directory, `${team.id}.json`));
+      if (process.platform !== "win32") {
+        const dir = await open(this.directory, "r");
+        try {
+          await dir.sync();
+        } finally {
+          await dir.close();
+        }
+      }
+    } finally {
+      await rm(temporary, { force: true }).catch(() => void 0);
+    }
+  }
+}
+export {
+  ProjectTeamConflict,
+  ProjectTeamStore
+};

package/src/project-team-usage.js

@@ -0,0 +1,24 @@
+import { digest } from "./project-team-model.js";
+import { recoverRun } from "./run-recovery.js";
+import { flushWrites } from "./store.js";
+function terminalEvidence(run) {
+  if (!["done", "failed", "cancelled", "stopped"].includes(run.status) || !Number.isSafeInteger(run.endedAt) || !Number.isSafeInteger(run.createdAt) || run.endedAt < run.createdAt) return;
+  if (!Number.isSafeInteger(run.usage.agentSteps) || run.usage.agentSteps < 0) return;
+  const turns = run.steps.filter((step) => step.kind === "agent");
+  if (turns.some((step) => !step.endedAt || ["running", "interrupted"].includes(step.status))) return;
+  const launches = turns.reduce((sum, step) => sum + (step.invocations ?? 1), 0);
+  const calls = Math.max(run.usage.agentSteps, run.team?.metrics.invocations ?? 0, launches);
+  if (!Number.isSafeInteger(calls) || calls < 0) return;
+  return { id: run.id, repo: run.repo, project: run.project, base: run.baseRef, contract: run.projectTeam, status: run.status, createdAt: run.createdAt, endedAt: run.endedAt, calls, turns: turns.map((step) => ({ id: step.id, status: step.status, invocations: step.invocations, endedAt: step.endedAt })) };
+}
+async function persistProjectTeamUsage(run, launch) {
+  const evidence = terminalEvidence(run);
+  if (!evidence || evidence.createdAt < launch.at || evidence.calls > launch.calls) return;
+  await flushWrites(run.id);
+  const saved = (await recoverRun(run.id)).run;
+  if (!saved || digest(terminalEvidence(saved) ?? null) !== digest(evidence)) return;
+  return { version: 1, calls: evidence.calls, durationMs: Math.min(launch.minutes * 6e4, evidence.endedAt - evidence.createdAt), endedAt: evidence.endedAt, recordedAt: Date.now(), digest: digest(evidence) };
+}
+export {
+  persistProjectTeamUsage
+};

package/src/project-teams-api.js

@@ -0,0 +1,43 @@
+import { HttpError, readJson, send } from "./http.js";
+import { allowance, closed, text } from "./project-team-model.js";
+import { agentAvailability } from "./adapters/index.js";
+import { providerEligibility } from "./provider-eligibility.js";
+async function handleProjectTeams(service, req, res, parts, url) {
+  try {
+    const id = parts[2];
+    if (id === "definitions") {
+      if (req.method === "GET" && parts.length === 3) return send(res, 200, { definitions: service.teamLibrary(), faults: Object.fromEntries(service.definitions.faults) });
+      if (req.method === "GET" && parts.length === 4) return send(res, 200, service.definitions.get(parts[3]));
+      if (req.method === "POST" && (parts.length === 3 || parts.length === 4)) return send(res, parts.length === 3 ? 201 : 200, await service.saveDefinition(await readJson(req, 128 * 1024), parts[3]));
+      throw new HttpError(405, "Use GET or POST for reusable agent teams");
+    }
+    if (id === "settings" && parts.length === 3) {
+      if (req.method === "GET") return send(res, 200, service.configuration());
+      if (req.method === "POST") return send(res, 200, await service.setEnabled(await readJson(req, 8192)));
+      throw new HttpError(405, "Use GET or POST for Standing teams settings");
+    }
+    if (req.method === "GET" && !id) return send(res, 200, { ...service.configuration(), teams: service.list(url.searchParams.get("project") ?? void 0), definitions: service.teamLibrary(), definitionFaults: Object.fromEntries(service.definitions.faults), faults: Object.fromEntries(service.store.faults), providers: (await agentAvailability()).map(({ id: id2, displayName, available }) => ({ id: id2, name: displayName, available, reason: providerEligibility(id2, { trust: "standard", unattended: true, projectTeam: true }) })) });
+    if (req.method === "GET" && id && parts.length === 3) {
+      const team = service.store.get(id);
+      return send(res, 200, { team, allowance: allowance(team) });
+    }
+    if (req.method === "GET" && id && parts[3] === "preview" && parts.length === 4) return send(res, 200, await service.preview(id));
+    if (req.method !== "POST") throw new HttpError(405, "Use GET or POST for project teams");
+    const body = await readJson(req, 128 * 1024);
+    if (!id) return send(res, 201, await service.create(body));
+    if (parts.length === 3) return send(res, 200, await service.update(id, body));
+    if (parts[3] === "cycle" && parts.length === 4) {
+      closed(body, ["operationId"], "cycle request");
+      return send(res, 200, await service.cycle(id, text(body.operationId, 150, "operation ID")));
+    }
+    if (parts[3] === "stop" && parts.length === 4) return send(res, 200, await service.stopCycle(id, body));
+    if (parts[3] === "tasks" && parts.length === 4) return send(res, 201, await service.assignTask(id, body));
+    if (parts[3] === "opportunities" && parts[4] && parts.length === 5) return send(res, 200, await service.decide(id, parts[4], body));
+    throw new HttpError(404, "Unknown project team operation");
+  } catch (error) {
+    throw new HttpError(error.status ?? 400, error.message);
+  }
+}
+export {
+  handleProjectTeams
+};