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

package/src/collab/terminals.js

@@ -0,0 +1,361 @@
+import { constants } from "node:fs";
+import { mkdir, open, realpath, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { CODEFLOW_HOME } from "../config.js";
+import { readJson, send } from "../http.js";
+import { logError } from "../log.js";
+import { Shells } from "../shell.js";
+import { roleAtLeast } from "../shared-accounts.js";
+import { CollabError } from "./model.js";
+const object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const id = (v) => typeof v === "string" && /^[a-zA-Z0-9_-]{1,100}$/.test(v);
+const keys = (v, allowed) => {
+  if (Object.keys(v).some((key) => !allowed.includes(key))) throw new CollabError("Unknown terminal field");
+};
+function grant(value) {
+  if (!object(value)) throw new CollabError("Invalid terminal grant");
+  keys(value, ["projectId", "enabled", "userIds"]);
+  if (!id(value.projectId) || typeof value.enabled !== "boolean" || !Array.isArray(value.userIds) || value.userIds.length > 128 || !value.userIds.every(id) || new Set(value.userIds).size !== value.userIds.length) throw new CollabError("Choose a project and its permitted teammates");
+  return structuredClone(value);
+}
+function size(raw) {
+  if (!Number.isInteger(raw.cols) || !Number.isInteger(raw.rows) || Number(raw.cols) < 2 || Number(raw.cols) > 500 || Number(raw.rows) < 1 || Number(raw.rows) > 200) throw new CollabError("Terminal size must be 2\u2013500 columns and 1\u2013200 rows");
+  return { cols: raw.cols, rows: raw.rows };
+}
+const metadata = ({ id: id2, projectId, repository, userId, displayName, startedAt, status }) => ({ id: id2, projectId, repository, userId, displayName, startedAt, status });
+const TERMINAL_IDLE_MS = 30 * 6e4;
+class TeamTerminals {
+  constructor(options) {
+    this.options = options;
+    this.shells = options.shells ?? new Shells();
+    this.file = options.file ?? join(CODEFLOW_HOME, "terminal-access.json");
+    this.now = options.now ?? Date.now;
+  }
+  state = { version: 1, revision: 0, grants: [], audit: [] };
+  sessions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  ready = false;
+  closed = false;
+  chain = Promise.resolve();
+  timer;
+  shells;
+  file;
+  now;
+  serial(fn) {
+    const next = this.chain.catch(() => {
+    }).then(fn);
+    this.chain = next;
+    return next;
+  }
+  require() {
+    if (!this.ready || this.closed) throw new CollabError("Team terminals are unavailable", 503);
+  }
+  async load() {
+    try {
+      const handle = await open(this.file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      let raw;
+      try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error("Invalid terminal access storage");
+        raw = JSON.parse(await handle.readFile("utf8"));
+      } finally {
+        await handle.close();
+      }
+      if (!object(raw) || raw.version !== 1 || !Number.isSafeInteger(raw.revision) || Number(raw.revision) < 0 || !Array.isArray(raw.grants) || raw.grants.length > 200 || !Array.isArray(raw.audit) || raw.audit.length > 500) throw new Error("Invalid terminal access storage");
+      raw.grants.forEach(grant);
+      if (new Set(raw.grants.map((g) => g.projectId)).size !== raw.grants.length) throw new Error("Duplicate terminal grants");
+      for (const event of raw.audit) if (!object(event) || !["opened", "closed"].includes(String(event.action)) || !Number.isFinite(event.at) || !id(event.by) || !object(event.session) || !id(event.session.id) || !id(event.session.projectId) || !id(event.session.userId) || !id(event.session.repository) || typeof event.session.displayName !== "string" || !Number.isFinite(event.session.startedAt) || !["running", "exited"].includes(String(event.session.status)) || event.reason !== void 0 && typeof event.reason !== "string") throw new Error("Invalid terminal audit record");
+      this.state = raw;
+      const openSessions = /* @__PURE__ */ new Map();
+      for (const event of this.state.audit) {
+        if (event.action === "opened") openSessions.set(event.session.id, event.session);
+        else openSessions.delete(event.session.id);
+      }
+      for (const session of openSessions.values()) this.record("closed", session, "owner", "Server restarted");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await this.persist();
+    this.ready = true;
+  }
+  start() {
+    this.timer ??= setInterval(() => void this.reap().catch((error) => logError("Team terminal cleanup failed", error)), 1e3);
+    this.timer.unref();
+  }
+  active() {
+    return this.sessions.size;
+  }
+  user(userId) {
+    return this.options.users().find((user) => user.id === userId && user.enabled);
+  }
+  allowed(userId, projectId) {
+    const user = this.user(userId), g = this.state.grants.find((g2) => g2.projectId === projectId);
+    return !!this.options.projectRepos(projectId) && !!user && roleAtLeast(user.roles[projectId], "contributor") && !!g?.enabled && g.userIds.includes(userId) && this.options.enabled();
+  }
+  valid(session) {
+    return this.allowed(session.userId, session.projectId) && this.user(session.userId)?.revision === session.accountRevision && this.options.resolveRepo(session.projectId, session.repository) === session.cwd && !!this.options.projectRepos(session.projectId)?.includes(session.cwd);
+  }
+  view(actor) {
+    this.require();
+    const owner = actor.kind === "owner";
+    const visible = (p) => !!this.options.projectRepos(p) && (owner || !!this.user(actor.userId)?.roles[p]);
+    return {
+      revision: this.state.revision,
+      available: this.options.enabled(),
+      grants: this.state.grants.filter((g) => visible(g.projectId)).map((g) => owner ? structuredClone(g) : { projectId: g.projectId, allowed: this.allowed(actor.userId, g.projectId) }),
+      sessions: [...this.sessions.values()].filter((s) => owner || s.userId === actor.userId && visible(s.projectId) && this.valid(s)).map(metadata),
+      audit: owner ? structuredClone(this.state.audit.slice(-100)) : [],
+      idleMinutes: 30,
+      maxPerUser: 2
+    };
+  }
+  configure(raw) {
+    return this.serial(async () => {
+      this.require();
+      keys(raw, ["revision", "grant"]);
+      if (raw.revision !== this.state.revision) throw new CollabError("Terminal settings changed; reload before saving", 409);
+      const next = grant(raw.grant);
+      if (!this.options.projectRepos(next.projectId)) throw new CollabError("Project not found", 404);
+      if (next.userIds.some((uid) => {
+        const user = this.user(uid);
+        return !user || !roleAtLeast(user.roles[next.projectId], "contributor");
+      })) throw new CollabError("Grant terminals only to enabled project contributors or maintainers");
+      if (!this.state.grants.some((g) => g.projectId === next.projectId) && this.state.grants.length >= 200) throw new CollabError("At most 200 project terminal policies may be configured");
+      this.state.grants = [...this.state.grants.filter((g) => g.projectId !== next.projectId), next];
+      this.state.revision++;
+      await this.persist();
+      await this.reapNow();
+      this.options.changed(next.projectId);
+      return this.view({ kind: "owner", userId: "owner", displayName: "Owner" });
+    });
+  }
+  open(actor, raw, authorize) {
+    return this.serial(async () => {
+      this.require();
+      authorize();
+      keys(raw, ["projectId", "repository", "cols", "rows"]);
+      if (actor.kind !== "member" || actor.via !== "browser") throw new CollabError("Use your teammate account to open a team terminal", 403);
+      if (!id(raw.projectId) || !id(raw.repository) || !this.allowed(actor.userId, raw.projectId)) throw new CollabError("The owner has not granted terminal access to this project", 403);
+      const cwd = this.options.resolveRepo(raw.projectId, raw.repository);
+      if (!cwd || !this.options.projectRepos(raw.projectId)?.includes(cwd) || await realpath(cwd).catch(() => void 0) !== cwd) throw new CollabError("The host repository mapping is unavailable", 409);
+      const dimensions = size(raw);
+      await this.reapNow();
+      if (this.sessions.size >= 8 || [...this.sessions.values()].filter((s) => s.userId === actor.userId).length >= 2) throw new CollabError("Close a terminal first: at most two per teammate and eight on the host", 409);
+      if (!await this.shells.interactive()) throw new CollabError("Interactive terminals require Python 3 PTY support on the host", 409);
+      authorize();
+      if (!this.allowed(actor.userId, raw.projectId)) throw new CollabError("Terminal permission changed", 403);
+      const user = this.user(actor.userId), revision = user.revision;
+      const shell = await this.shells.open(cwd, { pty: true, ...dimensions });
+      const session = { id: shell.id, projectId: raw.projectId, repository: raw.repository, userId: user.id, displayName: user.displayName, startedAt: this.now(), lastInput: this.now(), accountRevision: revision, cwd, status: shell.status };
+      try {
+        authorize();
+        if (!this.valid(session) || !shell.interactive || this.closed) throw new CollabError("Terminal access changed while opening", 403);
+      } catch (error) {
+        this.shells.close(shell.id);
+        throw error;
+      }
+      this.sessions.set(shell.id, session);
+      this.record("opened", session, actor.userId);
+      await this.persist();
+      this.options.activity?.();
+      this.options.changed(session.projectId);
+      return metadata(session);
+    });
+  }
+  own(actor, sessionId) {
+    this.require();
+    const session = this.sessions.get(sessionId);
+    if (!session || session.userId !== actor.userId || !this.valid(session)) throw new CollabError("Terminal unavailable", 404);
+    return session;
+  }
+  input(actor, sessionId, raw) {
+    const session = this.own(actor, sessionId);
+    keys(raw, ["data", "binary"]);
+    if (raw.data === void 0 === (raw.binary === void 0)) throw new CollabError("Send data or binary keystrokes");
+    const data = raw.data ?? raw.binary;
+    if (typeof data !== "string" || Buffer.byteLength(data) > 32 * 1024 || raw.binary !== void 0 && /[^\x00-\xff]/.test(data)) throw new CollabError("Send at most 32 KiB of terminal input");
+    if (this.shells.pendingInputBytes(sessionId) > 128 * 1024) throw new CollabError("Terminal input is backed up; wait before sending more", 429);
+    if (!this.shells.type(sessionId, data, raw.binary === void 0 ? "utf8" : "latin1")) throw new CollabError("Terminal has exited", 409);
+    session.lastInput = this.now();
+    this.options.activity?.();
+    return { ok: true };
+  }
+  resize(actor, sessionId, raw) {
+    this.own(actor, sessionId);
+    keys(raw, ["cols", "rows"]);
+    const s = size(raw);
+    if (!this.shells.resize(sessionId, s.cols, s.rows)) throw new CollabError("Terminal has exited", 409);
+    return { ok: true };
+  }
+  record(action, session, by, reason) {
+    this.state.audit.push({ at: this.now(), action, session: metadata(session), by, ...reason ? { reason } : {} });
+    this.state.audit = this.state.audit.slice(-500);
+  }
+  end(session, by, reason) {
+    this.shells.close(session.id);
+    this.sessions.delete(session.id);
+    for (const listener of this.listeners.get(session.id) ?? []) listener();
+    this.listeners.delete(session.id);
+    this.record("closed", session, by, reason);
+    this.options.changed(session.projectId);
+  }
+  closeSession(actor, sessionId) {
+    return this.serial(async () => {
+      this.require();
+      const session = this.sessions.get(sessionId);
+      if (!session || actor.kind !== "owner" && session.userId !== actor.userId) throw new CollabError("Terminal unavailable", 404);
+      this.end(session, actor.userId, "Closed by user");
+      await this.persist();
+      return { closed: true };
+    });
+  }
+  reap() {
+    return this.serial(() => this.reapNow());
+  }
+  async reapNow() {
+    if (!this.ready || this.closed) return;
+    let changed = false;
+    for (const session of this.sessions.values()) {
+      const shell = this.shells.get(session.id);
+      const reason = !this.valid(session) ? "Access revoked or repository changed" : this.now() - session.lastInput >= TERMINAL_IDLE_MS ? "No keyboard input for 30 minutes" : !shell || shell.status === "exited" ? "Shell exited" : void 0;
+      if (reason) {
+        this.end(session, "owner", reason);
+        changed = true;
+      }
+    }
+    if (changed) await this.persist();
+  }
+  watch(actor, sessionId, res, authorize) {
+    this.own(actor, sessionId);
+    authorize();
+    const watching = this.listeners.get(sessionId) ?? /* @__PURE__ */ new Set();
+    if (watching.size >= 2) throw new CollabError("This terminal is already open in two tabs", 429);
+    let closed = false, stop, timer;
+    const close = () => {
+      if (closed) return;
+      closed = true;
+      stop?.();
+      if (timer) clearInterval(timer);
+      watching.delete(close);
+      res.destroy();
+    };
+    watching.add(close);
+    this.listeners.set(sessionId, watching);
+    res.once("close", close);
+    const check = () => {
+      authorize();
+      this.own(actor, sessionId);
+    };
+    const emit = (event) => {
+      if (closed) return;
+      try {
+        check();
+        if (res.writableLength > 512 * 1024) return close();
+        res.write(`data: ${JSON.stringify(event)}
+
+`);
+      } catch {
+        close();
+      }
+    };
+    res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", "connection": "keep-alive", "x-accel-buffering": "no" });
+    res.flushHeaders();
+    stop = this.shells.subscribe(sessionId, emit);
+    emit({ type: "hello", shell: this.shells.get(sessionId), history: this.shells.history(sessionId) });
+    if (closed) {
+      stop?.();
+      return;
+    }
+    timer = setInterval(() => {
+      try {
+        check();
+        if (res.writableLength > 512 * 1024) return close();
+        res.write(": connected\n\n");
+      } catch {
+        close();
+      }
+    }, 1e3);
+    timer.unref();
+  }
+  async persist() {
+    const temp = `${this.file}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+      await mkdir(dirname(this.file), { recursive: true, mode: 448 });
+      const handle = await open(temp, "wx", 384);
+      try {
+        await handle.writeFile(JSON.stringify(this.state));
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temp, this.file);
+      if (process.platform !== "win32") {
+        const folder = await open(dirname(this.file), "r");
+        try {
+          await folder.sync();
+        } finally {
+          await folder.close();
+        }
+      }
+    } catch (error) {
+      this.ready = false;
+      for (const session of [...this.sessions.values()]) this.end(session, "owner", "Audit storage unavailable");
+      throw error;
+    } finally {
+      await rm(temp, { force: true }).catch(() => {
+      });
+    }
+  }
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    this.closed = true;
+    await this.chain.catch(() => {
+    });
+    for (const session of [...this.sessions.values()]) this.end(session, "owner", "Server stopped");
+    if (this.ready) await this.persist();
+    this.shells.closeAll();
+  }
+}
+async function handleTeamTerminals(req, res, parts, service, current, mutation) {
+  try {
+    const method = req.method ?? "GET", actor = current();
+    if (method !== "GET") mutation();
+    const body = () => readJson(req, 192 * 1024, { timeoutMs: 1e4 });
+    if (parts.length === 2 && method === "GET") return send(res, 200, service.view(actor));
+    if (parts.length === 2 && method === "POST") {
+      const raw = await body();
+      return send(res, 201, await service.open(current(), raw, () => {
+        current();
+      }));
+    }
+    if (parts.length === 3 && parts[2] === "settings" && method === "PUT") {
+      if (actor.kind !== "owner") throw new CollabError("Only the host owner may grant terminals", 403);
+      const raw = await body();
+      current();
+      return send(res, 200, await service.configure(raw));
+    }
+    const sessionId = parts[2];
+    if (sessionId && parts.length === 3 && method === "DELETE") {
+      const raw = await body();
+      keys(raw, []);
+      return send(res, 200, await service.closeSession(current(), sessionId));
+    }
+    if (sessionId && parts.length === 4 && method === "GET" && parts[3] === "events") return service.watch(actor, sessionId, res, () => {
+      current();
+    });
+    if (sessionId && parts.length === 4 && method === "POST" && ["input", "resize"].includes(parts[3])) {
+      const raw = await body();
+      return send(res, 200, parts[3] === "input" ? service.input(current(), sessionId, raw) : service.resize(current(), sessionId, raw));
+    }
+    throw new CollabError("Unknown team terminal operation", 404);
+  } catch (error) {
+    if (error instanceof CollabError) return send(res, error.status, { error: error.message });
+    throw error;
+  }
+}
+export {
+  TERMINAL_IDLE_MS,
+  TeamTerminals,
+  handleTeamTerminals
+};

package/src/collaboration-reviews.js

@@ -0,0 +1,116 @@
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { CODEFLOW_HOME } from "./config.js";
+import { redactExport } from "./privacy.js";
+class CollaborationReviewError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+}
+const queues = /* @__PURE__ */ new Map();
+const validId = (value) => typeof value === "string" && /^[a-zA-Z0-9_-]{1,100}$/.test(value);
+const validHead = (value) => typeof value === "string" && /^[a-f0-9]{40,64}$/.test(value);
+function actor(value) {
+  if (!value || typeof value.id !== "string" || !/^(?:owner|shared:[a-zA-Z0-9_-]{1,100})$/.test(value.id) || typeof value.name !== "string" || !value.name.trim() || value.name.length > 120 || /[\x00-\x1f\x7f]/.test(value.name)) throw new CollaborationReviewError("A server-authenticated review identity is required");
+  return { id: value.id, name: value.name.trim() };
+}
+function branch(value) {
+  if (typeof value !== "string" || !value || value.length > 250 || /[\x00-\x20\x7f]/.test(value)) throw new CollaborationReviewError("Choose a result branch");
+  return value;
+}
+class CollaborationReviews {
+  constructor(home = CODEFLOW_HOME) {
+    this.home = home;
+  }
+  path(runId) {
+    if (!validId(runId)) throw new CollaborationReviewError("Invalid run identity");
+    return join(this.home, "shared-reviews", `${runId}.json`);
+  }
+  async list(runId) {
+    return redactExport(await this.read(runId));
+  }
+  async read(runId) {
+    const file = this.path(runId);
+    let source;
+    try {
+      const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error("Invalid comment storage");
+        source = await handle.readFile("utf8");
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, revision: 0, comments: [] };
+      throw new CollaborationReviewError("Review comments cannot be read; existing records were left untouched", 503);
+    }
+    try {
+      const value = JSON.parse(source);
+      if (Object.keys(value).some((key) => !["version", "revision", "comments"].includes(key)) || value.version !== 1 || !Number.isSafeInteger(value.revision) || value.revision < 0 || !Array.isArray(value.comments) || value.comments.length > 200) throw new Error("Invalid thread");
+      for (const comment of value.comments) {
+        if (!comment || Object.keys(comment).some((key) => !["id", "branch", "head", "text", "actor", "at"].includes(key)) || typeof comment.id !== "string" || !/^[a-f0-9-]{36}$/.test(comment.id) || branch(comment.branch) !== comment.branch || !validHead(comment.head) || typeof comment.text !== "string" || !comment.text.trim() || comment.text.length > 4e3 || !Number.isSafeInteger(comment.at) || comment.at < 0) throw new Error("Invalid comment");
+        actor(comment.actor);
+        if (Object.keys(comment.actor).some((key) => !["id", "name"].includes(key))) throw new Error("Invalid actor");
+      }
+      if (new Set(value.comments.map((comment) => comment.id)).size !== value.comments.length) throw new Error("Duplicate comment");
+      return value;
+    } catch {
+      throw new CollaborationReviewError("Review comments are invalid; existing records were left untouched", 503);
+    }
+  }
+  async add(runId, input, identity, resolveHead, authorize = () => {
+  }) {
+    const file = this.path(runId);
+    const resultBranch = branch(input.branch);
+    const author = actor(identity);
+    if (!validHead(input.expectedHead)) throw new CollaborationReviewError("Choose an exact result commit");
+    if (typeof input.text !== "string" || !input.text.trim() || input.text.length > 4e3 || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(input.text)) throw new CollaborationReviewError("Review comments need 1\u20134000 characters of text");
+    const text = input.text.trim(), expectedHead = input.expectedHead;
+    const next = (queues.get(file) ?? Promise.resolve()).catch(() => void 0).then(async () => {
+      const current = await this.read(runId);
+      if (current.comments.length >= 200) throw new CollaborationReviewError("This thread has reached its 200-comment limit", 409);
+      if (await resolveHead() !== expectedHead) throw new CollaborationReviewError("The result commit changed; refresh before commenting", 409);
+      authorize();
+      const updated = { version: 1, revision: current.revision + 1, comments: [...current.comments, { id: randomUUID(), branch: resultBranch, head: expectedHead, text, actor: author, at: Date.now() }] };
+      await mkdir(dirname(file), { recursive: true, mode: 448 });
+      const temp = `${file}.${randomUUID()}.tmp`;
+      try {
+        const handle = await open(temp, "wx", 384);
+        try {
+          await handle.writeFile(JSON.stringify(updated));
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        authorize();
+        await rename(temp, file);
+        if (process.platform !== "win32") {
+          const directory = await open(dirname(file), "r");
+          try {
+            await directory.sync();
+          } finally {
+            await directory.close();
+          }
+        }
+      } finally {
+        await rm(temp, { force: true }).catch(() => {
+        });
+      }
+      return redactExport(updated);
+    });
+    queues.set(file, next);
+    try {
+      return await next;
+    } finally {
+      if (queues.get(file) === next) queues.delete(file);
+    }
+  }
+}
+export {
+  CollaborationReviewError,
+  CollaborationReviews
+};

package/src/config.js

@@ -0,0 +1,48 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CODEFLOW_HOME = process.env.CODEFLOW_HOME ?? join(homedir(), ".codeflow");
+const MAX_TIMER_MS = 2147483647;
+const warned = /* @__PURE__ */ new Set();
+function envNumber(name, fallback, range = {}) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  const { min = -Infinity, max = Infinity } = range;
+  if (!Number.isFinite(value) || value < min || value > max) {
+    if (!warned.has(name)) {
+      warned.add(name);
+      const bounds = [min > -Infinity ? `at least ${min}` : "", max < Infinity ? `at most ${max}` : ""].filter(Boolean).join(", ");
+      console.warn(`code-flow: ignoring ${name}=${JSON.stringify(raw)} (${bounds ? `must be a number, ${bounds}` : "not a number"}); using ${fallback}`);
+    }
+    return fallback;
+  }
+  return value;
+}
+function timerMs(ms, min = 0) {
+  return Number.isFinite(ms) ? Math.min(MAX_TIMER_MS, Math.max(min, ms)) : MAX_TIMER_MS;
+}
+const WORKTREE_DIR = process.env.CODEFLOW_WORKTREE_DIR ?? ".worktrees";
+const PORT = envNumber("PORT", 4317, { min: 1, max: 65535 });
+const MAX_DIFF_CHARS = envNumber("CODEFLOW_MAX_DIFF_CHARS", 6e4, { min: 1e3 });
+const STEP_TIMEOUT_MS = timerMs(envNumber("CODEFLOW_STEP_TIMEOUT_MIN", 30, { min: 0.01, max: 24 * 60 }) * 6e4);
+const STEP_IDLE_MS = timerMs(envNumber("CODEFLOW_STEP_IDLE_MIN", 15, { min: 0.01, max: 24 * 60 }) * 6e4);
+function codexTransport() {
+  const value = process.env.CODEFLOW_CODEX_TRANSPORT;
+  return value === "app-server" || value === "exec" ? value : "auto";
+}
+function autoTeamEnabled() {
+  return !["0", "false", "off"].includes((process.env.CODEFLOW_AUTO_TEAM_ENABLED ?? "true").toLowerCase());
+}
+export {
+  CODEFLOW_HOME,
+  MAX_DIFF_CHARS,
+  MAX_TIMER_MS,
+  PORT,
+  STEP_IDLE_MS,
+  STEP_TIMEOUT_MS,
+  WORKTREE_DIR,
+  autoTeamEnabled,
+  codexTransport,
+  envNumber,
+  timerMs
+};

package/src/context-budget.js

@@ -0,0 +1,14 @@
+function validateContextBudget(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Context budget must be an object.");
+  const budget = value;
+  if (Object.keys(budget).some((key) => !["maxPromptBytes", "maxApproximateTokens", "policy"].includes(key))) throw new Error("Unknown context budget field.");
+  const integer = (number, max) => Number.isSafeInteger(number) && Number(number) >= 1 && Number(number) <= max;
+  if (budget.maxPromptBytes !== void 0 && !integer(budget.maxPromptBytes, 64 * 1024 * 1024) || budget.maxApproximateTokens !== void 0 && !integer(budget.maxApproximateTokens, 16 * 1024 * 1024)) throw new Error("Context ceilings must be positive bounded integers.");
+  if (budget.maxPromptBytes === void 0 && budget.maxApproximateTokens === void 0) throw new Error("Choose at least one context ceiling.");
+  if (budget.policy !== void 0 && budget.policy !== "warn" && budget.policy !== "block") throw new Error("Context budget policy must be warn or block.");
+  return { ...budget.maxPromptBytes !== void 0 ? { maxPromptBytes: budget.maxPromptBytes } : {}, ...budget.maxApproximateTokens !== void 0 ? { maxApproximateTokens: budget.maxApproximateTokens } : {}, policy: budget.policy ?? "warn" };
+}
+export {
+  validateContextBudget
+};