billion-context 0.1.17 → 0.1.19

package/dist/index.js

@@ -3234,16 +3234,18 @@ function logMsg(opts, level, msg2) {
 }
 
 // src/update.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFile, writeFile, mkdir, access, constants, rm } from "fs/promises";
 import { execFile } from "child_process";
 import path4 from "path";
+import { fileURLToPath } from "url";
 var REGISTRY_BASE = "https://registry.npmjs.org";
 var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
 var THROTTLE_FILE = path4.join(cacheDir(), ".update-check");
-var SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/;
+var LOCK_FILE = path4.join(cacheDir(), ".update-lock");
+var LOCK_STALE_MS = 2 * 60 * 1e3;
 var timer;
 var inFlight = false;
-var notified = /* @__PURE__ */ new Set();
+var firstCheckDone = false;
 function parseVersion(v) {
   return v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
 }
@@ -3273,22 +3275,98 @@ async function writeLastCheck(ts) {
   } catch {
   }
 }
+async function findInstallDir(packageName) {
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    try {
+      const pkg = JSON.parse(await readFile(path4.join(dir, "package.json"), "utf-8"));
+      if (pkg.name === packageName) return dir;
+    } catch {
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+async function readDiskVersion(installDir) {
+  try {
+    const pkg = JSON.parse(await readFile(path4.join(installDir, "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return void 0;
+  }
+}
+async function tryAcquireLock() {
+  const pid = process.pid;
+  const now = Date.now();
+  async function readLock() {
+    try {
+      const raw = await readFile(LOCK_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data.pid === "number" && typeof data.ts === "number") {
+        return data;
+      }
+    } catch {
+    }
+    return null;
+  }
+  function isAlive(checkPid) {
+    try {
+      process.kill(checkPid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const existing = await readLock();
+  if (existing) {
+    const age = now - existing.ts;
+    const holderAlive = isAlive(existing.pid);
+    if (holderAlive && age < LOCK_STALE_MS) {
+      return null;
+    }
+    log("info", `[update] stealing stale lock (pid=${existing.pid}, age=${Math.round(age / 1e3)}s, alive=${holderAlive})`);
+  }
+  try {
+    await writeFile(LOCK_FILE, JSON.stringify({ pid, ts: now }), { flag: "wx" });
+  } catch {
+    const winner = await readLock();
+    if (winner && winner.pid !== pid) {
+      log("info", `[update] lost lock race to pid=${winner.pid}, skipping update`);
+      return null;
+    }
+  }
+  const confirmed = await readLock();
+  if (!confirmed || confirmed.pid !== pid) {
+    log("info", `[update] lock held by pid=${confirmed?.pid}, skipping update`);
+    return null;
+  }
+  return {
+    release: async () => {
+      const current = await readLock();
+      if (current?.pid === pid) {
+        await rm(LOCK_FILE, { force: true }).catch(() => {
+        });
+      }
+    }
+  };
+}
 async function checkForUpdate(opts, force = false) {
   if (!opts.autoUpdate && !force) return;
   if (inFlight) return;
   inFlight = true;
-  const firstInProcess = !notified.has("__first_check_done__");
   try {
     const now = Date.now();
     const lastCheck = await readLastCheck();
     const sinceLastSec = lastCheck ? (now - lastCheck) / 1e3 | 0 : -1;
-    if (!force && !firstInProcess && now - lastCheck < CHECK_INTERVAL_MS) {
+    if (!force && firstCheckDone && now - lastCheck < CHECK_INTERVAL_MS) {
       const retryIn = (CHECK_INTERVAL_MS - (now - lastCheck)) / 1e3 | 0;
       log("info", `[update] throttled \u2014 last checked ${sinceLastSec}s ago, retry in ${retryIn}s`);
       return;
     }
     await writeLastCheck(now);
-    log("info", `[update] checking npm registry for ${opts.packageName}${firstInProcess ? " (startup check)" : sinceLastSec < 0 ? "" : ` (last check ${sinceLastSec}s ago)`}\u2026`);
+    firstCheckDone = true;
+    log("info", `[update] checking npm registry for ${opts.packageName}${sinceLastSec < 0 ? " (startup check)" : sinceLastSec === 0 ? "" : ` (last check ${sinceLastSec}s ago)`}\u2026`);
     const url = `${REGISTRY_BASE}/${opts.packageName}/latest`;
     const res = await fetch(url, {
       signal: AbortSignal.timeout(5e3),
@@ -3304,44 +3382,124 @@ async function checkForUpdate(opts, force = false) {
       log("warn", `[update] registry response had no version, skipping`);
       return;
     }
-    if (!isNewer(latest, opts.currentVersion)) {
-      log("info", `[update] current=${opts.currentVersion} latest=${latest} (up to date)`);
+    const installDir = await findInstallDir(opts.packageName);
+    const diskVersion = installDir ? await readDiskVersion(installDir) : void 0;
+    const currentVersion = diskVersion ?? opts.currentVersion;
+    if (!isNewer(latest, currentVersion)) {
+      log("info", `[update] current=${currentVersion} latest=${latest} (up to date)`);
       return;
     }
-    if (notified.has(latest)) {
-      log("info", `[update] latest=${latest} already installed this run, awaiting restart`);
+    const tarballUrl = data.dist?.tarball;
+    if (!tarballUrl) {
+      log("warn", `[update] registry response for ${latest} had no tarball URL`);
       return;
     }
-    log("info", `[update] new version found: ${opts.currentVersion} \u2192 ${latest}, installing\u2026`);
-    const installed = await installLatest(opts.packageName, latest);
-    if (installed) {
-      notified.add(latest);
-      log("info", `[update] installed ${opts.packageName} ${opts.currentVersion} \u2192 ${latest}. Restart to finish.`);
-    } else {
-      log("warn", `[update] install failed; will retry next cycle. Or: npm install -g ${opts.packageName}@${latest}`);
+    log("info", `[update] new version found: ${currentVersion} \u2192 ${latest}, downloading\u2026`);
+    const lock = await tryAcquireLock();
+    if (!lock) {
+      log("info", `[update] another process is updating, will check next cycle`);
+      return;
+    }
+    try {
+      const result = await installViaTarball(latest, tarballUrl, installDir);
+      if (result.ok) {
+        log("info", `[update] installed ${currentVersion} \u2192 ${latest}. Restart to finish.`);
+      } else {
+        log("warn", `[update] install failed: ${result.error}. Will retry next cycle.`);
+      }
+    } finally {
+      await lock.release();
     }
   } catch (e) {
     log("warn", `[update] check failed: ${String(e)}`);
   } finally {
     inFlight = false;
-    notified.add("__first_check_done__");
   }
 }
-async function installLatest(packageName, latest) {
-  if (!SEMVER_RE.test(latest)) return false;
+async function installViaTarball(version, tarballUrl, installDir) {
+  if (!installDir) {
+    return { ok: false, error: "cannot determine install directory (package.json not found walking up from running binary)" };
+  }
+  try {
+    await access(installDir, constants.W_OK);
+  } catch {
+    return { ok: false, error: `install dir not writable: ${installDir}` };
+  }
+  let tgzBuffer;
+  try {
+    const tgzRes = await fetch(tarballUrl, { signal: AbortSignal.timeout(6e4) });
+    if (!tgzRes.ok) {
+      return { ok: false, error: `tarball download failed: HTTP ${tgzRes.status} ${tgzRes.statusText}` };
+    }
+    tgzBuffer = Buffer.from(await tgzRes.arrayBuffer());
+  } catch (e) {
+    return { ok: false, error: `tarball download failed: ${String(e)}` };
+  }
+  const tmpFile = path4.join(cacheDir(), `.update-${version}.tgz`);
   try {
-    const code = await new Promise((resolve) => {
+    await mkdir(cacheDir(), { recursive: true });
+    await writeFile(tmpFile, tgzBuffer);
+  } catch (e) {
+    return { ok: false, error: `failed to write temp file ${tmpFile}: ${String(e)}` };
+  }
+  const stagingDir = path4.join(cacheDir(), `.update-staging-${version}`);
+  try {
+    await rm(stagingDir, { recursive: true, force: true });
+    await mkdir(stagingDir, { recursive: true });
+    const { code, stderr } = await new Promise((resolve) => {
       execFile(
-        "npm",
-        ["install", "-g", `${packageName}@${latest}`, "--silent", "--no-audit", "--no-fund"],
-        { timeout: 12e4, shell: process.platform === "win32" },
-        (err) => resolve(err ? 1 : 0)
+        "tar",
+        ["xzf", tmpFile, "-C", stagingDir, "--strip-components=1"],
+        { timeout: 3e4 },
+        (err, _stdout, stderr2) => {
+          if (err) {
+            resolve({ code: 1, stderr: stderr2 || err.message });
+          } else {
+            resolve({ code: 0, stderr: stderr2 || "" });
+          }
+        }
       );
     });
-    return code === 0;
-  } catch {
-    return false;
+    if (code !== 0) {
+      return { ok: false, error: `extraction failed (tar exit ${code})${stderr.trim() ? `: ${stderr.trim()}` : ""}` };
+    }
+    const stagingVersion = await readDiskVersion(stagingDir);
+    if (stagingVersion !== version) {
+      return { ok: false, error: `staging verification failed: version is ${stagingVersion ?? "missing"}, expected ${version}` };
+    }
+  } catch (e) {
+    return { ok: false, error: `extraction failed: ${String(e)}` };
+  } finally {
+    await rm(tmpFile, { force: true });
   }
+  try {
+    const { code, stderr } = await new Promise((resolve) => {
+      execFile(
+        "cp",
+        ["-r", stagingDir + "/.", installDir + "/"],
+        { timeout: 3e4 },
+        (err, _stdout, stderr2) => {
+          if (err) {
+            resolve({ code: 1, stderr: stderr2 || err.message });
+          } else {
+            resolve({ code: 0, stderr: stderr2 || "" });
+          }
+        }
+      );
+    });
+    if (code !== 0) {
+      return { ok: false, error: `failed to copy to install dir (cp exit ${code})${stderr.trim() ? `: ${stderr.trim()}` : ""}` };
+    }
+  } catch (e) {
+    return { ok: false, error: `failed to copy to install dir: ${String(e)}` };
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+  const newVersion = await readDiskVersion(installDir);
+  if (newVersion !== version) {
+    return { ok: false, error: `post-install verification failed: package.json version is ${newVersion ?? "missing"}, expected ${version}` };
+  }
+  return { ok: true };
 }
 function startAutoUpdate(opts) {
   log("info", `[update] auto-update enabled (checking every ${CHECK_INTERVAL_MS / 1e3 | 0}s)`);
@@ -3356,11 +3514,11 @@ function startAutoUpdate(opts) {
 
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import path5 from "path";
 var VERSION = (() => {
   try {
-    const here = fileURLToPath(import.meta.url);
+    const here = fileURLToPath2(import.meta.url);
     const pkg = path5.join(path5.dirname(here), "..", "package.json");
     return JSON.parse(readFileSync3(pkg, "utf8")).version ?? "dev";
   } catch {
@@ -3369,7 +3527,7 @@ var VERSION = (() => {
 })();
 var PACKAGE_NAME = (() => {
   try {
-    const here = fileURLToPath(import.meta.url);
+    const here = fileURLToPath2(import.meta.url);
     const pkg = path5.join(path5.dirname(here), "..", "package.json");
     return JSON.parse(readFileSync3(pkg, "utf8")).name ?? "billion-context";
   } catch {