@foldrun/core 1.4.2 → 2.0.0

package/src/run-container.ts

@@ -121,6 +121,47 @@ export interface StepTiming {
   sandboxMs: number;
   firstOutputMs: number | null;
   totalMs: number;
+  /** Where the start-up went, phase by phase — see STARTUP_PHASES. Absent
+   *  from an executor that marks none, and from a resumed driver (the
+   *  first driver's phases are on the record already). */
+  phases?: StartupPhases;
+}
+
+/**
+ * The start-up of one step, in the order it happens. Each is the moment the
+ * phase ENDED, in ms since the executor began the step, so the gap between
+ * two neighbours is what the later one cost (FOL-29: "pod ready" was the
+ * only number, and the six seconds after it had no names).
+ *
+ * The executor marks its own: `services` (the account's search/browser pods
+ * up), `room` (room on the cluster to start — platform pod-room.ts),
+ * `applied` (pod created), `ready`, `files` (the workspace copied in),
+ * `go` (the step released). The sandbox marks the rest as `{"e":"mark"}`
+ * lines: `shim` (the shim saw go), `system` (system packages restored),
+ * `driver` (node up), `imports` (core loaded), `tools` (runtime and tools
+ * built, the SDK about to start) and `model` (the model's first text or tool
+ * call). A worker that predates a mark ignores the line — parseDriverLine
+ * answers null for an `e` it does not know.
+ */
+export const STARTUP_PHASES = [
+  "services", "room", "applied", "ready", "files", "go",
+  "shim", "system", "driver", "imports", "tools", "model",
+] as const;
+export type StartupPhase = (typeof STARTUP_PHASES)[number];
+export type StartupPhases = Partial<Record<StartupPhase, number>>;
+
+/** A sandbox-side mark: which phase ended, and when (epoch ms, the
+ *  sandbox's clock — the same machine's as the worker's on one node). */
+export function parseDriverMark(line: string): { name: StartupPhase; at: number } | null {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('{"e":"mark"')) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed.e !== "mark" || typeof parsed.at !== "number" || !Number.isFinite(parsed.at)) return null;
+    return (STARTUP_PHASES as readonly string[]).includes(parsed.name) ? { name: parsed.name, at: parsed.at } : null;
+  } catch {
+    return null;
+  }
 }
 
 export interface StepActuals {
@@ -168,7 +209,11 @@ export interface ContainerStepOutcome {
 export function timingLine(t: StepTiming): string {
   const s = (ms: number) => `${(ms / 1000).toFixed(2)}s`;
   const first = t.firstOutputMs === null ? "no output" : `first output +${s(t.firstOutputMs)}`;
-  return `timing: sandbox ready in ${s(t.sandboxMs)}, ${first}, ${s(t.totalMs)} total`;
+  const phases = t.phases
+    ? STARTUP_PHASES.filter((p) => typeof t.phases![p] === "number").map((p) => `${p} ${s(t.phases![p]!)}`)
+    : [];
+  return `timing: sandbox ready in ${s(t.sandboxMs)}, ${first}, ${s(t.totalMs)} total` +
+    (phases.length ? ` · start-up: ${phases.join(" → ")}` : "");
 }
 
 const cli = () => process.env.FOLDRUN_CONTAINER_CLI ?? "docker";
@@ -504,7 +549,17 @@ const DRIVER = `// The runner container's entrypoint. Reads one step, executes i
 // same core the server uses, speaks JSONL on stdout, exits.
 import fs from "node:fs";
 const input = JSON.parse(fs.readFileSync("/opt/runner/job/input.json", "utf8"));
-const emit = (type, text, extra) => process.stdout.write(JSON.stringify({ e: "event", type, text, ...extra }) + "\\n");
+// Start-up marks (run-container.ts#STARTUP_PHASES): which phase just ended,
+// on the sandbox's clock. A worker that does not know a mark skips the line.
+const mark = (name) => process.stdout.write(JSON.stringify({ e: "mark", name, at: Date.now() }) + "\\n");
+mark("driver");
+let modelSpoke = false;
+const emit = (type, text, extra) => {
+  // The model's first text or tool call is where start-up ends and the
+  // step's own work begins — runtime and tool lines before it are set-up.
+  if (!modelSpoke && (type === "text" || type === "tool")) { modelSpoke = true; mark("model"); }
+  process.stdout.write(JSON.stringify({ e: "event", type, text, ...extra }) + "\\n");
+};
 // What this sandbox actually touched, read at the last moment from the
 // kernel's own books: cgroup v2 for CPU busy-time and peak memory,
 // /proc/net/dev for bytes on the wire. Every read is best-effort — gVisor
@@ -560,6 +615,7 @@ try {
   const { prepareRuntime } = await import("@foldrun/core/runtime");
   const { materializeFileSecrets } = await import("@foldrun/core/secret-files");
   const { paidWebActions } = await import("@foldrun/core/browser-pod");
+  mark("imports");
 
   const agentDir = "/workspace/" + input.agentRel;
   // HOME is where a bare relative path lands when anything resolves one
@@ -642,6 +698,7 @@ try {
   const ask = input.ask ? buildAskTool({ channel, timeoutSec: input.ask.timeoutSec, emit }) : { server: null };
   const inbox = channel ? inboxReader(channel, emit) : undefined;
 
+  mark("tools");
   const outcome = await executeStep({
     agentDir,
     workspaceRoot: "/workspace",
@@ -1470,6 +1527,8 @@ export async function runStepInContainer(args: RunInContainerArgs): Promise<Cont
     if (create.status !== 0) throw new Error(`container create failed:\n${create.stderr}`);
     containerId = create.stdout.trim();
     const sandboxMs = Date.now() - t0;
+    // Docker's phases are measured from create, its rent clock.
+    const phases: StartupPhases = { ready: sandboxMs };
 
     const cp = (from: string, to: string) => {
       const out = spawnSync(cli(), ["cp", from, to], { encoding: "utf8" });
@@ -1478,6 +1537,7 @@ export async function runStepInContainer(args: RunInContainerArgs): Promise<Cont
     cp(`${wsIn}/.`, `${containerId}:/workspace`);
     cp(`${libIn}/.`, `${containerId}:/library`);
     cp(`${jobIn}/input.json`, `${containerId}:/opt/runner/job/input.json`);
+    phases.files = Date.now() - t0;
 
     // Start attached and read the driver's JSONL. The step timeout gets a
     // backstop out here — a wedged container is killed, not waited on.
@@ -1503,6 +1563,11 @@ export async function runStepInContainer(args: RunInContainerArgs): Promise<Cont
           if (nl < 0) break;
           const line = buffer.slice(0, nl);
           buffer = buffer.slice(nl + 1);
+          const marked = parseDriverMark(line);
+          if (marked) {
+            phases[marked.name] ??= Math.max(0, marked.at - t0);
+            continue;
+          }
           const parsed = parseDriverLine(line);
           if (!parsed) continue;
           firstOutputAt ??= Date.now();
@@ -1546,6 +1611,7 @@ export async function runStepInContainer(args: RunInContainerArgs): Promise<Cont
       sandboxMs,
       firstOutputMs: firstOutputAt === null ? null : firstOutputAt - t0 - sandboxMs,
       totalMs: Date.now() - t0,
+      phases,
     };
     args.emit("info", timingLine(timing));
     return { ...outcome, timing };

package/src/runner.ts

@@ -49,6 +49,7 @@ import {
   listWorkspaces,
   listTenants,
   listRuns,
+  liveRuns,
   syncBundleFor,
   parseToolDef,
   type ToolDef,
@@ -2890,6 +2891,12 @@ async function runStep(
       const secs = (ms: number) => Math.round(ms) / 1000;
       step.computeSecs = outcome.timing ? secs(outcome.timing.totalMs) : null;
       step.startupSecs = outcome.timing ? secs(outcome.timing.sandboxMs) : null;
+      // Where the start-up went, phase by phase (run-container.ts#STARTUP_PHASES),
+      // in seconds — what the cold-start numbers are computed from.
+      const phases = outcome.timing?.phases;
+      step.startup = phases && Object.keys(phases).length
+        ? Object.fromEntries(Object.entries(phases).map(([k, v]) => [k, secs(v)]))
+        : null;
       // Which reservation those seconds held — as numbers, because the bill
       // is per core-second and per GiB-second, and what was held must come
       // from the record, never from what the config says at billing time.
@@ -5054,7 +5061,9 @@ export function reconcileRuns(tenant: string, now = Date.now(), live?: ReadonlyS
   const closed: Reconciliation[] = [];
 
   for (const workspace of listWorkspaces(tenant)) {
-    for (const summary of listRuns(tenant, workspace.name)) {
+    // Live runs only, read whole — every other status is passed over below,
+    // and parsing the workspace's whole history every sweep was the cost.
+    for (const summary of liveRuns(tenant, workspace.name)) {
       if (drivingRuns.has(summary.id)) continue;
       // Driven by another process — a second worker pod, on a platform with
       // more than one. The idle window protects a quiet step from THIS

package/src/secrets.ts

@@ -252,11 +252,9 @@ export function setSecretSites(tenant: string, name: string, sites: string[], wo
 export function secretSites(tenant: string, names: string[], workspace?: string): Record<string, string[]> {
   const out: Record<string, string[]> = {};
   const own = workspace ? read(tenant, workspace) : {};
-  const source = workspace ? platform.previewSourceOf(tenant, workspace) : null;
-  const inherited = source ? read(tenant, source) : {};
   const account = read(tenant);
   for (const name of names) {
-    const rec = own[name] ?? inherited[name] ?? account[name];
+    const rec = own[name] ?? account[name];
     if (rec?.sites?.length) out[name] = [...rec.sites];
   }
   return out;
@@ -349,14 +347,6 @@ export function getSecret(
   if (workspace) {
     const own = decrypt(tenant, read(tenant, workspace)[name]);
     if (own !== null) return { value: own, scope: "workspace" };
-    // A preview is a branch of its source workspace, and the branch's
-    // agents need the same credentials the source's do. Its own store is
-    // still consulted first, so a preview can override one on purpose.
-    const source = platform.previewSourceOf(tenant, workspace);
-    if (source) {
-      const inherited = decrypt(tenant, read(tenant, source)[name]);
-      if (inherited !== null) return { value: inherited, scope: "workspace" };
-    }
   }
   const shared = decrypt(tenant, read(tenant)[name]);
   return shared === null ? null : { value: shared, scope: "account" };

package/src/starter.ts

@@ -389,8 +389,8 @@ Debugging a failed run is usually: \`runs\` to find it, \`runs/<id>\` to read wh
 step failed and what it cost, fix the markdown, \`deploy\`, then \`rerun\`.
 
 Every route, with request and response shapes, is in \`docs/api.md\` in the
-foldrun repository — including secrets, keys, billing, OAuth, webhooks and the
-git push endpoint.
+foldrun repository — including secrets, keys, billing, OAuth, webhooks and
+restore.
 
 ## Writing a flow
 

package/src/store.ts

@@ -2095,7 +2095,7 @@ export function mayApprove(
 
 /** A live run of this flow — the fact overlap: decisions are made on. */
 export function flowHasLiveRun(tenant: string, workspace: string, flowName: string): boolean {
-  return listRuns(tenant, workspace).some(
+  return listRunSummaries(tenant, workspace).some(
     (r) => r.flow === flowName && (r.status === "running" || r.status === "queued" || r.status === "awaiting-approval"),
   );
 }
@@ -2396,10 +2396,6 @@ export interface WorkspaceSummary {
   flows: number;
   deployedAt: string;
   runCount: number;
-  /** Set when this workspace is a branch's preview of another (preview.ts):
-   *  which one, which branch, which commit. Read from the marker beside the
-   *  directory here rather than through preview.ts, which imports this file. */
-  preview?: { source: string; branch: string; commit: string; at: string };
   /** The workspace's picture, as a URL, when the page that lists it looked
    *  one up (avatars.ts) — the store itself does not. */
   avatar?: string | null;
@@ -2460,12 +2456,6 @@ export function listWorkspaces(tenant: string): WorkspaceSummary[] {
         }
       }
       const runsDir = path.join(pDir, "runs");
-      let preview: WorkspaceSummary["preview"];
-      try {
-        preview = JSON.parse(fs.readFileSync(path.join(dir, `.${name}.preview.json`), "utf8"));
-      } catch {
-        // not a preview
-      }
       return {
         name,
         description,
@@ -2473,7 +2463,6 @@ export function listWorkspaces(tenant: string): WorkspaceSummary[] {
         flows: listFlows(tenant, name).length,
         deployedAt: fs.statSync(pDir).mtime.toISOString(),
         runCount: fs.existsSync(runsDir) ? fs.readdirSync(runsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length : 0,
-        ...(preview ? { preview } : {}),
       };
     })
     .sort((a, b) => b.deployedAt.localeCompare(a.deployedAt));
@@ -2709,7 +2698,7 @@ export function writeWorkspaceFile(
 }
 
 /** Tell the platform, and never let its listener fail a write. */
-function workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "push" | "delete") {
+function workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "delete") {
   try {
     platform.workspaceChanged(tenant, workspace, why);
   } catch {
@@ -3291,6 +3280,12 @@ export interface StepRecord {
    */
   computeSecs?: number | null;
   startupSecs?: number | null;
+  /** When each start-up phase ended, in seconds since the executor began
+   *  the step — `services`, `applied`, `ready`, `files`, `go`, `shim`,
+   *  `system`, `driver`, `imports`, `tools`, `model` (run-container.ts
+   *  #STARTUP_PHASES). Only the phases this step went through; null from
+   *  an executor that marks none, absent on steps from before 17 Oct 2026. */
+  startup?: Record<string, number> | null;
   /** Which reservation class the sandbox held (small | large), and the
    *  actual limits it held, as numbers. Facts of the step: a price is per
    *  core-second, so what was reserved must come from the record, never
@@ -3512,6 +3507,23 @@ export function writeRun(tenant: string, workspace: string, run: RunRecord) {
   noteRunWritten(path.dirname(p), run, p);
 }
 
+/**
+ * The workspace's live runs — queued, running, or parked at a gate — read
+ * whole, newest first. Off the run index: only the live records are opened,
+ * where listRuns parses every record the workspace ever kept. What the
+ * periodic sweeps want (reconcile, the watchdog), and on a box that keeps
+ * ninety days of runs that is a handful of files instead of thousands.
+ */
+export function liveRuns(tenant: string, workspace: string): RunRecord[] {
+  const out: RunRecord[] = [];
+  for (const s of listRunSummaries(tenant, workspace)) {
+    if (!LIVE_STATUSES.has(s.status)) continue;
+    const run = readRun(tenant, workspace, s.id);
+    if (run) out.push(run);
+  }
+  return out;
+}
+
 // Every run in an account, each tagged with the workspace it belongs to —
 // the observability surface.
 export interface RunWithWorkspace extends RunRecord {
@@ -3603,7 +3615,18 @@ export interface RunSummary {
 interface RunIndexRow extends RunSummary {
   /** mtime of the record this row was made from; a moved mtime means re-read. */
   mtimeMs: number;
+  /** mtime, inode and size together (fileStamp) — what freshness is decided
+   *  on now. A row from before it has none and is re-read once. */
+  stamp?: string;
 }
+
+/**
+ * Which version of a file this is. mtime alone missed a rewrite inside one
+ * mtime tick (coarse on some NFS servers), leaving a stale row that the
+ * sweeps act on; every write here is a rename to a new file, so the inode
+ * moves on each write whatever the clock says, and the size usually does.
+ */
+const fileStamp = (st: fs.Stats) => `${st.mtimeMs}:${st.ino}:${st.size}`;
 interface RunIndex {
   v: 1;
   runs: Record<string, RunIndexRow>;
@@ -3668,23 +3691,23 @@ export function runFromSummary(s: RunSummary): RunRecord {
   };
 }
 
-const runIndexCache = new Map<string, { index: RunIndex; mtimeMs: number }>();
+const runIndexCache = new Map<string, { index: RunIndex; stamp: string }>();
 
 function readRunIndex(dir: string): RunIndex | null {
   const file = path.join(dir, RUN_INDEX);
-  let mtimeMs: number;
+  let stamp: string;
   try {
-    mtimeMs = fs.statSync(file).mtimeMs;
+    stamp = fileStamp(fs.statSync(file));
   } catch {
     runIndexCache.delete(dir);
     return null;
   }
   const cached = runIndexCache.get(dir);
-  if (cached && cached.mtimeMs === mtimeMs) return cached.index;
+  if (cached && cached.stamp === stamp) return cached.index;
   try {
     const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as RunIndex;
     if (parsed?.v !== 1 || typeof parsed.runs !== "object" || !parsed.runs) return null;
-    runIndexCache.set(dir, { index: parsed, mtimeMs });
+    runIndexCache.set(dir, { index: parsed, stamp });
     return parsed;
   } catch {
     return null;
@@ -3697,14 +3720,17 @@ function writeRunIndex(dir: string, index: RunIndex) {
   fs.writeFileSync(tmp, JSON.stringify(index));
   fs.renameSync(tmp, file);
   try {
-    runIndexCache.set(dir, { index, mtimeMs: fs.statSync(file).mtimeMs });
+    runIndexCache.set(dir, { index, stamp: fileStamp(fs.statSync(file)) });
   } catch {
     runIndexCache.delete(dir);
   }
 }
 
-const sameRow = (a: RunIndexRow | undefined, b: RunSummary) =>
-  !!a && JSON.stringify({ ...a, mtimeMs: 0 }) === JSON.stringify({ ...b, mtimeMs: 0 });
+const sameRow = (a: RunIndexRow | undefined, b: RunSummary) => {
+  if (!a) return false;
+  const { mtimeMs: _m, stamp: _s, ...row } = a;
+  return JSON.stringify(row) === JSON.stringify(b);
+};
 
 /** writeRun just saved `run` at `file`: bring its row up to date. The file
  *  is rewritten only when the row's content moved — a live step appends an
@@ -3717,7 +3743,8 @@ function noteRunWritten(dir: string, run: RunRecord, file: string) {
     if (!index) return; // no index yet — the first reader builds it whole
     const row = summarizeRun(run);
     if (sameRow(index.runs[run.id], row)) return;
-    index.runs[run.id] = { ...row, mtimeMs: fs.statSync(file).mtimeMs };
+    const st = fs.statSync(file);
+    index.runs[run.id] = { ...row, mtimeMs: st.mtimeMs, stamp: fileStamp(st) };
     writeRunIndex(dir, index);
   } catch {
     // the index is a cache; the record is the truth and it is already on disk
@@ -3752,17 +3779,18 @@ export function listRunSummaries(tenant: string, workspace: string): RunSummary[
     if (!f.endsWith(".json") || f.startsWith(".")) continue;
     const id = f.slice(0, -".json".length);
     present.add(id);
-    let mtimeMs: number;
+    let st: fs.Stats;
     try {
-      mtimeMs = fs.statSync(path.join(dir, f)).mtimeMs;
+      st = fs.statSync(path.join(dir, f));
     } catch {
       continue; // pruned between the listing and the stat
     }
+    const stamp = fileStamp(st);
     const row = index.runs[id];
-    if (row && row.mtimeMs === mtimeMs) continue;
+    if (row && row.stamp === stamp) continue;
     try {
       const run = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")) as RunRecord;
-      index.runs[id] = { ...summarizeRun(run), mtimeMs };
+      index.runs[id] = { ...summarizeRun(run), mtimeMs: st.mtimeMs, stamp };
       changed = true;
     } catch {
       // a torn or foreign file is not a run; leave whatever row it had
@@ -3781,7 +3809,7 @@ export function listRunSummaries(tenant: string, workspace: string): RunSummary[
     }
   }
   return Object.values(index.runs)
-    .map(({ mtimeMs: _m, ...row }) => row)
+    .map(({ mtimeMs: _m, stamp: _s, ...row }) => row)
     .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 }
 

package/dist/src/git-hook.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/git-hook.js

@@ -1,70 +0,0 @@
-// The pre-receive check, run by git inside a push.
-//
-// git feeds "<old> <new> <ref>" lines on stdin. For a push to main, read the
-// tree at the new commit straight from the object store and run the deploy
-// checks on it. Any issue: print them and exit non-zero — the push is refused
-// and the person sees exactly what a dashboard deploy would have told them,
-// in their terminal, before anything changed.
-//
-// Runs as its own process under git's environment. GIT_DIR is set by git.
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { deployIssues, runsInFlight } from "./deploy.js";
-const dir = process.env.GIT_DIR;
-if (!dir)
-    process.exit(0);
-// `_library.git` is the account shelf, not a workspace: it holds tools,
-// skills and knowledge and has no agents by definition. The workspace rules
-// refused every push to it with "no agents". Its sync (syncLibraryFromTree)
-// validates what it accepts on receive; nothing here to add yet.
-// Inside a hook git sets GIT_DIR relative to the repo ("."), so resolve it
-// against the cwd before asking for its name.
-if (path.basename(path.resolve(process.cwd(), dir)) === "_library.git")
-    process.exit(0);
-const input = fs.readFileSync(0, "utf8");
-const git = (args) => {
-    const r = spawnSync("git", ["--git-dir", dir, ...args], { maxBuffer: 64 * 1024 * 1024 });
-    return r.status === 0 ? r.stdout.toString() : null;
-};
-// The client is gone by the time the deploy runs, so this is the only moment
-// a person can be told their push will not take effect yet. A warning, not a
-// refusal: the commit is fine and the scheduler applies it when the runs end.
-const here = path.basename(path.resolve(process.cwd(), dir));
-if (here.endsWith(".git")) {
-    const workspace = here.slice(0, -4);
-    const tenant = path.basename(path.resolve(process.cwd(), dir, "..", ".."));
-    try {
-        const live = runsInFlight(tenant, workspace);
-        if (live.length) {
-            process.stderr.write(`\nfoldrun: ${live.length} run${live.length === 1 ? " is" : "s are"} in flight, so this push is not live yet.\n` +
-                `  It is on main and will be applied automatically when they finish.\n\n`);
-        }
-    }
-    catch {
-        // A warning that cannot be computed must never fail a push.
-    }
-}
-let refused = false;
-for (const line of input.split("\n").filter(Boolean)) {
-    const [, newSha, ref] = line.split(" ");
-    if (ref !== "refs/heads/main" || /^0+$/.test(newSha))
-        continue;
-    const tree = git(["ls-tree", "-r", "--name-only", newSha]) ?? "";
-    const files = tree
-        .split("\n")
-        .filter(Boolean)
-        .flatMap((p) => {
-        const content = git(["show", `${newSha}:${p}`]);
-        return content === null ? [] : [{ path: p, content }];
-    });
-    const issues = deployIssues(files);
-    if (issues.length) {
-        refused = true;
-        process.stderr.write(`\nfoldrun: refusing this push — ${issues.length} problem${issues.length === 1 ? "" : "s"} the checks would have stopped at deploy:\n`);
-        for (const i of issues)
-            process.stderr.write(`  ${i.where}: ${i.message}\n`);
-        process.stderr.write(`\nFix and push again. (foldrun check runs the same rules locally.)\n\n`);
-    }
-}
-process.exit(refused ? 1 : 0);

package/dist/src/git.d.ts

@@ -1,37 +0,0 @@
-/**
- * The secret a repository signs its pushes with.
- *
- * Derived rather than stored, exactly like a flow's webhook token: HMAC of the
- * workspace's identity under the install key. Nothing new to persist, unique
- * per workspace, and rotating FOLDRUN_SECRET_KEY invalidates every connection
- * at once.
- */
-export declare function gitSecret(tenant: string, workspace: string): string;
-export declare function gitHookPath(tenant: string, workspace: string): string;
-/**
- * Whether a request really came from the repository it claims to.
- *
- * Compared in constant time: a byte-by-byte early return leaks the expected
- * signature to anyone willing to time enough requests. The raw body is
- * required — re-serializing parsed JSON changes bytes GitHub signed.
- */
-export declare function verifySignature(secret: string, rawBody: string, header: string | null): boolean;
-export interface PushEvent {
-    repo: string;
-    /** Full ref, e.g. refs/heads/main. */
-    ref: string;
-    branch: string;
-    commit: string;
-    message: string | null;
-    pusher: string | null;
-}
-/** What we need out of a GitHub push payload, or null if it isn't one. */
-export declare function parsePush(payload: unknown): PushEvent | null;
-/**
- * The repository at one commit, as a gzipped tarball.
- *
- * A token is only needed for a private repository. It is read from the
- * environment rather than taken as an argument so a caller cannot be tricked
- * into forwarding one somewhere else.
- */
-export declare function fetchTarball(repo: string, commit: string): Promise<Buffer>;

package/dist/src/git.js

@@ -1,101 +0,0 @@
-// git push → deployed.
-//
-// A workspace is markdown, so there is no build to run: a push is a fetch of
-// the tree at that commit, a check, and a swap. This module is the GitHub half
-// — the secret a repository signs with, the payload shape, and pulling the
-// tarball. `deploy.ts` decides whether the result is allowed to go live.
-//
-// The tarball, not a clone: one HTTP call, no git binary, no working copy kept
-// on the server. A markdown workspace is a few hundred kilobytes.
-import crypto from "node:crypto";
-import { installKey } from "./webhook.js";
-/** GitHub refuses to fetch anything larger, and neither should we. */
-const MAX_TARBALL = 25 * 1024 * 1024;
-/**
- * The secret a repository signs its pushes with.
- *
- * Derived rather than stored, exactly like a flow's webhook token: HMAC of the
- * workspace's identity under the install key. Nothing new to persist, unique
- * per workspace, and rotating FOLDRUN_SECRET_KEY invalidates every connection
- * at once.
- */
-export function gitSecret(tenant, workspace) {
-    return crypto
-        .createHmac("sha256", installKey())
-        .update(`git/${tenant}/${workspace}`)
-        .digest("hex");
-}
-export function gitHookPath(tenant, workspace) {
-    return `/api/git/${tenant}/${workspace}`;
-}
-/**
- * Whether a request really came from the repository it claims to.
- *
- * Compared in constant time: a byte-by-byte early return leaks the expected
- * signature to anyone willing to time enough requests. The raw body is
- * required — re-serializing parsed JSON changes bytes GitHub signed.
- */
-export function verifySignature(secret, rawBody, header) {
-    if (!header)
-        return false;
-    const expected = `sha256=${crypto.createHmac("sha256", secret).update(rawBody).digest("hex")}`;
-    const a = Buffer.from(expected);
-    const b = Buffer.from(header);
-    return a.length === b.length && crypto.timingSafeEqual(a, b);
-}
-/** What we need out of a GitHub push payload, or null if it isn't one. */
-export function parsePush(payload) {
-    if (!payload || typeof payload !== "object")
-        return null;
-    const p = payload;
-    const repo = p.repository?.full_name;
-    const ref = p.ref;
-    const commit = p.after;
-    if (typeof repo !== "string" || typeof ref !== "string" || typeof commit !== "string") {
-        return null;
-    }
-    // A deleted branch reports all zeros and ships no tree.
-    if (/^0+$/.test(commit))
-        return null;
-    return {
-        repo,
-        ref,
-        branch: ref.replace(/^refs\/heads\//, ""),
-        commit,
-        message: typeof p.head_commit?.message === "string" ? p.head_commit.message : null,
-        pusher: typeof p.pusher?.name === "string" ? p.pusher.name : null,
-    };
-}
-/**
- * The repository at one commit, as a gzipped tarball.
- *
- * A token is only needed for a private repository. It is read from the
- * environment rather than taken as an argument so a caller cannot be tricked
- * into forwarding one somewhere else.
- */
-export async function fetchTarball(repo, commit) {
-    if (!/^[\w.-]+\/[\w.-]+$/.test(repo))
-        throw new Error(`refusing to fetch "${repo}"`);
-    if (!/^[0-9a-f]{7,40}$/i.test(commit))
-        throw new Error(`refusing to fetch commit "${commit}"`);
-    const headers = {
-        accept: "application/vnd.github+json",
-        "user-agent": "foldrun",
-        "x-github-api-version": "2022-11-28",
-    };
-    const token = process.env.GITHUB_TOKEN;
-    if (token)
-        headers.authorization = `Bearer ${token}`;
-    const res = await fetch(`https://api.github.com/repos/${repo}/tarball/${commit}`, { headers });
-    if (!res.ok) {
-        throw new Error(`GitHub returned ${res.status} for ${repo}@${commit.slice(0, 8)}` +
-            (res.status === 404 && !token
-                ? " — a private repository needs GITHUB_TOKEN set on the server"
-                : ""));
-    }
-    const buf = Buffer.from(await res.arrayBuffer());
-    if (buf.length > MAX_TARBALL) {
-        throw new Error(`${repo} is ${Math.round(buf.length / 1e6)}MB — too large to deploy`);
-    }
-    return buf;
-}