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

package/src/repo-config.js

@@ -0,0 +1,201 @@
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { lstat, readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { COPIED_FILES, git, gitWithInput, worktreeGit } from "./git.js";
+const CONFIG_PATH = ".codeflow/config.json";
+async function readRepoConfig(repo) {
+  const file = join(repo, CONFIG_PATH);
+  if (!existsSync(file)) return { config: {}, found: false };
+  try {
+    const raw = JSON.parse(await readFile(file, "utf8"));
+    const config = {};
+    const str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+    config.check = str(raw.check);
+    config.setup = str(raw.setup);
+    if (Array.isArray(raw.copy)) config.copy = raw.copy.filter((p) => typeof p === "string" && !!p.trim());
+    if (raw.run && str(raw.run.command)) config.run = { command: str(raw.run.command), port: Number(raw.run.port) || void 0 };
+    if (raw.models && typeof raw.models === "object") config.models = raw.models;
+    if (raw.limits && typeof raw.limits === "object") {
+      const positive = (v) => Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : void 0;
+      const steps = positive(raw.limits.maxSteps);
+      config.limits = { maxMinutes: positive(raw.limits.maxMinutes), maxSteps: steps === void 0 ? void 0 : Math.max(1, Math.round(steps)) };
+    }
+    if (["safe", "standard", "trusted"].includes(raw.trust)) config.trust = raw.trust;
+    if (typeof raw.image === "string" && /^[\w./:@-]{1,200}$/.test(raw.image.trim())) config.image = raw.image.trim();
+    if (typeof raw.learn === "boolean") config.learn = raw.learn;
+    if (typeof raw.prove === "boolean") config.prove = raw.prove;
+    return { config, found: true };
+  } catch (err) {
+    return { config: {}, found: true, error: `${CONFIG_PATH}: ${err.message}` };
+  }
+}
+async function copyIntoWorktree(repo, worktree, patterns) {
+  const copied = [];
+  const refused = [];
+  const root = await realpath(repo);
+  const destination = resolve(worktree);
+  const destinationRoot = await realpath(worktree);
+  const candidates = /* @__PURE__ */ new Set();
+  for (const raw of patterns) {
+    const pattern = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!pattern || pattern.startsWith("/") || pattern.includes("\0") || pattern.split("/").some((part) => !part || part === ".." || part === ".")) continue;
+    for (const rel of await expand(repo, pattern)) {
+      const from = join(repo, rel);
+      const info = await lstat(from).catch(() => null);
+      if (!info) continue;
+      if (info.isSymbolicLink()) {
+        refused.push({ path: rel, why: "it's a symbolic link" });
+        continue;
+      }
+      if (!info.isFile()) continue;
+      const real = await realpath(from).catch(() => "");
+      if (!real.startsWith(root + sep)) {
+        refused.push({ path: rel, why: "it's outside the repository" });
+        continue;
+      }
+      candidates.add(rel);
+    }
+  }
+  const ignored = new Set(
+    candidates.size ? (await gitWithInput(["check-ignore", "--stdin", "-z"], repo, [...candidates].join("\0") + "\0")).stdout.split("\0").filter(Boolean) : []
+  );
+  for (const rel of candidates) {
+    if (!ignored.has(rel)) {
+      refused.push({ path: rel, why: "git doesn't ignore it, so it would be committed with the agents' work" });
+      continue;
+    }
+    const result = copyWithoutLinks(root, destination, destinationRoot, rel);
+    if (result === "copied") copied.push(rel);
+    else if (result !== "exists") refused.push({ path: rel, why: result });
+  }
+  await recordCopied(repo, worktree, copied);
+  return { copied, refused };
+}
+function copyWithoutLinks(sourceRoot, destination, destinationRoot, rel, opts = {}) {
+  let from;
+  let to;
+  let created;
+  const target = join(destinationRoot, rel);
+  let output = target;
+  try {
+    if (lstatSync(destination).isSymbolicLink() || !lstatSync(destination).isDirectory() || realpathSync(destination) !== destinationRoot) return "the worktree root is a symbolic link or has changed";
+    verifyParents(sourceRoot, dirname(opts.sourcePath ?? rel), false);
+    verifyParents(destinationRoot, dirname(rel), true);
+    const source = join(sourceRoot, opts.sourcePath ?? rel);
+    const sourceInfo = lstatSync(source);
+    if (sourceInfo.isSymbolicLink()) return "it's a symbolic link";
+    if (!sourceInfo.isFile() || !realpathSync(source).startsWith(sourceRoot + sep)) return "it's outside the repository or isn't a regular file";
+    from = openSync(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+    if (!sameFile(sourceInfo, fstatSync(from))) return "the source file changed while preparing the copy";
+    const existing = statIfPresent(target);
+    if (existing?.isSymbolicLink()) return "the destination is a symbolic link";
+    if (existing && !existing.isFile()) return "the destination isn't a regular file";
+    if (existing && !opts.overwrite) return "exists";
+    if (opts.overwrite) output = `${target}.codeflow-copy-${randomBytes(10).toString("hex")}`;
+    to = openSync(output, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    created = fstatSync(to);
+    verifyParents(destinationRoot, dirname(rel), false);
+    if (!sameFile(created, lstatSync(output))) throw new Error("the destination changed while preparing the copy");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let bytes;
+    while (bytes = readSync(from, buffer, 0, buffer.length, null)) {
+      let written = 0;
+      while (written < bytes) written += writeSync(to, buffer, written, bytes - written);
+    }
+    if (output !== target) {
+      closeSync(to);
+      to = void 0;
+      verifyParents(destinationRoot, dirname(rel), false);
+      if (statIfPresent(target)?.isSymbolicLink()) throw new Error("the destination is a symbolic link");
+      renameSync(output, target);
+    }
+    return "copied";
+  } catch (error) {
+    if (!created && error.code === "EEXIST") return "exists";
+    if (created && sameFile(created, statIfPresent(output))) {
+      try {
+        unlinkSync(output);
+      } catch {
+      }
+    }
+    return error.message;
+  } finally {
+    if (from !== void 0) closeSync(from);
+    if (to !== void 0) closeSync(to);
+  }
+}
+function verifyParents(root, relative, create) {
+  let path = root;
+  const expectedRoot = lstatSync(root);
+  if (!expectedRoot.isDirectory() || expectedRoot.isSymbolicLink()) throw new Error("the copy root is not a regular directory");
+  for (const part of relative === "." ? [] : relative.split(sep)) {
+    path = join(path, part);
+    if (create) {
+      try {
+        mkdirSync(path, { mode: 448 });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+    }
+    const info = lstatSync(path);
+    if (info.isSymbolicLink()) throw new Error(`a parent directory is a symbolic link at \`${path.slice(root.length + 1).split(sep).join("/")}\``);
+    if (!info.isDirectory() || realpathSync(path) !== path) throw new Error("a parent directory is outside the copy root or isn't a directory");
+  }
+  if (!sameFile(expectedRoot, lstatSync(root))) throw new Error("the copy root changed while preparing the copy");
+}
+function statIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+const sameFile = (a, b) => !!b && a.dev === b.dev && a.ino === b.ino;
+async function recordCopied(repo, worktree, copied) {
+  if (!copied.length) return;
+  const at = await worktreeGit(repo, worktree).catch(() => void 0);
+  if (!at) return;
+  const res = await git(["rev-parse", "--git-path", COPIED_FILES], at);
+  if (res.code !== 0 || !res.stdout.trim()) return;
+  const file = resolve(worktree, res.stdout.trim());
+  const known = (await readFile(file, "utf8").catch(() => "")).split("\0").filter(Boolean);
+  await writeFile(file, [.../* @__PURE__ */ new Set([...known, ...copied])].map((p) => `${p}\0`).join(""));
+}
+async function copyFileInside(root, rel, from, opts = {}) {
+  const parts = rel.split(/[\\/]+/).filter((p) => p && p !== ".");
+  if (!parts.length || parts.includes("..") || /^[\\/]|^[a-z]:/i.test(rel)) return { copied: false, why: `\`${rel}\` isn't a path inside the worktree` };
+  try {
+    const [realRoot, sourceRoot] = await Promise.all([realpath(root), realpath(dirname(from))]);
+    const result = copyWithoutLinks(sourceRoot, resolve(root), realRoot, parts.join("/"), { sourcePath: basename(from), overwrite: opts.overwrite !== false });
+    return result === "copied" ? { copied: true } : { copied: false, ...result === "exists" ? {} : { why: result } };
+  } catch (error) {
+    return { copied: false, why: error.message };
+  }
+}
+async function expand(repo, pattern) {
+  if (!pattern.includes("*")) return [pattern];
+  const parts = pattern.split("/");
+  let current = [""];
+  for (const part of parts) {
+    const next = [];
+    for (const base of current) {
+      if (!part.includes("*")) {
+        next.push(base ? `${base}/${part}` : part);
+        continue;
+      }
+      const re = new RegExp(`^${part.split("*").map(escape).join("[^/]*")}$`);
+      const entries = await readdir(join(repo, base)).catch(() => []);
+      for (const e of entries) if (re.test(e)) next.push(base ? `${base}/${e}` : e);
+    }
+    current = next;
+  }
+  return current;
+}
+const escape = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+export {
+  CONFIG_PATH,
+  copyFileInside,
+  copyIntoWorktree,
+  readRepoConfig
+};