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

package/src/projects.js

@@ -0,0 +1,286 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { CODEFLOW_HOME } from "./config.js";
+import { repoRoot } from "./git.js";
+import { logError } from "./log.js";
+const MAX_NAME = 60;
+const MAX_REPOS = 50;
+function projectOf(run, projects) {
+  if (run.project) return projects.some((p) => p.id === run.project) ? run.project : void 0;
+  return projects.find((p) => p.repos.includes(run.repo))?.id;
+}
+class Projects {
+  constructor(file = join(CODEFLOW_HOME, "projects.json")) {
+    this.file = file;
+  }
+  projects = [];
+  /** Public reads retain the last committed snapshot while an async mutation writes. */
+  committedWhileWriting;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Changes happen one at a time, so two runs starting in a new repo make one project, not two,
+   * and a change counts only once it's saved (see `change`).
+   */
+  queue = Promise.resolve();
+  /** False while projects.json can't be read (or set aside): it's never written over then. */
+  writable = true;
+  /** Projects can change, and runs record theirs (see `writable`). */
+  get available() {
+    return this.writable;
+  }
+  /**
+   * Read the projects. The first time (no file yet), every repo that already has runs gets a
+   * project named after it, so the runs you have are grouped from the start.
+   *
+   * A file that isn't valid JSON, or isn't a list, is moved aside to
+   * `projects.json.corrupt-<time>` (and logged), and code-flow starts with no projects; so is one
+   * with entries it can't use, keeping the usable ones. A file that can't be read at all, or
+   * moved aside, is left alone: projects are off until it's fixed, and runs record none.
+   */
+  async load(runs = []) {
+    this.projects = [];
+    this.writable = false;
+    let text;
+    try {
+      text = await readFile(this.file, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logError(`Couldn't read ${this.file}; projects are off and it won't be written over until it can be read`, err);
+        return;
+      }
+    }
+    if (text === void 0) {
+      this.writable = true;
+      const firstRun = /* @__PURE__ */ new Map();
+      for (const r of [...runs].sort((a, b) => a.createdAt - b.createdAt)) if (!firstRun.has(r.repo)) firstRun.set(r.repo, r.createdAt);
+      for (const [repo, at] of firstRun) this.add(repo, at);
+      await this.write().catch((err) => logError(`Couldn't save ${this.file}`, err));
+      return;
+    }
+    let parsed;
+    let why = "isn't a list of projects";
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      why = `isn't valid JSON (${err.message})`;
+    }
+    const entries = Array.isArray(parsed) ? parsed : [];
+    const usable = entries.filter(isProject);
+    const rejected = entries.length - usable.length;
+    if ((!Array.isArray(parsed) || rejected) && !await this.setAside(Array.isArray(parsed) ? `has ${rejected} project(s) code-flow can't read` : why)) return;
+    this.projects = usable;
+    this.writable = true;
+    if (rejected) await this.write().catch((err) => logError(`Couldn't save ${this.file}`, err));
+  }
+  /** Move projects.json aside so it isn't lost when the usable projects are saved. */
+  async setAside(why) {
+    const aside = `${this.file}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    try {
+      await rename(this.file, aside);
+      logError(`${this.file} ${why}: moved it to ${aside}`);
+      return true;
+    } catch (err) {
+      logError(`${this.file} ${why}, and it couldn't be moved aside; projects are off until it's fixed`, err);
+      return false;
+    }
+  }
+  list() {
+    return (this.committedWhileWriting ?? this.projects).map(copy);
+  }
+  /** Membership and metadata changes notify authorization streams after persistence succeeds. */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  get(id) {
+    const p = (this.committedWhileWriting ?? this.projects).find((project) => project.id === id);
+    return p && copy(p);
+  }
+  /** The project a repo's runs go in when none is named: the first one holding it. */
+  forRepo(repo) {
+    const p = (this.committedWhileWriting ?? this.projects).find((x) => x.repos.includes(repo));
+    return p && copy(p);
+  }
+  create(input) {
+    return this.change(async () => {
+      const project = { id: `p-${randomBytes(4).toString("hex")}`, name: this.checkName(input.name), repos: await checkRepos(input.repos ?? []), createdAt: Date.now() };
+      this.projects.push(project);
+      return copy(project);
+    });
+  }
+  /**
+   * Rename a project or change its repos. Runs already in it stay, even in a repo you take out
+   * (RunManager.updateProject records the project on older runs that relied on the repo).
+   */
+  update(id, patch) {
+    return this.change(async () => {
+      const p = this.require(id);
+      const name = patch.name !== void 0 ? this.checkName(patch.name, id) : p.name;
+      const repos = patch.repos !== void 0 ? await checkRepos(patch.repos, p.repos) : p.repos;
+      p.name = name;
+      p.repos = repos;
+      return copy(p);
+    });
+  }
+  /** Delete a project. Its runs are kept and belong to no project. */
+  remove(id) {
+    return this.change(() => {
+      this.require(id);
+      this.projects = this.projects.filter((p) => p.id !== id);
+    });
+  }
+  /**
+   * The project a new run in `repo` goes in: the one asked for, else the project of the run it
+   * continues, else the repo's project, else (the first run in a repo no project holds) a new
+   * project named after the repo. The repo joins the project if it isn't in it yet, so a
+   * project's runs always work in its repos.
+   *
+   * A project that was asked for but no longer exists is an error, unless `lenient` (an
+   * automation saved before you deleted it): then the repo decides.
+   */
+  place(repo, opts = {}) {
+    return this.change(() => {
+      if (opts.requireRepo && (!opts.requested || !this.find(opts.requested)?.repos.includes(repo))) throw new Error("The repository is no longer an explicit member of the requested project");
+      let project = opts.requested ? this.find(opts.requested) : void 0;
+      if (opts.requested && !project && !opts.lenient) throw new Error("That project no longer exists; pick another one");
+      project ??= (opts.parent ? this.find(opts.parent) : void 0) ?? this.projects.find((p) => p.repos.includes(repo));
+      const created = !project;
+      project ??= this.add(repo);
+      const added = !created && !project.repos.includes(repo);
+      if (added) project.repos.push(repo);
+      return { project: copy(project), created, added };
+    });
+  }
+  /** A run moved into a project brings its repo with it. */
+  include(id, repo) {
+    return this.change(() => {
+      const p = this.require(id);
+      const added = !p.repos.includes(repo);
+      if (added) {
+        if (p.repos.length >= MAX_REPOS) throw new Error(`A project holds at most ${MAX_REPOS} repositories`);
+        p.repos.push(repo);
+      }
+      return { project: copy(p), added };
+    });
+  }
+  /**
+   * Remember the pattern and team of a run you started here: the composer starts from them next
+   * time. A convenience, so it never fails the run: a save that fails is only logged.
+   */
+  async remember(id, run) {
+    await this.change(() => {
+      const p = this.find(id);
+      if (!p) return;
+      const team = { roles: run.roles };
+      if (run.roleSettings && Object.keys(run.roleSettings).length) team.roleSettings = run.roleSettings;
+      p.defaults = {
+        pattern: run.pattern,
+        teams: { ...p.defaults?.teams ?? {}, [run.pattern]: team },
+        agentSettings: run.agentSettings && Object.keys(run.agentSettings).length ? run.agentSettings : void 0
+      };
+    }).catch((err) => logError("Couldn't remember the team for the project", err));
+  }
+  /**
+   * Make a change and save it, one change at a time. If the save fails (a full disk, a folder
+   * that isn't writable), the change is undone and the caller gets the error: nothing is
+   * reported done, or written into a run's log, that a restart would lose.
+   */
+  change(fn) {
+    const next = this.queue.then(async () => {
+      if (!this.writable) throw new Error(`Projects are off: ${this.file} couldn't be read (see server.log)`);
+      const before = JSON.stringify(this.projects);
+      this.committedWhileWriting = JSON.parse(before);
+      try {
+        const result = await fn();
+        if (JSON.stringify(this.projects) === before) return result;
+        try {
+          await this.write();
+        } catch (err) {
+          throw new Error(`code-flow couldn't save projects: ${err.message}`);
+        }
+        this.committedWhileWriting = void 0;
+        for (const listener of this.listeners) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+        return result;
+      } catch (err) {
+        this.projects = JSON.parse(before);
+        throw err;
+      } finally {
+        this.committedWhileWriting = void 0;
+      }
+    });
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  async write() {
+    await mkdir(dirname(this.file), { recursive: true });
+    const tmp = `${this.file}.tmp`;
+    await writeFile(tmp, JSON.stringify(this.projects, null, 2), { mode: 384 });
+    await rename(tmp, this.file);
+  }
+  find(id) {
+    return this.projects.find((p) => p.id === id);
+  }
+  require(id) {
+    const p = this.find(id);
+    if (!p) throw new Error("Project not found");
+    return p;
+  }
+  /**
+   * A new project for a repo, named after it, or after it and its parent folder if that's taken,
+   * or numbered. Every candidate is cut to the length limit before it's checked, so two long
+   * names can't end up the same once shortened.
+   */
+  add(repo, createdAt = Date.now()) {
+    const base = basename(repo) || repo;
+    const fit = (suffix = "") => `${base.slice(0, MAX_NAME - suffix.length)}${suffix}`;
+    const taken = (name2) => this.projects.some((p) => p.name.toLowerCase() === name2.toLowerCase());
+    let name = fit();
+    if (taken(name)) name = fit(` (${basename(dirname(repo)).slice(0, 20)})`);
+    for (let i = 2; taken(name); i++) name = fit(` ${i}`);
+    const project = { id: `p-${randomBytes(4).toString("hex")}`, name, repos: [repo], createdAt };
+    this.projects.push(project);
+    return project;
+  }
+  checkName(input, self) {
+    const name = String(input ?? "").replace(/\s+/g, " ").trim();
+    if (!name) throw new Error("Name the project");
+    if (name.length > MAX_NAME) throw new Error(`Keep the name under ${MAX_NAME} characters`);
+    if (this.projects.some((p) => p.id !== self && p.name.toLowerCase() === name.toLowerCase())) throw new Error(`There's already a project called \u201C${name}\u201D`);
+    return name;
+  }
+}
+async function checkRepos(input, current = []) {
+  if (!Array.isArray(input)) throw new Error("Repositories must be a list of folders");
+  if (input.length > MAX_REPOS) throw new Error(`A project holds at most ${MAX_REPOS} repositories`);
+  const repos = [];
+  for (const raw of input) {
+    const path = String(raw ?? "").trim();
+    if (current.includes(path)) {
+      if (!repos.includes(path)) repos.push(path);
+      continue;
+    }
+    if (!path.startsWith("/")) throw new Error("Repositories must be absolute paths");
+    const root = await repoRoot(path).catch(() => {
+      throw new Error(`${path} isn't a git repository`);
+    });
+    if (!repos.includes(root)) repos.push(root);
+  }
+  return repos;
+}
+function copy(p) {
+  return structuredClone(p);
+}
+function isProject(p) {
+  const x = p;
+  return !!x && typeof x.id === "string" && typeof x.name === "string" && typeof x.createdAt === "number" && Array.isArray(x.repos) && x.repos.every((r) => typeof r === "string");
+}
+export {
+  Projects,
+  projectOf
+};

package/src/provider-eligibility.js

@@ -0,0 +1,9 @@
+function providerEligibility(id, input) {
+  const trust = input.unattended && input.trust === "full" ? "trusted" : input.trust;
+  if (id.startsWith("acp:") && (trust !== "full" || input.unattended || input.remote || input.container)) return "ACP connections are unavailable for scheduled teams; they require local interactive Full access";
+  if (input.projectTeam && !["claude", "codex", "agy"].includes(id)) return "This provider has not been validated for unattended project teams";
+  if (id.startsWith("plugin:") && (input.remote || input.container)) return "Extension providers require local execution";
+}
+export {
+  providerEligibility
+};

package/src/readiness.js

@@ -0,0 +1,98 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { repoRoot, resolveCommit, git, openDetachedWorktree, removeDetachedWorktree } from "./git.js";
+import { readRepoConfig } from "./repo-config.js";
+import { checkGit, doctor } from "./doctor.js";
+import { detectCheckCommand, runCheck } from "./checks.js";
+import { Slots } from "./slots.js";
+import { AGENT_IDS } from "./adapters/index.js";
+import { redactText } from "./privacy.js";
+const validationSlots = new Slots(1);
+async function inspectReadiness(input) {
+  const repo = await repoRoot(input.repo);
+  const base = await resolveCommit(repo, input.baseRef || "HEAD");
+  const [{ config, found, error }, health, gitHealth, detection, dirty] = await Promise.all([
+    readRepoConfig(repo),
+    doctor({}),
+    checkGit(),
+    detectCheckCommand(repo),
+    git(["status", "--porcelain"], repo)
+  ]);
+  const setup = input.setup === void 0 ? config.setup ?? detection?.setup : input.setup.trim();
+  const check = input.check === void 0 ? config.check ?? detection?.command : input.check.trim();
+  const items = [
+    { id: "git", label: "Git", status: gitHealth.ok ? "passed" : "failed", detail: gitHealth.warning ?? gitHealth.version },
+    { id: "repository", label: "Repository and base", status: "passed", detail: `${repo} \xB7 ${base.slice(0, 12)}` },
+    { id: "configuration", label: "Repository configuration", status: error ? "failed" : "passed", detail: error ?? (found ? "Using .codeflow/config.json" : "Using detected defaults") },
+    { id: "working-copy", label: "Working copy", status: dirty.stdout.trim() ? "warning" : "passed", detail: dirty.stdout.trim() ? "Uncommitted changes are not part of validation at the selected commit." : "Clean" },
+    ...providerReadiness(input, health),
+    { id: "check", label: "Verification command", status: check ? "passed" : "warning", detail: check || "No check configured; completion cannot be independently verified." }
+  ];
+  if (input.execute && !error) {
+    await inTemporaryWorktree(repo, base, async (path, opened) => {
+      if (opened.warning) items.push({ id: "submodules", label: "Submodules", status: "warning", detail: opened.warning });
+      let setupOk = true;
+      for (const [id, command] of [["setup-run", setup], ["check-run", check]]) {
+        if (!command || !setupOk) {
+          items.push({ id, label: id === "setup-run" ? "Setup execution" : "Check execution", status: "skipped", detail: !setupOk ? "Setup failed" : "No command configured" });
+          continue;
+        }
+        const result = await runCheck(path, command, { timeoutMs: 12e4, signal: input.signal });
+        items.push({ id, label: id === "setup-run" ? "Setup execution" : "Check execution", status: result.ok ? "passed" : "failed", detail: redactText(result.output.slice(-8e3) || `${command}: exit ${result.exitCode}`) });
+        if (id === "setup-run") setupOk = result.ok;
+      }
+    }, input.signal);
+  }
+  return { ok: !items.some((item) => item.status === "failed"), repo, base, setup, check, executed: input.execute === true, items, checkedAt: Date.now() };
+}
+function providerReadiness(input, health) {
+  const scoped = input.roles !== void 0 || input.providers !== void 0;
+  const roles = Object.entries(input.roles ?? {}).map(([role, values]) => [role, typeof values === "string" ? [values] : values]);
+  const required = new Set(roles.filter(([role]) => input.pattern !== "auto-team" || role !== "pool").flatMap(([, values]) => values).filter((id) => id !== "auto"));
+  if (input.roles === void 0) {
+    for (const id of input.providers ?? []) if (id !== "auto") required.add(id);
+  }
+  const autoTeam = input.pattern === "auto-team" && input.roles !== void 0;
+  const pool = autoTeam ? roles.find(([role]) => role === "pool")?.[1] ?? [] : input.providers ?? AGENT_IDS;
+  const needsAuto = autoTeam || roles.some(([, values]) => values.includes("auto")) || input.providers?.includes("auto") === true;
+  const eligible = new Set(pool.filter((id) => id !== "auto" && (!autoTeam || input.providers === void 0 || input.providers.includes(id))));
+  const usable = (agent) => agent.installed && agent.compatible !== false && agent.signedIn !== false;
+  const items = health.map((agent) => {
+    const needed = !scoped || required.has(agent.id);
+    const candidate = scoped && needsAuto && eligible.has(agent.id);
+    let status;
+    if (!needed && !(candidate && usable(agent))) status = "skipped";
+    else if (!agent.installed) status = scoped ? "failed" : "skipped";
+    else if (!usable(agent)) status = "failed";
+    else status = agent.signedIn === null ? "warning" : "passed";
+    return { id: `agent-${agent.id}`, label: agent.name, status, detail: !needed && !candidate ? "Not selected for this workflow" : agent.fix ?? [agent.version, agent.signedIn === true ? "Signed in" : agent.signedIn === null ? "Authentication unknown" : "Not signed in"].filter(Boolean).join(" \xB7 ") };
+  });
+  for (const id of required) if (!health.some((agent) => agent.id === id)) items.push({ id: `agent-${id}`, label: id, status: "failed", detail: "Selected provider is unavailable" });
+  if (!scoped || needsAuto || !required.size) {
+    const available = health.some((agent) => usable(agent) && (!scoped || needsAuto && eligible.has(agent.id)));
+    if (!available) items.push({ id: "available-agent", label: "Usable agent", status: "failed", detail: scoped ? "Select at least one usable provider within the permitted pool." : "Install and sign in to at least one compatible coding agent." });
+  }
+  return items;
+}
+async function inTemporaryWorktree(repo, ref, run, signal) {
+  const release = await validationSlots.acquire(signal);
+  let folder;
+  try {
+    folder = await mkdtemp(join(tmpdir(), "codeflow-validation-"));
+    const path = join(folder, "checkout");
+    try {
+      const opened = await openDetachedWorktree(repo, path, ref, { signal });
+      return await run(path, opened);
+    } finally {
+      await removeDetachedWorktree(repo, path);
+    }
+  } finally {
+    if (folder) await rm(folder, { recursive: true, force: true });
+    release();
+  }
+}
+export {
+  inTemporaryWorktree,
+  inspectReadiness
+};

package/src/remote-tls.js

@@ -0,0 +1,66 @@
+import { X509Certificate, createPrivateKey, randomBytes } from "node:crypto";
+import { createSecureContext } from "node:tls";
+import { isIP } from "node:net";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { CODEFLOW_HOME } from "./config.js";
+const FILE = join(CODEFLOW_HOME, "remote-tls.json");
+function certificateHostname(raw) {
+  if (typeof raw !== "string") throw new Error("Enter the hostname or IP address your other device will use");
+  const host = raw.trim().toLowerCase();
+  if (!host || host.length > 253 || !isIP(host) && !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(host)) throw new Error("Enter a hostname or IP address without https://, a port or a path");
+  return host;
+}
+function validateRemoteCertificate(input, now = Date.now(), allowExpired = false) {
+  const hostname = certificateHostname(input.hostname);
+  if (input.source !== "import" && input.source !== "tailscale") throw new Error("Choose Tailscale or import a certificate");
+  if (typeof input.cert !== "string" || typeof input.key !== "string" || input.cert.length > 128 * 1024 || input.key.length > 32 * 1024) throw new Error("Choose a PEM certificate and private key within the size limits");
+  let cert;
+  try {
+    cert = new X509Certificate(input.cert);
+    const key = createPrivateKey(input.key);
+    if (!cert.checkPrivateKey(key)) throw new Error("mismatch");
+    createSecureContext({ cert: input.cert, key: input.key, minVersion: "TLSv1.2" });
+  } catch {
+    throw new Error("The certificate and private key could not be read or do not match. Use PEM files with an unencrypted private key.");
+  }
+  const expiresAt = Date.parse(cert.validTo);
+  if (!Number.isFinite(expiresAt) || !allowExpired && expiresAt <= now || Date.parse(cert.validFrom) > now) throw new Error("The certificate is expired or not valid yet");
+  if (!(isIP(hostname) ? cert.checkIP(hostname) : cert.checkHost(hostname, { subject: "never" }))) throw new Error("The certificate does not cover this hostname or IP address");
+  return { hostname, source: input.source, expiresAt };
+}
+async function loadRemoteCertificate(file = FILE, allowExpired = false) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw new Error("Saved HTTPS configuration could not be read. Import or renew the certificate in Remote access settings.");
+  }
+  let value;
+  try {
+    value = JSON.parse(raw);
+    validateRemoteCertificate(value, Date.now(), allowExpired);
+  } catch {
+    throw new Error("Saved HTTPS configuration is invalid or expired. Import or renew the certificate in Remote access settings.");
+  }
+  return value;
+}
+async function saveRemoteCertificate(value, file = FILE) {
+  validateRemoteCertificate(value);
+  await mkdir(dirname(file), { recursive: true, mode: 448 });
+  const temporary = `${file}.${randomBytes(8).toString("hex")}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(value), { mode: 384, flag: "wx" });
+    await chmod(temporary, 384);
+    await rename(temporary, file);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+export {
+  certificateHostname,
+  loadRemoteCertificate,
+  saveRemoteCertificate,
+  validateRemoteCertificate
+};

package/src/remote-workers/bundles.js

@@ -0,0 +1,198 @@
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { git, resolveCommit, withRepoLock } from "../git.js";
+import { verificationIntegrity } from "../verification-integrity.js";
+import { childEnv } from "../env.js";
+import { CHUNK_BYTES, COMMIT_ID, contextPath, MAX_BUNDLE_BYTES, MAX_CONTEXT_BYTES, RemoteWorkerError, REQUEST_ID } from "./protocol.js";
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+const identity = ["-c", "core.hooksPath=/dev/null", "-c", "fetch.fsckObjects=true", "-c", "transfer.fsckObjects=true", "-c", "submodule.recurse=false"];
+async function boundedBundle(repo, path, revisions) {
+  const data = await new Promise((resolve, reject) => {
+    const child = spawn("git", [...identity, "bundle", "create", "-", ...revisions], { cwd: repo, env: childEnv({ GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" }), detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const parts = [];
+    let size = 0, stderr = "", error;
+    const kill = () => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    };
+    const timer = setTimeout(() => {
+      error = new RemoteWorkerError("Git bundle creation exceeded 30 seconds. Sync the provisioned worker mapping, then retry explicitly.");
+      kill();
+    }, 3e4);
+    child.stdout.on("data", (part) => {
+      size += part.length;
+      if (size > MAX_BUNDLE_BYTES) {
+        error = new RemoteWorkerError("Git bundle exceeds 64 MiB. Sync the provisioned worker mapping to the repository base, then retry explicitly.");
+        kill();
+      } else if (!error) parts.push(part);
+    });
+    child.stderr.on("data", (part) => {
+      stderr = (stderr + part.toString()).slice(-2e3);
+    });
+    child.on("error", (failure) => {
+      error = failure;
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (error || code) reject(error ?? new RemoteWorkerError(stderr.trim() || "Cannot create Git bundle"));
+      else resolve(Buffer.concat(parts));
+    });
+  });
+  await writeFile(path, data, { flag: "wx", mode: 384 });
+  return data;
+}
+async function gitChecked(repo, args) {
+  const result = await git([...identity, ...args], repo, { timeoutMs: 3e4 });
+  if (result.code) throw new RemoteWorkerError(result.stderr.trim().slice(-1e3) || `Remote Git ${args[0]} failed`);
+  return result.stdout.trim();
+}
+async function assertTransferTree(repo, revision) {
+  if (!COMMIT_ID.test(revision)) throw new RemoteWorkerError("Remote transfer needs an exact Git object ID");
+  const entries = (await gitChecked(repo, ["ls-tree", "-r", "-l", "-z", revision])).split("\0").filter(Boolean);
+  let bytes = 0;
+  const attributes = [];
+  for (const entry of entries) {
+    const at = entry.indexOf("	"), fields = entry.slice(0, at).split(/\s+/), path = entry.slice(at + 1);
+    if (fields[0] === "160000") throw new RemoteWorkerError("Remote Git bundle turns do not transfer submodule contents. Use local execution for this repository.");
+    bytes += Number(fields[3]) || 0;
+    if (path === ".gitattributes" || path.endsWith("/.gitattributes")) attributes.push(path);
+  }
+  if (entries.length > 2e4 || bytes > 256 * 1024 * 1024 || attributes.length > 100) throw new RemoteWorkerError("Remote source/result tree exceeds 20,000 files, 256 MiB or 100 attribute files");
+  let attributeBytes = 0;
+  for (const path of attributes) {
+    const value = await gitChecked(repo, ["show", `${revision}:${path}`]);
+    attributeBytes += Buffer.byteLength(value);
+    if (attributeBytes > 256 * 1024) throw new RemoteWorkerError("Remote checkout attributes exceed 256 KiB");
+    if (value.split(/\r?\n/).some((row) => !row.trimStart().startsWith("#") && row.split(/\s+/).some((part) => /^[-!]?filter(?:=|$)/.test(part)))) throw new RemoteWorkerError("Remote Git bundle turns do not materialize checkout filters such as Git LFS. Use local execution or a repository without checkout filters.");
+  }
+}
+async function disabledCheckoutFilters(repo) {
+  const result = await git(["config", "--name-only", "--get-regexp", "^filter\\..*\\.(smudge|clean|process|required)$"], repo, { timeoutMs: 1e4 });
+  if (result.code > 1) throw new RemoteWorkerError("Cannot inspect checkout filter policy");
+  const keys = [...new Set(result.stdout.split(/\r?\n/).filter(Boolean))];
+  if (keys.length > 100 || keys.some((key) => !/^filter\.[^\x00-\x20\x7f]+\.(?:smudge|clean|process|required)$/.test(key))) throw new RemoteWorkerError("Worker Git checkout filter configuration exceeds its supported bound");
+  return keys.flatMap((key) => ["-c", `${key}=${key.endsWith(".required") ? "false" : ""}`]);
+}
+async function sourceBundle(repo, baseCommit, requestId, exclude) {
+  if (!COMMIT_ID.test(baseCommit) || !REQUEST_ID.test(requestId) || exclude && !COMMIT_ID.test(exclude)) throw new RemoteWorkerError("Choose exact transfer commits and a valid request ID");
+  const folder = await mkdtemp(join(tmpdir(), "codeflow-remote-source-")), path = join(folder, "source.bundle"), ref = `refs/codeflow/transfers/${requestId}`;
+  let claimed = false;
+  try {
+    await gitChecked(repo, ["update-ref", ref, baseCommit, "0".repeat(baseCommit.length)]);
+    claimed = true;
+    const data = await boundedBundle(repo, path, [ref, ...exclude && exclude !== baseCommit ? [`^${exclude}`] : []]);
+    return { data, size: data.length, sha256: sha256(data), ref };
+  } finally {
+    try {
+      if (claimed) await gitChecked(repo, ["update-ref", "-d", ref, baseCommit]);
+    } finally {
+      await rm(folder, { recursive: true, force: true });
+    }
+  }
+}
+async function contextManifest(repo) {
+  const root = join(repo, ".codeflow-context"), files = [], data = /* @__PURE__ */ new Map();
+  let total = 0, entries = 0;
+  const info = await lstat(root).catch((error) => {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (!info) return { files, data };
+  if (!info.isDirectory() || info.isSymbolicLink()) throw new RemoteWorkerError("Remote staged context must be a regular directory");
+  const visit = async (directory, relative) => {
+    for (const name of await readdir(directory)) {
+      if (++entries > 1e3) throw new RemoteWorkerError("Remote context contains too many filesystem entries");
+      const path = `${relative}/${name}`, absolute = join(directory, name), info2 = await lstat(absolute);
+      if (info2.isSymbolicLink()) throw new RemoteWorkerError("Remote context cannot contain symbolic links");
+      if (info2.isDirectory()) {
+        if (path.split("/").length > 32) throw new RemoteWorkerError("Remote context nesting exceeds its bound");
+        await visit(absolute, path);
+        continue;
+      }
+      if (!info2.isFile() || !contextPath(path) || info2.size > 8 * 1024 * 1024 || files.length >= 100) throw new RemoteWorkerError("Remote context contains an unsupported, sensitive or oversized file");
+      const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+      let value;
+      try {
+        const current = await handle.stat();
+        if (!current.isFile() || current.size > 8 * 1024 * 1024 || current.ino !== info2.ino || current.dev !== info2.dev) throw new RemoteWorkerError("Staged context changed while being inspected");
+        value = await handle.readFile();
+        const after = await handle.stat();
+        if (after.size !== current.size || after.mtimeMs !== current.mtimeMs || value.length > 8 * 1024 * 1024) throw new RemoteWorkerError("Staged context changed while being copied");
+      } finally {
+        await handle.close();
+      }
+      total += value.length;
+      if (total > MAX_CONTEXT_BYTES) throw new RemoteWorkerError("Remote staged context exceeds 16 MiB");
+      files.push({ path, size: value.length, sha256: sha256(value) });
+      data.set(path, value);
+    }
+  };
+  await visit(root, ".codeflow-context");
+  return { files, data };
+}
+async function importWorkerArtifact(repo, artifact, expectedHead) {
+  if (!REQUEST_ID.test(artifact.requestId) || !COMMIT_ID.test(artifact.head) || artifact.baseCommit !== expectedHead || artifact.ref !== `refs/codeflow/results/${artifact.requestId}` || artifact.size > MAX_BUNDLE_BYTES) throw new RemoteWorkerError("Invalid remote result artifact");
+  const info = await lstat(artifact.file);
+  if (!info.isFile() || info.isSymbolicLink() || info.size !== artifact.size || sha256(await readFile(artifact.file)) !== artifact.sha256) throw new RemoteWorkerError("Remote result bundle failed its integrity check");
+  return withRepoLock(typeof repo === "string" ? repo : repo.path, async () => {
+    if (await resolveCommit(repo) !== expectedHead) throw new RemoteWorkerError("The local worktree changed while remote work was running");
+    const integrity = await verificationIntegrity(repo);
+    const ref = `refs/codeflow/imports/${artifact.requestId}`;
+    let claimed = false;
+    try {
+      const heads = await gitChecked(repo, ["bundle", "list-heads", artifact.file]);
+      if (heads !== `${artifact.head} ${artifact.ref}`) throw new RemoteWorkerError("Remote result bundle has unexpected references");
+      await gitChecked(repo, ["bundle", "verify", artifact.file]);
+      const exists = await git(["show-ref", "--verify", "--quiet", ref], repo);
+      if (!exists.code) throw new RemoteWorkerError("This remote import reference is already claimed");
+      await gitChecked(repo, ["fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", artifact.file, `${artifact.ref}:${ref}`]);
+      claimed = true;
+      const imported = await resolveCommit(repo, ref);
+      if (imported !== artifact.head || (await git(["merge-base", "--is-ancestor", expectedHead, imported], repo)).code) throw new RemoteWorkerError("Remote result is not a descendant of the accepted base");
+      await assertTransferTree(repo, imported);
+      const filters = await disabledCheckoutFilters(repo);
+      await integrity.assert("remote result import");
+      await gitChecked(repo, [...filters, "merge", "--ff-only", "--no-edit", imported]);
+      return { head: imported };
+    } finally {
+      if (claimed) await gitChecked(repo, ["update-ref", "-d", ref, artifact.head]);
+    }
+  });
+}
+async function writeContext(root, path, value) {
+  if (!contextPath(path)) throw new RemoteWorkerError("Invalid remote context path");
+  let current = root;
+  for (const part of path.split("/").slice(0, -1)) {
+    current = join(current, part);
+    await mkdir(current, { recursive: false, mode: 448 }).catch((error) => {
+      if (error.code !== "EEXIST") throw error;
+    });
+    const info = await lstat(current);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new RemoteWorkerError("Remote context directory is not regular");
+  }
+  await writeFile(join(root, path), value, { flag: "wx", mode: 384 });
+}
+function chunks(data) {
+  const parts = [];
+  for (let offset = 0; offset < data.length; offset += CHUNK_BYTES) parts.push({ offset, data: Buffer.from(data.subarray(offset, offset + CHUNK_BYTES)).toString("base64") });
+  return parts;
+}
+export {
+  assertTransferTree,
+  boundedBundle,
+  chunks,
+  contextManifest,
+  disabledCheckoutFilters,
+  gitChecked,
+  importWorkerArtifact,
+  sha256,
+  sourceBundle,
+  writeContext
+};