@niroai/niro 0.16.0 → 0.18.0

package/src/lib/engine.js

@@ -0,0 +1,619 @@
+/**
+ * Puts the local engine on the machine, once, and finds it every time after that.
+ *
+ * The engine is a compiled binary of its own, not part of this npm package. It is about 60 MB
+ * per platform and there are four of them, so shipping all four to every install would be
+ * 240 MB on a machine that needs one, and publishing it at all would hand the whole engine to
+ * anybody who runs `npm pack` (Niraj, 2026-10-14: the engine is "downloaded on first use from
+ * an authenticated endpoint, not published to npm").
+ *
+ * **The fast path first.** Every run after the first costs one `existsSync`. Nothing here
+ * touches the network when the engine is already in the cache, and nothing here is called
+ * when the CLI only needs to ASK the engine something: a download must be something a person
+ * started, not a side effect of the watcher checking whether a folder is indexed.
+ *
+ * **Where it comes from, and why the digest does not come with it.** The CLI asks a Niro
+ * service for a manifest naming the version, the address of the tarball for this platform and
+ * its SHA-256. The digest comes from the service, which is authenticated, and never from the
+ * host serving the download: a digest published beside the file it describes proves only that
+ * the two agree, so whoever controls the download would control both. With the digest from
+ * somewhere else, a tarball that has been replaced is refused before anything is unpacked.
+ *
+ * **One download at a time.** Two commands can start within a second of each other: the
+ * wizard and a watcher, or two terminals. So the download takes a lock, streams to a `.part`
+ * file, and the finished folder is put in place with a rename, which is atomic. A reader
+ * either sees the whole folder or does not see it.
+ */
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const api = require("./api");
+const color = require("./color");
+
+/**
+ * Where the cache lives, beside the credentials and config the CLI already keeps.
+ *
+ * Worked out when it is used rather than when this file loads, which is how `receiptStore.js`
+ * does it too: a value fixed at load time cannot be repointed, and both a test and a machine
+ * with a small home partition need to repoint it.
+ */
+function home() {
+  return process.env.NIRO_ENGINE_HOME || path.join(os.homedir(), ".niro", "bin");
+}
+
+/** The manifest route, on the service that knows what this account may run. */
+const MANIFEST_PATH = "/api/local-engine/engine";
+
+/** The name of the executable inside the tarball's folder. */
+const EXECUTABLE = process.platform === "win32" ? "niro-local.exe" : "niro-local";
+
+/**
+ * How long to wait for another process's download, and how long a lock may sit untouched
+ * before it is treated as left behind by a process that died.
+ *
+ * Read when they are used, not when this file loads. A value fixed at load time ignores an
+ * override set by whatever started the process, and a test that sets one is then testing the
+ * default while appearing to test the override. Not hypothetical: the first run of this
+ * file's own tests sat for five minutes on a 300-second default it had asked to be 300
+ * milliseconds.
+ */
+function lockWaitMs() {
+  return Number(process.env.NIRO_ENGINE_LOCK_WAIT_MS) || 300_000;
+}
+
+function lockStaleMs() {
+  return Number(process.env.NIRO_ENGINE_LOCK_STALE_MS) || 600_000;
+}
+
+/**
+ * This machine, as the release names it.
+ *
+ * Five labels exist because the engine is compiled, and a compiled binary is per platform and
+ * per processor. Anything else is told plainly that there is no engine for it rather than
+ * being given one that cannot run: "no build for your platform" is a far better message than
+ * an exec failure. Windows is built for Intel only (2026-11-10).
+ */
+function label(platform = process.platform, architecture = process.arch) {
+  const architectures = { x64: "x86_64", arm64: "arm64" };
+  const found = architectures[architecture];
+  if (platform === "darwin" && found) return `macos-${found}`;
+  if (platform === "linux" && found) return `linux-${found}`;
+  if (platform === "win32" && architecture === "x64") return "windows-x86_64";
+  const problem = new Error(
+    `There is no local engine for ${platform} ${architecture}. ` +
+      "It is built for macOS and Linux on Intel and ARM, and for Windows on Intel."
+  );
+  problem.code = "ENOENGINEFORPLATFORM";
+  throw problem;
+}
+
+/** Which service to ask. The lease comes from the same place, so one variable moves both. */
+function manifestUrl() {
+  const base = process.env.NIRO_BILLING_URL || require("./lease").billingUrl();
+  return `${String(base).replace(/\/+$/, "")}${MANIFEST_PATH}`;
+}
+
+/** Where a given version's engine lives once it is unpacked. */
+function versionDir(version, which = label()) {
+  return path.join(home(), String(version), `niro-local-${which}`);
+}
+
+/**
+ * The engine on this machine, or null.
+ *
+ * `NIRO_LOCAL_BIN` wins, because a developer working on the engine points it at their own
+ * build and nothing should quietly download over that. Then the cache for the version asked
+ * for, if one was named; then the newest version in the cache, so a CLI that cannot reach us
+ * still runs the engine it already has.
+ */
+function installed(version = null) {
+  if (process.env.NIRO_LOCAL_BIN) return process.env.NIRO_LOCAL_BIN;
+  let which;
+  try {
+    which = label();
+  } catch {
+    return null;
+  }
+  if (version) {
+    const exact = path.join(versionDir(version, which), EXECUTABLE);
+    return fs.existsSync(exact) ? exact : null;
+  }
+  let versions = [];
+  try {
+    versions = fs.readdirSync(home());
+  } catch {
+    return null;
+  }
+  const usable = versions
+    .filter((name) => fs.existsSync(path.join(versionDir(name, which), EXECUTABLE)))
+    .sort(compareVersions);
+  return usable.length ? path.join(versionDir(usable[usable.length - 1], which), EXECUTABLE) : null;
+}
+
+/**
+ * A machine holds one version (Niraj, 2026-11-05: "we need to focus on that there is only one version on the
+ * system"). Once the published one is in place, every other version folder in the cache goes. A running engine keeps
+ * its file open, so one still answering a session finishes normally. A folder that will not go is left and
+ * never fails the install: the newest is the one started anyway. Dot files and downloads in progress are not
+ * version folders.
+ */
+function removeOtherVersions(keep) {
+  let names = [];
+  try {
+    names = fs.readdirSync(home());
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name === String(keep) || name.startsWith(".") || name.includes(".part-")) continue;
+    // Only older ones, and only when no engine runs from them: a running engine reads files from its folder after it
+    // starts, and only the executable stays open (independent check: a read failed once 2.0.0 was deleted under it).
+    // A folder in use goes at a later start (`tidy`).
+    if (compareVersions(name, keep) >= 0 || inUse(name)) continue;
+    try {
+      if (fs.statSync(path.join(home(), name)).isDirectory()) {
+        fs.rmSync(path.join(home(), name), { recursive: true, force: true });
+      }
+    } catch {
+      // Left for the next install.
+    }
+  }
+}
+
+/** The newest version in the cache with an engine in it, by number, or null. */
+function newestVersion(which = label()) {
+  let names = [];
+  try {
+    names = fs.readdirSync(home());
+  } catch {
+    return null;
+  }
+  const usable = names
+    .filter((name) => fs.existsSync(path.join(versionDir(name, which), EXECUTABLE)))
+    .sort(compareVersions);
+  return usable.length ? usable[usable.length - 1] : null;
+}
+
+/** The mark an engine started from this version's folder leaves while it runs. */
+function marksIn(version) {
+  const dir = versionDir(version);
+  try {
+    return fs.readdirSync(dir).filter((name) => name.startsWith(".in-use-")).map((name) => path.join(dir, name));
+  } catch {
+    return [];
+  }
+}
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+/** Whether an engine runs from this version's folder. A mark whose process is gone is removed. */
+function inUse(version) {
+  let running = false;
+  for (const mark of marksIn(version)) {
+    const pid = Number(path.basename(mark).slice(".in-use-".length));
+    if (pid && alive(pid)) running = true;
+    else fs.rmSync(mark, { force: true });
+  }
+  return running;
+}
+
+/** At every start: the older versions no engine runs from any more go, so one is on the machine. */
+function tidy() {
+  if (process.env.NIRO_LOCAL_BIN) return;
+  try {
+    const newest = newestVersion();
+    if (newest) removeOtherVersions(newest);
+  } catch {
+    // Never in the way of starting an engine.
+  }
+}
+
+/**
+ * Start an engine with `start()` (which returns the child process), marking its version's folder as in use for as
+ * long as the child runs. The starter's own mark covers the moment before the child has a pid. An engine from
+ * outside the cache (NIRO_LOCAL_BIN, the PATH) is started as it is.
+ */
+function startHeld(executable, start) {
+  tidy();
+  const relative = path.relative(home(), executable);
+  const version = relative.startsWith("..") || path.isAbsolute(relative) ? null : relative.split(path.sep)[0];
+  if (!version || !fs.existsSync(executable)) return start();
+  const mark = (pid) => {
+    const file = path.join(path.dirname(executable), `.in-use-${pid}`);
+    try {
+      fs.writeFileSync(file, "");
+    } catch {
+      return () => {};
+    }
+    return () => fs.rmSync(file, { force: true });
+  };
+  const releaseOwn = mark(process.pid);
+  let child;
+  try {
+    child = start();
+  } catch (err) {
+    releaseOwn();
+    throw err;
+  }
+  if (child && child.pid) {
+    const release = mark(child.pid);
+    child.once("close", release);
+    child.once("error", release);
+  }
+  releaseOwn();
+  return child;
+}
+
+/**
+ * Bring the cached engine to the published version, for `niro upgrade`: the engine moves with the CLI, so an old
+ * one is not left running. Null, with nothing fetched, when there is none in the cache (a first download is a
+ * person's choice) or NIRO_LOCAL_BIN names somebody's own build.
+ */
+async function upgradeInstalled({ log = console.log } = {}) {
+  if (process.env.NIRO_LOCAL_BIN || !installed()) return null;
+  return ensure({ log, latest: true });
+}
+
+/**
+ * Oldest first, by number: 0.10.0 is newer than 0.9.0, which sorting the names as text gets backwards. That
+ * would have run the OLDER engine for good after an upgrade, on a home the newer one had already opened, and an
+ * older engine picks the first of a folder's rows and writes one branch's files into another's index
+ * (independent check of niro-local, 5 of 5 homes). A name with no numbers sorts below every version.
+ */
+function compareVersions(one, two) {
+  const parts = (name) => String(name).split(".").map((part) => (/^\d+$/.test(part) ? Number(part) : -1));
+  const [a, b] = [parts(one), parts(two)];
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const difference = (a[i] ?? 0) - (b[i] ?? 0);
+    if (difference) return difference;
+  }
+  return String(one).localeCompare(String(two));
+}
+
+/**
+ * The engine this machine would RUN, and where it came from, or null when there is none.
+ *
+ * **Why this sits beside `installed()`, which looks like the same question.** `installed()`
+ * answers "is there one in the download cache", which is what `niro engine install` needs: a
+ * developer whose package manager already put the engine on their PATH still wants `install`
+ * to fetch one into the cache. Everything else wants the engine that will actually be
+ * started, and that includes the plain name on the PATH, which is how the engine runs for
+ * anybody working on it. The two answers disagreeing is what made `niro engine status` say
+ * "not installed" on a machine where the engine runs perfectly well, reported 2026-10-16:
+ * the status line read the cache while `localEngine.run` used the PATH.
+ *
+ * `source` is `"env"` for `NIRO_LOCAL_BIN`, `"cache"` for the download cache, `"path"` for a
+ * name found on the PATH.
+ */
+function resolve() {
+  const named = process.env.NIRO_LOCAL_BIN;
+  if (named) return { path: named, source: "env" };
+  const cached = installed();
+  if (cached) return { path: cached, source: "cache" };
+  // The platform question comes before the PATH, and takes no VERSION at all. Both are
+  // answers to the same trap: this says "there is an engine", and the PATH cannot support a
+  // narrower claim than that. A version was asked for and silently ignored once (`installed`
+  // takes one), so the parameter is gone rather than documented. And on a platform we publish
+  // no engine for, something called niro-local on the PATH is somebody else's program:
+  // reporting it would turn an honest "not installed" into a confident wrong answer. A
+  // developer's own build on such a machine is still named by NIRO_LOCAL_BIN above, which is
+  // exactly what that variable is for.
+  try {
+    label();
+  } catch {
+    return null;
+  }
+  const onPath = onThePath(EXECUTABLE);
+  return onPath ? { path: onPath, source: "path" } : null;
+}
+
+/** Why tar failed: its own words, else why it never started (a missing tar.exe), else its exit code. */
+function unpackProblem(result) {
+  const said = (result.stderr || "").trim();
+  if (said) return said;
+  if (result.error) return result.error.message;
+  return `tar exited with ${result.status}`;
+}
+
+/**
+ * Where a bare command name resolves on this machine's PATH, or null.
+ *
+ * Not needed to RUN the engine: `spawn` resolves a bare name itself. It is needed to SAY
+ * where the engine is, and to answer "is there one at all" before trying to run it.
+ *
+ * There is no extension list and no PATHEXT branch: the one name asked for is `EXECUTABLE`,
+ * which already carries `.exe` on Windows. On Windows `fs.accessSync(..., X_OK)` does not
+ * test an execute bit (Node documents it as behaving like `F_OK`), so there any file of that
+ * name counts, which is what Windows itself does with a `.exe`.
+ *
+ * Three details that each stop a wrong answer. The `isFile` check, because every directory
+ * passes an executable test, so a FOLDER called niro-local would otherwise be reported as the
+ * engine. `path.resolve`, so a relative PATH entry (`.`) gives an absolute answer rather than
+ * the bare name, which names no file once printed. And empty PATH entries are dropped rather
+ * than read as the current directory, which POSIX allows and nobody wants here: picking up a
+ * binary from whatever folder the developer happens to be in is not a feature.
+ *
+ * First match wins, which is what the shell does and what `spawn` did before anything called
+ * this. Two engines on one PATH is a real situation, an old one in /usr/local/bin and a new
+ * one in ~/.local/bin, and the one that would run is the one to report.
+ */
+function onThePath(name) {
+  const entries = String(process.env.PATH || "")
+    .split(path.delimiter)
+    .filter(Boolean);
+  for (const entry of entries) {
+    const candidate = path.resolve(entry, name);
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (fs.statSync(candidate).isFile()) return candidate;
+    } catch {
+      // Not there, or not runnable by us. Try the next one.
+    }
+  }
+  return null;
+}
+
+/** What the service says this account should run. */
+/**
+ * The statuses that are the service ANSWERING rather than breaking.
+ *
+ * Every one of them is a sentence a developer can act on, written by the service: this plan
+ * does not include the local engine (403), this account is stopped (403), no engine is
+ * published for your platform yet (503), this deployment has no signing key (503), we do not
+ * build for your platform (400), we do not know who you are (401). None of them is a fault to
+ * investigate, so none of them should arrive looking like one. Anything else, 500 included,
+ * keeps the route and the status code, because then somebody has to debug it.
+ */
+const ANSWERED_STATUSES = new Set([400, 401, 403, 503]);
+
+/** The sentence the service sent, or null when it sent none. */
+function serviceSaid(err) {
+  const body = err && err.body;
+  if (!body) return null;
+  if (typeof body === "string") return body.trim() || null;
+  const said = body.error || body.message;
+  return typeof said === "string" && said.trim() ? said.trim() : null;
+}
+
+/**
+ * Turn a refusal from the manifest endpoint into words, or return null to leave it alone.
+ *
+ * Why this exists: the HTTP layer names the route and the status in every failure, which is
+ * right for a fault and wrong for an answer. Asking for an engine before one is published
+ * printed `Error: GET /api/local-engine/engine failed: No local engine is published for
+ * linux-x86_64 yet` and then `(HTTP 503)`, so a correct, expected answer read as a crash in
+ * our code and handed the reader a route they can do nothing with (reported 2026-10-16).
+ */
+function manifestRefusal(err) {
+  if (!err || !ANSWERED_STATUSES.has(err.status)) return null;
+  const said = serviceSaid(err);
+  if (!said) return null;
+  const refusal = new Error(/[.!?]$/.test(said) ? said : `${said}.`);
+  // The code is how the command tells an answer from a fault. The status is deliberately NOT
+  // carried over: the printer appends "(HTTP n)" to anything that has one.
+  refusal.code = "EENGINEREFUSED";
+  return refusal;
+}
+
+async function manifest({ which = label() } = {}) {
+  let data;
+  try {
+    data = await api.request("GET", MANIFEST_PATH, {
+      apiUrl: process.env.NIRO_BILLING_URL || require("./lease").billingUrl(),
+      query: { label: which },
+    });
+  } catch (err) {
+    throw manifestRefusal(err) || err;
+  }
+  const version = data && (data.version || data.engine_version);
+  const url = data && data.url;
+  const digest = data && (data.sha256 || data.digest);
+  if (!version || !url || !digest) {
+    throw new Error("The engine manifest came back incomplete.");
+  }
+  return { version: String(version), url: String(url), sha256: String(digest).toLowerCase() };
+}
+
+/**
+ * Take the download lock, or wait for whoever has it.
+ *
+ * A directory is the lock, because `mkdir` either creates it or fails, in one step, on every
+ * filesystem this runs on. A lock whose directory has not been touched for a while is treated
+ * as left behind by a process that died, which is the case this has to survive: a download
+ * interrupted by Ctrl-C must not stop the next one for ever.
+ */
+async function withLock(version, run) {
+  const lock = path.join(home(), `.lock-${version}`);
+  fs.mkdirSync(home(), { recursive: true });
+  const until = Date.now() + lockWaitMs();
+  for (;;) {
+    try {
+      fs.mkdirSync(lock);
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      let age = Infinity;
+      try {
+        age = Date.now() - fs.statSync(lock).mtimeMs;
+      } catch {
+        continue; // it went away between the failure and the question
+      }
+      if (age > lockStaleMs()) {
+        fs.rmSync(lock, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() > until) {
+        throw new Error(
+          "Another process has been downloading the local engine for too long. " +
+            `If nothing is, remove ${lock} and try again.`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  }
+  try {
+    return await run();
+  } finally {
+    fs.rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Download to `into`, hashing the bytes as they arrive. Returns the digest.
+ *
+ * No credential is sent. The address came from the manifest and may be storage belonging to
+ * somebody else, so putting this machine's login token in that request would hand it over to
+ * whoever serves the file. Whatever authorises the download has to be in the address itself,
+ * which is what a signed URL is for.
+ */
+async function downloadTo(url, into) {
+  const answer = await fetch(url);
+  if (!answer.ok || !answer.body) {
+    throw new Error(`Downloading the local engine failed: HTTP ${answer.status}`);
+  }
+  const hash = crypto.createHash("sha256");
+  const file = fs.createWriteStream(into);
+  try {
+    for await (const chunk of answer.body) {
+      hash.update(chunk);
+      if (!file.write(chunk)) {
+        await new Promise((resolve) => file.once("drain", resolve));
+      }
+    }
+  } finally {
+    await new Promise((resolve) => file.end(resolve));
+  }
+  return hash.digest("hex");
+}
+
+/**
+ * The engine, downloading it first if this machine does not have it.
+ *
+ * Returns the path to the executable. The caller is whatever is about to run a build: not the
+ * watcher asking whether a folder is indexed, and not the MCP bridge answering a question from
+ * the cloud, because neither of those is a reason to pull 60 MB down somebody's connection.
+ */
+async function ensure({ log = console.log, which = label(), force = false, latest = false } = {}) {
+  // With an engine here this asks nobody, unless a person is upgrading (`latest`) or asked for a fresh download
+  // (`force`): the watcher comes through here.
+  const already = installed();
+  if (already && !force && !(latest && !process.env.NIRO_LOCAL_BIN)) return already;
+
+  const wanted = await manifest({ which });
+  const newestHere = newestVersion(which);
+  if (newestHere && compareVersions(newestHere, wanted.version) > 0) {
+    // Never an older version over a newer one: across a major version every start would be refused, and every
+    // install would fetch the older one again.
+    log(
+      `This machine has the local engine ${newestHere}, newer than the published ${wanted.version}, so it is kept ` +
+        `and nothing was fetched. To use ${wanted.version} instead, delete ${path.join(home(), newestHere)} and ` +
+        "run niro engine install."
+    );
+    removeOtherVersions(newestHere);
+    return installed(newestHere);
+  }
+  return withLock(wanted.version, async () => {
+    // Asked again under the lock: another process may have finished while this one waited,
+    // and unpacking the same tarball over its own folder is the one thing the rename cannot
+    // make safe.
+    const meanwhile = installed(wanted.version);
+    if (meanwhile && force && inUse(wanted.version)) {
+      // `--force` unpacks again, but never over the folder a running engine reads from (merge of the plan-page
+      // release with the one-version work: deleting it under a running bridge or watcher broke their reads).
+      log(
+        `The local engine ${wanted.version} is running (the assistant's bridge or the background watcher), so it ` +
+          "was not downloaded again. Close them and run niro engine install --force again."
+      );
+      removeOtherVersions(wanted.version);
+      return meanwhile;
+    }
+    if (meanwhile && !force) {
+      removeOtherVersions(wanted.version);
+      return meanwhile;
+    }
+
+    const target = versionDir(wanted.version, which);
+    const staging = `${target}.part-${process.pid}`;
+    const tarball = path.join(
+      home(),
+      `niro-local-${which}-${wanted.version}.part-${process.pid}`
+    );
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    log(color.gray(`Downloading the local engine ${wanted.version} for ${which}...`));
+    try {
+      const got = await downloadTo(wanted.url, tarball);
+      if (got !== wanted.sha256) {
+        // Refused before anything is unpacked, which is the whole reason the digest comes
+        // from the service rather than from the download.
+        throw new Error(
+          "The local engine that arrived is not the one Niro published, so it was not " +
+            "installed. Try again, and tell us if it keeps happening."
+        );
+      }
+      // A checksum against the service's digest, and only that: the engine is not signed, so
+      // nothing here may say it is.
+      log("Checking SHA-256… ok");
+      fs.mkdirSync(staging, { recursive: true });
+      // Windows: the tar.exe Windows ships (10 and later), named in full. A GNU tar from Git for Windows
+      // earlier on the PATH reads "C:\..." as a remote host and fails.
+      const tar = process.platform === "win32" ? require("./windowsPaths").system32("tar.exe") : "tar";
+      const untarred = spawnSync(tar, ["-xzf", tarball, "-C", staging, "--strip-components", "1"], {
+        encoding: "utf8",
+      });
+      if (untarred.status !== 0) {
+        throw new Error(`Unpacking the local engine failed: ${unpackProblem(untarred)}`);
+      }
+      const binary = path.join(staging, EXECUTABLE);
+      if (!fs.existsSync(binary)) {
+        throw new Error(`The local engine's archive holds no ${EXECUTABLE}.`);
+      }
+      fs.chmodSync(binary, 0o755);
+      // Atomic: a reader sees the whole folder or none of it. A folder already there is one
+      // another process put down while this one worked, and is kept rather than replaced,
+      // unless this call was asked to replace it.
+      if (force) fs.rmSync(target, { recursive: true, force: true });
+      try {
+        fs.renameSync(staging, target);
+      } catch (err) {
+        if (err.code !== "ENOTEMPTY" && err.code !== "EEXIST") throw err;
+        fs.rmSync(staging, { recursive: true, force: true });
+      }
+      removeOtherVersions(wanted.version);
+      return path.join(target, EXECUTABLE);
+    } finally {
+      fs.rmSync(tarball, { force: true });
+      fs.rmSync(staging, { recursive: true, force: true });
+    }
+  });
+}
+
+module.exports = {
+  EXECUTABLE,
+  startHeld,
+  upgradeInstalled,
+  home,
+  lockStaleMs,
+  lockWaitMs,
+  MANIFEST_PATH,
+  ensure,
+  manifestRefusal,
+  installed,
+  label,
+  onThePath,
+  unpackProblem,
+  resolve,
+  manifest,
+  manifestUrl,
+  versionDir,
+  withLock,
+};

package/src/lib/folderSync.js

@@ -202,7 +202,7 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  */
 /** Current nesting depth as spaces. \r-repainted lines bypass withIndent's console wrappers. */
 function nestPad() {
-  return " ".repeat(require("./nestedOutput").currentIndent());
+  return require("./nestedOutput").currentPad();
 }
 
 function buildManifest(rootDir, opts = {}) {
@@ -573,6 +573,7 @@ module.exports = {
   isConfigName,
   chunk,
   doInitialSync,
+  uploadBatchWithRetry,
   aggregateGuard,
   SOURCE_EXTENSIONS,
   STRUCTURAL_FILENAMES,

package/src/lib/graphCheck.js

@@ -0,0 +1,40 @@
+/**
+ * Can the local engine on this machine serve a graph?
+ *
+ * The engine keeps its graph in one SQLite file in its own home folder, so there is nothing to
+ * install or start: the question is only whether that file can be opened (a full disk, a home
+ * folder it may not write to). It is put to the engine itself, `niro-local db check`, which
+ * prints nothing when it can and says why in its own words when it cannot, so the reasons live
+ * in one place rather than in a JavaScript copy that would drift.
+ *
+ * **What was here before.** The engine's graph was a Memgraph container, many company laptops
+ * forbid a container runtime, and this file offered to index in Niro's cloud instead after
+ * asking (Niraj, 2026-10-16). With the graph in SQLite that machine no longer exists, and Niraj
+ * decided on 2026-10-31 to "drop the cloud offer altogether and remove the docker wording" (D2
+ * of niro-local's docs/usecases/sqlite-graph-store.md). A `cloudIndexingApproved` answer an
+ * older version saved in ~/.niro/config.json is simply never read again.
+ */
+const localEngine = require("./localEngine");
+const engine = require("./engine");
+
+/**
+ * Returns `{ ok: true }`, or `{ ok: false, problem }` where `problem` is the engine's own
+ * message, or `{ ok: false, missing: true, problem }` when there is no engine here to ask, which
+ * is not a problem with the graph and must not be reported as one.
+ */
+async function graphDatabaseUsable() {
+  if (!engine.resolve()) {
+    return { ok: false, missing: true, problem: "The local engine is not installed on this machine." };
+  }
+  try {
+    await localEngine.run(["db", "check"]);
+    return { ok: true };
+  } catch (err) {
+    // The engine's own stderr when there is any. Its `error:` prefix is for a person reading a
+    // command's output and is dropped here, since the caller prints the lines itself.
+    const words = (err && err.stderr) || (err && err.message) || String(err);
+    return { ok: false, problem: words.replace(/^error:\s*/m, "").trim() };
+  }
+}
+
+module.exports = { graphDatabaseUsable };