@niroai/niro 0.5.0 → 0.7.0

package/src/index.js

@@ -9,7 +9,34 @@ function main() {
     .name("niro")
     .description("Niro CLI — onboard repos, build indexes, manage projects from the terminal.")
     .version(pkg.version)
-    .option("--api-url <url>", "override API base URL (default: $NIRO_API_URL or https://aiorchestrator.niroai.dev)");
+    .option("--api-url <url>", "backend to log in to — `niro login` only (default: $NIRO_API_URL or https://aiorchestrator.niroai.dev)");
+
+  // --api-url is accepted by `niro login` and REFUSED everywhere else.
+  //
+  // It used to be a global override, but it was only half honoured. api.request takes it
+  // (api.js: `const base = apiUrl || baseUrl(creds)`), while the upload chain builds its own
+  // URL from the stored credentials and never sees it (agentApi.js:113 and :175). So
+  // `niro init --api-url <local>` while logged in elsewhere listed projects from one backend
+  // and uploaded the folder's source to the other — one command, two servers, no warning.
+  //
+  // Threading it through every path is the other possible fix, but the backend is a property
+  // of a SESSION, not of a single command: credentials, tokens, gitIds and watchState tags are
+  // all scoped to one backend, so a per-command override can only ever be a way to mix them.
+  // Choosing it once, at login, is the honest contract. NIRO_API_URL and the config file still
+  // work for every command, because both feed the same resolution chain the uploader uses.
+  //
+  // `niro new-temp-project` already refused this flag for exactly this reason; that local
+  // check is now redundant and has been removed in favour of this one.
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    if (!program.opts().apiUrl) return;
+    if (actionCommand.name() === "login") return;
+    console.error("`--api-url` only applies to `niro login`.");
+    console.error("  It was ignored by the upload path, so using it here would read from one");
+    console.error("  backend and write to another. Pick the backend once instead:");
+    console.error("    niro login --api-url <url>        log in to that backend");
+    console.error("    NIRO_API_URL=<url> niro <cmd>     or set it for every command");
+    process.exit(1);
+  });
 
   program
     .command("login")
@@ -19,7 +46,7 @@ function main() {
     .option("--email <email>", "email address (password flow only)")
     .action((opts) => run(async () => {
       const loginCmd = require("./commands/login");
-      await loginCmd.login({ ...opts, apiUrl: program.opts().apiUrl });
+      await loginCmd.login({ ...opts, apiUrl: program.opts().apiUrl }); // login: the one command that may set it
     }));
 
   program
@@ -48,7 +75,7 @@ function main() {
     .option("--quiet-period <seconds>", "debounce seconds before an auto-build (used with --auto-build on)")
     .option("--confirm-build <yes|no>", "whether to trigger the initial index build now without prompting")
     .option("--defaults", "accept default values for all env vars without prompting")
-    .option("--force", "proceed past cross-project/overlap warnings without confirming")
+    .option("--force", "onboard a folder with no build file, and proceed past cross-project/overlap warnings without confirming (never bypasses the home/root refusal)")
     .option("--no-watch", "return immediately after triggering the build instead of watching")
     .option(
       "-X, --module-exclude <pattern>",
@@ -64,7 +91,7 @@ function main() {
     )
     .action((pathArg, opts) => run(async () => {
       const initCmd = require("./commands/init");
-      await initCmd.init(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+      await initCmd.init(pathArg, { ...opts });
     }));
 
   // `niro add` subcommand group
@@ -79,6 +106,7 @@ function main() {
     .option("--name <name>", "display name for this repo")
     .option("--sync-mode <local|remote>", "sync on local file changes or remote commits (skips the interactive choice)")
     .option("--no-confirm", "skip confirmation prompts (non-interactive)")
+    .option("--force", "onboard a folder with no build file in it (never bypasses the home/root refusal)")
     .option("--token-id <id>", "git token ID for private repos")
     .option(
       "-X, --module-exclude <pattern>",
@@ -94,7 +122,7 @@ function main() {
     )
     .action((pathArg, opts) => run(async () => {
       const cmd = require("./commands/add-repo");
-      await cmd.addRepo(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+      await cmd.addRepo(pathArg, { ...opts });
     }));
 
   add
@@ -103,7 +131,7 @@ function main() {
     .option("--no-watch", "return immediately after triggering the build")
     .action((opts) => run(async () => {
       const cmd = require("./commands/add-project");
-      await cmd.addProject({ ...opts, apiUrl: program.opts().apiUrl });
+      await cmd.addProject({ ...opts });
     }));
 
   program
@@ -112,7 +140,7 @@ function main() {
     .option("--json", "emit machine-readable JSON")
     .action((pathArg, opts) => run(async () => {
       const infoCmd = require("./commands/info");
-      await infoCmd.info(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+      await infoCmd.info(pathArg, { ...opts });
     }));
 
   program
@@ -131,7 +159,7 @@ function main() {
     .option("--json", "emit machine-readable JSON where supported (set-env, list-env)")
     .action((opts) => run(async () => {
       const editCmd = require("./commands/edit");
-      await editCmd.edit({ ...opts, apiUrl: program.opts().apiUrl });
+      await editCmd.edit({ ...opts });
     }));
 
   program
@@ -143,7 +171,7 @@ function main() {
     .option("--confirm-name <value>", "required for --project: must equal the project's alias or id")
     .action((opts) => run(async () => {
       const removeCmd = require("./commands/remove");
-      await removeCmd.remove({ ...opts, apiUrl: program.opts().apiUrl });
+      await removeCmd.remove({ ...opts });
     }));
 
   program
@@ -161,7 +189,7 @@ function main() {
     .option("--project <id_or_alias>", "which project to base the temporary project on when the repo maps to several")
     .action((pathArg, opts) => run(async () => {
       const cmd = require("./commands/takeover");
-      await cmd.takeover(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+      await cmd.takeover(pathArg, { ...opts });
     }));
 
   program
@@ -172,7 +200,7 @@ function main() {
     .option("--project <temp_project_id>", "the temporary project to discard, when this machine has no local record of it (e.g. created elsewhere)")
     .action((pathArg, opts) => run(async () => {
       const cmd = require("./commands/release");
-      await cmd.release(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+      await cmd.release(pathArg, { ...opts });
     }));
 
   program
@@ -181,7 +209,7 @@ function main() {
     .option("--json", "emit machine-readable JSON")
     .action((projectId, opts) => run(async () => {
       const statusCmd = require("./commands/status");
-      await statusCmd.status(projectId, { ...opts, apiUrl: program.opts().apiUrl });
+      await statusCmd.status(projectId, { ...opts });
     }));
 
   program
@@ -191,7 +219,7 @@ function main() {
     .option("--json", "emit machine-readable JSON")
     .action((opts) => run(async () => {
       const projectsCmd = require("./commands/projects");
-      await projectsCmd.projects({ ...opts, apiUrl: program.opts().apiUrl });
+      await projectsCmd.projects({ ...opts });
     }));
 
   program
@@ -202,7 +230,7 @@ function main() {
     .option("--json", "emit machine-readable JSON status (NDJSON: one object per status change + a final summary)")
     .action((projectId, opts) => run(async () => {
       const buildCmd = require("./commands/build");
-      await buildCmd.build(projectId, { ...opts, apiUrl: program.opts().apiUrl });
+      await buildCmd.build(projectId, { ...opts });
     }));
 
   program
@@ -211,7 +239,7 @@ function main() {
     .option("-y, --yes", "skip the confirmation prompt")
     .action((projectId, opts) => run(async () => {
       const deleteCmd = require("./commands/delete");
-      await deleteCmd.deleteProject(projectId, { ...opts, apiUrl: program.opts().apiUrl });
+      await deleteCmd.deleteProject(projectId, { ...opts });
     }));
 
   const svc = program

package/src/lib/onboardTarget.js

@@ -0,0 +1,258 @@
+/**
+ * Is this folder a sane thing to onboard? The check that runs BEFORE
+ * `niro init` / `niro add repo` register anything on the server or upload a byte.
+ *
+ * Two independent rules:
+ *
+ *   1. PROTECTED ROOT — never bypassable. $HOME, the filesystem root, any ancestor
+ *      of $HOME (/home, /Users) and the well-known system dirs are refused outright.
+ *      Onboarding one of these is never intended, and the damage is not the kind
+ *      --force should be able to cause by accident: source from every project on the
+ *      machine uploaded as one blob, a .niro-project pin dropped at $HOME, and a
+ *      watch daemon streaming the whole home tree. Worse, .gitignore is only honoured
+ *      when the onboarded folder is itself a git work tree, so onboarding $HOME
+ *      silently uploads files that each nested repo deliberately ignores.
+ *
+ *   2. PROJECT INDICATOR — bypassable with --force. The folder must LOOK like a
+ *      project: a build descriptor at the folder itself, or in a directory just below
+ *      it. This mirrors ai-orchestrator
+ *      ProjectStructureResolverService.detectProjects(), which marks any directory
+ *      holding a descriptor from the ConfigFileParser SUPPORTED_FILES union as a
+ *      project root. folderSync already carries that union as STRUCTURAL_FILENAMES /
+ *      STRUCTURAL_EXTENSIONS (documented there as byte-identical to the server), so
+ *      this REUSES those sets. There is deliberately no second list to drift.
+ *
+ * Two deliberate differences from the server:
+ *
+ *   - Depth-bounded (INDICATOR_MAX_DEPTH) instead of a full-tree walk. The question
+ *     here is "is THIS folder a project", not "which projects live somewhere inside
+ *     it". A descriptor buried deep is precisely the accident being caught: $HOME
+ *     contains thousands of them.
+ *   - No parser veto. The server asks the owning parser isProjectIndicator(file) to
+ *     reject a false match (a Python module literally named setup.py). The CLI cannot
+ *     parse, so a name match is accepted. That errs toward ALLOWING onboarding, which
+ *     is the safe direction for a guard: the worst case is the behaviour we had before.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const color = require("./color");
+const folderSync = require("./folderSync");
+
+// How far below the target we look for a build descriptor. 0 = the folder itself.
+// 2 covers a monorepo root whose deployables sit under a grouping dir
+// (services/foo/pom.xml, packages/foo/package.json) and still refuses a folder whose
+// only descriptors are buried deeper than any real project root would be.
+const INDICATOR_MAX_DEPTH = 2;
+
+// Hard bound on the walk so a pathological tree cannot stall the command.
+const MAX_DIRS_SCANNED = 2000;
+
+// Refused outright, by exact path match. Ancestors of $HOME (/home, /Users) are
+// caught by the ancestor rule below as well; listed here for the case where $HOME
+// lives somewhere unusual.
+const SYSTEM_DIRS = new Set([
+  "/", "/bin", "/boot", "/dev", "/etc", "/home", "/lib", "/lib64", "/media",
+  "/mnt", "/opt", "/proc", "/root", "/run", "/sbin", "/srv", "/sys", "/tmp",
+  "/usr", "/var", "/Applications", "/Library", "/System", "/Users", "/Volumes",
+]);
+
+// Windows paths are case-insensitive; POSIX paths are not.
+function samePath(a, b) {
+  if (process.platform === "win32") return a.toLowerCase() === b.toLowerCase();
+  return a === b;
+}
+
+// Resolve symlinks before comparing, so a symlinked route to a protected path (macOS
+// /tmp -> /private/tmp, an $HOME reached through /mnt/home/<user>) cannot walk past the
+// refusal on a string mismatch. Falls back to the lexical path when the target does not
+// exist or is unreadable — the comparison is then no worse than before.
+function realPath(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+
+/**
+ * Why this folder must never be onboarded, or null when it is fine.
+ * Returns a human phrase that slots into "Refusing to onboard <phrase>".
+ */
+function protectedRootReason(dir) {
+  const target = realPath(path.resolve(dir));
+
+  if (samePath(target, path.parse(target).root)) return "the filesystem root";
+
+  let home = null;
+  try {
+    home = os.homedir() ? realPath(path.resolve(os.homedir())) : null;
+  } catch {
+    home = null; // no home resolvable -> only the root/system rules apply
+  }
+  if (home) {
+    if (samePath(target, home)) return "your home folder";
+    // home lives INSIDE target => target is an ancestor of home (/home, /Users, ...).
+    const rel = path.relative(target, home);
+    if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+      return "a parent of your home folder";
+    }
+  }
+
+  if (SYSTEM_DIRS.has(target)) return "a system folder";
+  // Also refuse the lexical path when it differs from the resolved one, so a symlink
+  // POINTING AT an ordinary folder cannot be used to name a protected path either way.
+  if (SYSTEM_DIRS.has(path.resolve(dir))) return "a system folder";
+  return null;
+}
+
+/**
+ * The indicator kind this filename represents, or null. Name match wins over
+ * extension match, mirroring the server's parserRegistry-then-extensionRegistry
+ * lookup order. Returned as a display label ("pom.xml", "*.csproj").
+ */
+function indicatorName(fileName) {
+  const lower = path.basename(fileName).toLowerCase();
+  if (folderSync.STRUCTURAL_FILENAMES.has(lower)) return lower;
+  const ext = path.extname(lower);
+  if (ext && folderSync.STRUCTURAL_EXTENSIONS.has(ext)) return `*${ext}`;
+  return null;
+}
+
+/**
+ * Look for project roots at `targetDir` and just below it.
+ *
+ * Stops descending as soon as a directory IS a project root: once a descriptor is
+ * found there is nothing further to prove, and it keeps the common case (a normal
+ * repo with a descriptor at its top) down to a single readdir.
+ *
+ * Returns { roots, indicators: Map(label -> count), truncated }.
+ */
+function findProjectIndicators(targetDir, opts = {}) {
+  const maxDepth = Number.isInteger(opts.maxDepth) ? opts.maxDepth : INDICATOR_MAX_DEPTH;
+  // Injectable so the breadth-first guarantee can be tested without a 2000-directory fixture.
+  const maxDirs = Number.isInteger(opts.maxDirs) ? opts.maxDirs : MAX_DIRS_SCANNED;
+  const indicators = new Map();
+  let roots = 0;
+  let dirsScanned = 0;
+  let truncated = false;
+
+  // Breadth-first, one depth level at a time. Depth-first would let a single wide or
+  // deep subtree spend the whole MAX_DIRS_SCANNED budget before the walk ever looked
+  // at the target's own siblings, so a real project root could go unseen while junk
+  // was scanned. Breadth-first means level 0 is always examined, then all of level 1,
+  // and only the deepest level can ever be cut short.
+  let frontier = [path.resolve(targetDir)];
+  for (let depth = 0; depth <= maxDepth && frontier.length > 0; depth++) {
+    const next = [];
+    for (const dir of frontier) {
+      if (dirsScanned >= maxDirs) { truncated = true; break; }
+      dirsScanned++;
+
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue; // unreadable (permissions, vanished) -> nothing to prove here
+      }
+
+      let isRoot = false;
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const label = indicatorName(entry.name);
+        if (!label) continue;
+        isRoot = true;
+        indicators.set(label, (indicators.get(label) || 0) + 1);
+      }
+      // A project root proves what we came to prove; there is no reason to look inside it.
+      if (isRoot) { roots++; continue; }
+      if (depth >= maxDepth) continue;
+
+      // Sorted so the walk is deterministic: readdir order is filesystem-dependent, and
+      // which directories fall inside the budget must not vary between machines.
+      const children = entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith(".") && !folderSync.IGNORED_DIRS.has(e.name))
+        .map((e) => e.name)
+        .sort();
+      for (const name of children) next.push(path.join(dir, name));
+    }
+    if (truncated) break;
+    frontier = next;
+  }
+
+  return { roots, indicators, truncated };
+}
+
+// "pom.xml x10, package.json x1" — the three commonest kinds, then a tail count.
+function describeIndicators(indicators) {
+  const sorted = [...indicators.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const shown = sorted.slice(0, 3).map(([label, n]) => (n > 1 ? `${label} x${n}` : label));
+  const rest = sorted.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")}, and ${rest} more` : shown.join(", ");
+}
+
+/**
+ * The gate itself. Prints the refusal and returns false when this folder must not be
+ * onboarded; returns true when the caller may proceed.
+ *
+ * opts.force bypasses the INDICATOR rule only. It deliberately does not bypass a
+ * protected root: there is no legitimate reason to upload $HOME, and a scripted
+ * --force must not be able to do it by accident.
+ *
+ * opts.alreadyRegistered likewise bypasses the INDICATOR rule only, for a folder this
+ * backend already holds a repo for. Callers pass it from watchState so that adding the
+ * gate never breaks a sync that was already working.
+ */
+function ensureOnboardable(targetDir, opts = {}) {
+  const resolved = path.resolve(targetDir);
+
+  const reason = protectedRootReason(resolved);
+  if (reason) {
+    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.`);
+    return false;
+  }
+
+  const { roots, indicators, truncated } = findProjectIndicators(resolved, opts);
+  if (indicators.size === 0) {
+    // A folder this backend ALREADY has a repo for is exempt from the descriptor rule.
+    // That rule gates NEW onboarding; it is not a reason to start failing a re-sync of a
+    // folder onboarded by an earlier CLI, which would strand the user with no way back in.
+    // 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.`
+      ));
+      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.");
+    return false;
+  }
+
+  console.log(
+    `  ${color.green("✓")} Found ${roots} project${roots === 1 ? "" : "s"} ` +
+    `(${describeIndicators(indicators)}).`
+  );
+  return true;
+}
+
+module.exports = {
+  ensureOnboardable,
+  protectedRootReason,
+  findProjectIndicators,
+  indicatorName,
+  describeIndicators,
+  INDICATOR_MAX_DEPTH,
+  MAX_DIRS_SCANNED,
+};

package/src/lib/tempProject.js

@@ -0,0 +1,37 @@
+/**
+ * Reading the state of a temporary project.
+ *
+ * A developer gets ONE temporary project per project, and `niro new-temp-project` MOVES it rather than
+ * adding a second. So "which folder does Niro currently reflect?" has exactly one answer, and it lives
+ * on the server: the branch recorded against the temporary project's repo.
+ *
+ * That matters because a folder cannot tell locally whether it still holds the slot. Every folder taken
+ * over for one project shares the SAME repo id, so the server cannot tell them apart either — if two
+ * folders upload, their branches blend into one copy and every answer drawn from it is a mixture. The
+ * only way to know is to ask which branch the copy is on and compare it with your own.
+ */
+const api = require("./api");
+
+/**
+ * The branch a temporary project is currently bound to, or null if it cannot be determined.
+ *
+ * Returns null rather than throwing on a server or network problem: this is used to decide whether to
+ * hold back an upload, and "I could not reach the server" must never be read as "you have lost the
+ * slot" — that would stop a perfectly healthy folder syncing every time the network hiccuped.
+ */
+async function currentBranch(tempProjectId, gitId, opts = {}) {
+  if (!tempProjectId) return null;
+  let project;
+  try {
+    project = await api.get(`/api/projects/${encodeURIComponent(tempProjectId)}`, opts);
+  } catch {
+    return null;
+  }
+  const repos = project.git_details || project.gitDetails || [];
+  // Match the repo by id when we can. Falling back to the first is safe for the single-repo case and
+  // still right for multi-repo: every repo in one temporary project is taken over onto one branch.
+  const match = repos.find((r) => r.id === gitId) || repos[0];
+  return match && match.branch ? match.branch : null;
+}
+
+module.exports = { currentBranch };

package/src/lib/watchState.js

@@ -127,6 +127,46 @@ function update(folderPath, patch) {
   save(state);
 }
 
+/**
+ * Merge per-path hash changes into an entry instead of replacing the whole map.
+ *
+ * `update({ fileHashes })` replaces the map wholesale, so whichever writer saves last wins and every
+ * entry the other writer added in the meantime is silently gone. The delta sync computes a map from
+ * its own walk and writes it at the end, which can take minutes on a large upload; any live per-file
+ * event that landed during that window is erased. Losing a baseline entry is not cosmetic — the file
+ * stops being tracked, so it is never re-sent and the divergence is permanent. That is the difference
+ * between the 27 July incident, which healed itself in 35 minutes, and 31 July, which never did.
+ *
+ * Removals must be explicit rather than implied by absence, so nothing disappears by accident.
+ *
+ * load/save are synchronous and save renames atomically, so this is safe against other writers in
+ * THIS process. The watch daemon is a separate process, so a cross-process interleave is still
+ * possible; this shrinks the window from minutes to microseconds rather than closing it entirely.
+ */
+function mergeFileHashes(folderPath, { set = {}, remove = [], patch = {}, expectedGitId } = {}) {
+  const state = load();
+  const key = path.resolve(folderPath);
+  if (!state[key]) return false;
+  // Compare-and-merge, exactly as `remove` above does its compare-and-delete, and for the same reason.
+  // A sync pass can take minutes on a large tree. If a `niro new-temp-project` or
+  // `niro discard-temp-project` re-points the folder DURING that pass, the hashes it computed describe
+  // a repo the folder is no longer registered against — and writing them lands a stale baseline on the
+  // new gitId. Discard was the case that bit: it clears the baseline so the source repo gets a full
+  // re-upload, and an in-flight pass finishing afterwards restored the old map, so the next pass said
+  // "No changes since last sync" and the sandbox edits were never uploaded. Exactly the silent loss
+  // clearing the baseline was meant to prevent.
+  if (expectedGitId !== undefined && state[key].gitId !== expectedGitId) {
+    return false;
+  }
+  const merged = { ...(state[key].fileHashes || {}) };
+  for (const rp of remove) delete merged[rp];
+  // Applied after the removals, so a file deleted and re-created within one run keeps its new hash.
+  Object.assign(merged, set);
+  state[key] = { ...state[key], ...patch, fileHashes: merged };
+  save(state);
+  return true;
+}
+
 /**
  * Remove a folder's entry. When `expectedGitId` is given, only remove if the CURRENT entry still has that
  * gitId (compare-and-delete): the self-heal path removes a poison entry after an async repoExists round-trip,
@@ -214,4 +254,5 @@ function hashFile(filePath) {
   }
 }
 
-module.exports = { get, peek, set, update, remove, allLocal, findOverlapping, matchesBackend, hashFile, FILE };
+module.exports = { get, peek, set, update, remove, allLocal, findOverlapping, matchesBackend, hashFile,
+  mergeFileHashes, FILE };