@visulima/task-runner 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/Cache-IYpTYVUC.js

@@ -0,0 +1,298 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readFile,
+  mkdir,
+  writeFile,
+  rename,
+  stat,
+  rm,
+  cp,
+  readdir
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join, resolve, dirname } from '@visulima/path';
+import { formatBytes, parseBytes } from '@visulima/humanizer';
+import { u as uniqueId } from './utils-zO0ZRgtf.js';
+
+const DEFAULT_MAX_CACHE_AGE = 7 * 24 * 60 * 60 * 1e3;
+const removeEntry = async (entryPath) => {
+  try {
+    await rm(entryPath, { force: true, recursive: true });
+  } catch {
+  }
+};
+const getDirectorySize = async (directoryPath) => {
+  let totalSize = 0;
+  try {
+    const entries = await readdir(directoryPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        totalSize += await getDirectorySize(fullPath);
+      } else if (entry.isFile()) {
+        const fileStat = await stat(fullPath);
+        totalSize += fileStat.size;
+      }
+    }
+  } catch {
+  }
+  return totalSize;
+};
+const parseCacheSize = (sizeString) => {
+  const result = parseBytes(sizeString.trim());
+  if (Number.isNaN(result)) {
+    throw new Error(`Invalid cache size format: "${sizeString}". Expected format like "500MB" or "1GB".`);
+  }
+  return result;
+};
+const formatCacheSize = (bytes) => formatBytes(bytes, { decimals: 1, space: false });
+class Cache {
+  #workspaceRoot;
+  #cacheDirectory;
+  #maxCacheAge;
+  #maxCacheSize;
+  /** Serializes concurrent setTaskIndex writes to prevent lost updates */
+  #indexWriteQueue = Promise.resolve();
+  constructor(options) {
+    this.#workspaceRoot = options.workspaceRoot;
+    this.#cacheDirectory = options.cacheDirectory ?? join(options.workspaceRoot, ".task-runner-cache");
+    this.#maxCacheAge = options.maxCacheAge ?? DEFAULT_MAX_CACHE_AGE;
+    this.#maxCacheSize = options.maxCacheSize ? parseCacheSize(options.maxCacheSize) : void 0;
+  }
+  /**
+   * Gets the cache directory path.
+   */
+  get cacheDirectory() {
+    return this.#cacheDirectory;
+  }
+  /**
+   * Retrieves a cached result for the given task hash.
+   * Returns undefined if no valid cache entry exists.
+   */
+  async get(hash) {
+    const cacheEntryDirectory = join(this.#cacheDirectory, hash);
+    try {
+      await readFile(join(cacheEntryDirectory, ".commit"));
+      const codeString = await readFile(join(cacheEntryDirectory, "code"), "utf8");
+      const code = Number.parseInt(codeString.trim(), 10);
+      if (Number.isNaN(code)) {
+        return void 0;
+      }
+      let terminalOutput = "";
+      try {
+        terminalOutput = await readFile(join(cacheEntryDirectory, "terminalOutput"), "utf8");
+      } catch {
+      }
+      let fingerprint;
+      try {
+        const fingerprintContent = await readFile(join(cacheEntryDirectory, "fingerprint.json"), "utf8");
+        fingerprint = JSON.parse(fingerprintContent);
+      } catch {
+      }
+      return { code, fingerprint, hash, terminalOutput };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Stores a task result in the cache.
+   *
+   * Uses atomic write: builds the entry in a temporary directory,
+   * then renames into place to avoid partial reads by concurrent processes.
+   */
+  async put(hash, terminalOutput, outputs, code, fingerprint) {
+    const cacheEntryDirectory = join(this.#cacheDirectory, hash);
+    const temporaryDirectory = join(this.#cacheDirectory, `.tmp-${hash}-${uniqueId()}`);
+    try {
+      await mkdir(temporaryDirectory, { recursive: true });
+      const writes = [
+        writeFile(join(temporaryDirectory, "code"), String(code)),
+        writeFile(join(temporaryDirectory, "terminalOutput"), terminalOutput),
+        this.#archiveOutputs(temporaryDirectory, outputs)
+      ];
+      if (fingerprint) {
+        writes.push(writeFile(join(temporaryDirectory, "fingerprint.json"), JSON.stringify(fingerprint)));
+      }
+      await Promise.all(writes);
+      await writeFile(join(temporaryDirectory, ".commit"), "");
+      await removeEntry(cacheEntryDirectory);
+      await rename(temporaryDirectory, cacheEntryDirectory);
+    } catch {
+      await removeEntry(temporaryDirectory);
+    }
+  }
+  /**
+   * Restores cached outputs to their original locations.
+   */
+  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;
+    }
+  }
+  /**
+   * Retrieves the most recent cached result for a task by its ID.
+   * Used in auto-fingerprint mode where the hash is derived from
+   * tracked file accesses rather than computed upfront.
+   */
+  async getByTaskId(taskId) {
+    const indexFile = join(this.#cacheDirectory, ".task-index.json");
+    try {
+      const indexContent = await readFile(indexFile, "utf8");
+      const index = JSON.parse(indexContent);
+      const hash = index[taskId];
+      if (!hash) {
+        return void 0;
+      }
+      return this.get(hash);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Stores the mapping from task ID to cache hash.
+   * Uses a write queue to serialize concurrent writes and prevent lost updates.
+   * Each write is atomic (temp file + rename).
+   */
+  async setTaskIndex(taskId, hash) {
+    this.#indexWriteQueue = this.#indexWriteQueue.then(() => this.#writeTaskIndex(taskId, hash)).catch(() => {
+    });
+    return this.#indexWriteQueue;
+  }
+  async #writeTaskIndex(taskId, hash) {
+    const indexFile = join(this.#cacheDirectory, ".task-index.json");
+    const temporaryFile = join(this.#cacheDirectory, `.task-index-${uniqueId()}.tmp`);
+    let index = {};
+    try {
+      const indexContent = await readFile(indexFile, "utf8");
+      index = JSON.parse(indexContent);
+    } catch {
+    }
+    index[taskId] = hash;
+    await mkdir(this.#cacheDirectory, { recursive: true });
+    await writeFile(temporaryFile, JSON.stringify(index));
+    try {
+      await rename(temporaryFile, indexFile);
+    } catch {
+      await writeFile(indexFile, JSON.stringify(index));
+      await rm(temporaryFile, { force: true });
+    }
+  }
+  /**
+   * Removes old cache entries that exceed the maximum age,
+   * and enforces the maximum cache size by evicting oldest entries.
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async removeOldEntries() {
+    try {
+      const entries = await readdir(this.#cacheDirectory);
+      const now = Date.now();
+      const entryInfos = [];
+      for (const entry of entries) {
+        if (entry.startsWith(".")) {
+          continue;
+        }
+        const entryPath = join(this.#cacheDirectory, entry);
+        try {
+          const entryStat = await stat(entryPath);
+          if (now - entryStat.mtimeMs > this.#maxCacheAge) {
+            await removeEntry(entryPath);
+          } else {
+            const size = await getDirectorySize(entryPath);
+            entryInfos.push({
+              mtimeMs: entryStat.mtimeMs,
+              name: entry,
+              path: entryPath,
+              size
+            });
+          }
+        } catch {
+        }
+      }
+      if (this.#maxCacheSize !== void 0) {
+        const sortedEntries = entryInfos.toSorted((a, b) => a.mtimeMs - b.mtimeMs);
+        let totalSize = 0;
+        for (const info of sortedEntries) {
+          totalSize += info.size;
+        }
+        for (const info of sortedEntries) {
+          if (totalSize <= this.#maxCacheSize) {
+            break;
+          }
+          await removeEntry(info.path);
+          totalSize -= info.size;
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Clears the entire cache.
+   */
+  async clear() {
+    try {
+      await rm(this.#cacheDirectory, { force: true, recursive: true });
+    } catch {
+    }
+  }
+  /**
+   * Archives task output files into the cache.
+   */
+  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);
+      try {
+        await stat(absoluteOutput);
+        const cachedOutputParent = join(cachedOutput, "..");
+        await mkdir(cachedOutputParent, { recursive: true });
+        await cp(absoluteOutput, cachedOutput, { recursive: true });
+      } catch {
+      }
+    }
+  }
+}
+
+export { Cache, formatCacheSize, parseCacheSize };

package/dist/packem_shared/CompositeLifeCycle-7AtYw1dv.js

@@ -0,0 +1,112 @@
+const getStatusIcon = (status) => {
+  switch (status) {
+    case "failure": {
+      return "[failure]";
+    }
+    case "local-cache":
+    case "local-cache-kept-existing":
+    case "remote-cache": {
+      return "[cache]";
+    }
+    case "skipped": {
+      return "[skipped]";
+    }
+    case "success": {
+      return "[success]";
+    }
+    default: {
+      return "[unknown]";
+    }
+  }
+};
+class CompositeLifeCycle {
+  #lifeCycles;
+  constructor(lifeCycles) {
+    this.#lifeCycles = lifeCycles;
+  }
+  startCommand() {
+    for (const lc of this.#lifeCycles) {
+      lc.startCommand?.();
+    }
+  }
+  endCommand() {
+    for (const lc of this.#lifeCycles) {
+      lc.endCommand?.();
+    }
+  }
+  scheduleTask(task) {
+    for (const lc of this.#lifeCycles) {
+      lc.scheduleTask?.(task);
+    }
+  }
+  startTasks(tasks) {
+    for (const lc of this.#lifeCycles) {
+      lc.startTasks?.(tasks);
+    }
+  }
+  endTasks(taskResults) {
+    for (const lc of this.#lifeCycles) {
+      lc.endTasks?.(taskResults);
+    }
+  }
+  printTaskTerminalOutput(task, status, terminalOutput) {
+    for (const lc of this.#lifeCycles) {
+      lc.printTaskTerminalOutput?.(task, status, terminalOutput);
+    }
+  }
+  printCacheMiss(task, reasons) {
+    for (const lc of this.#lifeCycles) {
+      lc.printCacheMiss?.(task, reasons);
+    }
+  }
+}
+class ConsoleLifeCycle {
+  #verbose;
+  constructor(verbose = false) {
+    this.#verbose = verbose;
+  }
+  startCommand() {
+    if (this.#verbose) {
+      console.log("[task-runner] Starting command execution");
+    }
+  }
+  endCommand() {
+    if (this.#verbose) {
+      console.log("[task-runner] Command execution complete");
+    }
+  }
+  scheduleTask(task) {
+    if (this.#verbose) {
+      console.log(`[task-runner] Scheduled: ${task.id}`);
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this
+  startTasks(tasks) {
+    for (const task of tasks) {
+      console.log(`> ${task.id}`);
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this
+  endTasks(taskResults) {
+    for (const result of taskResults) {
+      const duration = result.startTime && result.endTime ? ` (${result.endTime - result.startTime}ms)` : "";
+      const statusIcon = getStatusIcon(result.status);
+      console.log(`${statusIcon} ${result.task.id}${duration}`);
+    }
+  }
+  // eslint-disable-next-line class-methods-use-this
+  printTaskTerminalOutput(_task, _status, terminalOutput) {
+    if (terminalOutput.trim()) {
+      console.log(terminalOutput);
+    }
+  }
+  printCacheMiss(task, reasons) {
+    if (this.#verbose) {
+      console.log(`[task-runner] ${task.id}: ${reasons}`);
+    }
+  }
+}
+class EmptyLifeCycle {
+}
+
+export { CompositeLifeCycle, ConsoleLifeCycle, EmptyLifeCycle };

package/dist/packem_shared/FileAccessTracker-CrtBAt5D.js

@@ -0,0 +1,239 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  exec,
+  execFileSync
+} = __cjs_getBuiltinModule("node:child_process");
+const {
+  mkdir,
+  readFile,
+  rm
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  platform
+} = __cjs_getBuiltinModule("node:os");
+import { resolve, join } from '@visulima/path';
+import { u as uniqueId } from './utils-zO0ZRgtf.js';
+
+import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
+const require = __cjs_mod__.createRequire(import.meta.url);
+let straceAvailable;
+const isStraceAvailable = () => {
+  if (straceAvailable === void 0) {
+    try {
+      execFileSync("strace", ["-V"], { stdio: "ignore" });
+      straceAvailable = true;
+    } catch {
+      straceAvailable = false;
+    }
+  }
+  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" }
+];
+class FileAccessTracker {
+  #workspaceRoot;
+  #excludePatterns;
+  /** Tracks active child processes for cleanup on abort */
+  #activeProcesses = /* @__PURE__ */ new Set();
+  constructor(workspaceRoot, excludePatterns) {
+    this.#workspaceRoot = resolve(workspaceRoot);
+    this.#excludePatterns = excludePatterns ?? [
+      /\/proc\//,
+      /\/sys\//,
+      /\/dev\//,
+      /\/tmp\//,
+      /\/etc\//,
+      /\.so(\.\d+)*$/,
+      /node_modules\/.package-lock\.json$/
+    ];
+  }
+  /**
+   * Returns true if file access tracking is supported on the current platform.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  isSupported() {
+    return platform() === "linux" && isStraceAvailable();
+  }
+  /**
+   * Runs a command and tracks all file system accesses.
+   * On unsupported platforms, runs the command without tracking.
+   */
+  async track(command, options = {}) {
+    if (!this.isSupported()) {
+      return this.#runWithoutTracking(command, options);
+    }
+    return this.#runWithStrace(command, options);
+  }
+  /**
+   * Runs a command wrapped with strace to capture file accesses.
+   */
+  async #runWithStrace(command, options) {
+    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}`;
+    return new Promise((_resolve) => {
+      const child = exec(
+        straceCommand,
+        {
+          cwd: options.cwd ?? this.#workspaceRoot,
+          env: { ...process.env, ...options.env },
+          maxBuffer: 50 * 1024 * 1024
+          // 50MB
+        },
+        async (_error, stdout, stderr) => {
+          this.#activeProcesses.delete(child);
+          let accesses = [];
+          try {
+            const traceContent = await readFile(traceFile, "utf8");
+            accesses = this.#parseStraceOutput(traceContent, options.cwd ?? this.#workspaceRoot);
+          } catch {
+          }
+          await rm(traceFile, { force: true }).catch(() => {
+          });
+          _resolve({
+            accesses,
+            code: child.exitCode ?? 1,
+            output: stdout + stderr
+          });
+        }
+      );
+      this.#activeProcesses.add(child);
+    });
+  }
+  /**
+   * Parses strace output to extract file accesses.
+   */
+  #parseStraceOutput(traceContent, cwd) {
+    const accesses = [];
+    const seenPaths = /* @__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);
+        accesses.push(parsed);
+      }
+    }
+    return accesses;
+  }
+  /**
+   * Parses a single strace output line.
+   * Each entry maps a regex to the file access type it represents.
+   */
+  #parseStraceLine(line, cwd) {
+    const isMissing = line.includes("ENOENT");
+    for (const { pattern, type } of STRACE_PATTERNS) {
+      const match = pattern.exec(line);
+      if (!match?.[1]) {
+        continue;
+      }
+      let path = match[1];
+      if (!path.startsWith("/")) {
+        path = resolve(cwd, path);
+      }
+      if (this.#shouldExclude(path) || !path.startsWith(this.#workspaceRoot)) {
+        return void 0;
+      }
+      return { path, type: isMissing ? "missing" : type };
+    }
+    return void 0;
+  }
+  /**
+   * Checks if a path should be excluded from tracking.
+   */
+  #shouldExclude(filePath) {
+    return this.#excludePatterns.some((pattern) => pattern.test(filePath));
+  }
+  /**
+   * Kills all active child processes. Called on abort/signal to prevent orphans.
+   */
+  killAll() {
+    for (const child of this.#activeProcesses) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    this.#activeProcesses.clear();
+  }
+  /**
+   * Runs a command without file access tracking.
+   */
+  async #runWithoutTracking(command, options) {
+    return new Promise((_resolve) => {
+      const child = exec(
+        command,
+        {
+          cwd: options.cwd ?? this.#workspaceRoot,
+          env: { ...process.env, ...options.env },
+          maxBuffer: 50 * 1024 * 1024
+        },
+        (_error, stdout, stderr) => {
+          this.#activeProcesses.delete(child);
+          _resolve({
+            accesses: [],
+            code: child.exitCode ?? 1,
+            output: stdout + stderr
+          });
+        }
+      );
+      this.#activeProcesses.add(child);
+    });
+  }
+}
+const generatePreloadScript = (outputPath) => String.raw`
+import { createWriteStream } from "node:fs";
+
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const logStream = createWriteStream(${JSON.stringify(outputPath)}, { flags: "a" });
+const log = (type, path) => { logStream.write(JSON.stringify({ type, path }) + "\n"); };
+
+// Patch each fs method: save original, replace with logged wrapper
+const patch = (obj, method, type) => {
+    const orig = obj[method];
+    obj[method] = function(...args) {
+        log(type, args[0]?.toString());
+        return orig.apply(this, args);
+    };
+};
+
+// Sync
+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");
+
+process.on("beforeExit", () => { logStream.end(); });
+`;
+
+export { FileAccessTracker, generatePreloadScript };