pi-supernova 0.0.15 → 0.2.0

package/vfs.js

@@ -1,5 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { isString } from "./decode.js";
+import { randomUUID } from "node:crypto";
 
 const VFS_CACHE_MAX = 1024;
 
@@ -8,13 +10,17 @@ export class CausalVfs {
     this.cache = new Map();
     this.overlays = [];
     this.onNewFile = onNewFile;
+    this.closed = false;
+    this.signal = undefined;
+  }
+
+  assertWritable() {
+    if (this.closed) throw new Error("program is already complete");
+    this.signal?.throwIfAborted();
   }
 
   setCache(target, content) {
-    if (this.cache.size >= VFS_CACHE_MAX && !this.cache.has(target)) {
-      const oldest = this.cache.keys().next().value;
-      if (oldest !== undefined) this.cache.delete(oldest);
-    }
+    if (this.cache.size >= VFS_CACHE_MAX && !this.cache.has(target)) this.cache.delete(this.cache.keys().next().value);
     this.cache.set(target, content);
   }
 
@@ -22,34 +28,25 @@ export class CausalVfs {
     for (let i = this.overlays.length - 1; i >= 0; i--) {
       if (this.overlays[i].has(target)) return this.overlays[i].get(target);
     }
-    return undefined;
   }
 
   getOverlayPaths() {
-    const paths = new Set();
-    for (const overlay of this.overlays) {
-      for (const target of overlay.keys()) paths.add(target);
-    }
-    return [...paths];
+    return [...new Set(this.overlays.flatMap(overlay => [...overlay.keys()]))];
   }
 
   async read(target) {
     const overlay = this.getOverlay(target);
     if (overlay !== undefined) return overlay;
-
-    const cached = this.cache.get(target);
-    if (cached !== undefined) return cached;
-
+    // External editors and captured tools can change a file between any two reads.
     try {
       const text = await fs.readFile(target, "utf8");
       this.setCache(target, text);
       return text;
     } catch (err) {
-      if (err.code === "EISDIR") {
-        throw new Error(`read path is a directory, not a file: ${target}`);
-      }
+      this.cache.delete(target);
+      if (err.code === "EISDIR") throw new Error("read path is a directory, not a file: " + target);
       if (err.code === "ENOENT") {
-        const missing = new Error(`no such file: ${target} (locate it with nova.call("glob", {pattern}) or snap(query))`);
+        const missing = new Error("no such file: " + target + ' (locate it with nova.call("glob", {pattern}) or snap(query))');
         missing.code = "ENOENT";
         throw missing;
       }
@@ -58,82 +55,129 @@ export class CausalVfs {
   }
 
   async write(target, content) {
-    if (this.overlays.length > 0) {
-      this.overlays[this.overlays.length - 1].set(target, content);
-      return { speculative: true };
-    }
-
-    let existed = true;
+    this.assertWritable();
+    if (!isString(content)) throw new Error("write requires string content");
     try {
-      const stat = await fs.stat(target);
-      if (stat.isDirectory()) {
-        throw new Error(`cannot write to a directory: ${target}`);
-      }
+      if ((await fs.stat(target)).isDirectory()) throw new Error("cannot write to a directory: " + target);
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
-      existed = false;
     }
-
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await fs.writeFile(target, content, "utf8");
-    this.setCache(target, content);
-    if (!existed) this.onNewFile?.(target);
+    this.assertWritable();
+    if (this.overlays.length) {
+      this.overlays.at(-1).set(target, content);
+      return { speculative: true };
+    }
+    await this.flush(new Map([[target, content]]));
     return { speculative: false };
   }
 
   begin() {
+    this.assertWritable();
     this.overlays.push(new Map());
     return this.overlays.length;
   }
 
-  async commit() {
-    if (this.overlays.length === 0) return { committed: 0, depth: 0 };
-    const top = this.overlays.pop();
-    if (this.overlays.length > 0) {
-      const parent = this.overlays[this.overlays.length - 1];
-      for (const [k, v] of top.entries()) parent.set(k, v);
-      return { committed: top.size, depth: this.overlays.length };
+  /** Stage every file and its backup before replacing any destination. */
+  async flush(writes) {
+    const staged = [];
+    const createdDirs = [];
+    let failed = false;
+    try {
+      for (const [logicalPath, content] of writes) {
+        this.signal?.throwIfAborted();
+        let target = logicalPath;
+        let stat;
+        try {
+          target = await fs.realpath(logicalPath);
+          stat = await fs.stat(target);
+          if (!stat.isFile()) throw new Error("cannot write to a non-file: " + logicalPath);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        const parent = path.dirname(target);
+        const missing = [];
+        let probe = parent;
+        for (;;) {
+          try { await fs.stat(probe); break; } catch (err) {
+            if (err.code !== "ENOENT") throw err;
+            missing.push(probe);
+            probe = path.dirname(probe);
+          }
+        }
+        await fs.mkdir(parent, { recursive: true });
+        createdDirs.push(...missing.reverse());
+        const token = ".supernova-" + randomUUID();
+        const entry = { logicalPath, target, content, temporary: path.join(parent, token + ".new"), backup: path.join(parent, token + ".bak"), existed: !!stat, replaced: false };
+        staged.push(entry);
+        await fs.writeFile(entry.temporary, content, { encoding: "utf8", flag: "wx", mode: stat ? stat.mode & 0o7777 : 0o666 });
+        if (stat) {
+          await fs.chmod(entry.temporary, stat.mode & 0o7777);
+          await fs.copyFile(target, entry.backup, fs.constants.COPYFILE_EXCL);
+        }
+      }
+      for (const entry of staged) {
+        this.signal?.throwIfAborted();
+        await fs.rename(entry.temporary, entry.target);
+        entry.replaced = true;
+      }
+      for (const entry of staged) this.setCache(entry.logicalPath, entry.content);
+      if (staged.length) this.onNewFile?.();
+    } catch (error) {
+      failed = true;
+      const recoveryErrors = [];
+      for (const entry of staged.toReversed()) {
+        if (!entry.replaced) continue;
+        try {
+          if (entry.existed) await fs.rename(entry.backup, entry.target);
+          else await fs.unlink(entry.target);
+        } catch (err) {
+          // Keep the backup if recovery fails; never delete the remaining original.
+          entry.keepBackup = true;
+          recoveryErrors.push(entry.target + ": " + err.message + " (backup: " + entry.backup + ")");
+        }
+      }
+      this.invalidateCache();
+      if (recoveryErrors.length) throw new AggregateError([error, ...recoveryErrors.map(message => new Error(message))], "commit failed: " + error.message + "; recovery failed: " + recoveryErrors.join("; "));
+      throw error;
+    } finally {
+      for (const entry of staged) {
+        await fs.rm(entry.temporary, { force: true }).catch(() => {});
+        if (!entry.keepBackup) await fs.rm(entry.backup, { force: true }).catch(() => {});
+      }
+      if (failed) for (const dir of createdDirs.toReversed()) await fs.rmdir(dir).catch(() => {});
     }
-    for (const [filePath, fileContent] of top.entries()) {
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(filePath, fileContent, "utf8");
-      this.setCache(filePath, fileContent);
+  }
+
+  async commit() {
+    if (!this.overlays.length) return { committed: 0, depth: 0 };
+    const top = this.overlays.at(-1);
+    if (this.overlays.length > 1) {
+      const parent = this.overlays[this.overlays.length - 2];
+      for (const [key, value] of top) parent.set(key, value);
+    } else {
+      await this.flush(top);
     }
-    if (top.size > 0) this.onNewFile?.();
-    return { committed: top.size, depth: 0 };
+    this.overlays.pop();
+    return { committed: top.size, depth: this.overlays.length };
   }
 
   rollback() {
-    if (this.overlays.length === 0) return { rolledBack: 0, depth: 0 };
     const top = this.overlays.pop();
-    return { rolledBack: top.size, depth: this.overlays.length };
+    return { rolledBack: top?.size ?? 0, depth: this.overlays.length };
   }
 
   async prepareExternalMutation(name) {
-    if (this.overlays.length > 1) {
-      throw new Error(`${name} cannot run inside nova.speculate because external mutations cannot be rolled back`);
-    }
-    if (this.overlays.length === 0) return false;
+    this.assertWritable();
+    if (this.overlays.length > 1) throw new Error(name + " cannot run inside nova.speculate because external mutations cannot be rolled back");
+    if (!this.overlays.length) return false;
     const pending = this.overlays[0];
-    for (const [filePath, fileContent] of pending.entries()) {
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(filePath, fileContent, "utf8");
-      this.setCache(filePath, fileContent);
-    }
-    if (pending.size > 0) this.onNewFile?.();
+    await this.flush(pending);
+    this.assertWritable();
     this.overlays[0] = new Map();
     return pending.size > 0;
   }
 
-  invalidateCache() {
-    this.cache.clear();
-  }
-
-  getCacheSize() {
-    return this.cache.size;
-  }
-
-  getOverlayDepth() {
-    return this.overlays.length;
-  }
+  invalidateCache() { this.cache.clear(); }
+  getCacheSize() { return this.cache.size; }
+  getOverlayDepth() { return this.overlays.length; }
 }

package/workspace.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
+import { constants } from "node:os";
 import { isString } from "./decode.js";
 
 let cachedCwd = null;
@@ -81,63 +82,66 @@ export async function resolveWorkspacePath(cwd, inputPath, opName, allowRoot = f
 }
 
 export async function runCommand(argv, options = {}) {
+  options.signal?.throwIfAborted();
   const cwd = options.cwd || process.cwd();
   const timeoutMs = options.timeoutMs ?? 60_000;
   const maxOutputChars = options.maxOutputChars ?? 2 * 1024 * 1024;
-  return await new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(argv[0], argv.slice(1), {
-      cwd,
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"],
+      cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32",
     });
     let stdout = "";
     let stderr = "";
     let settled = false;
     let outputTruncated = false;
-    let onAbort;
-
+    let terminationError;
+    let escalation;
     const cleanup = () => {
       clearTimeout(timer);
-      if (options.signal && onAbort) options.signal.removeEventListener("abort", onAbort);
+      clearTimeout(escalation);
+      options.signal?.removeEventListener("abort", onAbort);
     };
-    const fail = (err) => {
+    const fail = error => {
       if (settled) return;
       settled = true;
       cleanup();
-      reject(err);
+      reject(error);
+    };
+    const signalTree = signal => {
+      if (!child.pid) return;
+      if (process.platform === "win32") {
+        const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
+        killer.on("error", () => child.kill(signal));
+      } else {
+        try { process.kill(-child.pid, signal); } catch (err) { if (err.code !== "ESRCH") child.kill(signal); }
+      }
     };
+    const terminate = error => {
+      if (settled || terminationError) return;
+      terminationError = error;
+      signalTree("SIGTERM");
+      // Keep ownership after the direct child exits: descendants may ignore SIGTERM.
+      escalation = setTimeout(() => { signalTree("SIGKILL"); fail(error); }, 150);
+    };
+    const onAbort = () => terminate(new Error("aborted"));
+    const timer = setTimeout(() => terminate(new Error("command timed out after " + timeoutMs + "ms: " + argv.join(" "))), timeoutMs);
     const append = (current, chunk) => {
-      const remaining = Math.max(0, maxOutputChars - current.length);
+      const remaining = Math.max(0, maxOutputChars - stdout.length - stderr.length);
       if (chunk.length > remaining) outputTruncated = true;
-      return remaining > 0 ? current + chunk.slice(0, remaining) : current;
+      return remaining ? current + chunk.slice(0, remaining) : current;
     };
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      fail(new Error(`command timed out after ${timeoutMs}ms: ${argv.join(" ")}`));
-    }, timeoutMs);
-
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout = append(stdout, chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr = append(stderr, chunk);
-    });
+    child.stdout.on("data", chunk => { stdout = append(stdout, chunk); });
+    child.stderr.on("data", chunk => { stderr = append(stderr, chunk); });
     child.on("error", fail);
-    child.on("close", (code) => {
-      if (settled) return;
+    child.on("close", (code, signal) => {
+      if (settled || terminationError) return;
       settled = true;
       cleanup();
-      resolve({ stdout, stderr, exitCode: code ?? 0, outputTruncated });
+      resolve({ stdout, stderr, exitCode: code ?? (128 + (constants.signals[signal] ?? 1)), signal, outputTruncated });
     });
-    if (options.signal) {
-      onAbort = () => {
-        child.kill("SIGTERM");
-        fail(new Error("aborted"));
-      };
-      if (options.signal.aborted) onAbort();
-      else options.signal.addEventListener("abort", onAbort, { once: true });
-    }
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) onAbort();
   });
 }