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

package/src/run-permissions.js

@@ -0,0 +1,110 @@
+function antigravityExecution(value, parent) {
+  if (value !== void 0 && value !== "isolated" && value !== "native") throw new Error("Invalid Antigravity execution mode");
+  if (parent && value === "native" && parent.antigravityExecution !== "native") throw new Error("A child run cannot enable unrestricted Antigravity permissions");
+  return value ?? parent?.antigravityExecution;
+}
+const AGY_NATIVE_LIMITATION = "Unrestricted Antigravity uses your existing login and normal provider configuration. Terminal, browser, MCP, hooks and native agents are not restricted by Code Flow. Read-only requests are advisory; native child usage is outside Code Flow's worker budget. A valid saved login is required.";
+const levels = ["safe", "standard", "trusted", "full"];
+function narrowerTrust(run, turn) {
+  if (!levels.includes(run) || turn !== void 0 && !levels.includes(turn)) throw new Error("Unknown turn permissions");
+  return levels[Math.min(levels.indexOf(run), levels.indexOf(turn ?? run))];
+}
+function permissionRequirements(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length > 3 || value.some((v) => !["workspace-writes", "no-command-network", "no-external-tools"].includes(v))) throw new Error("Unknown required permission enforcement");
+  return [...new Set(value)];
+}
+function validateRunPermissions(value) {
+  const p = value;
+  if (!p || typeof p !== "object" || Array.isArray(p) || Object.keys(p).some((k) => !["version", "revision", "trust", "toolApprovals", "delegation", "required", "antigravityExecution"].includes(k)) || p.version !== 1 || !Number.isSafeInteger(p.revision) || p.revision < 1 || !levels.includes(p.trust) || typeof p.toolApprovals !== "boolean" || !["managed", "none"].includes(p.delegation) || !Array.isArray(p.required)) throw new Error("Invalid run permission policy");
+  antigravityExecution(p.antigravityExecution);
+  return { ...p, required: permissionRequirements(p.required) };
+}
+function createRunPermissions(trust, tools, solo, required, execution) {
+  return validateRunPermissions({ version: 1, revision: 1, trust, toolApprovals: tools, delegation: solo ? "none" : "managed", required: permissionRequirements(required), ...execution !== void 0 ? { antigravityExecution: antigravityExecution(execution) } : {} });
+}
+const supportsRunPermissions = (provider) => provider === "claude" || provider === "codex" || provider === "agy";
+const AGY_MANAGED_PERMISSION_PROBLEM = "Antigravity managed execution requires the verified local macOS file-only executor and existing Keychain login. Remote/container execution and interactive approvals are unsupported. Choose Claude or Codex for other environments.";
+function permissionProviderProblem(provider, policy) {
+  if (policy && provider === "agy" && policy.antigravityExecution !== "native" && (typeof process === "undefined" || process.platform !== "darwin")) return AGY_MANAGED_PERMISSION_PROBLEM;
+  if (policy && !supportsRunPermissions(provider)) return `${provider} cannot enforce Code Flow's native-delegation restriction. Choose Claude or Codex for this run.`;
+}
+function resolveRunPermissions(input) {
+  const { provider, mode } = input;
+  const policy = validateRunPermissions(input.policy);
+  if (!["read", "write"].includes(mode)) throw new Error("Invalid turn access mode");
+  const problem = permissionProviderProblem(provider, policy);
+  if (problem) throw new Error(problem);
+  const trust = narrowerTrust(narrowerTrust(policy.trust, input.currentTrust), input.turnTrust);
+  if (provider === "agy" && policy.antigravityExecution === "native") {
+    if (input.remote || input.container || input.unattended || policy.toolApprovals || policy.required.length || trust === "safe" || trust !== policy.trust) throw new Error("Unrestricted Antigravity requires a local attended run without mandatory boundaries, Safe mode, narrowed trust or interactive approvals");
+    return {
+      required: [],
+      delegation: policy.delegation,
+      policyRevision: policy.revision,
+      provider,
+      trust: "full",
+      mode,
+      nativeDelegation: true,
+      toolApprovals: false,
+      isolation: "none",
+      implementation: "agy-native-v1",
+      commandNetwork: "allowed",
+      externalTools: "provider-configured",
+      limitations: [AGY_NATIVE_LIMITATION, "Each managed turn starts fresh using portable context; native sessions are not resumed."]
+    };
+  }
+  if (provider === "agy") {
+    if (input.remote || input.container || policy.toolApprovals && input.currentTools && input.tools !== false && mode === "write") throw new Error(AGY_MANAGED_PERMISSION_PROBLEM);
+    return {
+      required: [...policy.required],
+      delegation: policy.delegation,
+      policyRevision: policy.revision,
+      provider,
+      trust,
+      mode,
+      nativeDelegation: false,
+      toolApprovals: false,
+      isolation: "os-sandbox",
+      implementation: "macos-file-only-v1",
+      commandNetwork: "denied",
+      externalTools: "disabled",
+      limitations: ["Antigravity has file tools only; terminal, browser, MCP, hooks and native delegation are disabled.", "The official CLI uses the existing macOS Keychain login; inference networking remains enabled.", "System runtime files and the native security helper remain accessible; model file tools are denied authentication and runtime state.", "Code Flow runs setup and checks in their separately configured command environment.", "Every turn starts with a fresh provider profile and portable context; native sessions are not resumed."]
+    };
+  }
+  const externalTools = policy.required.includes("no-external-tools") ? "disabled" : "provider-configured";
+  if (externalTools === "disabled" && provider !== "claude") throw new Error(`${provider} has no verified external-tool isolation in this adapter`);
+  const isolation = input.container ? "container" : trust === "full" && mode === "write" ? "none" : provider === "codex" ? "provider-sandbox" : "tool-rules";
+  const commandNetwork = provider === "codex" && (mode === "read" || trust === "safe" || trust === "standard") ? "denied" : trust === "full" || trust === "trusted" ? "allowed" : "provider-configured";
+  if (policy.required.includes("workspace-writes") && (isolation === "none" || isolation === "tool-rules" || input.remote || input.container)) throw new Error(`${provider} cannot enforce the required workspace write boundary in this environment`);
+  if (policy.required.includes("no-command-network") && (commandNetwork !== "denied" || input.remote || input.container)) throw new Error(`${provider} cannot enforce the required command network restriction in this environment`);
+  const wantsApprovals = policy.toolApprovals && input.currentTools && input.tools !== false && mode === "write";
+  if (wantsApprovals && policy.required.some((r) => r === "workspace-writes" || r === "no-command-network")) throw new Error("Interactive command approvals cannot be combined with mandatory sandbox boundaries");
+  if (wantsApprovals && (provider !== "codex" || input.remote || input.container || input.unattended)) throw new Error(`${provider} cannot provide the run's required interactive approvals in this environment`);
+  return {
+    required: [...policy.required],
+    delegation: policy.delegation,
+    policyRevision: policy.revision,
+    provider,
+    trust,
+    mode,
+    nativeDelegation: false,
+    toolApprovals: policy.toolApprovals && input.currentTools && input.tools !== false && !input.container && !input.remote && !input.unattended && mode === "write",
+    isolation,
+    commandNetwork,
+    externalTools,
+    limitations: ["Worktrees do not restrict file reads.", "Setup and check commands use the run\u2019s separately configured command environment.", ...isolation === "tool-rules" ? ["CLI tool rules are not an operating-system filesystem sandbox."] : [], ...externalTools === "provider-configured" ? ["Browser and external MCP permissions follow the provider configuration; terminal network policy does not restrict them."] : []]
+  };
+}
+export {
+  AGY_MANAGED_PERMISSION_PROBLEM,
+  AGY_NATIVE_LIMITATION,
+  antigravityExecution,
+  createRunPermissions,
+  narrowerTrust,
+  permissionProviderProblem,
+  permissionRequirements,
+  resolveRunPermissions,
+  supportsRunPermissions,
+  validateRunPermissions
+};

package/src/run-projection.js

@@ -0,0 +1,75 @@
+import { join } from "node:path";
+import { worktreeRoot } from "./git.js";
+import { RunLogReader } from "./run-log.js";
+const DEFAULT_LOOP = { maxMinutes: 60, maxSteps: 40, checkTimeoutMin: 10 };
+class RunProjection {
+  snapshot;
+  steps = /* @__PURE__ */ new Map();
+  reader = new RunLogReader();
+  seq = 0;
+  records = 0;
+  fullSnapshots = 0;
+  patches = 0;
+  apply(line) {
+    this.records++;
+    if (Number.isSafeInteger(line.seq) && line.seq > this.seq) this.seq = line.seq;
+    if (line.type === "run") this.fullSnapshots++;
+    else if (line.type === "run-patch") this.patches++;
+    const event = this.reader.decode(line);
+    if (!event) return;
+    if (event.type === "run" && event.run) this.snapshot = event.run;
+    else if (event.type === "step" && event.step) this.steps.set(event.step.id, { ...event.step, kind: event.step.kind ?? "agent" });
+  }
+  finish() {
+    return rebuildSnapshot(this.snapshot, this.steps);
+  }
+}
+function rebuildRun(events) {
+  const projection = new RunProjection();
+  for (const event of events) projection.apply(event);
+  return projection.finish();
+}
+function rebuildSnapshot(snapshot, steps) {
+  if (!snapshot) return void 0;
+  const legacy = snapshot;
+  return {
+    ...legacy,
+    context: legacy.context ?? { paths: [], attachments: [] },
+    agentSettings: legacy.agentSettings ?? {},
+    loop: { ...DEFAULT_LOOP, ...legacy.loop ?? {} },
+    usage: legacy.usage ?? { agentSteps: 0, checks: 0 },
+    // Runs saved before patternDone existed: a finished run's pattern finished.
+    patternDone: legacy.patternDone ?? (legacy.status === "done" ? true : void 0),
+    patternSummary: legacy.patternSummary ?? (legacy.status === "done" && legacy.summary ? withoutFollowUps(legacy.summary) : void 0),
+    worktrees: legacy.worktrees ?? [],
+    baseLabel: legacy.baseLabel ?? "HEAD",
+    branchPrefix: legacy.branchPrefix ?? `codeflow/${legacy.id}`,
+    worktreeDir: legacy.worktreeDir ?? join(worktreeRoot(legacy.repo), legacy.id),
+    followUps: legacy.followUps ?? [],
+    notes: legacy.notes ?? [],
+    roleSettings: legacy.roleSettings ?? {},
+    trust: legacy.trust ?? "standard",
+    approvals: legacy.approvals ?? {},
+    merges: legacy.merges ?? [],
+    prs: legacy.prs ?? {},
+    watches: legacy.watches ?? {},
+    seen: legacy.seen ?? true,
+    archived: legacy.archived ?? false,
+    artifacts: legacy.artifacts ?? [],
+    steps: [...steps.values()]
+  };
+}
+function strip(run) {
+  const { steps: _steps, ...rest } = run;
+  return structuredClone(rest);
+}
+function withoutFollowUps(summary) {
+  return summary.split("\n\n## Follow-ups\n")[0];
+}
+export {
+  DEFAULT_LOOP,
+  RunProjection,
+  rebuildRun,
+  strip,
+  withoutFollowUps
+};

package/src/run-recovery.js

@@ -0,0 +1,53 @@
+import { constants, closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { join } from "node:path";
+import { RunProjection, strip } from "./run-projection.js";
+import { readRunCheckpoint, RUNS_DIR, visitJsonLines } from "./store.js";
+async function recoverRun(id) {
+  const projection = new RunProjection(), checkpoint = await readRunCheckpoint(id);
+  if (checkpoint) {
+    projection.apply({ seq: checkpoint.seq, ts: checkpoint.run.createdAt, runId: id, type: "run", run: strip(checkpoint.run) });
+    for (const step of checkpoint.run.steps) projection.apply({ seq: checkpoint.seq, ts: step.startedAt, runId: id, type: "step", step });
+  } else await visitJsonLines(`${id}.jsonl`, (event) => projection.apply(event));
+  return { run: projection.finish(), seq: projection.seq, records: projection.records, fullSnapshots: projection.fullSnapshots, patches: projection.patches };
+}
+function recoverRunSync(id) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,199}$/.test(id)) throw new Error("Invalid run ID");
+  const file = openSync(join(RUNS_DIR, `${id}.jsonl`), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)), projection = new RunProjection(), decoder = new StringDecoder("utf8"), chunk = Buffer.alloc(64 * 1024);
+  let pending = "";
+  const parse = (line) => {
+    if (Buffer.byteLength(line) > 64 * 1024 * 1024) throw new Error("Run log record exceeds the 64 MiB recovery bound");
+    if (!line.trim()) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    projection.apply(event);
+  };
+  try {
+    const before = fstatSync(file, { bigint: true });
+    if (!before.isFile()) throw new Error("Run log must be a regular file");
+    let count;
+    while (count = readSync(file, chunk, 0, chunk.length, null)) {
+      pending += decoder.write(chunk.subarray(0, count));
+      let index;
+      while ((index = pending.indexOf("\n")) >= 0) {
+        parse(pending.slice(0, index));
+        pending = pending.slice(index + 1);
+      }
+      if (Buffer.byteLength(pending) > 64 * 1024 * 1024) throw new Error("Run log record exceeds the 64 MiB recovery bound");
+    }
+    parse(pending + decoder.end());
+    const after = fstatSync(file, { bigint: true });
+    if (before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs) throw new Error("Run log changed while recovering; retry the read");
+    return { run: projection.finish(), seq: projection.seq };
+  } finally {
+    closeSync(file);
+  }
+}
+export {
+  recoverRun,
+  recoverRunSync
+};

package/src/run-status.js

@@ -0,0 +1,54 @@
+function checksLabel(run, checking = false, branch) {
+  if (checking) return "Running";
+  if (run.status === "running") return "Pending";
+  const checkedBranch = run.verification?.branch ?? run.worktrees?.find((tree) => tree.name === run.lastCheck?.worktree)?.branch;
+  if (branch && checkedBranch !== branch) return "Not verified for this branch";
+  if (run.checkCantRun) return "Blocked";
+  if (run.verdict === "failing") return "Failed";
+  if (run.verification) return { verified: "Passed", "needs-changes": "Failed", blocked: "Blocked", unchecked: "Unverified" }[run.verification.state];
+  if (run.verdict === "passed") return "Passed";
+  return run.loop?.check ? "Not verified" : "Not configured";
+}
+const runPassed = (run) => run.status === "done" && checksLabel(run) === "Passed";
+function runState(run) {
+  if (run.status !== "done") return run.status;
+  const check = checksLabel(run);
+  return check === "Failed" ? "failing" : check === "Blocked" ? "unchecked" : check === "Passed" ? "done" : "unverified";
+}
+function needsYou(run) {
+  if (run.archived) return false;
+  const question = run.status === "running" && !!run.team?.awaitingRequestId;
+  if (run.awaiting || question) return true;
+  if (run.projectTeam) return false;
+  return run.team?.status === "blocked" || run.triage?.state === "pending" || Object.values(run.watches ?? {}).some((watch) => watch.state === "needs-you") || run.status !== "running" && (run.status === "interrupted" || !run.seen);
+}
+const isFlagged = (run) => Object.keys(run.integrity ?? {}).length > 0 || !!run.followUps?.some((turn) => turn.integrity?.length);
+const HISTORY_STATUSES = ["all", "attention", "running", "passed", "failing", "flagged"];
+function matchesHistoryFilter(run, filter) {
+  if (filter.repo && run.repo !== filter.repo || filter.pattern && run.pattern !== filter.pattern) return false;
+  if (filter.agent && !Object.values(run.roles).some((ids) => ids.some((id) => id === filter.agent))) return false;
+  if (filter.section && (run.archived || (filter.section === "waiting" ? !needsYou(run) : needsYou(run) || (filter.section === "running" ? run.status !== "running" : run.status === "running")))) return false;
+  switch (filter.status) {
+    case "attention":
+      return needsYou(run);
+    case "running":
+      return run.status === "running";
+    case "passed":
+      return runPassed(run);
+    case "failing":
+      return checksLabel(run) === "Failed" || ["failed", "stopped", "interrupted"].includes(run.status);
+    case "flagged":
+      return isFlagged(run);
+    default:
+      return true;
+  }
+}
+export {
+  HISTORY_STATUSES,
+  checksLabel,
+  isFlagged,
+  matchesHistoryFilter,
+  needsYou,
+  runPassed,
+  runState
+};

package/src/serve.js

@@ -0,0 +1,138 @@
+import { spawn, execFile } from "node:child_process";
+import { createServer, createConnection } from "node:net";
+import { platform } from "node:os";
+import { killGroup, trackGroup, untrackGroup } from "./adapters/process.js";
+import { childEnv } from "./env.js";
+const MAX_LOG_LINES = 400;
+class DevServers {
+  servers = /* @__PURE__ */ new Map();
+  get(key) {
+    const s = this.servers.get(key);
+    if (!s) return void 0;
+    const { child: _child, ...rest } = s;
+    return { ...rest, logs: [...rest.logs] };
+  }
+  /** Every server, without their logs: what the side panel's Browser can open. */
+  list() {
+    return [...this.servers.values()].map(({ child: _child, logs: _logs, ...rest }) => ({ ...rest }));
+  }
+  async ready(key) {
+    const server = this.servers.get(key);
+    if (!server || server.status !== "running") return false;
+    return new Promise((resolve) => {
+      const socket = createConnection({ host: "localhost", port: server.port, autoSelectFamily: true });
+      let settled = false;
+      const finish = (ready) => {
+        if (settled) return;
+        settled = true;
+        socket.destroy();
+        resolve(ready);
+      };
+      socket.setTimeout(500, () => finish(false));
+      socket.once("connect", () => finish(true));
+      socket.once("error", () => finish(false));
+    });
+  }
+  async start(key, cwd, command, preferredPort, generatedEnv = {}, signal) {
+    this.stop(key);
+    const port = await freePort(preferredPort);
+    if (signal?.aborted) throw new Error("Service startup was cancelled before spawning");
+    if (generatedEnv.PORT !== void 0 && generatedEnv.PORT !== String(port)) throw new Error("The allocated service port became busy. Restart the launch profile to allocate fresh ports.");
+    const child = spawn("/bin/sh", ["-c", command], {
+      cwd,
+      detached: true,
+      // own process group: stopping it stops whatever the command started
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...childEnv(generatedEnv), PORT: String(port), BROWSER: "none", FORCE_COLOR: "0" }
+    });
+    trackGroup(child.pid);
+    const server = { key, command, cwd, port, url: `http://localhost:${port}`, status: "running", startedAt: Date.now(), logs: [], child };
+    const collect = (chunk) => {
+      for (const line of chunk.toString().split("\n")) {
+        if (!line.trim()) continue;
+        server.logs.push(line.slice(-4e3));
+        if (server.logs.length > MAX_LOG_LINES) server.logs.shift();
+      }
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+    child.on("exit", (code) => {
+      untrackGroup(child.pid);
+      server.status = "exited";
+      server.exitCode = code;
+    });
+    child.on("error", (err) => {
+      server.status = "exited";
+      server.logs.push(`Failed to start: ${err.message}`);
+    });
+    this.servers.set(key, server);
+    return this.get(key);
+  }
+  stop(key) {
+    const s = this.servers.get(key);
+    if (!s) return false;
+    killGroup(s.child.pid);
+    untrackGroup(s.child.pid);
+    this.servers.delete(key);
+    return true;
+  }
+  /** Stop every server whose key starts with `prefix` (e.g. one run's). */
+  stopMatching(prefix) {
+    for (const key of [...this.servers.keys()]) if (key.startsWith(prefix)) this.stop(key);
+  }
+  stopAll() {
+    for (const key of [...this.servers.keys()]) this.stop(key);
+  }
+}
+async function freePort(preferred) {
+  const tryPort = (port) => new Promise((resolve) => {
+    const srv = createServer();
+    srv.once("error", () => resolve(null));
+    srv.listen(port, "127.0.0.1", () => {
+      const actual = srv.address().port;
+      srv.close(() => resolve(actual));
+    });
+  });
+  if (preferred) {
+    for (let p = preferred; p < preferred + 20; p++) {
+      const ok = await tryPort(p);
+      if (ok) return ok;
+    }
+  }
+  return await tryPort(0);
+}
+async function openFolder(path, target) {
+  const os = platform();
+  if (target === "editor") {
+    for (const cli of ["cursor", "code", "zed", "subl"]) {
+      if (await has(cli)) {
+        await run(cli, [path]);
+        return cli;
+      }
+    }
+    throw new Error("No editor command found (cursor, code, zed or subl on PATH)");
+  }
+  if (os === "darwin") {
+    if (target === "terminal") await run("open", ["-a", "Terminal", path]);
+    else await run("open", [path]);
+    return target === "terminal" ? "Terminal" : "Finder";
+  }
+  if (target === "terminal") {
+    for (const term of ["x-terminal-emulator", "gnome-terminal", "konsole"]) {
+      if (await has(term)) {
+        spawn(term, [], { cwd: path, detached: true, stdio: "ignore" }).unref();
+        return term;
+      }
+    }
+    throw new Error("No terminal emulator found");
+  }
+  await run("xdg-open", [path]);
+  return "file manager";
+}
+const has = (cmd) => new Promise((resolve) => execFile("which", [cmd], (err) => resolve(!err)));
+const run = (cmd, args) => new Promise((resolve, reject) => execFile(cmd, args, (err) => err ? reject(new Error(`${cmd} failed: ${err.message}`)) : resolve()));
+export {
+  DevServers,
+  freePort,
+  openFolder
+};