@niroai/niro 0.16.0 → 0.18.0

package/src/commands/status.js

@@ -4,6 +4,9 @@ const color = require("../lib/color");
 const watchState = require("../lib/watchState");
 const watchDaemon = require("../lib/watchDaemon");
 const resolveProject = require("./_resolveProject");
+const localOnboard = require("../lib/localOnboard");
+const lease = require("../lib/lease");
+const mcpClients = require("../lib/mcpClients");
 
 function tintStatus(st) {
   if (st === "COMPLETED") return color.green(st);
@@ -36,7 +39,61 @@ const AUTO_SYNC_LINES = {
   pm2_missing: color.yellow("OFF — PM2 is missing. Run `npm install -g pm2`, then `niro service install`"),
 };
 
+/**
+ * `niro status` in a folder the local engine holds: everything is answered on this machine,
+ * plus the plan and whether code is shared, from the lease. Returns false when the folder is
+ * not local, so the cloud answer below runs as before.
+ */
+async function localStatus(opts) {
+  const found = await localOnboard.worktreeFor(process.cwd(), { inside: true }).catch(() => null);
+  if (!found) return false;
+  const { project, worktree } = found;
+  const signedIn = !!(credentials.load() || {}).token || !!(credentials.load() || {}).cliToken;
+  const claims = signedIn ? await lease.currentClaims().catch(() => null) : null;
+  const shareCode = claims && typeof claims.share_code === "boolean" ? claims.share_code : null;
+  let assistants = [];
+  try {
+    assistants = mcpClients.clientNames(mcpClients.configuredClients());
+  } catch {
+    // Unknown is shown as none.
+  }
+  const autoSync = watchDaemon.watchDaemonState();
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      local: true,
+      project: project.name,
+      folder: worktree.path,
+      indexed: !!worktree.indexed,
+      last_build_at: worktree.last_build_at || null,
+      plan: (claims && claims.plan_name) || null,
+      share_code: shareCode,
+      assistants,
+      auto_sync: autoSync,
+    }));
+    return true;
+  }
+  const label = (s) => color.dim(s.padEnd(13));
+  console.log(`${label("Project:")} ${color.bold(project.name)} ${color.dim("(indexed on this machine)")}`);
+  console.log(`${label("Folder:")} ${worktree.path}`);
+  console.log(`${label("Graph:")} ${worktree.indexed ? color.green("built") : color.yellow("not built yet — run `niro start` here")}`);
+  if (worktree.last_build_at) console.log(`${label("Last build:")} ${color.dim(worktree.last_build_at)}`);
+  console.log(`${label("Plan:")} ${(claims && claims.plan_name) || color.dim(signedIn ? "unknown (could not reach Niro)" : "not signed in")}`);
+  // Help improve Niro is shown by `niro plan`, not here (2026-11-11); --json still carries share_code.
+  console.log(`${label("Assistant:")} ${assistants.length ? assistants.join(", ") : color.yellow("none — run `niro mcp install`")}`);
+  console.log(`${label("Auto-sync:")} ${AUTO_SYNC_LINES[autoSync] || autoSync}`);
+  return true;
+}
+
 async function status(projectIdArg, opts = {}) {
+  if (!projectIdArg && (await localStatus(opts))) return;
+  // Without the cloud there is nothing else to ask: a folder the engine does not hold is simply
+  // not set up yet, so say that rather than sending them to the cloud's `niro init`.
+  if (!require("../lib/release").cloud) {
+    console.log(`This folder is not indexed on this machine. Run ${color.cyan("niro start")} here to set it up.`);
+    process.exitCode = 1;
+    return;
+  }
   credentials.requireCreds();
   const projectId = await resolveProject.resolveProjectId(projectIdArg, { apiUrl: opts.apiUrl });
   const data = await api.get(`/api/graph/${encodeURIComponent(projectId)}/status`);

package/src/commands/takeover.js

@@ -23,6 +23,7 @@ const prompt = require("../lib/prompt");
 const watchState = require("../lib/watchState");
 const resolveCtxLib = require("../lib/resolveContext");
 const spinner = require("../lib/spinner");
+const cloudGuard = require("../lib/cloudGuard");
 
 const ok = (s) => color.green(s);
 const warn = (s) => color.yellow(s);
@@ -40,6 +41,11 @@ async function takeover(pathArg, opts = {}) {
         + "Select the backend with `niro login` / your config first, then run this without --api-url.");
   }
   const targetDir = require("path").resolve(pathArg || process.cwd());
+  // Said, not refused. A temporary project is deliberately a cloud project (decision 3): it
+  // serves pull request review and root cause analysis, which the local graph does not
+  // answer, and an assistant following `should_create_temp_project` runs this command with
+  // no terminal, so a refusal or a prompt here would break that route.
+  await cloudGuard.noticeIfIndexedLocally(targetDir, { what: "A temporary project" });
   const { repoRoot, branch } = git.inspect(targetDir);
   if (!repoRoot) {
     throw new Error("Not a git repository — run takeover inside the repo you want to work on.");

package/src/commands/uninstall.js

@@ -0,0 +1,180 @@
+/**
+ * `niro uninstall` — take Niro off this machine (design §9.5, addendum D4).
+ *
+ * In order, because each step needs what the next removes:
+ *   1. the assistant entries `niro mcp install` wrote (teardown.js --all -y)
+ *   2. the niro-watch daemon
+ *   3. ~/.niro (credentials, config, the engine) and ~/.niro-local (the engine's registry and
+ *      its graph, graph.db)
+ *
+ * Asks first, and a no changes nothing. A failed step is said and the rest still run, so a
+ * broken editor config cannot leave credentials behind. The npm package itself is the one
+ * thing a running program cannot remove cleanly, so the command to do it is printed.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const prompt = require("../lib/prompt");
+const color = require("../lib/color");
+const service = require("../lib/service");
+
+const n = (x) => x.toLocaleString("en-US");
+const tilde = (p) => p.replace(os.homedir(), "~");
+
+/**
+ * What is on this machine, for the list shown before asking. Every part is best effort: a broken
+ * editor config or a missing engine must not stop someone from removing Niro.
+ */
+async function survey({ claims, folders, assistants, watcher }) {
+  const [c, f] = await Promise.all([
+    claims().catch(() => null),
+    folders().catch(() => []),
+  ]);
+  let names = [];
+  try { names = assistants(); } catch { /* shown as "your AI assistants" */ }
+  let watch = null;
+  try { watch = watcher(); } catch { /* unknown */ }
+  return { claims: c, folders: f, assistants: names, watch };
+}
+
+/**
+ * Send everything the engine is holding, batch after batch, and return how many went. Stops when
+ * a round sends nothing, so a queue the server keeps refusing cannot loop.
+ */
+async function flushUploads() {
+  let total = 0;
+  for (const send of [() => require("../lib/auditUpload").uploadPending(), () => require("../lib/journalUpload").uploadPending()]) {
+    for (let round = 0; round < 20; round++) {
+      const r = await send();
+      const sent = (r && (r.submitted || r.sent)) || 0;
+      total += sent;
+      if (sent === 0) break;
+    }
+  }
+  return total;
+}
+
+async function uninstall(opts = {}, {
+  claims = () => withTimeout(require("../lib/lease").currentClaims(), 4000),
+  folders = () => require("../lib/planUsage").folders(),
+  assistants = () => { const m = require("../lib/mcpClients"); return m.clientNames(m.configuredClients()); },
+  watcher = () => require("../lib/watchDaemon").watchDaemonState(),
+  flush = flushUploads,
+} = {}) {
+  const home = os.homedir();
+  const niroDir = path.join(home, ".niro");
+  const localDir = path.join(home, ".niro-local");
+  const creds = (() => { try { return require("../lib/credentials").load(); } catch { return null; } })();
+  const s = await survey({ claims, folders, assistants, watcher });
+
+  // Only what is still here: a second run after a full uninstall has nothing to list.
+  const has = {
+    assistants: s.assistants.length > 0,
+    watcher: s.watch === "running" || s.watch === "stopped",
+    graphs: fs.existsSync(localDir),
+    account: fs.existsSync(niroDir),
+  };
+  if (!Object.values(has).some(Boolean)) {
+    console.log(`\nNiro is not installed on this machine, so there is nothing to remove. If the ${color.cyan("niro")} command is still here:  ${color.cyan("npm uninstall -g @niroai/niro")}\n`);
+    return;
+  }
+
+  console.log("");
+  console.log("┌  Remove Niro from this machine");
+  console.log("│");
+  console.log("│  This removes:");
+  if (has.assistants) console.log(`│    · Niro from ${s.assistants.join(", ")}`);
+  if (has.watcher) console.log(`│    · the background watcher (niro-watch)${s.watch === "running" ? ", now running" : ""}`);
+  const lines = s.folders.reduce((sum, f) => sum + f.lines, 0);
+  if (has.graphs) {
+    console.log(s.folders.length
+      ? `│    · ${s.folders.length} indexed folder${s.folders.length === 1 ? "" : "s"} and their graphs, ${n(lines)} lines  ${color.dim(tilde(localDir))}`
+      : `│    · the local engine's graphs  ${color.dim(tilde(localDir))}`);
+  }
+  if (has.account) console.log(`│    · ${creds && creds.email ? `your sign-in (${creds.email}), ` : "your sign-in, "}settings and the local engine  ${color.dim(tilde(niroDir))}`);
+  console.log(`│  Your code and repositories are not touched. Your Niro account stays.`);
+  if (s.claims && s.claims.share_code) {
+    console.log("│");
+    console.log(`│  ${color.yellow("⚠")} Help improve Niro is on for your account. Uninstalling does not turn it off;`);
+    console.log(`│    turn it off at ${color.cyan(`${require("../lib/planUsage").consoleUrl()}/settings?tab=privacy`)}`);
+  }
+  console.log("│");
+  console.log(`│  ${color.dim(`To stop indexing one folder instead:  niro plan remove <folder>`)}`);
+  console.log("│");
+
+  if (!opts.yes) {
+    if (prompt.isNonInteractive()) {
+      console.error("└  Nothing removed: there is no terminal to confirm on. Pass --yes to go ahead.");
+      process.exitCode = 1;
+      return;
+    }
+    if (!(await prompt.confirm("◆  Remove all of this?", false))) {
+      console.log("└  Nothing removed.");
+      return;
+    }
+    console.log("│");
+  }
+
+  let failed = 0;
+  const attempt = async (what, fn) => {
+    try {
+      await fn();
+      console.log(`│  ${color.green("✓")} ${what}`);
+    } catch (err) {
+      failed += 1;
+      console.log(`│  ${color.yellow("⚠")} ${what}: ${err && err.message ? err.message : err}`);
+    }
+  };
+
+  // What the engine still holds to send goes before the graphs are deleted with it. Not a removal
+  // step: a failure is said, and uninstalling carries on.
+  if (has.graphs) {
+    try {
+      const sent = await withTimeout(flush(), 60000);
+      if (sent > 0) console.log(`│  ${color.green("✓")} Sent ${sent} waiting usage and audit record${sent === 1 ? "" : "s"} to Niro`);
+    } catch (err) {
+      console.log(`│  ${color.yellow("⚠")} Could not send the waiting usage and audit records: ${err && err.message ? err.message : err}`);
+    }
+  }
+
+  // The assistants' entries are cleared whenever anything else is being removed, even when none
+  // was detected: detection is best effort and the teardown is harmless where nothing is set.
+  await attempt(has.assistants ? `Removed Niro from ${s.assistants.join(", ")}` : "Cleared Niro from your assistants' settings",
+    () => require("./mcp").uninstall(["--all", "-y"], { quiet: true }));
+  let startupCommand = null;
+  if (has.watcher) {
+    await attempt("Stopped and removed the background watcher", () => {
+      // false means PM2 is not here, so there is no daemon to remove: not a failure.
+      const r = service.uninstall();
+      if (r && r.hook === "manual") startupCommand = r.command;
+    });
+  }
+  if (has.graphs) {
+    await attempt(s.folders.length ? `Deleted ${s.folders.length} graph${s.folders.length === 1 ? "" : "s"}  ${color.dim(tilde(localDir))}` : `Deleted ${tilde(localDir)}`,
+      () => fs.rmSync(localDir, { recursive: true, force: true }));
+  }
+  if (has.account) {
+    await attempt(`Deleted your sign-in, settings and the engine  ${color.dim(tilde(niroDir))}`,
+      () => fs.rmSync(niroDir, { recursive: true, force: true }));
+  }
+
+  if (failed) process.exitCode = 1;
+  console.log("│");
+  console.log(`└  ${failed ? "Niro is partly removed; see the problems above." : "Niro is removed from this machine."}`);
+  console.log("");
+  console.log("   Two last steps:");
+  console.log(`     1. Remove the command itself:  ${color.cyan("npm uninstall -g @niroai/niro")}`);
+  console.log("     2. Restart your AI assistants so they stop loading Niro.");
+  if (startupCommand) {
+    // PM2's start-on-login entry needs root to remove here, and starts nothing of Niro's now.
+    console.log(color.dim(`   PM2 still starts on login (with nothing of Niro's). To remove that too:  ${startupCommand}`));
+  }
+  console.log("");
+}
+
+function withTimeout(promise, ms) {
+  return Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(null), ms).unref())]);
+}
+
+module.exports = { uninstall };

package/src/commands/upgrade.js

@@ -107,7 +107,7 @@ function replaceAndHandOver(force) {
   console.log(`\n  Upgrading niro. Installed now: ${VERSION}\n`);
 
   const installed = childProcess.spawnSync("npm", ["install", "-g", `${PACKAGE_NAME}@latest`], {
-    shell: true,
+    shell: process.platform === "win32",
     stdio: "inherit",
   });
 
@@ -194,7 +194,7 @@ function replaceAndHandOver(force) {
 
 /** Where npm would install this package globally. */
 function globalPackageDir() {
-  const r = childProcess.spawnSync("npm", ["prefix", "-g"], { shell: true, encoding: "utf8" });
+  const r = childProcess.spawnSync("npm", ["prefix", "-g"], { shell: process.platform === "win32", encoding: "utf8" });
   if (r.status !== 0) return null;
   const prefix = String(r.stdout || "").trim();
   if (!prefix) return null;
@@ -281,11 +281,31 @@ async function finish(fromVersion) {
   const complete = await refreshAssistantFiles();
   if (!complete) process.exitCode = EXIT_REFRESH_INCOMPLETE;
 
+  await upgradeEngine();
+
+  // Said after the files are in place, so it is the last thing on screen and is read. Local
+  // state only: no network call, because an upgrade must not be able to hang on one.
+  for (const line of require("../lib/migrationNotice").lines()) console.log(line);
+
   console.log(`  ${color.yellow("One thing left:")} restart your AI assistant.`);
   console.log("  Hooks and skills are read when it starts, so an assistant that is already open");
   console.log("  is still using the old ones.\n");
 }
 
+/**
+ * The local engine moves with the CLI, so a machine holds one version of it. Failing to fetch it does not fail the
+ * upgrade: the engine already there keeps working, and the words say how to try again.
+ */
+async function upgradeEngine() {
+  const engine = require("../lib/engine");
+  try {
+    await engine.upgradeInstalled({ log: (line) => console.log(`  ${line}`) });
+  } catch (err) {
+    console.log(`  The local engine was not upgraded: ${err.message}`);
+    console.log(`  Try again with ${color.cyan("niro engine install")}.\n`);
+  }
+}
+
 /**
  * Re-run the installer once per configured client, so their hooks, skills and instruction files
  * match the package that is now installed. Returns false when anything was skipped or failed, so
@@ -312,9 +332,18 @@ async function refreshAssistantFiles() {
     return true;
   }
 
-  if (!startCmd.hasCredentials()) {
-    console.log(`  ${color.yellow("Heads up:")} you are not signed in, so each client's installer will ask`);
-    console.log(`  for an API key. ${color.cyan("niro login")} first if you would rather it did not.\n`);
+  // The installer's own test (src/mcp/setup.js main): after `niro login --api-key` there is a key but no
+  // cli token, and it still refuses. With the cloud it then asks for a key; without, it exits 1 for every
+  // client and the run ends "N of M refreshed, K failed". Called through the module so tests can stub it.
+  if (!require("../mcp/setup").hasCliToken()) {
+    if (require("../lib/release").cloud) {
+      console.log(`  ${color.yellow("Heads up:")} you are not signed in, so each client's installer will ask`);
+      console.log(`  for an API key. ${color.cyan("niro login")} first if you would rather it did not.\n`);
+    } else {
+      console.log(`  ${color.yellow("Heads up:")} you are not signed in, so each client's installer will stop`);
+      console.log("  without refreshing it.");
+      console.log(`  Run ${color.cyan("niro login")}, then ${color.cyan("niro upgrade --finish")}.\n`);
+    }
   }
 
   // Cursor's installer writes a project-scoped rule to <cwd>/.cursor/rules/niro.mdc, so refreshing
@@ -375,9 +404,10 @@ function restartWatcher() {
 
   console.log("  Restarting the background watcher, which is still running the old code...");
   if (service.restart()) {
-    // Deliberately not "now on <version>": pm2 re-execs the script path recorded when the daemon
-    // was installed (service.js records process.argv[1]), which is not necessarily the copy that
-    // was just upgraded. All that is known here is that pm2 restarted it.
+    // service.restart() deletes, starts and saves niro-watch with the short environment list and
+    // makes ~/.pm2/dump.pm2 private, so an install saved with the whole shell is rewritten here
+    // too. It registers process.argv[1], which in `--finish` is the copy just installed; still not
+    // "now on <version>", since only PM2's answer is known here.
     console.log(`  ${color.green("Done.")} niro-watch restarted. Check it with ${color.cyan("niro service status")}.\n`);
   } else {
     console.log(`  ${color.yellow("!")} Could not restart it. Run ${color.cyan("niro service install")}.\n`);