@niroai/niro 0.8.0 → 0.10.0

package/src/commands/release.js

@@ -22,6 +22,7 @@ const git = require("../lib/git");
 const niroProjectFile = require("../lib/niroProjectFile");
 const prompt = require("../lib/prompt");
 const watchState = require("../lib/watchState");
+const tempProject = require("../lib/tempProject");
 
 const ok = (s) => color.green(s);
 const warn = (s) => color.yellow(s);
@@ -56,26 +57,80 @@ async function release(pathArg, opts = {}) {
         "`niro discard-temp-project --project <temp-project-id>`. The server refuses to delete anything " +
         "that is not a temporary project, so this is always safe.");
   }
-  const project = await api.get(`/api/projects/${encodeURIComponent(tempProjectId)}`);
-  const cloneOf = project.clone_of_project_id || project.cloneOfProjectId;
-  if (!cloneOf) {
-    throw new Error(`Project ${tempProjectId} is not a temporary project — refusing. ` +
-        "(discard only deletes projects created by `niro new-temp-project`)");
+  // The temporary project may ALREADY be gone from the server, and nothing tells this machine when
+  // that happens: the idle sweeper reaps it after N days, and deleting it in the UI goes down the
+  // ordinary project-delete path. This fetch used to throw on that, BEFORE any local cleanup ran, so
+  // the folder kept a registration pointing at a project that no longer exists — and the only advice
+  // anything offered ("run `niro discard-temp-project` in that folder first") named this very command,
+  // which then failed the same way. A definitive not-found means there is nothing left to delete, so
+  // skip the server half and do the local half, which is the half that was still needed.
+  let project = null;
+  let cloneOf = null;
+  let alreadyGone = false;
+  try {
+    project = await api.get(`/api/projects/${encodeURIComponent(tempProjectId)}`);
+  } catch (err) {
+    // Only a definitive "no such project" counts. A network blip, a 401, a 500 or a genuine
+    // permissions refusal must still fail loudly — rewriting local registrations because the server
+    // could not be reached is exactly the mistake this command exists to undo.
+    if (!tempProject.isProjectNotFound(err)) throw err;
+    alreadyGone = true;
+  }
+  if (alreadyGone && !opts.project && !(entry && entry.takeover)) {
+    // The id did not come from a takeover backup or from the user — it came from a `.niro-project`
+    // pin that happens to name a missing project. Nothing here says this folder was ever taken over,
+    // so there is no warrant to touch its registration.
+    throw new Error(`Project ${tempProjectId} does not exist on this backend, and nothing on this ` +
+        "machine records a temporary project for this folder — refusing to change anything. " +
+        "If you know the temporary project's id, pass it explicitly: " +
+        "`niro discard-temp-project --project <temp-project-id>`.");
+  }
+  if (!alreadyGone) {
+    cloneOf = project.clone_of_project_id || project.cloneOfProjectId;
+    if (!cloneOf) {
+      throw new Error(`Project ${tempProjectId} is not a temporary project — refusing. ` +
+          "(discard only deletes projects created by `niro new-temp-project`)");
+    }
   }
 
   // Every folder registered against this temp project (multi-repo takeover, ADR-016).
   const currentDir = path.resolve(targetDir);
-  const folders = watchState.allLocal(baseUrl).filter((e) => e.projectId === tempProjectId);
+  let folders = watchState.allLocal(baseUrl).filter((e) => e.projectId === tempProjectId);
   if (!folders.some((e) => path.resolve(e.folderPath) === currentDir)) {
     folders.push({ folderPath: targetDir, ...(entry || {}) });
   }
+  if (alreadyGone) {
+    // Two corrections that only matter once the server is no longer there to check the id against.
+    //
+    // Drop any folder not actually registered against THIS project. The line above adds the current
+    // folder unconditionally, which is right when the id came from that folder, and wrong when it came
+    // from `--project`: a mistyped or already-discarded id, run from a folder holding a DIFFERENT live
+    // working copy, would rewrite that copy's registration and report it as cleaned up. On the alive
+    // path the server's own answer bounds the damage; here nothing does.
+    folders = folders.filter((e) => e.projectId === tempProjectId);
+    // Then recover the source project from whichever folder recorded it. Every folder in one working
+    // copy is a clone of the SAME source project (ADR-016 extends a copy with more repos, it never
+    // spans two sources), so any one backup answers for all of them — including a sibling that has no
+    // backup of its own, which would otherwise be left pointing at the deleted project while the alive
+    // path restores it from `clone_of_project_id`.
+    const witness = folders.find((e) => e.takeover && e.takeover.sourceProjectId);
+    if (!witness) {
+      throw new Error(`Project ${tempProjectId} does not exist on this backend, and no folder on this ` +
+          "machine records which project it was a working copy of — refusing to guess. " +
+          "Nothing has been changed.");
+    }
+    cloneOf = witness.takeover.sourceProjectId;
+  }
 
   // ADR-018 discard guard: deleting the temp project kills coverage for EVERY repo in it. Check each
   // folder's CURRENT branch against its recorded source branch; a folder still on a feature branch is
   // in-flight work whose coverage this discard would destroy. Old entries without sourceBranch can't be
   // verified client-side (the server-side nudge guard still covers the agent-driven path).
+  // Skipped when the copy is already gone: this guard exists to warn BEFORE destroying coverage, and
+  // there is no coverage left to destroy. Leaving it on would ask the developer to confirm losing
+  // something they have already lost, and then refuse non-interactively over it.
   const stillDiverged = [];
-  for (const e of folders) {
+  for (const e of alreadyGone ? [] : folders) {
     const sourceBranch = e.takeover && e.takeover.sourceBranch;
     if (!sourceBranch || !fs.existsSync(e.folderPath)) continue;
     try {
@@ -86,11 +141,11 @@ async function release(pathArg, opts = {}) {
     } catch { /* can't inspect — don't block on it */ }
   }
   if (stillDiverged.length) {
-    console.log(warn(`\n  ⚠ This temporary project still covers in-flight work:`));
+    console.log(warn(`\n    ⚠ This temporary project still covers in-flight work:`));
     for (const d of stillDiverged) {
       console.log(warn(`    ${d.folder} is on \`${d.branch}\` (source: \`${d.sourceBranch}\`)`));
     }
-    console.log(warn("  Discarding deletes the WHOLE temporary project — those repos lose their coverage" +
+    console.log(warn("    Discarding deletes the WHOLE temporary project — those repos lose their coverage" +
         " until you run `niro new-temp-project` there again (local code is untouched)."));
     if (!opts.yes) {
       if (!process.stdout.isTTY || prompt.isNonInteractive()) {
@@ -103,7 +158,7 @@ async function release(pathArg, opts = {}) {
         return;
       }
     }
-  } else if (process.stdout.isTTY && !opts.yes) {
+  } else if (!alreadyGone && process.stdout.isTTY && !opts.yes) {
     const sure = await prompt.confirm(
       `Discard temporary project ${color.bold(project.alias || tempProjectId)}?`);
     if (!sure) {
@@ -112,7 +167,9 @@ async function release(pathArg, opts = {}) {
     }
   }
 
-  await api.post(`/api/projects/${encodeURIComponent(tempProjectId)}/clone/release`, {});
+  if (!alreadyGone) {
+    await api.post(`/api/projects/${encodeURIComponent(tempProjectId)}/clone/release`, {});
+  }
 
   // Restore each folder's local registration. ADR-018: the .niro-project file is left ALONE unless it
   // still carries the OLD-STYLE swapped pin (pre-ADR-018 takeover) — then it points at a now-deleted
@@ -175,17 +232,26 @@ async function release(pathArg, opts = {}) {
     }
   }
 
-  console.log(`\n  ${ok("✓")} Temporary project discarded. Niro routes back to the original project automatically.`);
+  if (alreadyGone) {
+    console.log(`\n    ${ok("✓")} Temporary project ${color.bold(tempProjectId)} was already gone from the server` +
+        color.dim(" (deleted from the UI, or reaped after sitting idle)."));
+    console.log(repinned.length
+      ? `  ${ok("✓")} Cleaned up ${repinned.length} local registration(s) that still pointed at it. ` +
+        "Niro routes back to the original project automatically."
+      : `  ${ok("✓")} Nothing left to clean up locally.`);
+  } else {
+    console.log(`\n    ${ok("✓")} Temporary project discarded. Niro routes back to the original project automatically.`);
+  }
   if (healed.length) {
-    console.log(color.dim("  Healed old-style pins:"));
+    console.log(color.dim("    Healed old-style pins:"));
     for (const h of healed) console.log(color.dim(`    ${h.folder} → ${h.to}`));
   }
   if (failed.length) {
-    console.log(warn(`\n  ⚠ ${failed.length} folder(s) could not be restored locally (the temporary project` +
+    console.log(warn(`\n    ⚠ ${failed.length} folder(s) could not be restored locally (the temporary project` +
         " is already gone server-side):"));
     for (const f of failed) console.log(color.dim(`    ${f.folder} — ${f.error}`));
   }
-  console.log(color.dim("  The original project picks up your merged commits via its normal remote polling."));
+  console.log(color.dim("    The original project picks up your merged commits via its normal remote polling."));
 }
 
 module.exports = { release };

package/src/commands/remove.js

@@ -71,9 +71,9 @@ async function remove(opts = {}) {
     const expected = alias ? `"${alias}" or ${projectId}` : projectId;
     console.error(`${color.red("✗")} Refusing to delete: --confirm-name must equal the project's name (${expected}).`);
     if (confirm == null) {
-      console.error(color.dim("   Pass --confirm-name <name> to confirm this destructive delete."));
+      console.error(color.dim("    Pass --confirm-name <name> to confirm this destructive delete."));
     } else {
-      console.error(color.dim(`   You passed --confirm-name "${confirm}", which does not match.`));
+      console.error(color.dim(`    You passed --confirm-name "${confirm}", which does not match.`));
     }
     process.exitCode = 1;
     return;
@@ -86,9 +86,9 @@ async function remove(opts = {}) {
 
 function printUsage() {
   console.error("niro remove — remove a project or a repo mapping. Exactly one mode required:");
-  console.error("  --project                  delete the whole project (DESTRUCTIVE)");
-  console.error("                             requires --confirm-name <project alias or id>");
-  console.error("  --unmap-repo <gitId>       remove one repo from the project (non-destructive)");
+  console.error("    --project                  delete the whole project (DESTRUCTIVE)");
+  console.error("                                requires --confirm-name <project alias or id>");
+  console.error("    --unmap-repo <gitId>       remove one repo from the project (non-destructive)");
   console.error("Target project: --target <alias|id>, or a .niro-project pin in this folder.");
 }