@niroai/niro 0.11.0 → 0.13.0

package/src/lib/mcpClients.js

@@ -0,0 +1,241 @@
+/**
+ * Which AI clients on this machine already have niro registered?
+ *
+ * `niro upgrade` needs this list. The hooks, skills and instruction files an install writes are
+ * fixed text in the user's home folder, not read out of the package as it runs, so replacing the
+ * package leaves them exactly as they were. Putting them back means re-running the installer, and
+ * the installer configures ONE client, named with `--client`. Nothing on disk records which
+ * clients were ever chosen, so the list has to be worked out from what is there.
+ *
+ * Every client in the CLIENTS map is covered, because the installer leaves a file this repo owns
+ * in every case. Eight are registered by writing a JSON config whose path setup.js builds. The
+ * other six are registered by shelling out to another tool's CLI, but each one also gets a marker
+ * appended to a markdown file this repo writes and teardown.js later strips: ~/.claude/CLAUDE.md,
+ * ~/.gemini/GEMINI.md, ~/.copilot/copilot-instructions.md, ~/.factory/AGENTS.md, plus codex's
+ * [mcp_servers.niro] table and goose's extensions entry, both written here too. The marker is
+ * appended only after the registration command succeeded, so its presence means the client really
+ * was configured.
+ *
+ * Two rules keep this honest, and both exist because of what got the serve-time self-heal reverted
+ * on 2026-07-30 (d3ff3d8):
+ *
+ *   Every path must be absolute. That revert's worst finding was a settings path resolving against
+ *   the current folder and a project's own git-tracked .claude/settings.json being written. It is
+ *   not enough to check that a home folder exists: HOME can be set to the EMPTY string while
+ *   USERPROFILE is set, and userHome() then returns USERPROFILE and looks fine, while four of the
+ *   path builders in setup.js read process.env.HOME directly and hand back a relative path. So the
+ *   home is rejected unless it is absolute, and each individual path is rejected the same way.
+ *
+ *   Markers are matched on a whole line, never as a substring of prose. That revert also failed on
+ *   substring tests over prose, which captured a user's unrelated hook. A sentence mentioning the
+ *   marker is not an install.
+ *
+ * Everything here is read-only. Nothing in this file creates, writes or deletes anything.
+ */
+const fs = require("fs");
+const path = require("path");
+
+const setup = require("../mcp/setup");
+
+const { CLIENTS, NIRO_MD_MARKER, userHome, gooseConfigPath } = setup;
+
+/**
+ * Biggest file worth reading. None of these configs is more than a few kilobytes, and without a
+ * cap a config path that is a huge file, a FIFO or a symlink to /dev/zero makes `niro upgrade`
+ * hang or allocate without limit rather than reporting a client.
+ */
+const MAX_CONFIG_BYTES = 4 * 1024 * 1024;
+
+/**
+ * The markdown file each shell-registered client gets a niro marker appended to, written by
+ * setup.js after the registration command succeeds and removed by teardown.js. Relative to home.
+ */
+const MARKER_FILES = {
+  "claude-code": [".claude", "CLAUDE.md"],
+  "gemini-cli": [".gemini", "GEMINI.md"],
+  "copilot-cli": [".copilot", "copilot-instructions.md"],
+  factory: [".factory", "AGENTS.md"],
+};
+
+/** The marker on a line of its own. A sentence that merely mentions it is not an install. */
+const MARKER_LINE = new RegExp(
+  `^[ \\t]*${NIRO_MD_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[ \\t]*$`,
+  "m"
+);
+
+/**
+ * The home folder, or null when there is not one that can be trusted.
+ *
+ * Rejects an empty or relative home, and rejects a HOME that is set to the empty string even when
+ * USERPROFILE would fill in, because setup.js's claude-desktop, windsurf, vscode and cline path
+ * builders read process.env.HOME directly and would produce paths relative to the current folder.
+ */
+function homeOrNull() {
+  if (process.env.HOME === "") return null;
+  const home = userHome();
+  return home && path.isAbsolute(home) ? home : null;
+}
+
+/** Read a config file, or null when it is missing, unreadable, not a regular file, or too big. */
+function readConfig(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile()) return null; // a directory, a FIFO, a device
+    if (stat.size > MAX_CONFIG_BYTES) return null;
+    return fs.readFileSync(file, "utf-8");
+  } catch (err) {
+    return null; // missing or unreadable is not evidence of an install
+  }
+}
+
+/**
+ * True when `file` holds a real niro registration under `key`.
+ *
+ * Presence of the key is not enough. An empty object is not a working entry, and `enabled: false`
+ * (opencode) or `disabled: true` (cline) is a registration the user switched OFF. Reporting those
+ * would make `niro upgrade` re-run the installer, which rewrites the whole entry and turns niro
+ * back on without being asked.
+ */
+function jsonHasNiro(file, key) {
+  const raw = readConfig(file);
+  if (raw === null) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object") return false;
+  const section = parsed[key];
+  if (!section || typeof section !== "object") return false;
+  const entry = section.niro;
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  if (entry.disabled === true) return false;
+  if (entry.enabled === false) return false;
+  return Object.keys(entry).length > 0;
+}
+
+/** True when `file` exists and matches `re`. */
+function fileMatches(file, re) {
+  const raw = readConfig(file);
+  return raw === null ? false : re.test(raw);
+}
+
+/**
+ * The JSON config paths worth checking for a client. Antigravity has two: setup.js writes to the
+ * legacy file only while the unified one is absent, so once both exist the builder stops returning
+ * the legacy path and a registration living there becomes invisible. teardown.js already checks
+ * both unconditionally, and the reason is written up in test/mcpClientCoverage.test.js.
+ */
+function jsonPathsFor(id, client, home) {
+  if (id === "antigravity") {
+    return [
+      path.join(home, ".gemini", "antigravity", "mcp_config.json"),
+      path.join(home, ".gemini", "config", "mcp_config.json"),
+    ];
+  }
+  try {
+    return [client.configPath()];
+  } catch (err) {
+    return []; // a path built from an env var this platform does not set
+  }
+}
+
+/**
+ * claude-code leaves two markers and either one is proof: the niro-skill file, and the marked
+ * section in ~/.claude/CLAUDE.md. There is no JSON config to read, because the MCP entry itself
+ * goes in through `claude mcp add`.
+ */
+function claudeCodeConfigured(home) {
+  const skill = path.join(home, ".claude", "skills", "niro-skill", "SKILL.md");
+  try {
+    if (fs.statSync(skill).isFile()) return skill;
+  } catch (err) {
+    // fall through to the CLAUDE.md marker
+  }
+  const memory = path.join(home, MARKER_FILES["claude-code"][0], MARKER_FILES["claude-code"][1]);
+  return fileMatches(memory, MARKER_LINE) ? memory : null;
+}
+
+/** codex registers the [mcp_servers.niro] table in ~/.codex/config.toml. */
+function codexConfigured(home) {
+  const toml = path.join(home, ".codex", "config.toml");
+  return fileMatches(toml, /^\s*\[mcp_servers\.niro\]\s*$/m) ? toml : null;
+}
+
+/**
+ * goose: the same two-space-indented `niro:` line the installer writes and the uninstaller
+ * removes, but only when it sits under the top-level `extensions:` key. The installer's own guard
+ * matches that line anywhere in the file, so a `niro:` nested under some other top-level key reads
+ * as installed; here that would cost a wizard run that rewrites a config the user did not ask us
+ * to touch, so the parent key is checked as well.
+ */
+function gooseConfigured() {
+  let yaml;
+  try {
+    yaml = gooseConfigPath();
+  } catch (err) {
+    return null;
+  }
+  if (!yaml || !path.isAbsolute(yaml)) return null;
+  const raw = readConfig(yaml);
+  if (raw === null) return null;
+
+  let underExtensions = false;
+  for (const line of raw.split(/\r?\n/)) {
+    if (/^\S/.test(line)) underExtensions = /^extensions:\s*$/.test(line);
+    else if (underExtensions && /^ {2}niro:\s*$/.test(line)) return yaml;
+  }
+  return null;
+}
+
+/**
+ * Returns { home, configured }.
+ *
+ *   home        the home folder used, or null when there was no usable one
+ *   configured  [{ id, name, where }] for every client proved to have niro registered
+ */
+function configuredClients() {
+  const home = homeOrNull();
+  // Without a trustworthy home every path below could resolve against the current folder, so a
+  // repo that happens to hold a .claude or .cursor folder would be read as the user's own
+  // settings and then written to. Check nothing rather than check the wrong thing.
+  if (!home) return { home: null, configured: [] };
+
+  const configured = [];
+  const add = (id, where) => {
+    if (!where || !path.isAbsolute(where)) return;
+    configured.push({ id, name: CLIENTS[id] ? CLIENTS[id].name : id, where });
+  };
+
+  for (const [id, client] of Object.entries(CLIENTS)) {
+    if (id === "claude-code") {
+      add(id, claudeCodeConfigured(home));
+    } else if (id === "codex") {
+      add(id, codexConfigured(home));
+    } else if (id === "goose") {
+      add(id, gooseConfigured());
+    } else if (client.configPath || id === "antigravity") {
+      const key = client.topLevelKey || "mcpServers";
+      for (const file of jsonPathsFor(id, client, home)) {
+        if (file && path.isAbsolute(file) && jsonHasNiro(file, key)) {
+          add(id, file);
+          break;
+        }
+      }
+    } else if (MARKER_FILES[id]) {
+      add(id, fileMatches(path.join(home, ...MARKER_FILES[id]), MARKER_LINE)
+        ? path.join(home, ...MARKER_FILES[id])
+        : null);
+    }
+  }
+
+  return { home, configured };
+}
+
+/** Every client id in the CLIENTS map, so a caller can prove none is silently uncovered. */
+function allClientIds() {
+  return Object.keys(CLIENTS);
+}
+
+module.exports = { configuredClients, allClientIds, MARKER_FILES, MAX_CONFIG_BYTES };

package/src/lib/receiptStore.js

@@ -82,4 +82,4 @@ function purge() {
   }
 }
 
-module.exports = { disabledFlagPath, isDisabled, setDisabled, purge };
+module.exports = { niroHome, disabledFlagPath, isDisabled, setDisabled, purge };

package/src/lib/service.js

@@ -152,6 +152,23 @@ function uninstall() {
   return true;
 }
 
+/**
+ * Restart niro-watch so it re-execs its script and picks up a replaced package.
+ *
+ * `npm install -g` swaps the files on disk. A process that is already running keeps the code it
+ * loaded when it started, so after an upgrade the watcher is still on the old version until this
+ * runs. Returns false when PM2 is missing or the restart failed; the caller decides what to say.
+ */
+function restart() {
+  if (!pm2Available()) return false;
+  const r = spawnSync("pm2", ["restart", PROCESS_NAME], {
+    shell: true,
+    stdio: "pipe",
+    encoding: "utf8",
+  });
+  return r.status === 0;
+}
+
 /**
  * Print PM2 process status for niro-watch.
  */
@@ -226,4 +243,4 @@ function getInitSystem() {
   }
 }
 
-module.exports = { install, uninstall, status, processState, pm2Available, installPm2 };
+module.exports = { install, uninstall, restart, status, processState, pm2Available, installPm2 };

package/src/mcp/server.js

@@ -52,6 +52,12 @@ function niroProjectsFilePath() {
   return path.join(home, ".niro", "projects.json");
 }
 const { createPendingTracker, isTrackableRequest, resolveTimeoutMs } = require("../lib/pendingRequests");
+const { createImpactRecorder } = require("../lib/impactLog");
+
+// Evidence for the Edit|Write impact gate (docs/usecases/impact-gate.md): which impact tools this
+// session called, and that the server is answering. Keyed by this process's working directory, which
+// is the session folder the hook sees as `cwd` (checked on 8 live bridges, 2026-09-04).
+const impact = createImpactRecorder({ cwd: process.cwd() });
 
 /**
  * This package's version, sent as X-Niro-Cli-Version so the server can tell an out-of-date install to
@@ -150,17 +156,26 @@ function resolveProjectIdFromNiroProjects() {
 }
 
 /**
- * Step 3: Detect the git remote URL and current branch for server-side project resolution.
- * Used when no project_id could be resolved locally. The server matches the remote URL
- * against stored project git mappings.
- * Returns { remote, branch } or null if not in a git repo or git is unavailable.
+ * Step 3: Detect the current git branch, HEAD and dirty state — plus the origin remote when there is
+ * one — for the freshness/takeover notices, server-side project resolution, and per-branch temp routing.
+ * The gate is HEAD (is this a git repo with a commit?), NOT origin: a local repo with commits but no
+ * origin remote (a `local://` niro project, or a repo not yet pushed) still has a branch that drives
+ * routing, so its git state must be reported with a null remote rather than dropped entirely.
+ * Returns { remote (nullable), branch, commit, dirty } or null if not a git repo / no commit / git unavailable.
  */
 function detectGitContext(dir) {
   try {
     const opts = { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] };
     if (dir) opts.cwd = dir;
-    const remote = execSync("git remote get-url origin 2>/dev/null", opts).trim();
-    if (!remote) return null;
+    // HEAD first: this is the "real git repo with a commit?" test. The old `if (!remote) return null`
+    // bailed on a MISSING ORIGIN and so discarded the branch + commit of every no-origin repo — those
+    // repos then sent no _niroGit and never routed to their temp project. The owned-temp match needs
+    // only the branch, not the remote, so keep going and let the remote be null.
+    let commit = null;
+    try { commit = execSync("git rev-parse HEAD 2>/dev/null", opts).trim(); } catch (_) {}
+    if (!commit) return null; // not a git repo, or a repo with no commit yet — nothing to report
+    let remote = null;
+    try { remote = execSync("git remote get-url origin 2>/dev/null", opts).trim() || null; } catch (_) {}
     // normalizeBranch, not a bare trim: on a detached HEAD this command PRINTS "HEAD" instead of
     // failing, and sending that verbatim told the server the checkout was on a branch called "HEAD".
     // Nothing indexes such a branch, so the routing ladder read every bisect / tag checkout as
@@ -168,10 +183,6 @@ function detectGitContext(dir) {
     // a null branch. `git.inspect` has always collapsed "HEAD" to null; this shares that one rule.
     let branch = null;
     try { branch = normalizeBranch(execSync("git rev-parse --abbrev-ref HEAD 2>/dev/null", opts)); } catch (_) {}
-    // The freshness/takeover notices compare the local HEAD + dirty state against what Niro indexed, so
-    // the bridge must report them — without git_commit the server-side check no-ops entirely.
-    let commit = null;
-    try { commit = execSync("git rev-parse HEAD 2>/dev/null", opts).trim(); } catch (_) {}
     let dirty = false;
     try { dirty = execSync("git status --porcelain 2>/dev/null", opts).trim().length > 0; } catch (_) {}
     return { remote, branch, commit, dirty };
@@ -535,6 +546,8 @@ function connectSse() {
               } else {
                 // Cancel the client-side deadline when a delivered result matches an in-flight request.
                 pending.onIncoming(msg);
+                impact.noteResult(msg);
+                impact.touchAlive();
                 rewritten = captureReceipt(msg);
               }
             } catch (_) { /* not correlatable JSON — forward unchanged */ }
@@ -827,6 +840,7 @@ async function main() {
     // Remember the host's initialize so we can replay it verbatim to re-authenticate a fresh
     // session after a transparent reconnect.
     if (message.method === "initialize") initializeRaw = line;
+    impact.noteRequest(message);
 
     // Arm the deadline for a real request before sending; a delivered result (or the
     // send-failure path below) cancels it.
@@ -836,6 +850,9 @@ async function main() {
       await sendMessage(message);
     } catch (err) {
       process.stderr.write(`[niro-mcp] Failed to send message: ${err.message}\n`);
+      // The attempt still counts for the impact gate: a server that cannot be reached must not leave
+      // the file locked until the alive marker ages out (review finding, 2026-09-05).
+      impact.noteResult({ jsonrpc: "2.0", id: message.id, error: { code: -32001, message: err.message } });
       // The POST never reached the server, so no result will arrive: fail this request fast
       // instead of waiting out the deadline.
       if (trackable) {
@@ -852,6 +869,9 @@ async function main() {
   rl.on("close", () => {
     process.exit(0);
   });
+  // A bridge that is gone must not keep the impact gate denying edits for up to 30 minutes on the
+  // strength of a stale alive marker. A hard kill still leaves it; the hook ages it out.
+  process.on("exit", () => impact.clearAlive());
 }
 
 main();