@niroai/niro 0.3.0

package/src/index.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+const { Command } = require("commander");
+
+const pkg = require("../package.json");
+
+function main() {
+  const program = new Command();
+  program
+    .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)");
+
+  program
+    .command("login")
+    .description("Log in to Niro. Default: device authorization in your browser. (--api-key or --password for alternatives.)")
+    .option("--api-key", "paste a Niro API key instead of the browser device flow")
+    .option("--password", "use email + password instead of the browser device flow")
+    .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 });
+    }));
+
+  program
+    .command("logout")
+    .description("Remove locally stored credentials.")
+    .action(() => run(async () => {
+      const logoutCmd = require("./commands/logout");
+      await logoutCmd.logout();
+    }));
+
+  program
+    .command("whoami")
+    .description("Print the account currently logged in.")
+    .option("--json", "emit machine-readable JSON (includes authed:true|false)")
+    .action((opts) => run(async () => {
+      const whoami = require("./commands/whoami");
+      await whoami.whoami(opts);
+    }));
+
+  program
+    .command("init [path]")
+    .description("Onboard a local repo end-to-end: create project, register repo, scan env vars, build index.")
+    .option("--project-name <name>", "project name for a NEW project (default: derived from repo)")
+    .option("--add-to <alias|id>", "add this folder to an EXISTING project instead of creating a new one")
+    .option("--auto-build <on|off>", "enable/disable auto-build on file changes without prompting")
+    .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("--no-watch", "return immediately after triggering the build instead of watching")
+    .option(
+      "-X, --module-exclude <pattern>",
+      "exclude modules matching glob (repeatable, e.g. **/qa/**)",
+      collectOption,
+      []
+    )
+    .option(
+      "-F, --file-exclude <pattern>",
+      "exclude files matching glob across all modules (repeatable, e.g. **/src/test/**)",
+      collectOption,
+      []
+    )
+    .action((pathArg, opts) => run(async () => {
+      const initCmd = require("./commands/init");
+      await initCmd.init(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+    }));
+
+  // `niro add` subcommand group
+  const add = program
+    .command("add")
+    .description("Add a repo or project.");
+
+  add
+    .command("repo [path]")
+    .description("Register a local folder or remote URL and start syncing.")
+    .option("--branch <branch>", "branch name (remote repos; local repos auto-detect from .git)")
+    .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("--token-id <id>", "git token ID for private repos")
+    .option(
+      "-X, --module-exclude <pattern>",
+      "exclude modules matching glob (repeatable, e.g. **/qa/**)",
+      collectOption,
+      []
+    )
+    .option(
+      "-F, --file-exclude <pattern>",
+      "exclude files matching glob across all modules (repeatable, e.g. **/src/test/**)",
+      collectOption,
+      []
+    )
+    .action((pathArg, opts) => run(async () => {
+      const cmd = require("./commands/add-repo");
+      await cmd.addRepo(pathArg, { ...opts, apiUrl: program.opts().apiUrl });
+    }));
+
+  add
+    .command("project")
+    .description("Create a project and map registered repos to it.")
+    .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 });
+    }));
+
+  program
+    .command("info [path]")
+    .description("Show what Niro knows about this folder: git info + which project(s) it maps to and their status.")
+    .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 });
+    }));
+
+  program
+    .command("edit")
+    .description("Change an existing project: map/unmap repos, set/list/rescan env vars (incl. choosing which file drives a var or which property files to consider), or rename.")
+    .option("--project <alias|id>", "target project (default: .niro-project in this folder)")
+    .option("--repo <gitId>", "repo to target for env actions (default: the project's only repo)")
+    .option("--add-repo <gitId>", "map a registered repo to the project")
+    .option("--remove-repo <gitId>", "unmap a repo from the project (non-destructive)")
+    .option("--set-env <KEY=VALUE>", "set an env var (repeatable; value is never printed)", collectOption, [])
+    .option("--set-env-from <KEY=FILE>", "adopt the value FILE carries for KEY (repeatable; value is never printed)", collectOption, [])
+    .option("--active-files <files>", "comma-separated property files to keep active for env-var defaults; the rest are ignored (default: all active; at least one required)")
+    .option("--list-env", "list env var keys + per-file candidates (secret values masked)")
+    .option("--rescan-env", "rescan the repo for env vars")
+    .option("--alias <newAlias>", "rename the project")
+    .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 });
+    }));
+
+  program
+    .command("remove")
+    .description("Remove a whole project (destructive) or unmap a single repo from it.")
+    .option("--target <alias|id>", "target project (default: .niro-project in this folder)")
+    .option("--project", "delete the WHOLE project (destructive; requires --confirm-name)")
+    .option("--unmap-repo <gitId>", "remove one repo from the project (non-destructive)")
+    .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 });
+    }));
+
+  program
+    .command("watch [path]")
+    .description("Resume watching an already-registered local repo (use after restart).")
+    .action((pathArg) => run(async () => {
+      const cmd = require("./commands/watch");
+      await cmd.watch(pathArg, { apiUrl: program.opts().apiUrl });
+    }));
+
+  program
+    .command("new-temp-project [path]")
+    .aliases(["sandbox", "takeover"])
+    .description("Create a temporary private project for this folder that reflects your branch + local edits, so Niro's answers match your work (teammates unaffected). Remove it with `niro discard-temp-project`.")
+    .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 });
+    }));
+
+  program
+    .command("discard-temp-project [path]")
+    .aliases(["discard", "release"])
+    .description("Discard the temporary project created by `niro new-temp-project`; Niro routes back to the original project automatically.")
+    .option("-y, --yes", "skip the confirmation prompt (still prints the in-flight-work warning)")
+    .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 });
+    }));
+
+  program
+    .command("status [project_id]")
+    .description("Show the current build status for a project.")
+    .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 });
+    }));
+
+  program
+    .command("projects")
+    .alias("ls")
+    .description("List the projects in your account (account-wide; use `niro info` for the current folder).")
+    .option("--json", "emit machine-readable JSON")
+    .action((opts) => run(async () => {
+      const projectsCmd = require("./commands/projects");
+      await projectsCmd.projects({ ...opts, apiUrl: program.opts().apiUrl });
+    }));
+
+  program
+    .command("build [project_id]")
+    .description("Trigger a rebuild and watch it to completion.")
+    .option("--no-full-rebuild", "incremental build (default: force full rebuild)")
+    .option("--no-watch", "return immediately instead of streaming progress")
+    .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 });
+    }));
+
+  program
+    .command("delete [project_id]")
+    .description("Delete a project from the server (destructive). Uses .niro-project if no id is given.")
+    .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 });
+    }));
+
+  const svc = program
+    .command("service")
+    .description("Manage the niro-watch background daemon (auto-sync on login).");
+  svc
+    .command("install")
+    .description("Install niro-watch as a system service that starts automatically on login.")
+    .action(() => run(async () => {
+      // Shared flow: offers to install PM2 when it's missing (interactive runs).
+      const { ensureWatchDaemon } = require("./lib/watchDaemon");
+      const result = await ensureWatchDaemon();
+      if (!result.ok) process.exitCode = 1;
+    }));
+  svc
+    .command("uninstall")
+    .description("Stop niro-watch and remove it from system startup.")
+    .action(() => run(async () => {
+      const service = require("./lib/service");
+      service.uninstall();
+      console.log("✓ niro-watch removed.");
+    }));
+  svc
+    .command("status")
+    .description("Show niro-watch daemon status.")
+    .action(() => run(async () => {
+      const service = require("./lib/service");
+      service.status();
+    }));
+
+  const mcp = program
+    .command("mcp")
+    .description("MCP server helpers.");
+  mcp
+    .command("install")
+    .description("Configure your editor(s) to use the Niro MCP server (no API key needed after `niro login`). Flags: --client <id> | --url <mcp-server-url>.")
+    .allowUnknownOption(true)
+    .action(() => run(async () => {
+      const mcpCmd = require("./commands/mcp");
+      await mcpCmd.install();
+    }));
+  mcp
+    .command("uninstall")
+    .description("Remove the Niro MCP server config install added (reverses `mcp install`). Flags: --client <id>[,<id>...] | --all [-y].")
+    .allowUnknownOption(true)
+    .action(() => run(async () => {
+      const mcpCmd = require("./commands/mcp");
+      await mcpCmd.uninstall();
+    }));
+  mcp
+    .command("serve")
+    .description("Run the Niro MCP server over stdio (used by your editor's MCP config).")
+    .action(() => { require("./commands/mcp").serve(); });
+
+  program.parseAsync(process.argv).catch((err) => {
+    console.error(err && err.message ? err.message : err);
+    process.exit(1);
+  });
+}
+
+function collectOption(value, previous) {
+  return Array.isArray(previous) ? [...previous, value] : [value];
+}
+
+function run(fn) {
+  return Promise.resolve()
+    .then(fn)
+    .catch((err) => {
+      if (err && (err.code === "ENOAUTH" || err.code === "ENOPROJECT" || err.code === "EAMBIGUOUS")) {
+        console.error(err.message);
+        process.exit(1);
+      }
+      console.error(err && err.stack ? err.stack.split("\n")[0] : String(err));
+      if (err && err.status) console.error(`  (HTTP ${err.status})`);
+      process.exit(1);
+    });
+}
+
+main();

package/src/lib/agentApi.js

@@ -0,0 +1,276 @@
+/**
+ * HTTP calls to the AgentSyncController endpoints.
+ * All requests use the JWT Bearer token (same as all other CLI commands).
+ * File content is never logged.
+ */
+const fs = require("fs");
+const path = require("path");
+const api = require("./api");
+
+const DEFAULT_UPLOAD_TIMEOUT_MS = 60000;
+
+/** Per-call upload timeout (ms). Overridable via NIRO_UPLOAD_TIMEOUT_MS. */
+function uploadTimeoutMs() {
+  const v = Number.parseInt(process.env.NIRO_UPLOAD_TIMEOUT_MS, 10);
+  return Number.isFinite(v) && v > 0 ? v : DEFAULT_UPLOAD_TIMEOUT_MS;
+}
+
+/**
+ * fetch() wrapped in an AbortController + timeout so a stalled upload aborts
+ * instead of hanging forever. On timeout the abort surfaces as an AbortError;
+ * callers translate that into a clear "timed out" message so the caller's retry
+ * logic counts it as a failed attempt. Each call gets a fresh controller, so a
+ * 401-retry re-arms the timeout.
+ *
+ * Returns { res, clear }. The timer stays ARMED until the caller invokes
+ * clear() — call it only AFTER reading the body (res.json()/res.text()), so a
+ * server that returns headers and then stalls the body stream also aborts. On a
+ * fetch-level failure the timer is cleared before throwing.
+ */
+async function fetchWithTimeout(url, options) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), uploadTimeoutMs());
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    return { res, clear: () => clearTimeout(timer) };
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}
+
+function isAbort(err) {
+  return err && (err.name === "AbortError" || err.code === "ABORT_ERR");
+}
+
+/**
+ * Register a new CLI-synced repo. Returns gitId.
+ */
+async function registerRepo({ displayName, repositoryUrl, branch, moduleExcludePatterns, fileExcludePatterns }) {
+  const body = { display_name: displayName };
+  if (repositoryUrl) body.repository_url = repositoryUrl;
+  if (branch) body.branch = branch;
+  if (moduleExcludePatterns && moduleExcludePatterns.length > 0) {
+    body.module_exclude_patterns = moduleExcludePatterns;
+  }
+  if (fileExcludePatterns && fileExcludePatterns.length > 0) {
+    body.file_exclude_patterns = fileExcludePatterns;
+  }
+  const data = await api.post("/api/agent/repos", body);
+  return data.git_id;
+}
+
+/**
+ * Fetch backend-suggested module exclude patterns for a repo.
+ * Returns an array of { pattern, label, module_count, sample_modules }.
+ */
+async function getModuleExcludeSuggestions(gitId) {
+  return api.get(`/api/git/${encodeURIComponent(gitId)}/module-exclude-suggestions`);
+}
+
+/**
+ * Replace the module exclude patterns for a repo. The backend re-resolves
+ * project structure with the new patterns applied.
+ */
+async function updateModuleExcludePatterns(gitId, patterns) {
+  return api.put(`/api/git/${encodeURIComponent(gitId)}/module-exclude-patterns`, {
+    module_exclude_patterns: patterns,
+  });
+}
+
+/**
+ * Submit a manifest of { path, size_bytes, mime_type } entries.
+ * Returns { includedPaths, excludedPaths, includePatterns, excludePatterns }.
+ */
+async function filterManifest(gitId, manifest) {
+  return api.post(`/api/agent/repos/${encodeURIComponent(gitId)}/filter`, manifest);
+}
+
+/**
+ * Start a sync session. Returns sessionId.
+ */
+async function startSync(gitId) {
+  const data = await api.post(`/api/agent/repos/${encodeURIComponent(gitId)}/sync/start`, {});
+  return data.session_id;
+}
+
+/**
+ * Upload a batch of files for the given session.
+ * Each file: { relativePath: string, absolutePath: string }
+ */
+async function uploadFileBatch(gitId, sessionId, fileBatch) {
+  const { FormData, Blob } = await getFormDataImpl();
+  const form = new FormData();
+
+  for (const { relativePath, absolutePath } of fileBatch) {
+    const content = fs.readFileSync(absolutePath);
+    const blob = new Blob([content]);
+    // Set the filename as the relative path so the server can write to the right location
+    form.append("files", blob, relativePath);
+  }
+
+  const creds = require("./credentials").load();
+  const baseUrl = (creds && creds.apiUrl) || api.DEFAULT_API_URL;
+  const url = `${baseUrl}/api/agent/repos/${encodeURIComponent(gitId)}/sync/${encodeURIComponent(sessionId)}/files`;
+
+  // Ensure a current JWT before building the request (the daemon may have run
+  // long enough for the short-lived JWT to expire). Retry once on 401. Each
+  // attempt is bounded by a timeout so a stalled connection aborts instead of
+  // hanging the upload pool.
+  let handle;
+  try {
+    let authToken = await api.ensureFreshToken();
+    handle = await fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        // Content-Type is set automatically by fetch for FormData
+      },
+      body: form,
+    });
+    if (handle.res.status === 401) {
+      handle.clear();
+      authToken = await api.ensureFreshToken();
+      handle = await fetchWithTimeout(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${authToken}` },
+        body: form,
+      });
+    }
+    const res = handle.res;
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Upload batch failed (HTTP ${res.status}): ${text.slice(0, 200)}`);
+    }
+    const json = await res.json();
+    return json.data;
+  } catch (err) {
+    if (isAbort(err)) {
+      throw new Error(`Upload batch timed out after ${uploadTimeoutMs()}ms`);
+    }
+    throw err;
+  } finally {
+    if (handle) handle.clear();
+  }
+}
+
+/**
+ * Complete a sync session, triggering atomic move and staleness.
+ */
+async function completeSync(gitId, sessionId) {
+  return api.post(`/api/agent/repos/${encodeURIComponent(gitId)}/sync/${encodeURIComponent(sessionId)}/complete`, {});
+}
+
+/**
+ * Incremental single-file upsert.
+ */
+async function upsertFile(gitId, relativePath, absolutePath) {
+  const { FormData, Blob } = await getFormDataImpl();
+  const form = new FormData();
+  form.append("path", relativePath);
+  const content = fs.readFileSync(absolutePath);
+  form.append("file", new Blob([content]), path.basename(relativePath));
+
+  const creds = require("./credentials").load();
+  const baseUrl = (creds && creds.apiUrl) || api.DEFAULT_API_URL;
+  const url = `${baseUrl}/api/agent/repos/${encodeURIComponent(gitId)}/files`;
+
+  // Ensure a current JWT before building the request; retry once on 401 so the
+  // watch/auto-sync daemon survives short-lived JWT expiry. Each attempt is
+  // bounded by the same upload timeout as batch uploads (a stalled single-file
+  // upsert previously had no timeout — a latent hang on the watch path).
+  let handle;
+  try {
+    let authToken = await api.ensureFreshToken();
+    handle = await fetchWithTimeout(url, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${authToken}` },
+      body: form,
+    });
+    if (handle.res.status === 401) {
+      handle.clear();
+      authToken = await api.ensureFreshToken();
+      handle = await fetchWithTimeout(url, {
+        method: "PUT",
+        headers: { Authorization: `Bearer ${authToken}` },
+        body: form,
+      });
+    }
+    const res = handle.res;
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Upsert file failed (HTTP ${res.status}): ${text.slice(0, 200)}`);
+    }
+  } catch (err) {
+    if (isAbort(err)) {
+      throw new Error(`Upsert file timed out after ${uploadTimeoutMs()}ms`);
+    }
+    throw err;
+  } finally {
+    if (handle) handle.clear();
+  }
+}
+
+/**
+ * Incremental single-file delete.
+ */
+async function deleteFile(gitId, relativePath) {
+  return api.del(`/api/agent/repos/${encodeURIComponent(gitId)}/files`, {
+    body: { path: relativePath },
+  });
+}
+
+/**
+ * Send heartbeat.
+ */
+async function heartbeat(gitId) {
+  return api.post(`/api/agent/repos/${encodeURIComponent(gitId)}/heartbeat`, {});
+}
+
+/**
+ * Get sync status for a repo.
+ */
+async function getStatus(gitId) {
+  return api.get(`/api/agent/repos/${encodeURIComponent(gitId)}/status`);
+}
+
+/**
+ * True when an error from an /api/agent/repos/{gitId}/* call is a DEFINITIVE
+ * "this repo does not exist on this backend" — a 404, or the 400 the
+ * AgentSyncController returns ("Repository not found: <gitId>"). Anything else
+ * (network failure, 401, 500) is NOT a not-found and must not be treated as one.
+ */
+function isRepoNotFound(err) {
+  if (!err) return false;
+  if (err.status === 404) return true;
+  const text = `${err.message || ""} ${typeof err.body === "string" ? err.body : ""}`;
+  return err.status === 400 && /repository not found/i.test(text);
+}
+
+/**
+ * Does `gitId` still exist on the CURRENT backend? Returns false ONLY on a
+ * definitive not-found (see isRepoNotFound); any other error propagates so the
+ * caller fails loudly instead of silently re-registering (which would duplicate
+ * the repo and re-upload). Used by `niro init` to self-heal a stale cached gitId
+ * left behind by a backend switch or a deleted repo.
+ */
+async function repoExists(gitId) {
+  try {
+    await getStatus(gitId);
+    return true;
+  } catch (err) {
+    if (isRepoNotFound(err)) return false;
+    throw err;
+  }
+}
+
+// Node 18+ has FormData and Blob built-in (no-import needed in ESM, but CJS needs this)
+async function getFormDataImpl() {
+  // Node 18+ has FormData globally; use it if available
+  if (typeof FormData !== "undefined" && typeof Blob !== "undefined") {
+    return { FormData, Blob };
+  }
+  throw new Error("FormData/Blob not available. Node 18+ is required.");
+}
+
+module.exports = { registerRepo, filterManifest, startSync, uploadFileBatch, completeSync, upsertFile, deleteFile, heartbeat, getStatus, repoExists, isRepoNotFound, getModuleExcludeSuggestions, updateModuleExcludePatterns };