nomarmy 0.1.0-alpha.2 → 0.1.0-alpha.21

package/lib/registry-python.mjs

@@ -0,0 +1,98 @@
+// Fail closed before any credentialed Python fetch; diagnostics never echo input.
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { toPosix } from './path-utils.mjs';
+
+const refuse = (line, kind) => { throw new Error(`registries: Python line ${line}: ${kind} is not allowed with credentials`); };
+function requirement(value, line, cwd) {
+  if (/(?:^|\s)--?[^\s]/.test(value)) refuse(line, 'requirements option');
+  const dep = value.split(';')[0].trim();
+  if (/^(git|hg|svn|bzr)\+/i.test(dep)) refuse(line, 'VCS requirement');
+  if (dep.includes('@') || /^[a-z][a-z0-9+.-]*:/i.test(dep)) refuse(line, 'URL requirement');
+  if (fs.existsSync(path.join(cwd, dep)) || /[/\\]|^\.|\.(whl|zip|tar|gz|bz2|xz)$/i.test(dep)) refuse(line, 'path requirement');
+  // Accept only named index requirements. Unknown syntax cannot enable a build.
+  if (!/^[a-z0-9][a-z0-9._-]*(?:\[[a-z0-9_., -]+\])?\s*(?:\(?\s*(?:===|~=|==|!=|<=|>=|<|>)\s*[a-z0-9.*+!_-]+(?:\s*,\s*(?:===|~=|==|!=|<=|>=|<|>)\s*[a-z0-9.*+!_-]+)*\s*\)?)?$/i.test(dep)) refuse(line, 'unsupported requirement');
+}
+
+export function requirementsInputs(cwd, roots, validate) {
+  const files = [], seen = new Map();
+  function visit(source, line = 1) {
+    const absolute = path.resolve(cwd, source), root = fs.realpathSync(cwd);
+    try {
+      if (!fs.realpathSync(absolute).startsWith(root + path.sep) || !fs.statSync(absolute).isFile()) refuse(line, 'escaping requirements include');
+    } catch { refuse(line, 'escaping requirements include'); }
+    // Docker build-context paths must not contain Windows escape backslashes.
+    source = toPosix(path.relative(cwd, absolute));
+    if (seen.has(source)) return seen.get(source);
+    const index = files.length;
+    seen.set(source, index);
+    const file = { source, destination: `py/req-${index}.txt` };
+    files.push(file);
+    const input = fs.readFileSync(absolute, 'utf8');
+    const lines = input.split(/\r?\n/), output = [];
+    let rewritten = false;
+    for (let i = 0; i < lines.length; i++) {
+      const number = i + 1;
+      let text = lines[i];
+      while (/\\\s*$/.test(text) && i + 1 < lines.length) text = text.replace(/\\\s*$/, '') + lines[++i];
+      const clean = text.replace(/(^|\s)#.*$/, '').trim();
+      const include = clean.match(/^(?:-r\s*|--requirement(?:=|\s+)|-c\s*|--constraint(?:=|\s+))(.+)$/);
+      if (include) {
+        let target = include[1].trim().replace(/^(['"])(.*)\1$/, '$2');
+        if (path.isAbsolute(target) || /^[a-z]+:/i.test(target)) refuse(number, 'escaping requirements include');
+        const child = visit(path.join(path.dirname(source), target), number);
+        output.push(`${/^(-c|--constraint)/.test(clean) ? '-c' : '-r'} req-${child}.txt`);
+        rewritten = true;
+        continue;
+      }
+      if (validate && clean) {
+        if (/^(-e|--editable)(\s|=|\S)/.test(clean)) refuse(number, 'editable requirement');
+        if (clean.startsWith('-')) {
+          const allowed = /^(?:--index-url(?:=|\s+)|-i\s*|--extra-index-url(?:=|\s+)|--find-links(?:=|\s+))https:\/\/[^\s]+$/.test(clean)
+            || /^--trusted-host(?:=|\s+)[a-z0-9.-]+(?::\d+)?$/i.test(clean)
+            || /^--require-hashes$/.test(clean)
+            || /^--hash(?:=|\s+)[a-z0-9]+:[a-f0-9]+$/i.test(clean);
+          if (!allowed) refuse(number, 'requirements option');
+        } else {
+          const withoutHashes = clean.replace(/\s+--hash(?:=|\s+)[a-z0-9]+:[a-f0-9]+/gi, '');
+          requirement(withoutHashes, number, cwd);
+        }
+      }
+      output.push(text);
+    }
+    if (rewritten) file.content = output.join('\n');
+    return index;
+  }
+  const indexes = roots.map(source => visit(source));
+  return { files, indexes };
+}
+
+export function validatePythonProject(cwd, manager) {
+  // tomllib parses data only; never import or execute project code. Suppress
+  // parser diagnostics, which can contain dependency URLs or credentials.
+  function parse(name) {
+    try {
+      return JSON.parse(execFileSync('python3', ['-I', '-c', 'import json,sys,tomllib; print(json.dumps(tomllib.loads(sys.stdin.read())))'], {
+        input: fs.readFileSync(path.join(cwd, name), 'utf8'), encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'],
+      }));
+    } catch { throw new Error(`registries: cannot safely parse ${name} (Python 3.11+ required)`); }
+  }
+  const project = parse('pyproject.toml');
+  const lists = [project.project?.dependencies ?? [], ...Object.values(project.project?.['optional-dependencies'] ?? {}), ...Object.values(project['dependency-groups'] ?? {})];
+  for (const list of lists) for (const dep of list) {
+    if (typeof dep === 'string') requirement(dep, 'dependency list', cwd);
+    else if (!(dep && typeof dep['include-group'] === 'string' && Object.keys(dep).length === 1)) refuse('dependency list', 'unsupported requirement');
+  }
+  if (manager === 'uv') {
+    const walk = value => {
+      if (!value || typeof value !== 'object') return;
+      if (value.source && ['git', 'url', 'path', 'directory', 'editable'].some(key => Object.hasOwn(value.source, key))) {
+        // The root virtual project is not installed; all dependency sources are checked.
+        refuse('uv.lock', 'git/url/path source');
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    walk(parse('uv.lock'));
+  }
+}

package/lib/registry-secrets.mjs

@@ -0,0 +1,140 @@
+// Operator-only registry declarations. Never merge these into job configuration.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import YAML from "yaml";
+
+const fail = (message) => { throw new Error("registries: " + message); };
+const mapping = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+// Inspect only the local YAML key; never resolve or inspect declared paths.
+export function hasRegistryDeclarations(cwd) {
+  const local = path.join(cwd, ".nomarmy.local.yml");
+  if (!fs.existsSync(local)) return false;
+  let doc;
+  try { doc = YAML.parse(fs.readFileSync(local, "utf8")); }
+  catch { fail("cannot parse .nomarmy.local.yml"); }
+  return mapping(doc) && Object.hasOwn(doc, "registries");
+}
+
+export function readRegistrySecrets(cwd) {
+  // Check both spellings, even if the normal loader would select only one.
+  for (const name of [".nomarmy.yml", ".nomarmy.yaml"]) {
+    const file = path.join(cwd, name);
+    if (!fs.existsSync(file)) continue;
+    let doc;
+    try { doc = YAML.parse(fs.readFileSync(file, "utf8")); }
+    catch { fail("cannot parse repository configuration"); }
+    if (mapping(doc) && Object.hasOwn(doc, "registries")) {
+      fail("allowed only in .nomarmy.local.yml, never in committed repository configuration");
+    }
+  }
+  const local = path.join(cwd, ".nomarmy.local.yml");
+  if (!fs.existsSync(local)) return [];
+  let doc;
+  // Parser errors can echo input; do not include them in a public error.
+  try { doc = YAML.parse(fs.readFileSync(local, "utf8")); }
+  catch { fail("cannot parse .nomarmy.local.yml"); }
+  if (!mapping(doc) || !Object.hasOwn(doc, "registries")) return [];
+  if (!mapping(doc.registries)) fail("must be a mapping of credential file paths");
+  const declarations = doc.registries;
+  if (Object.keys(declarations).some((key) => !["npm", "pip", "go", "cargo"].includes(key))) {
+    fail("supported ecosystems are npm, pip, go and cargo");
+  }
+  return ["npm", "pip", "go", "cargo"].filter((key) => Object.hasOwn(declarations, key)).map((ecosystem) => {
+    const value = declarations[ecosystem];
+    let source = value, format = "config", privatePatterns = "";
+    if (ecosystem === "go" || (ecosystem === "pip" && mapping(value))) {
+      const keys = ecosystem === "go" ? ["netrc", "private"] : ["netrc"];
+      if (!mapping(value) || Object.keys(value).some((key) => !keys.includes(key)) || !Object.hasOwn(value, "netrc")) {
+        fail(ecosystem + " accepts only a netrc file path" + (ecosystem === "go" ? " and private patterns" : ""));
+      }
+      source = value.netrc;
+      format = "netrc";
+      if (ecosystem === "go" && value.private !== undefined) {
+        if (typeof value.private !== "string" || !/^[a-zA-Z0-9_.*?\/[\],!~+-]+$/.test(value.private)) {
+          fail("go.private must contain module patterns, not credentials or shell commands");
+        }
+        privatePatterns = value.private;
+      }
+    }
+    if (typeof source !== "string" || !source || /[\r\n\0,]/.test(source) ||
+        !(path.isAbsolute(source) || source.startsWith("~/") || source.startsWith("./") || source.startsWith("../"))) {
+      fail(ecosystem + " requires an absolute, ~/ or ./ credential file path; inline credentials are not accepted");
+    }
+    if (ecosystem === "pip" && [".netrc", "netrc"].includes(path.basename(source))) format = "netrc";
+    const resolved = path.resolve(cwd, source.startsWith("~/") ? path.join(os.homedir(), source.slice(2)) : source);
+    let stat, bytes;
+    try {
+      stat = fs.statSync(resolved, { bigint: true });
+      if (!stat.isFile()) fail(ecosystem + " credential must be a regular file");
+      bytes = fs.readFileSync(resolved);
+    } catch { fail(ecosystem + " credential must be an existing readable regular file"); }
+    return {
+      ecosystem, id: ecosystem === "go" ? "go-netrc" : ecosystem, source: resolved, format, privatePatterns,
+      digest: crypto.createHash("sha256").update(bytes).digest("hex"),
+      ...fileIdentity(resolved, stat),
+    };
+  });
+}
+
+// Same file, hardlinks included. Exact (bigint) IDs, as strings: Windows file
+// IDs are 64-bit (128 on ReFS) and collide once rounded to a double, which
+// flagged unrelated files as the credential on CI. A filesystem that reports
+// no ID (inode 0) falls back to the real path.
+function fileIdentity(file, stat = fs.statSync(file, { bigint: true })) {
+  const real = () => { const p = fs.realpathSync.native(file); return process.platform === "win32" ? p.toLowerCase() : p; };
+  return stat.ino === 0n ? { device: null, inode: null, realPath: real() }
+    : { device: String(stat.dev), inode: String(stat.ino), realPath: null };
+}
+
+const sameFile = (a, b) => a.inode !== null ? a.device === b.device && a.inode === b.inode : a.realPath === b.realPath;
+
+// A selected credential must not also be a dependency input (including hardlinks).
+export function assertNoRegistryCopies(cwd, files, secrets) {
+  for (const { source } of files) {
+    if (!source) continue;
+    const input = fileIdentity(path.resolve(cwd, source));
+    if (secrets.some((secret) => sameFile(secret, input))) {
+      fail("a credential file cannot also be a build-context input");
+    }
+  }
+}
+
+const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+
+// Only built-in install RUNs get mounts. Custom harness commands never do.
+// /tmp and manager caches are ephemeral so diagnostics/auth caches cannot
+// survive a successful install. No credentialed command output is retained.
+export function registryInstallRun(command, ecosystem, secrets) {
+  const secret = secrets.find((entry) => entry.ecosystem === ecosystem);
+  if (!secret) return "RUN " + command;
+  const target = ecosystem === "npm" ? "/home/node/.npmrc"
+    : ecosystem === "pip" ? (secret.format === "netrc" ? "/root/.netrc" : "/etc/pip.conf")
+    : ecosystem === "go" ? "/home/node/.netrc" : "/home/node/.cargo/credentials.toml";
+  const uid = ecosystem === "pip" ? 0 : 1000;
+  const mounts = [
+    `--mount=type=secret,id=${secret.id},target=${target},uid=${uid},required=true`,
+    "--mount=type=tmpfs,target=/tmp",
+    "--mount=type=tmpfs,target=/root/.cache",
+    // Corepack lives in ~/.cache/node/corepack: do not hide its prepared binaries.
+    // npm-family archive caches are redirected to tmpfs by the environment below.
+    ...(ecosystem === "npm" ? [] : ["--mount=type=tmpfs,target=/home/node/.cache"]),
+    ...(ecosystem === "npm" ? ["--mount=type=tmpfs,target=/home/node/.npm"] : []),
+  ].join(" ");
+  const env = ecosystem === "go"
+    ? `export GOPRIVATE=${quote(secret.privatePatterns)} GONOSUMDB=${quote(secret.privatePatterns)}; `
+    : ecosystem === "pip" ? "export UV_CACHE_DIR=/tmp/uv-cache POETRY_CACHE_DIR=/tmp/poetry-cache; "
+    : ecosystem === "npm" ? "export npm_config_cache=/tmp/npm-cache COREPACK_ENABLE_NETWORK=0 COREPACK_ENABLE_DOWNLOAD_PROMPT=0 YARN_CACHE_FOLDER=/tmp/yarn-cache YARN_GLOBAL_FOLDER=/tmp/yarn-global BUN_INSTALL_CACHE_DIR=/tmp/bun-cache; " : "";
+  // Podman's layer cache does not include secret contents. A one-way salt in
+  // the RUN is necessary: a new image tag alone could reuse a failed install.
+  const { source, format, privatePatterns, digest } = secret;
+  const salt = crypto.createHash("sha256").update(JSON.stringify({ ecosystem, source, format, privatePatterns, digest })).digest("hex");
+  const run = `RUN ${mounts} { : ${salt}; ${env}${command}; } >/dev/null 2>&1`;
+  // Python has no rebuild step to check mount removal. Fail closed before
+  // subsequent layers can execute installed code. npm checks before rebuild.
+  return ecosystem === "pip"
+    ? run + `\nRUN (test ! -e ${target} && test ! -L ${target}) || { touch /deps/.nomarmy-pip-install-failed; exit 1; }`
+    : run;
+}

package/lib/repo-query.mjs

@@ -31,18 +31,22 @@ const TEXT_EXT_HINT = /\.(mjs|cjs|js|jsx|ts|tsx|py|go|rs|java|kt|kts|cs|rb|php|s
 // ---------------------------------------------------------------------------
 // File walk
 // ---------------------------------------------------------------------------
-function globToRegex(glob) {
-  // Minimal glob: ** any path, * within a segment, ? one char, {a,b} alternation.
+// Minimal glob: ** any path, * within a segment, ? one char, {a,b}
+// alternation. Everything else is literal, so the regex built here can only
+// ever contain the fragments below, whatever the glob says.
+function globBody(glob) {
   let re = "";
   for (let i = 0; i < glob.length; i++) {
     const ch = glob[i];
-    if (ch === "*") { if (glob[i + 1] === "*") { re += "(?:.*\\/)?"; i++; if (glob[i + 1] === "/") { i++; } } else re += "[^/]*"; }
+    if (ch === "*") { if (glob[i + 1] === "*") { re += glob[i + 2] === "/" ? "(?:.*/)?" : ".*"; i++; if (glob[i + 1] === "/") { i++; } } else re += "[^/]*"; }
     else if (ch === "?") re += "[^/]";
-    else if (ch === "{") { const j = glob.indexOf("}", i); if (j > i) { re += "(" + glob.slice(i + 1, j).split(",").map(s => s.replace(/[.+^$()|[\]\\]/g, "\\$&")).join("|") + ")"; i = j; } else re += "\\{"; }
-    else if (/[.+^$()|[\]\\]/.test(ch)) re += "\\" + ch;
-    else re += ch;
+    else if (ch === "{") { const j = glob.indexOf("}", i); if (j > i) { re += "(?:" + glob.slice(i + 1, j).split(",").map(globBody).join("|") + ")"; i = j; } else re += "\\{"; }
+    else re += ch.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
   }
-  return new RegExp("^(?:.*/)?" + re + "$");
+  return re;
+}
+function globToRegex(glob) {
+  return new RegExp("^(?:.*/)?" + globBody(glob) + "$");
 }
 export function matchesGlob(rel, glob) {
   if (!glob) return true;
@@ -98,6 +102,8 @@ export function grepRepo(root, { pattern, regex = true, ignoreCase = false, whol
   let src = regex ? pattern : pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (wholeWord) src = `\\b(?:${src})\\b`;
   let re;
+  // A regex from the caller is the point of grep (repo_evidence); the
+  // caller is the operator's own coordinator session.
   try { re = new RegExp(src, ignoreCase ? "i" : ""); } catch (e) { throw new Error(`invalid pattern: ${e.message}`); }
   const { files, truncated: filesTruncated } = listFiles(root, { glob, ignores });
   const hits = [];

package/lib/runs.mjs

@@ -80,10 +80,16 @@ function writeRun(runsDir, run) {
 export function createRun(runsDir, { name, repo, limits, now = Date.now() }) {
   const slug = String(name ?? "feature").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "feature";
   const id = `run-${slug}-${crypto.randomBytes(3).toString("hex")}`;
-  return writeRun(runsDir, {
+  const run = writeRun(runsDir, {
     id, name: name ?? slug, repo, status: "running", createdAt: new Date(now).toISOString(),
     limits, jobs: [], pausedAgents: {}, logPath: path.join(runsDir, `${id}.md`), finishedAt: null, summary: null,
   });
+  // The General keeps this log (playbooks/feature.md); start it with the
+  // sections it fills in, so the path it's handed already exists.
+  if (!fs.existsSync(run.logPath)) {
+    fs.writeFileSync(run.logPath, `# ${run.name} (${id})\n\nRepository: ${repo}\nStarted: ${run.createdAt}\n\n## Plan\n\n## Decisions\n\n## Jobs\n\n## Review\n\n## What's left\n`);
+  }
+  return run;
 }
 
 export function loadRun(runsDir, id) {

package/lib/same-path.mjs

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Compare canonical paths so Windows case, slash, and 8.3 spellings agree. */
+export function samePath(a, b, platform = process.platform) {
+  const canonical = (value) => {
+    const resolved = path.resolve(value);
+    let real = resolved;
+    try { real = fs.realpathSync.native(resolved); } catch { /* Missing paths still compare resolved spellings. */ }
+    const normalized = platform === "win32" ? real.replaceAll("\\", "/").toLowerCase() : real;
+    return normalized.replace(/\/$/, "");
+  };
+  return canonical(a) === canonical(b);
+}