@niroai/niro 0.12.0 → 0.15.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/onboardTarget.js

@@ -227,16 +227,25 @@ function ensureOnboardable(targetDir, opts = {}) {
       ));
       return true;
     }
+    // A folder holding git repos declares its projects with .git rather than with a build file.
+    // Onboarding handles that case by indexing each repo separately, so refusing here would send the
+    // user to --force, which uploads the whole tree as one repo instead.
+    if (typeof opts.hasGitReposBeneath === "function" && opts.hasGitReposBeneath()) {
+      return true;
+    }
     if (opts.force) {
       console.log(color.yellow(
         `\n    ⚠ No project found in ${resolved}, but --force was passed. Onboarding it anyway.`
       ));
       return true;
     }
-    console.error(color.red(`\n    ✗ No project found in ${resolved}.`));
-    console.error("    Niro looks for a build file (package.json, pom.xml, go.mod, ...) in this");
-    console.error(`    folder or just below it${truncated ? " (the scan stopped early — the tree is very large)" : ""}. None found.`);
-    console.error("    Pass --force if you really mean to upload this folder.");
+    console.error(color.red(`\n    ✗ Nothing to index in ${resolved}.`));
+    console.error("    Niro indexes either a git repository, or a folder holding a build file");
+    console.error(`    (package.json, pom.xml, go.mod, ...) at it or just below it${truncated ? ", though the scan stopped early because the tree is very large" : ""}.`);
+    console.error("    This folder has neither, so there is nothing to build a graph from.");
+    console.error("");
+    console.error("    If the code you meant is deeper down, run niro init from that folder.");
+    console.error("    Pass --force to upload this folder anyway.");
     return false;
   }
 

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/setup.js

@@ -2783,6 +2783,9 @@ module.exports = {
   addAgentsSkill,
   addAgentsCliSkill,
   CLIENTS,
+  // Exported so `niro upgrade` can detect a configured Goose install by reading the same
+  // file setupGoose writes, instead of rebuilding that platform-specific path a second time.
+  gooseConfigPath,
   NIRO_MD_MARKER,
   NIRO_MD_SECTIONS,
   isNiroPostCompactHook,