@niroai/niro 0.8.0 → 0.10.0

package/src/lib/git.js

@@ -7,6 +7,25 @@ const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
 
+/**
+ * The branch name from `git rev-parse --abbrev-ref HEAD`, or null when there is no branch.
+ *
+ * On a detached HEAD (a bisect, a tag checkout, a plain commit checkout) that command does not
+ * fail — it prints the literal string "HEAD". A caller that trusts it verbatim therefore reports a
+ * branch named "HEAD", which no repository has, and everything downstream reads the checkout as
+ * being on an unknown branch rather than on no branch at all.
+ *
+ * `inspect` below has always collapsed that to null, matching what the `.git/HEAD` file read
+ * returns. This is that one rule, shared, so a second caller cannot drift from it. One already had:
+ * the MCP bridge sent "HEAD" straight through, so the server's routing ladder took every detached
+ * checkout for a diverged branch and refused to answer it, even though the ladder has an explicit
+ * guard meant to route exactly that case to the indexed project.
+ */
+function normalizeBranch(raw) {
+  const b = typeof raw === "string" ? raw.trim() : "";
+  return b && b !== "HEAD" ? b : null;
+}
+
 function findGitDir(startDir) {
   let dir = path.resolve(startDir);
   const root = path.parse(dir).root;
@@ -93,8 +112,7 @@ function inspect(startDir) {
   // unavailable the calls return null and behaviour is identical to before.
   if (originUrl === null) originUrl = redactRemoteCreds(gitOut("git remote get-url origin", found.repoRoot));
   if (branch === null) {
-    const b = gitOut("git rev-parse --abbrev-ref HEAD", found.repoRoot);
-    branch = b && b !== "HEAD" ? b : null; // "HEAD" = detached; keep null like the file read
+    branch = normalizeBranch(gitOut("git rev-parse --abbrev-ref HEAD", found.repoRoot));
   }
   return { repoRoot: found.repoRoot, originUrl, branch };
 }
@@ -210,4 +228,4 @@ function isTracked(repoRoot, relativePath) {
 }
 
 module.exports = { inspect, mainWorktreeRoot, deriveRepoName, checkIgnored, checkIgnoredPaths,
-  redactRemoteCreds, isTracked };
+  redactRemoteCreds, isTracked, normalizeBranch };

package/src/lib/moduleExcludeSuggestions.js

@@ -23,7 +23,7 @@ async function offerModuleExcludeSuggestions(gitId, opts = {}, alreadySupplied =
   }
   if (!Array.isArray(suggestions) || suggestions.length === 0) return;
 
-  console.log(`\n  ${color.cyan("Suggested module exclusions")} (modules that are usually noise):`);
+  console.log(`\n    ${color.cyan("Suggested module exclusions")} (modules that are usually noise):`);
   const accepted = [];
   for (const s of suggestions) {
     const count = s.module_count || s.moduleCount || 0;
@@ -33,24 +33,24 @@ async function offerModuleExcludeSuggestions(gitId, opts = {}, alreadySupplied =
       `    ${color.dim(s.pattern.padEnd(28))} ${String(count).padStart(3)} module${count === 1 ? "" : "s"}  ${color.dim(label)}`
     );
     if (samples.length > 0) {
-      console.log(`      ${color.dim("e.g. " + samples.join(", "))}`);
+      console.log(`        ${color.dim("e.g. " + samples.join(", "))}`);
     }
     const yes = await prompt.confirm(`    Apply ${color.cyan(s.pattern)}?`, true);
     if (yes) accepted.push(s.pattern);
   }
 
   if (accepted.length === 0) {
-    console.log(`  ${color.dim("No exclusions applied.")}`);
+    console.log(`    ${color.dim("No exclusions applied.")}`);
     return;
   }
 
   try {
     await agentApi.updateModuleExcludePatterns(gitId, accepted);
     console.log(
-      `  ${color.green("✓")} Applied ${accepted.length} exclusion${accepted.length === 1 ? "" : "s"}.`
+      `    ${color.green("✓")} Applied ${accepted.length} exclusion${accepted.length === 1 ? "" : "s"}.`
     );
   } catch (err) {
-    console.log(`  ${color.yellow("Warning:")} failed to save exclusions: ${err.message || err}`);
+    console.log(`    ${color.yellow("Warning:")} failed to save exclusions: ${err.message || err}`);
   }
 }
 

package/src/lib/nestedOutput.js

@@ -0,0 +1,49 @@
+/**
+ * Run something and shift everything it prints one rung deeper.
+ *
+ * `niro start` is a shell around commands that also run on their own. `niro init` printing at
+ * the top level is right when you typed `niro init`; inside the wizard the same lines belong
+ * UNDER "4/5 Onboarding and building the index", and printing them flush with the step markers
+ * is what made step 4 look like a different program had taken over.
+ *
+ * Wrapping the call is the only approach that does not require every helper it reaches
+ * (folderSync, onboardTarget, moduleExcludeSuggestions, watchDaemon, service) to know how deep
+ * it happens to be running. They keep printing at their own level; this adds the offset.
+ *
+ * Blank lines are left blank rather than padded with spaces, so nothing trails whitespace.
+ * process.stdout.write is untouched: the upload progress bar repaints one line with \r, and
+ * prefixing every repaint would smear it across the terminal.
+ */
+let current = 0;
+
+/** How deep the output is nested right now. prompt.js prefixes its questions with this. */
+function currentIndent() {
+  return current;
+}
+
+function withIndent(spaces, fn) {
+  const pad = " ".repeat(spaces);
+  const shift = (orig) => (...args) => {
+    const text = args.map((a) => (typeof a === "string" ? a : String(a))).join(" ");
+    // A line with nothing but spaces is emitted empty. Some callers print a whitespace-only
+    // string as a spacer, and padding it left a visible run of trailing whitespace.
+    orig(text.split("\n").map((l) => (l.trim() ? pad + l : "")).join("\n"));
+  };
+  const log = console.log;
+  const error = console.error;
+  const warn = console.warn;
+  current += spaces;
+  console.log = shift(log);
+  console.error = shift(error);
+  console.warn = shift(warn);
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      current -= spaces;
+      console.log = log;
+      console.error = error;
+      console.warn = warn;
+    });
+}
+
+module.exports = { withIndent, currentIndent };

package/src/lib/onboardTarget.js

@@ -208,7 +208,7 @@ function ensureOnboardable(targetDir, opts = {}) {
 
   const reason = protectedRootReason(resolved);
   if (reason) {
-    console.error(color.red(`\n  ✗ Refusing to onboard ${reason} (${resolved}).`));
+    console.error(color.red(`\n    ✗ Refusing to onboard ${reason} (${resolved}).`));
     console.error("    That would upload source from every project underneath it, pin this folder");
     console.error("    with a .niro-project file, and watch the whole tree for changes.");
     console.error(`    Change into the project folder you meant, then run the command there.`);
@@ -223,17 +223,17 @@ function ensureOnboardable(targetDir, opts = {}) {
     // The protected-root rule above still applied, and still refuses.
     if (opts.alreadyRegistered) {
       console.log(color.dim(
-        `  No build file in ${resolved}, but it is already registered here — continuing.`
+        `    No build file in ${resolved}, but it is already registered here — continuing.`
       ));
       return true;
     }
     if (opts.force) {
       console.log(color.yellow(
-        `\n  ⚠ No project found in ${resolved}, but --force was passed. Onboarding it anyway.`
+        `\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(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.");
@@ -241,7 +241,7 @@ function ensureOnboardable(targetDir, opts = {}) {
   }
 
   console.log(
-    `  ${color.green("✓")} Found ${roots} project${roots === 1 ? "" : "s"} ` +
+    `    ${color.green("✓")} Found ${roots} project${roots === 1 ? "" : "s"} ` +
     `(${describeIndicators(indicators)}).`
   );
   return true;

package/src/lib/prompt.js

@@ -18,6 +18,9 @@ function rl() {
  * Also shared by the MCP setup/teardown wizards' own ask() helpers.
  */
 function formatPrompt(question, defaultValue) {
+  // Questions asked from inside a nested step sit at that step's depth. readline writes
+  // straight to stdout, so withIndent's console wrappers never see them.
+  question = " ".repeat(require("./nestedOutput").currentIndent()) + question;
   return defaultValue != null && defaultValue !== ""
     ? `${question} ${color.dim(`(default: ${defaultValue})`)}: `
     : `${question}: `;

package/src/lib/service.js

@@ -68,26 +68,30 @@ function install() {
   // Stop any existing instance so we can re-register cleanly
   spawnSync("pm2", ["delete", PROCESS_NAME], { shell: true, stdio: "pipe" });
 
-  // Start niro-watch under PM2
+  // PM2's own output is captured, not inherited. Inheriting it put ~55 lines into the middle
+  // of setup: a box-drawing process table, the entire generated systemd unit file, and the
+  // user's PATH twice. None of it is ours and none of it is actionable while it is working.
+  // It IS printed on failure, where it is the only diagnostic there is.
   const startResult = spawnSync(
     "pm2",
     ["start", niroBin, "--name", PROCESS_NAME, "--", "watch"],
-    { shell: true, stdio: "inherit" }
+    { shell: true, encoding: "utf8" }
   );
   if (startResult.status !== 0) {
+    console.error(color.dim(`${startResult.stdout || ""}${startResult.stderr || ""}`));
     throw new Error("pm2 start failed");
   }
 
   // Persist the process list so PM2 restores it after a manual `pm2 resurrect`
-  spawnSync("pm2", ["save"], { shell: true, stdio: "inherit" });
+  spawnSync("pm2", ["save"], { shell: true, encoding: "utf8" });
 
   // Wire into OS startup — pm2 startup detects systemd / launchd / etc.
   // It prints the exact privileged command we need to run.
   console.log(
-    `\n  ${color.bold("Setting up auto-start on login")} — PM2 will ask for your password to register`
+    `\n    ${color.bold("Setting up auto-start on login")} — PM2 will ask for your password to register`
   );
   console.log(
-    `  with the system startup manager (${getInitSystem()}). This only needs to happen once.\n`
+    `    with the system startup manager (${getInitSystem()}). This only needs to happen once.\n`
   );
 
   const startupProbe = spawnSync("pm2", ["startup"], {
@@ -97,21 +101,25 @@ function install() {
 
   const setupCmd = extractSetupCommand(startupProbe.stdout + startupProbe.stderr);
   if (setupCmd) {
-    console.log(`  Running: ${color.dim(setupCmd)}\n`);
+    console.log(`    Running: ${color.dim(setupCmd)}\n`);
+    // stdio is split: stdin stays connected so sudo can still prompt for the password, but
+    // PM2's forty lines of generated unit file are captured and only shown if it fails.
     const r = spawnSync(setupCmd, {
       shell: true,
-      stdio: "inherit",
+      stdio: ["inherit", "pipe", "pipe"],
+      encoding: "utf8",
     });
     if (r.status !== 0) {
+      console.error(color.dim(`${r.stdout || ""}${r.stderr || ""}`));
       console.log(
         color.yellow(
-          `  ⚠ Startup hook failed (exit ${r.status}). You can run it manually:\n    ${setupCmd}`
+          `    ⚠ Startup hook failed (exit ${r.status}). You can run it manually:\n    ${setupCmd}`
         )
       );
     }
   } else {
     // PM2 may print nothing if startup is already configured
-    console.log(`  ${color.green("✓")} Startup already configured.`);
+    console.log(`    ${color.green("✓")} Startup already configured.`);
   }
 
   return true;
@@ -127,7 +135,7 @@ function uninstall() {
   spawnSync("pm2", ["save"], { shell: true, stdio: "inherit" });
 
   console.log(
-    `\n  ${color.bold("Removing auto-start hook")} — PM2 may ask for your password.\n`
+    `\n    ${color.bold("Removing auto-start hook")} — PM2 may ask for your password.\n`
   );
   const unstartupResult = spawnSync("pm2", ["unstartup"], {
     shell: true,
@@ -137,7 +145,7 @@ function uninstall() {
     unstartupResult.stdout + unstartupResult.stderr
   );
   if (setupCmd) {
-    console.log(`  Running: ${color.dim(setupCmd)}\n`);
+    console.log(`    Running: ${color.dim(setupCmd)}\n`);
     spawnSync(setupCmd, { shell: true, stdio: "inherit" });
   }
 
@@ -149,7 +157,7 @@ function uninstall() {
  */
 function status() {
   if (!pm2Available()) {
-    console.log(color.yellow("  PM2 is not installed. Run: npm install -g pm2"));
+    console.log(color.yellow("    PM2 is not installed. Run: npm install -g pm2"));
     return;
   }
   spawnSync("pm2", ["show", PROCESS_NAME], { shell: true, stdio: "inherit" });

package/src/lib/spinner.js

@@ -22,6 +22,17 @@ const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "
 const FRAME_MS = 120;
 const HEARTBEAT_MS = 30_000;
 const ERASE_LINE = "\r\x1b[2K";
+
+/**
+ * Current nesting depth as spaces.
+ *
+ * The spinner writes straight to the stream, so withIndent's console wrappers never see it.
+ * Left alone, the build status and its "Build completed" line print flush left in the middle
+ * of an indented step, which is where they were.
+ */
+function pad() {
+  return " ".repeat(require("./nestedOutput").currentIndent());
+}
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
 
 /**
@@ -40,8 +51,18 @@ function fit(line, width) {
  * Labels can carry backend text (e.g. build log messages); an embedded
  * newline would defeat the single-line overwrite, so flatten whitespace.
  */
+/**
+ * Flatten a label to one line, but KEEP its leading indent.
+ *
+ * The old version trimmed both ends, which silently ate the indent callers use to place the
+ * label in the output tree: "        Waiting for build..." came out flush left, four columns
+ * off from every line around it. Interior whitespace still collapses, because a newline would
+ * defeat the single-line overwrite.
+ */
 function sanitize(label) {
-  return String(label).replace(/\s+/g, " ").trim();
+  const text = String(label);
+  const indent = /^[ \t]*/.exec(text)[0].replace(/\t/g, "  ");
+  return indent + text.replace(/\s+/g, " ").trim();
 }
 
 function start(label, opts = {}) {
@@ -58,9 +79,9 @@ function start(label, opts = {}) {
   let stopped = false;
 
   if (!isTty) {
-    stream.write(`${label}\n`);
+    stream.write(`${pad()}${label}\n`);
     const timer = setInterval(() => {
-      stream.write(`${label} ${color.dim(`(still waiting — ${elapsed()}s)`)}\n`);
+      stream.write(`${pad()}${label} ${color.dim(`(still waiting — ${elapsed()}s)`)}\n`);
     }, heartbeatMs);
     if (timer.unref) timer.unref();
     return {
@@ -68,13 +89,13 @@ function start(label, opts = {}) {
         newLabel = sanitize(newLabel);
         if (stopped || newLabel === label) return;
         label = newLabel;
-        stream.write(`${label}\n`);
+        stream.write(`${pad()}${label}\n`);
       },
       stop(finalLine) {
         clearInterval(timer);
         if (stopped) return;
         stopped = true;
-        if (finalLine) stream.write(finalLine + "\n");
+        if (finalLine) stream.write(pad() + finalLine + "\n");
       },
     };
   }
@@ -83,7 +104,7 @@ function start(label, opts = {}) {
   const render = () => {
     const frame = FRAMES[i = (i + 1) % FRAMES.length];
     const line = `${color.cyan(frame)} ${label} ${color.dim("(" + elapsed() + "s)")}`;
-    stream.write(ERASE_LINE + fit(line, (stream.columns || 80) - 1));
+    stream.write(ERASE_LINE + pad() + fit(line, (stream.columns || 80) - 1 - pad().length));
   };
 
   render();
@@ -101,7 +122,7 @@ function start(label, opts = {}) {
       if (stopped) return;
       stopped = true;
       stream.write(ERASE_LINE);
-      if (finalLine) stream.write(finalLine + "\n");
+      if (finalLine) stream.write(pad() + finalLine + "\n");
     },
   };
 }

package/src/lib/tempProject.js

@@ -34,4 +34,28 @@ async function currentBranch(tempProjectId, gitId, opts = {}) {
   return match && match.branch ? match.branch : null;
 }
 
-module.exports = { currentBranch };
+/**
+ * True when an error from a project read means "this project does not exist on this backend".
+ *
+ * Status alone cannot answer it. A deleted project fails its access check before anything looks for
+ * the row, and that check raises AccessDeniedException, which the backend maps to 403 — the SAME
+ * status it returns when the project is alive but belongs to someone else
+ * (AccessControlService.validateProjectAccess, GlobalExceptionHandler). Treating every 403 as "gone"
+ * would let a permissions problem wipe a healthy local registration, and treating none of them as
+ * gone is what left dead registrations behind in the first place. So the message decides: only a
+ * missing row produces "Project not found", while the other two say "User does not have access to
+ * project" and "User not found".
+ *
+ * A bare status is deliberately NOT enough, not even a 404. This route does not produce one today,
+ * so a 404 here means something other than the API answered: a proxy, or an HTML error page. Its
+ * sibling agentApi.isRepoNotFound does accept a bare 404, and can afford to — being wrong there
+ * costs a re-registration. Being wrong here destroys the record of how to undo a takeover, so this
+ * one fails toward keeping it: an unrecognised failure throws and changes nothing.
+ */
+function isProjectNotFound(err) {
+  if (!err) return false;
+  const text = `${err.message || ""} ${typeof err.body === "string" ? err.body : ""}`;
+  return /project not found/i.test(text);
+}
+
+module.exports = { currentBranch, isProjectNotFound };

package/src/lib/watchDaemon.js

@@ -33,7 +33,7 @@ const color = require("./color");
  */
 async function ensureWatchDaemon({ skipPrompts = false } = {}) {
   if (!service.pm2Available()) {
-    console.log(`\n  ${color.yellow("⚠")} PM2 is not installed. Niro uses PM2 to keep your synced folders`);
+    console.log(`\n    ${color.yellow("⚠")} PM2 is not installed. Niro uses PM2 to keep your synced folders`);
     console.log(`    up to date in the background, including after a reboot.`);
 
     if (skipPrompts || prompt.isNonInteractive()) {
@@ -49,29 +49,29 @@ async function ensureWatchDaemon({ skipPrompts = false } = {}) {
 
     console.log("");
     if (!service.installPm2()) {
-      console.log(`\n  ${color.yellow("⚠")} PM2 install failed (a permission error is the usual cause).`);
+      console.log(`\n    ${color.yellow("⚠")} PM2 install failed (a permission error is the usual cause).`);
       console.log(`    Try manually: ${color.cyan("sudo npm install -g pm2")} then ${color.cyan("niro service install")}`);
       return { ok: false, reason: "pm2_install_failed" };
     }
-    console.log(`  ${color.green("✓")} PM2 installed.`);
+    console.log(`    ${color.green("✓")} PM2 installed.`);
   }
 
-  console.log(`\n  ${color.cyan("●")}  Installing niro-watch daemon (keeps your synced folders up to date, auto-starts on login)...`);
+  console.log(`\n    ${color.cyan("●")}  Installing niro-watch daemon (keeps your synced folders up to date, auto-starts on login)...`);
   try {
     // install() returns false when pm2 turns out not to be runnable after
     // all — e.g. npm installed it into a global bin dir that isn't on PATH
     // (npm exits 0 for that). Treat it as the failure it is; the old code's
     // unchecked call here is how "✓ Done." lied to customers.
     if (!service.install()) {
-      console.log(`       ${color.yellow("⚠")} PM2 was installed but isn't runnable from this shell (its global bin`);
-      console.log(`       directory may not be on your PATH). Open a NEW terminal and run ${color.cyan("niro service install")}.`);
+      console.log(`        ${color.yellow("⚠")} PM2 was installed but isn't runnable from this shell (its global bin`);
+      console.log(`        directory may not be on your PATH). Open a NEW terminal and run ${color.cyan("niro service install")}.`);
       return { ok: false, reason: "daemon_install_failed" };
     }
-    console.log(`       ${color.green("✓")} niro-watch is running and will start automatically on login.`);
+    console.log(`        ${color.green("✓")} niro-watch is running and will start automatically on login.`);
     return { ok: true };
   } catch (err) {
-    console.log(`       ${color.yellow("⚠")} Could not install the watch daemon: ${err.message}`);
-    console.log(`       Run ${color.cyan("niro service install")} to try again, or ${color.cyan("niro watch")} to sync manually.`);
+    console.log(`        ${color.yellow("⚠")} Could not install the watch daemon: ${err.message}`);
+    console.log(`        Run ${color.cyan("niro service install")} to try again, or ${color.cyan("niro watch")} to sync manually.`);
     return { ok: false, reason: "daemon_install_failed" };
   }
 }

package/src/mcp/server.js

@@ -41,7 +41,7 @@ const path = require("path");
 const readline = require("readline");
 const { execSync } = require("child_process");
 const niroProjectFile = require("../lib/niroProjectFile");
-const { redactRemoteCreds } = require("../lib/git");
+const { redactRemoteCreds, normalizeBranch } = require("../lib/git");
 const receiptStore = require("../lib/receiptStore");
 
 /** Absolute path to ~/.niro/projects.json. Uses os.homedir() so it also resolves on Windows, where HOME is
@@ -161,8 +161,13 @@ function detectGitContext(dir) {
     if (dir) opts.cwd = dir;
     const remote = execSync("git remote get-url origin 2>/dev/null", opts).trim();
     if (!remote) return null;
+    // 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
+    // diverged and refused to answer it — past its own guard for detached HEAD, which only fires on
+    // a null branch. `git.inspect` has always collapsed "HEAD" to null; this shares that one rule.
     let branch = null;
-    try { branch = execSync("git rev-parse --abbrev-ref HEAD 2>/dev/null", opts).trim(); } catch (_) {}
+    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;