mcproc 0.14.1 → 0.14.3

package/dist/cli.js

@@ -2631,7 +2631,7 @@ async function unpack(target, opts, deps2) {
 }
 
 // src/core/leases/view.ts
-import fs8 from "fs";
+import fs9 from "fs";
 
 // src/core/memory.ts
 var KB = 1024;
@@ -2688,8 +2688,8 @@ function stateDir(env = process.env) {
 }
 
 // src/core/leases/ensure.ts
-import fs7 from "fs";
-import path11 from "path";
+import fs8 from "fs";
+import path12 from "path";
 
 // src/core/ecosystem.ts
 import path9 from "path";
@@ -2731,11 +2731,95 @@ function buildEcosystem(m, host) {
   return { apps };
 }
 
-// src/core/leases/store.ts
+// src/core/slots.ts
 import crypto from "crypto";
 import fs6 from "fs";
-import os5 from "os";
 import path10 from "path";
+function registryKey(baseProject, repo) {
+  return `${baseProject}-${crypto.createHash("sha256").update(realOf(repo)).digest("hex").slice(0, 8)}`;
+}
+function registryPath(stateDir2, baseProject, repo) {
+  return path10.join(stateDir2, "slots", `${registryKey(baseProject, repo)}.json`);
+}
+function emptyRegistry(repo) {
+  return { repo, slots: {} };
+}
+function readRegistry(file) {
+  if (!fs6.existsSync(file)) return null;
+  return JSON.parse(fs6.readFileSync(file, "utf8"));
+}
+function writeRegistry(file, r) {
+  fs6.mkdirSync(path10.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs6.writeFileSync(tmp, JSON.stringify(r, null, 2));
+  fs6.renameSync(tmp, file);
+}
+function withMain(r, entry) {
+  return { ...r, slots: { ...r.slots, "0": entry } };
+}
+function claimSlot(r, opts) {
+  if (opts.want !== void 0) {
+    if (opts.want < 1 || opts.want > opts.max)
+      throw new McprocError(
+        "BAD_ARGUMENT",
+        `slot ${opts.want} is outside 1..${opts.max} (slot 0 is the main checkout)`
+      );
+    if (Object.hasOwn(r.slots, String(opts.want)))
+      throw new McprocError(
+        "SLOT_TAKEN",
+        `slot ${opts.want} is taken by ${r.slots[String(opts.want)].path}`,
+        { hint: "Pick another slot, or remove that worktree first." }
+      );
+    return {
+      registry: { ...r, slots: { ...r.slots, [opts.want]: opts.entry } },
+      slot: opts.want
+    };
+  }
+  for (let s = 1; s <= opts.max; s++)
+    if (!Object.hasOwn(r.slots, String(s)))
+      return {
+        registry: { ...r, slots: { ...r.slots, [s]: opts.entry } },
+        slot: s
+      };
+  throw new McprocError(
+    "NO_FREE_SLOT",
+    `all ${opts.max} worktree slots of ${r.repo} are taken`,
+    {
+      hint: "Remove a worktree (worktree remove), or raise worktree.slots in the manifest."
+    }
+  );
+}
+function releaseSlot(r, slot) {
+  const slots = { ...r.slots };
+  delete slots[String(slot)];
+  return { ...r, slots };
+}
+function realOf(p) {
+  try {
+    return fs6.realpathSync(p);
+  } catch {
+    return path10.resolve(p);
+  }
+}
+function reclaimGone(r, exists) {
+  const freed = [];
+  let out = r;
+  for (const [k, e] of Object.entries(r.slots)) {
+    if (k === "0" || exists(realOf(e.path))) continue;
+    out = releaseSlot(out, Number(k));
+    freed.push(Number(k));
+  }
+  return { registry: out, freed: freed.sort((a, b) => a - b) };
+}
+function siblingsOf(r, root) {
+  return Object.entries(r.slots).filter(([, e]) => realOf(e.path) !== realOf(root)).map(([k, entry]) => ({ slot: Number(k), entry })).sort((a, b) => a.slot - b.slot);
+}
+
+// src/core/leases/store.ts
+import crypto2 from "crypto";
+import fs7 from "fs";
+import os5 from "os";
+import path11 from "path";
 var ALLOWED = {
   pending: ["starting", "running", "cancelled"],
   starting: ["running", "failed", "cancelled"],
@@ -2776,7 +2860,7 @@ function parseHeld(raw) {
 }
 function readHeld(file) {
   try {
-    return parseHeld(fs6.readFileSync(file, "utf8"));
+    return parseHeld(fs7.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -2791,13 +2875,13 @@ var LeaseStore = class {
    * `beforeUnlink` (tests only) runs while a breaker holds the break guard, before the re-read that decides the unlink.
    */
   constructor(stateDir2, deps2 = {}) {
-    this.dir = path10.join(stateDir2, "leases");
+    this.dir = path11.join(stateDir2, "leases");
     this.now = deps2.now ?? (() => Date.now());
     this.pid = deps2.pid ?? process.pid;
     this.beforeUnlink = deps2.beforeUnlink;
   }
   file(l) {
-    return path10.join(
+    return path11.join(
       this.dir,
       `${String(l.seq).padStart(6, "0")}-${l.id}.json`
     );
@@ -2806,11 +2890,11 @@ var LeaseStore = class {
     return new Date(this.now()).toISOString();
   }
   write(l) {
-    fs6.mkdirSync(this.dir, { recursive: true });
+    fs7.mkdirSync(this.dir, { recursive: true });
     const f = this.file(l);
     const tmp = `${f}.${this.pid}.tmp`;
-    fs6.writeFileSync(tmp, JSON.stringify(l, null, 2));
-    fs6.renameSync(tmp, f);
+    fs7.writeFileSync(tmp, JSON.stringify(l, null, 2));
+    fs7.renameSync(tmp, f);
     return l;
   }
   /**
@@ -2820,13 +2904,13 @@ var LeaseStore = class {
    * breakIfStale), never by moving it aside, so the lock path is never left free while a live holder has it.
    */
   async withLock(fn) {
-    fs6.mkdirSync(this.dir, { recursive: true });
-    const lock = path10.join(this.dir, ".lock");
-    const token = `${this.pid}-${crypto.randomBytes(6).toString("hex")}`;
-    const tmp = path10.join(this.dir, `.lock.${token}.tmp`);
+    fs7.mkdirSync(this.dir, { recursive: true });
+    const lock = path11.join(this.dir, ".lock");
+    const token = `${this.pid}-${crypto2.randomBytes(6).toString("hex")}`;
+    const tmp = path11.join(this.dir, `.lock.${token}.tmp`);
     const writeToken = () => {
-      fs6.mkdirSync(this.dir, { recursive: true });
-      fs6.writeFileSync(
+      fs7.mkdirSync(this.dir, { recursive: true });
+      fs7.writeFileSync(
         tmp,
         JSON.stringify({ pid: this.pid, at: this.now(), token })
       );
@@ -2857,7 +2941,7 @@ var LeaseStore = class {
         await new Promise((r2) => setTimeout(r2, 50));
       }
     } finally {
-      fs6.rmSync(tmp, { force: true });
+      fs7.rmSync(tmp, { force: true });
     }
     LIVE_TOKENS.add(token);
     try {
@@ -2883,15 +2967,15 @@ var LeaseStore = class {
   sweepStrays() {
     let names;
     try {
-      names = fs6.readdirSync(this.dir);
+      names = fs7.readdirSync(this.dir);
     } catch {
       return;
     }
     for (const n of names) {
       if (!STRAY.test(n)) continue;
-      const f = path10.join(this.dir, n);
+      const f = path11.join(this.dir, n);
       if (this.mtimeAgeMs(f) > LOCK_STALE_MS)
-        fs6.rmSync(f, { recursive: true, force: true });
+        fs7.rmSync(f, { recursive: true, force: true });
     }
   }
   /**
@@ -2902,12 +2986,12 @@ var LeaseStore = class {
   tryLink(tmp, lock, rewrite) {
     for (let attempt = 0; ; attempt++) {
       try {
-        fs6.linkSync(tmp, lock);
+        fs7.linkSync(tmp, lock);
         return true;
       } catch (e) {
         const code = e.code;
         if (code === "EEXIST") return false;
-        if (code === "ENOENT" && attempt === 0 && !fs6.existsSync(tmp)) {
+        if (code === "ENOENT" && attempt === 0 && !fs7.existsSync(tmp)) {
           rewrite();
           continue;
         }
@@ -2919,7 +3003,7 @@ var LeaseStore = class {
   stillStale(lock, judged) {
     let raw;
     try {
-      raw = fs6.readFileSync(lock, "utf8");
+      raw = fs7.readFileSync(lock, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return false;
       throw e;
@@ -2932,7 +3016,7 @@ var LeaseStore = class {
    * or, with no readable holder, the directory's mtime is older than LOCK_STALE_MS.
    */
   guardStale(guard) {
-    const held = readHeld(path10.join(guard, "holder"));
+    const held = readHeld(path11.join(guard, "holder"));
     if (held)
       return this.now() - held.at > LOCK_STALE_MS && !pidAlive(held.pid);
     return this.mtimeAgeMs(guard) > LOCK_STALE_MS;
@@ -2950,7 +3034,7 @@ var LeaseStore = class {
   breakIfStale(lock, token, take) {
     let raw;
     try {
-      raw = fs6.readFileSync(lock, "utf8");
+      raw = fs7.readFileSync(lock, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return "retry";
       throw e;
@@ -2960,57 +3044,57 @@ var LeaseStore = class {
     if (!stale) return "wait";
     const guard = `${lock}.break`;
     try {
-      fs6.mkdirSync(guard);
+      fs7.mkdirSync(guard);
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
       if (!this.guardStale(guard)) return "wait";
       const moved = `${guard}.${token}.stale`;
       try {
-        fs6.renameSync(guard, moved);
+        fs7.renameSync(guard, moved);
       } catch (err) {
         if (err.code === "ENOENT") return "retry";
         throw err;
       }
-      fs6.rmSync(moved, { recursive: true, force: true });
+      fs7.rmSync(moved, { recursive: true, force: true });
       return "retry";
     }
     try {
-      fs6.writeFileSync(
-        path10.join(guard, "holder"),
+      fs7.writeFileSync(
+        path11.join(guard, "holder"),
         JSON.stringify({ pid: this.pid, at: this.now(), token })
       );
       this.beforeUnlink?.();
       if (!this.stillStale(lock, held)) return "retry";
       try {
-        fs6.unlinkSync(lock);
+        fs7.unlinkSync(lock);
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
       }
       return take() ? "taken" : "retry";
     } finally {
-      fs6.rmSync(guard, { recursive: true, force: true });
+      fs7.rmSync(guard, { recursive: true, force: true });
     }
   }
   /** Age of a lock file by its modification time on the file system's clock; 0 when it is gone. */
   mtimeAgeMs(lock) {
     try {
-      return Date.now() - fs6.statSync(lock).mtimeMs;
+      return Date.now() - fs7.statSync(lock).mtimeMs;
     } catch {
       return 0;
     }
   }
   /** Unlinks the lock only when it still carries this holder's token; a lock it does not own is never removed. */
   release(lock, token) {
-    if (readHeld(lock)?.token === token) fs6.rmSync(lock, { force: true });
+    if (readHeld(lock)?.token === token) fs7.rmSync(lock, { force: true });
   }
   /** Every readable lease, in sequence order; a half-written file is skipped. */
   list() {
-    if (!fs6.existsSync(this.dir)) return [];
-    return fs6.readdirSync(this.dir).filter((f) => f.endsWith(".json")).sort().flatMap((f) => {
+    if (!fs7.existsSync(this.dir)) return [];
+    return fs7.readdirSync(this.dir).filter((f) => f.endsWith(".json")).sort().flatMap((f) => {
       try {
         return [
           JSON.parse(
-            fs6.readFileSync(path10.join(this.dir, f), "utf8")
+            fs7.readFileSync(path11.join(this.dir, f), "utf8")
           )
         ];
       } catch {
@@ -3023,25 +3107,25 @@ var LeaseStore = class {
     return this.list().find((l) => l.id === id) ?? null;
   }
   nextSeq() {
-    const f = path10.join(this.dir, ".seq");
+    const f = path11.join(this.dir, ".seq");
     const onDisk = Math.max(
       0,
-      ...fs6.readdirSync(this.dir).filter((name2) => name2.endsWith(".json")).map((name2) => Number(name2.split("-")[0])).filter(Number.isFinite)
+      ...fs7.readdirSync(this.dir).filter((name2) => name2.endsWith(".json")).map((name2) => Number(name2.split("-")[0])).filter(Number.isFinite)
     );
-    const parsed = fs6.existsSync(f) ? Number(fs6.readFileSync(f, "utf8")) : 0;
+    const parsed = fs7.existsSync(f) ? Number(fs7.readFileSync(f, "utf8")) : 0;
     const n = Math.max(Number.isFinite(parsed) ? parsed : 0, onDisk);
     const tmp = `${f}.${this.pid}.tmp`;
-    fs6.writeFileSync(tmp, String(n + 1));
-    fs6.renameSync(tmp, f);
+    fs7.writeFileSync(tmp, String(n + 1));
+    fs7.renameSync(tmp, f);
     return n + 1;
   }
   /** A new lease, pending (queued) or running (admitted at once), with `child_pid` the process running its start; call it under the lock. */
   async create(input, state, opts = {}) {
-    fs6.mkdirSync(this.dir, { recursive: true });
+    fs7.mkdirSync(this.dir, { recursive: true });
     const at = this.stamp();
     const l = {
       ...input,
-      id: `l_${crypto.randomBytes(8).toString("base64url").replace(/[^a-z0-9]/gi, "").toLowerCase().padEnd(10, "0").slice(0, 10)}`,
+      id: `l_${crypto2.randomBytes(8).toString("base64url").replace(/[^a-z0-9]/gi, "").toLowerCase().padEnd(10, "0").slice(0, 10)}`,
       seq: this.nextSeq(),
       state,
       child_pid: opts.child_pid ?? null,
@@ -3119,7 +3203,7 @@ var LeaseStore = class {
     for (const l of this.list()) {
       if (!ENDED.has(l.state) || !l.ended_at) continue;
       if (this.now() - Date.parse(l.ended_at) > maxAgeMs) {
-        fs6.rmSync(this.file(l), { force: true });
+        fs7.rmSync(this.file(l), { force: true });
         n++;
       }
     }
@@ -3137,7 +3221,7 @@ var EXIT_POLL_MS = 250;
 function exitingAt(dir) {
   try {
     const v = JSON.parse(
-      fs7.readFileSync(path11.join(dir, WATCHER_NOTE), "utf8")
+      fs8.readFileSync(path12.join(dir, WATCHER_NOTE), "utf8")
     );
     const at = typeof v.exiting_at === "string" ? Date.parse(v.exiting_at) : Number.NaN;
     return Number.isFinite(at) ? at : null;
@@ -3146,9 +3230,10 @@ function exitingAt(dir) {
   }
 }
 function watcherEntry(env = process.env, argv = process.argv) {
-  if (env.MCPROC_CLI_ENTRY) return path11.resolve(env.MCPROC_CLI_ENTRY);
+  if (env.MCPROC_CLI_ENTRY) return path12.resolve(env.MCPROC_CLI_ENTRY);
   const own2 = argv[1] ?? "";
-  if (own2.endsWith("cli.js")) return path11.resolve(own2);
+  const real = own2 ? realOf(own2) : "";
+  if (real.endsWith("cli.js")) return real;
   throw new McprocError(
     "NOT_STARTED",
     `cannot launch the lease watcher: this mcproc runs from ${own2 || "an unknown entry"}, not from a built cli.js`,
@@ -3180,10 +3265,10 @@ async function lookAndLaunch(ctx, dir, leaving) {
   if (await watcherOnline(ctx) && (leaving === null || exitingAt(dir) !== leaving))
     return "online";
   const entry = watcherEntry();
-  const file = path11.join(dir, "watcher.ecosystem.json");
-  fs7.mkdirSync(dir, { recursive: true });
-  fs7.rmSync(path11.join(dir, WATCHER_NOTE), { force: true });
-  fs7.writeFileSync(
+  const file = path12.join(dir, "watcher.ecosystem.json");
+  fs8.mkdirSync(dir, { recursive: true });
+  fs8.rmSync(path12.join(dir, WATCHER_NOTE), { force: true });
+  fs8.writeFileSync(
     file,
     JSON.stringify(
       {
@@ -3219,7 +3304,7 @@ async function lookAndLaunch(ctx, dir, leaving) {
 // src/core/leases/view.ts
 async function leasesView(dir = stateDir(), ctx) {
   const store = new LeaseStore(dir);
-  if (fs8.existsSync(store.dir))
+  if (fs9.existsSync(store.dir))
     await store.withLock(() => store.prune()).catch(() => {
     });
   const leases = store.list().map((l) => ({ ...l, position: store.positionOf(l.id) }));
@@ -3280,11 +3365,11 @@ import fs12 from "fs";
 import path16 from "path";
 
 // src/core/actions.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/core/list.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 
 // src/core/metrics.ts
 function cpuPercent(pids, before, after, clkTck, intervalSec) {
@@ -4345,8 +4430,8 @@ var depView = (d) => ({
   timeout_s: d.timeoutMs / 1e3
 });
 function describeProject(m) {
-  const readmePath = path12.join(m.root, ".mcproc", "README.md");
-  const readme = fs9.existsSync(readmePath) ? fs9.readFileSync(readmePath, "utf8") : null;
+  const readmePath = path13.join(m.root, ".mcproc", "README.md");
+  const readme = fs10.existsSync(readmePath) ? fs10.readFileSync(readmePath, "utf8") : null;
   return {
     project: m.project,
     root: m.root,
@@ -4379,7 +4464,7 @@ function describeProject(m) {
 
 // src/core/logfollow.ts
 import { open } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 
 // src/core/logwatch.ts
 import { watch as fsWatch } from "fs";
@@ -4873,8 +4958,8 @@ var LogFollower = class {
     }
     const byDir = /* @__PURE__ */ new Map();
     for (const p of [this.paths.out, this.paths.err]) {
-      const dir = path13.dirname(p);
-      byDir.set(dir, (byDir.get(dir) ?? /* @__PURE__ */ new Set()).add(path13.basename(p)));
+      const dir = path14.dirname(p);
+      byDir.set(dir, (byDir.get(dir) ?? /* @__PURE__ */ new Set()).add(path14.basename(p)));
     }
     for (const [dir, names] of byDir)
       this.unwatch.push(
@@ -6331,7 +6416,7 @@ function assertNoCollision(ctx, procs, names) {
     const name2 = pm2Name(ctx.manifest.project, n);
     const expectedCwd = appCwd(ctx.host, ctx.manifest.apps[n]);
     const other = procs.find(
-      (p) => p.name === name2 && (p.namespace !== ctx.manifest.project || p.cwd !== "" && path14.posix.resolve(p.cwd) !== expectedCwd)
+      (p) => p.name === name2 && (p.namespace !== ctx.manifest.project || p.cwd !== "" && path15.posix.resolve(p.cwd) !== expectedCwd)
     );
     if (other && other.namespace !== ctx.manifest.project) {
       throw new McprocError(
@@ -6358,7 +6443,7 @@ async function shipEcosystem(ctx) {
   const eco = buildEcosystem(ctx.manifest, ctx.host);
   const file = ecosystemPath(ctx.host);
   const dir = generatedDir(ctx.host);
-  const gi = path14.posix.join(path14.posix.dirname(dir), ".gitignore");
+  const gi = path15.posix.join(path15.posix.dirname(dir), ".gitignore");
   const cmd = `mkdir -p ${shq(dir)} && { [ -e ${shq(gi)} ] || printf '*\\n' > ${shq(gi)}; } && cat > ${shq(file)}`;
   const res = ensureOk(
     await ctx.transport.exec(cmd, { stdin: JSON.stringify(eco, null, 2) }),
@@ -6536,92 +6621,6 @@ function admit(opts) {
 
 // src/core/leases/siblings.ts
 import fs11 from "fs";
-
-// src/core/slots.ts
-import crypto2 from "crypto";
-import fs10 from "fs";
-import path15 from "path";
-function registryKey(baseProject, repo) {
-  return `${baseProject}-${crypto2.createHash("sha256").update(realOf(repo)).digest("hex").slice(0, 8)}`;
-}
-function registryPath(stateDir2, baseProject, repo) {
-  return path15.join(stateDir2, "slots", `${registryKey(baseProject, repo)}.json`);
-}
-function emptyRegistry(repo) {
-  return { repo, slots: {} };
-}
-function readRegistry(file) {
-  if (!fs10.existsSync(file)) return null;
-  return JSON.parse(fs10.readFileSync(file, "utf8"));
-}
-function writeRegistry(file, r) {
-  fs10.mkdirSync(path15.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs10.writeFileSync(tmp, JSON.stringify(r, null, 2));
-  fs10.renameSync(tmp, file);
-}
-function withMain(r, entry) {
-  return { ...r, slots: { ...r.slots, "0": entry } };
-}
-function claimSlot(r, opts) {
-  if (opts.want !== void 0) {
-    if (opts.want < 1 || opts.want > opts.max)
-      throw new McprocError(
-        "BAD_ARGUMENT",
-        `slot ${opts.want} is outside 1..${opts.max} (slot 0 is the main checkout)`
-      );
-    if (Object.hasOwn(r.slots, String(opts.want)))
-      throw new McprocError(
-        "SLOT_TAKEN",
-        `slot ${opts.want} is taken by ${r.slots[String(opts.want)].path}`,
-        { hint: "Pick another slot, or remove that worktree first." }
-      );
-    return {
-      registry: { ...r, slots: { ...r.slots, [opts.want]: opts.entry } },
-      slot: opts.want
-    };
-  }
-  for (let s = 1; s <= opts.max; s++)
-    if (!Object.hasOwn(r.slots, String(s)))
-      return {
-        registry: { ...r, slots: { ...r.slots, [s]: opts.entry } },
-        slot: s
-      };
-  throw new McprocError(
-    "NO_FREE_SLOT",
-    `all ${opts.max} worktree slots of ${r.repo} are taken`,
-    {
-      hint: "Remove a worktree (worktree remove), or raise worktree.slots in the manifest."
-    }
-  );
-}
-function releaseSlot(r, slot) {
-  const slots = { ...r.slots };
-  delete slots[String(slot)];
-  return { ...r, slots };
-}
-function realOf(p) {
-  try {
-    return fs10.realpathSync(p);
-  } catch {
-    return path15.resolve(p);
-  }
-}
-function reclaimGone(r, exists) {
-  const freed = [];
-  let out = r;
-  for (const [k, e] of Object.entries(r.slots)) {
-    if (k === "0" || exists(realOf(e.path))) continue;
-    out = releaseSlot(out, Number(k));
-    freed.push(Number(k));
-  }
-  return { registry: out, freed: freed.sort((a, b) => a - b) };
-}
-function siblingsOf(r, root) {
-  return Object.entries(r.slots).filter(([, e]) => realOf(e.path) !== realOf(root)).map(([k, entry]) => ({ slot: Number(k), entry })).sort((a, b) => a.slot - b.slot);
-}
-
-// src/core/leases/siblings.ts
 var MIB = 1024 * 1024;
 var repoOf = (m) => m.repo;
 function registryOf(m, dir = stateDir()) {