billion-context 0.1.18 → 0.1.20

package/dist/index.js

@@ -2,7 +2,8 @@
 
 // src/config.ts
 import { defaultConfig } from "acp-kernel";
-import { readFileSync } from "fs";
+import { readFileSync, existsSync, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { dirname } from "path";
 
 // src/paths.ts
 import { homedir } from "os";
@@ -194,6 +195,22 @@ function loadConfigFile() {
   }
   return {};
 }
+var TEMPLATE_CONFIG = `{
+  "providers": {
+  }
+}`;
+function ensureConfigTemplate() {
+  const p = configFile();
+  if (existsSync(p)) return false;
+  try {
+    mkdirSync2(dirname(p), { recursive: true });
+    writeFileSync(p, TEMPLATE_CONFIG + "\n", "utf8");
+    log("info", `[acp-config] created empty config at ${p} \u2014 add your providers (see README Quickstart), then restart`);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function parseRouteEntry(v) {
   if (typeof v === "string" && v.length > 0) {
     return { url: v.replace(/\/$/, "") };
@@ -743,7 +760,7 @@ import { createInitialState as createInitialState2 } from "acp-kernel";
 
 // src/persist.ts
 import { promises as fs } from "fs";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash2 } from "crypto";
 import * as path3 from "path";
 import { createInitialState } from "acp-kernel";
@@ -859,7 +876,7 @@ var SessionStore = class {
     const candidates = [this.filePath(id, meta?.protocol, meta?.upstreamOrigin)];
     if (meta?.protocol) candidates.push(this.filePath(id));
     for (const file of candidates) {
-      if (!existsSync(file)) continue;
+      if (!existsSync2(file)) continue;
       try {
         const parsed = JSON.parse(readFileSync2(file, "utf8"));
         if (!isValidRecord(parsed) || parsed.id !== id) continue;
@@ -926,13 +943,13 @@ var SessionStore = class {
     const record = buildRecord(session);
     const file = this.filePath(session.id, session.protocol, session.upstreamOrigin);
     try {
-      mkdirSync2(path3.dirname(file), { recursive: true });
+      mkdirSync3(path3.dirname(file), { recursive: true });
     } catch (e) {
       this.log("warn", `[persist] could not create session dir ${this.dir}: ${msg(e)}`);
     }
     const tmp = this.tempPath(session.id);
     try {
-      writeFileSync(tmp, JSON.stringify(record), "utf8");
+      writeFileSync2(tmp, JSON.stringify(record), "utf8");
       renameSync2(tmp, file);
       return true;
     } catch (e) {
@@ -1608,8 +1625,8 @@ import {
   collectBlockContent as collectBlockContent2,
   deactivateBlock
 } from "acp-kernel";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
 import { tmpdir } from "os";
 function resolveDecompress(args, ctx) {
   const rawBlockId = args.blockId;
@@ -1641,8 +1658,8 @@ function resolveDecompress(args, ctx) {
   const outPath = body.length > 1e4 ? join2(tmpdir(), `acp-decompress-${safeBlockId}-${Date.now()}.txt`) : null;
   if (outPath) {
     try {
-      mkdirSync3(dirname2(outPath), { recursive: true });
-      writeFileSync2(outPath, body, "utf8");
+      mkdirSync4(dirname3(outPath), { recursive: true });
+      writeFileSync3(outPath, body, "utf8");
       return `${header}
 Content (${body.length} chars) written to: ${outPath}
 Use the read tool to access it.`;
@@ -3161,10 +3178,10 @@ async function pipeThrough(stream2, res) {
   }
 }
 async function dumpStreamToFile(stream2, dir, name) {
-  const { mkdirSync: mkdirSync4, createWriteStream: createWriteStream2 } = await import("fs");
+  const { mkdirSync: mkdirSync5, createWriteStream: createWriteStream2 } = await import("fs");
   const { join: join3 } = await import("path");
   try {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
     const ws = createWriteStream2(join3(dir, name));
     const reader = stream2.getReader();
     try {
@@ -3234,16 +3251,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 +3292,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 +3399,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 {
+    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(
+        "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 || "" });
+          }
+        }
+      );
+    });
+    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 = await new Promise((resolve) => {
+    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)
+        "cp",
+        ["-r", stagingDir + "/.", installDir + "/"],
+        { 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: `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 +3531,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 +3544,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 {
@@ -3483,6 +3658,7 @@ async function main() {
   for (const [k, v] of Object.entries(overrides)) {
     if (v !== void 0) process.env[k] = v;
   }
+  ensureConfigTemplate();
   const opts = loadOptions();
   await startServer(opts);
   if (opts.autoUpdate) {