@visulima/task-runner 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/packem_shared/{Cache-iAjRMV2d.js → Cache-CWaX_c8U.js}

@@ -22,17 +22,30 @@ const {
   mkdir,
   writeFile,
   rename,
-  stat,
   rm,
-  cp,
-  readdir
+  readdir,
+  stat,
+  cp
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { formatBytes, parseBytes } from '@visulima/humanizer';
 import { join, resolve, dirname } from '@visulima/path';
+import { e as extractTarBrotli, c as createTarBrotli } from './archive-UQHAnZUa.js';
+import { resolveOutputs } from './resolveOutputs-n6MCKoTe.js';
 import { u as uniqueId } from './utils-zO0ZRgtf.js';
 
 const DEFAULT_MAX_CACHE_AGE = 7 * 24 * 60 * 60 * 1e3;
 const DEFAULT_CACHE_DIRECTORY_NAME = ".task-runner-cache";
+const assertSafeNamespace = (namespace) => {
+  if (namespace.includes("\0")) {
+    throw new Error("cacheNamespace: null bytes are not allowed.");
+  }
+  if (namespace.includes("/") || namespace.includes("\\")) {
+    throw new Error(`cacheNamespace: path separators are not allowed (received ${JSON.stringify(namespace)}).`);
+  }
+  if (namespace === "." || namespace === "..") {
+    throw new Error(`cacheNamespace: "${namespace}" would escape the cache subtree.`);
+  }
+};
 const removeEntry = async (entryPath) => {
   try {
     await rm(entryPath, { force: true, recursive: true });
@@ -73,7 +86,11 @@ class Cache {
   #indexWriteQueue = Promise.resolve();
   constructor(options) {
     this.#workspaceRoot = options.workspaceRoot;
-    this.#cacheDirectory = options.cacheDirectory ?? join(options.workspaceRoot, DEFAULT_CACHE_DIRECTORY_NAME);
+    const baseDirectory = options.cacheDirectory ?? join(options.workspaceRoot, DEFAULT_CACHE_DIRECTORY_NAME);
+    if (options.cacheNamespace !== void 0 && options.cacheNamespace.length > 0) {
+      assertSafeNamespace(options.cacheNamespace);
+    }
+    this.#cacheDirectory = options.cacheNamespace && options.cacheNamespace.length > 0 ? join(baseDirectory, "ns", options.cacheNamespace) : baseDirectory;
     this.#maxCacheAge = options.maxCacheAge ?? DEFAULT_MAX_CACHE_AGE;
     this.#maxCacheSize = options.maxCacheSize ? parseCacheSize(options.maxCacheSize) : void 0;
   }
@@ -117,8 +134,14 @@ class Cache {
    *
    * Uses atomic write: builds the entry in a temporary directory,
    * then renames into place to avoid partial reads by concurrent processes.
+   *
+   * `outputs` accepts the richer `OutputSpec[]` shape — glob
+   * patterns, negative globs, and `{ auto: true }` entries. Pass
+   * `autoWrites` alongside `{ auto: true }` so the resolver knows
+   * which files the task actually wrote; otherwise auto entries
+   * contribute nothing.
    */
-  async put(hash, terminalOutput, outputs, code, fingerprint) {
+  async put(hash, terminalOutput, outputs, code, fingerprint, autoWrites) {
     const cacheEntryDirectory = join(this.#cacheDirectory, hash);
     const temporaryDirectory = join(this.#cacheDirectory, `.tmp-${hash}-${uniqueId()}`);
     try {
@@ -126,7 +149,7 @@ class Cache {
       const writes = [
         writeFile(join(temporaryDirectory, "code"), String(code)),
         writeFile(join(temporaryDirectory, "terminalOutput"), terminalOutput),
-        this.#archiveOutputs(temporaryDirectory, outputs)
+        this.#archiveOutputs(temporaryDirectory, outputs, autoWrites)
       ];
       if (fingerprint) {
         writes.push(writeFile(join(temporaryDirectory, "fingerprint.json"), JSON.stringify(fingerprint)));
@@ -140,36 +163,21 @@ class Cache {
     }
   }
   /**
-   * Restores cached outputs to their original locations.
+   * Restores cached outputs from the compressed `outputs.tar.br`
+   * archive. Returns `true` either when the archive was extracted
+   * successfully OR when the entry simply has no outputs to restore.
+   *
+   * The restore flow stages into a temp directory, then swaps each
+   * top-level entry into place (see {@link restoreOutputsCompressed})
+   * so a mid-restore failure never destroys the user's working tree.
+   * The `outputs` parameter is no longer consulted at restore time —
+   * the archive is authoritative, and top-level entries in the
+   * extracted staging become the set of swap roots. Still accepted
+   * for backward compat.
    */
-  async restoreOutputs(hash, outputs) {
+  async restoreOutputs(hash, _outputs) {
     const cacheEntryDirectory = join(this.#cacheDirectory, hash);
-    const outputsDirectory = join(cacheEntryDirectory, "outputs");
-    try {
-      await stat(outputsDirectory);
-    } catch {
-      return true;
-    }
-    try {
-      await Promise.all(
-        outputs.map(async (output) => {
-          const absoluteOutput = resolve(this.#workspaceRoot, output);
-          const cachedOutput = join(outputsDirectory, output);
-          try {
-            await stat(cachedOutput);
-          } catch {
-            return;
-          }
-          const parentDirectory = dirname(absoluteOutput);
-          await mkdir(parentDirectory, { recursive: true });
-          await rm(absoluteOutput, { force: true, recursive: true });
-          await cp(cachedOutput, absoluteOutput, { recursive: true });
-        })
-      );
-      return true;
-    } catch {
-      return false;
-    }
+    return restoreOutputsCompressed(cacheEntryDirectory, this.#workspaceRoot);
   }
   /**
    * Retrieves the most recent cached result for a task by its ID.
@@ -276,23 +284,105 @@ class Cache {
     }
   }
   /**
-   * Archives task output files into the cache.
+   * Archives task output files into the cache as a single
+   * brotli-compressed tarball (`outputs.tar.br`). See
+   * {@link archiveOutputsCompressed} for the staging + compression
+   * flow.
    */
-  async #archiveOutputs(cacheEntryDirectory, outputs) {
-    const outputsDirectory = join(cacheEntryDirectory, "outputs");
-    await mkdir(outputsDirectory, { recursive: true });
-    for (const output of outputs) {
-      const absoluteOutput = resolve(this.#workspaceRoot, output);
-      const cachedOutput = join(outputsDirectory, output);
+  async #archiveOutputs(cacheEntryDirectory, outputs, autoWrites) {
+    await archiveOutputsCompressed(this.#workspaceRoot, cacheEntryDirectory, outputs, autoWrites);
+  }
+}
+const OUTPUTS_ARCHIVE_FILENAME = "outputs.tar.br";
+const archiveOutputsCompressed = async (workspaceRoot, cacheEntryDirectory, outputs, autoWrites) => {
+  if (outputs.length === 0) {
+    return;
+  }
+  const resolvedPaths = await resolveOutputs(workspaceRoot, outputs, autoWrites);
+  if (resolvedPaths.length === 0) {
+    return;
+  }
+  const stagingDirectory = join(cacheEntryDirectory, `.outputs-stage-${uniqueId()}`);
+  const finalPath = join(cacheEntryDirectory, OUTPUTS_ARCHIVE_FILENAME);
+  try {
+    await mkdir(stagingDirectory, { recursive: true });
+    const stagedFlags = await runBounded(STAGE_CONCURRENCY, resolvedPaths, async (relativePath) => {
+      const absoluteOutput = resolve(workspaceRoot, relativePath);
+      const stagedOutput = join(stagingDirectory, relativePath);
+      try {
+        await mkdir(dirname(stagedOutput), { recursive: true });
+        await cp(absoluteOutput, stagedOutput, { recursive: true });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    const stagedCount = stagedFlags.filter(Boolean).length;
+    if (stagedCount === 0) {
+      return;
+    }
+    await createTarBrotli(stagingDirectory, finalPath);
+  } finally {
+    await rm(stagingDirectory, { force: true, recursive: true }).catch(() => {
+    });
+  }
+};
+const STAGE_CONCURRENCY = 16;
+const runBounded = async (limit, items, fn) => {
+  const results = Array.from({ length: items.length });
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor;
+      cursor += 1;
+      results[index] = await fn(items[index], index);
+    }
+  };
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+};
+const restoreOutputsCompressed = async (cacheEntryDirectory, workspaceRoot) => {
+  const archivePath = join(cacheEntryDirectory, OUTPUTS_ARCHIVE_FILENAME);
+  try {
+    await stat(archivePath);
+  } catch {
+    return true;
+  }
+  const stagingDirectory = join(cacheEntryDirectory, `.restore-${uniqueId()}`);
+  const backups = [];
+  try {
+    await mkdir(stagingDirectory, { recursive: true });
+    await extractTarBrotli(archivePath, stagingDirectory);
+    const topLevel = await readdir(stagingDirectory);
+    await runBounded(STAGE_CONCURRENCY, topLevel, async (entry) => {
+      const absoluteOutput = resolve(workspaceRoot, entry);
+      const stagedOutput = join(stagingDirectory, entry);
+      await mkdir(dirname(absoluteOutput), { recursive: true });
       try {
         await stat(absoluteOutput);
-        const cachedOutputParent = join(cachedOutput, "..");
-        await mkdir(cachedOutputParent, { recursive: true });
-        await cp(absoluteOutput, cachedOutput, { recursive: true });
+        const backup = `${absoluteOutput}.pre-restore-${uniqueId()}`;
+        await rename(absoluteOutput, backup);
+        backups.push({ backup, original: absoluteOutput });
       } catch {
       }
+      await cp(stagedOutput, absoluteOutput, { recursive: true });
+    });
+    await Promise.all(backups.map(({ backup }) => rm(backup, { force: true, recursive: true }).catch(() => {
+    })));
+    return true;
+  } catch {
+    for (const { backup, original } of backups) {
+      await rm(original, { force: true, recursive: true }).catch(() => {
+      });
+      await rename(backup, original).catch(() => {
+      });
     }
+    return false;
+  } finally {
+    await rm(stagingDirectory, { force: true, recursive: true }).catch(() => {
+    });
   }
-}
+};
 
 export { Cache, DEFAULT_CACHE_DIRECTORY_NAME, formatCacheSize, parseCacheSize };

package/dist/packem_shared/{CompositeLifeCycle-7AtYw1dv.js → CompositeLifeCycle-CSVbRC_5.js}

@@ -59,6 +59,16 @@ class CompositeLifeCycle {
       lc.printCacheMiss?.(task, reasons);
     }
   }
+  onTaskStdout(task, chunk) {
+    for (const lc of this.#lifeCycles) {
+      lc.onTaskStdout?.(task, chunk);
+    }
+  }
+  onTaskStderr(task, chunk) {
+    for (const lc of this.#lifeCycles) {
+      lc.onTaskStderr?.(task, chunk);
+    }
+  }
 }
 class ConsoleLifeCycle {
   #verbose;

package/dist/packem_shared/{FileAccessTracker-CrtBAt5D.js → FileAccessTracker-CQ5Ot7Hd.js}

@@ -47,11 +47,19 @@ const isStraceAvailable = () => {
   return straceAvailable;
 };
 const STRACE_PATTERNS = [
-  { pattern: /openat\(AT_FDCWD,\s*"([^"]+)"/, type: "read" },
-  { pattern: /^(?:\d+\s+)?open\("([^"]+)"/, type: "read" },
-  { pattern: /(?:stat|lstat|newfstatat)\((?:AT_FDCWD,\s*)?"([^"]+)"/, type: "stat" },
-  { pattern: /access\("([^"]+)"/, type: "stat" }
+  { kind: "open", pattern: /openat\(AT_FDCWD,\s*"([^"]+)"/ },
+  { kind: "open", pattern: /^(?:\d+\s+)?open\("([^"]+)"/ },
+  { kind: "creat", pattern: /(?:^|\s)creat\("([^"]+)"/ },
+  { kind: "stat", pattern: /(?:stat|lstat|newfstatat)\((?:AT_FDCWD,\s*)?"([^"]+)"/ },
+  { kind: "stat", pattern: /access\("([^"]+)"/ },
+  { kind: "getdents", pattern: /getdents(?:64)?\(\d+/ }
 ];
+const parseOpenAccessType = (line) => {
+  if (/O_WRONLY|O_RDWR|O_CREAT|O_TRUNC|O_APPEND/.test(line)) {
+    return "write";
+  }
+  return "read";
+};
 class FileAccessTracker {
   #workspaceRoot;
   #excludePatterns;
@@ -93,7 +101,7 @@ class FileAccessTracker {
     const traceDirectory = join(this.#workspaceRoot, "node_modules", ".cache", "task-runner");
     await mkdir(traceDirectory, { recursive: true });
     const traceFile = join(traceDirectory, `strace-${uniqueId()}.log`);
-    const straceCommand = `strace -f -qq -e trace=open,openat,stat,lstat,newfstatat,access,getdents,getdents64 -o ${traceFile} -- ${command}`;
+    const straceCommand = `strace -f -qq -e trace=open,openat,creat,stat,lstat,newfstatat,access,getdents,getdents64,unlink,unlinkat,rename,renameat,renameat2 -o ${traceFile} -- ${command}`;
     return new Promise((_resolve) => {
       const child = exec(
         straceCommand,
@@ -125,14 +133,23 @@ class FileAccessTracker {
   }
   /**
    * Parses strace output to extract file accesses.
+   *
+   * A single path may appear with both `read` and `write` types when a
+   * task reads a file and later rewrites it — self-modifying detection
+   * relies on seeing both, so we dedupe per `(path, type)` rather than
+   * by path alone.
    */
   #parseStraceOutput(traceContent, cwd) {
     const accesses = [];
-    const seenPaths = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
     for (const line of traceContent.split("\n")) {
       const parsed = this.#parseStraceLine(line, cwd);
-      if (parsed && !seenPaths.has(parsed.path)) {
-        seenPaths.add(parsed.path);
+      if (!parsed) {
+        continue;
+      }
+      const key = `${parsed.type}:${parsed.path}`;
+      if (!seen.has(key)) {
+        seen.add(key);
         accesses.push(parsed);
       }
     }
@@ -140,23 +157,46 @@ class FileAccessTracker {
   }
   /**
    * Parses a single strace output line.
-   * Each entry maps a regex to the file access type it represents.
+   * Each entry maps a regex to the file access kind; the actual type
+   * (read vs write) depends on flag inspection for `open`/`openat`.
    */
   #parseStraceLine(line, cwd) {
     const isMissing = line.includes("ENOENT");
-    for (const { pattern, type } of STRACE_PATTERNS) {
+    for (const { kind, pattern } of STRACE_PATTERNS) {
       const match = pattern.exec(line);
-      if (!match?.[1]) {
+      if (!match) {
         continue;
       }
-      let path = match[1];
+      if (kind === "getdents") {
+        return void 0;
+      }
+      const capturedPath = match[1];
+      if (!capturedPath) {
+        continue;
+      }
+      let path = capturedPath;
       if (!path.startsWith("/")) {
         path = resolve(cwd, path);
       }
       if (this.#shouldExclude(path) || !path.startsWith(this.#workspaceRoot)) {
         return void 0;
       }
-      return { path, type: isMissing ? "missing" : type };
+      if (isMissing) {
+        return { path, type: "missing" };
+      }
+      const type = kind === "open" ? parseOpenAccessType(line) : kind === "creat" ? "write" : "stat";
+      return { path, type };
+    }
+    const destructive = /(?:^|\s)(?:unlink|unlinkat|rename|renameat|renameat2)\((?:AT_FDCWD,\s*)?"([^"]+)"/.exec(line);
+    if (destructive?.[1]) {
+      let path = destructive[1];
+      if (!path.startsWith("/")) {
+        path = resolve(cwd, path);
+      }
+      if (this.#shouldExclude(path) || !path.startsWith(this.#workspaceRoot)) {
+        return void 0;
+      }
+      return { path, type: "write" };
     }
     return void 0;
   }
@@ -220,19 +260,31 @@ const patch = (obj, method, type) => {
     };
 };
 
-// Sync
+// Reads / stats / directory listing
 patch(fs, "readFileSync", "read");
 patch(fs, "statSync", "stat");
 patch(fs, "readdirSync", "readdir");
-// Async (callback)
 patch(fs, "readFile", "read");
 patch(fs, "stat", "stat");
 patch(fs, "readdir", "readdir");
-// Async (promises)
 patch(fsp, "readFile", "read");
 patch(fsp, "stat", "stat");
 patch(fsp, "readdir", "readdir");
 
+// Writes and path-mutating ops — needed for self-modifying task detection
+patch(fs, "writeFileSync", "write");
+patch(fs, "appendFileSync", "write");
+patch(fs, "unlinkSync", "write");
+patch(fs, "renameSync", "write");
+patch(fs, "writeFile", "write");
+patch(fs, "appendFile", "write");
+patch(fs, "unlink", "write");
+patch(fs, "rename", "write");
+patch(fsp, "writeFile", "write");
+patch(fsp, "appendFile", "write");
+patch(fsp, "unlink", "write");
+patch(fsp, "rename", "write");
+
 process.on("beforeExit", () => { logStream.end(); });
 `;
 

package/dist/packem_shared/{FingerprintManager-Cu-ta9ee.js → FingerprintManager-CV7U4f4f.js}

@@ -34,6 +34,8 @@ class FingerprintManager {
     const fileHashes = {};
     const missingPaths = /* @__PURE__ */ new Set();
     const directoryListings = {};
+    const readPaths = /* @__PURE__ */ new Set();
+    const writePaths = /* @__PURE__ */ new Set();
     for (const access of accesses) {
       const relativePath = relative(this.#workspaceRoot, access.path);
       switch (access.type) {
@@ -43,6 +45,7 @@ class FingerprintManager {
         }
         case "read":
         case "stat": {
+          readPaths.add(relativePath);
           if (!fileHashes[relativePath]) {
             const hash = await this.#hashFileWithCache(access.path);
             if (hash) {
@@ -62,8 +65,19 @@ class FingerprintManager {
           }
           break;
         }
+        case "write": {
+          writePaths.add(relativePath);
+          break;
+        }
+      }
+    }
+    const modifiedInputs = [];
+    for (const path of writePaths) {
+      if (readPaths.has(path)) {
+        modifiedInputs.push(path);
       }
     }
+    modifiedInputs.sort();
     const commandHash = hashStrings(`${command}:${JSON.stringify(sortObjectKeys(args))}`);
     const envHashes = {};
     const matchedEnvVariables = FingerprintManager.#resolveEnvPatterns(envPatterns, envVariables);
@@ -75,7 +89,14 @@ class FingerprintManager {
       envHashes[key] = hashStrings(`${key}=${value ?? ""}`);
     }
     const missingFiles = [...missingPaths].toSorted();
-    return { commandHash, directoryListings, envHashes, fileHashes, missingFiles };
+    return {
+      commandHash,
+      directoryListings,
+      envHashes,
+      fileHashes,
+      missingFiles,
+      ...modifiedInputs.length > 0 ? { modifiedInputs } : {}
+    };
   }
   /**
    * Validates a stored fingerprint against the current state.

package/dist/packem_shared/{IncrementalFileHasher-Cm_kJY5V.js → IncrementalFileHasher-BRS76-mb.js}

@@ -146,6 +146,32 @@ class IncrementalFileHasher {
   clear() {
     this.#snapshot.clear();
   }
+  /**
+   * Looks up the cached hash for `absolutePath` when its mtime and
+   * size match the snapshot; returns `undefined` otherwise. Callers
+   * that already have a `stat` result (e.g. `InProcessTaskHasher`)
+   * skip an extra syscall by passing it through directly.
+   *
+   * The snapshot is considered loaded on first call — lazy-load is
+   * synchronous-friendly here because the caller already performed
+   * an async `stat` before calling this method.
+   */
+  getSnapshotHash(absolutePath, mtimeMs, size) {
+    const entry = this.#snapshot.get(absolutePath);
+    if (!entry) {
+      return void 0;
+    }
+    return entry.mtimeMs === mtimeMs && entry.size === size ? entry.hash : void 0;
+  }
+  /**
+   * Writes a fresh snapshot entry after the caller has computed the
+   * hash. Pairs with {@link IncrementalFileHasher.getSnapshotHash}
+   * — after a miss, the caller hashes the file and records the
+   * result here so the next run can reuse it.
+   */
+  recordSnapshot(absolutePath, hash, mtimeMs, size) {
+    this.#snapshot.set(absolutePath, { hash, mtimeMs, size });
+  }
 }
 
 export { IncrementalFileHasher };

package/dist/packem_shared/LogReporter-BDt52HLu.js

@@ -0,0 +1,44 @@
+const formatTaskLabel = (task) => `${task.target.project}#${task.target.target}`;
+const prefixLines = (text, label) => {
+  const trailing = text.endsWith("\n") ? "\n" : "";
+  const body = trailing ? text.slice(0, -1) : text;
+  if (body.length === 0) {
+    return trailing;
+  }
+  return `${body.split("\n").map((line) => `[${label}] ${line}`).join("\n")}${trailing}`;
+};
+class LogReporter {
+  #mode;
+  #write;
+  constructor(mode, write = (chunk) => process.stdout.write(chunk)) {
+    this.#mode = mode;
+    this.#write = write;
+  }
+  printTaskTerminalOutput(task, _status, terminalOutput) {
+    if (terminalOutput.length === 0) {
+      return;
+    }
+    if (this.#mode === "interleaved") {
+      this.#write(terminalOutput.endsWith("\n") ? terminalOutput : `${terminalOutput}
+`);
+      return;
+    }
+    const label = formatTaskLabel(task);
+    if (this.#mode === "labeled") {
+      this.#write(prefixLines(terminalOutput.endsWith("\n") ? terminalOutput : `${terminalOutput}
+`, label));
+      return;
+    }
+    const body = terminalOutput.endsWith("\n") ? terminalOutput : `${terminalOutput}
+`;
+    this.#write(`── ${label} ──
+${body}
+`);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  endTasks(_taskResults) {
+  }
+}
+const createLogReporter = (mode, write) => new LogReporter(mode, write);
+
+export { LogReporter, createLogReporter };