@retasc/cli 1.9.0 → 1.10.0

package/dist/commands/identity.js

@@ -0,0 +1,96 @@
+import { api } from "../api.js";
+import { clean } from "../lib/text.js";
+import { isInteractive } from "./bind.js";
+import { identityLoop } from "./join.js";
+/**
+ * Which org's placeholders to offer.
+ *
+ * Same rule as `retasc billing`: explicit `--org-id` wins, one membership needs no
+ * question, several must be named. Deliberately NOT the folder binding — that resolves
+ * through an agent key, and this is a question only a signed-in human can answer, so
+ * reading identity off the folder would name an org this person might not even be in.
+ */
+export function resolveOrg(orgs, orgId) {
+    // Org names are human-typed and land in a terminal that acts on escape sequences, the
+    // same rule the ghost rows follow. `clean` here rather than at each interpolation so a
+    // later line added to this list cannot forget it.
+    const list = () => orgs.map((o) => `  ${o.id}  ${clean(o.name)}${o.slug ? ` (${clean(o.slug)})` : ""}`);
+    if (orgId) {
+        const found = orgs.find((o) => o.id === orgId);
+        // REFUSE an id we can't see, rather than passing it through for the server to reject.
+        // The server does not reject it: `memberOf` returns null for a non-member AND for a
+        // suspended one, and `claimableGhosts` maps null to `{asked: true}` — the exact shape a
+        // permanent decline returns. Passing through would make this command answer "you've
+        // already said none of these are you" to someone who simply typed the wrong id, which
+        // is a false statement about their own history and the one thing it must never say.
+        if (!found) {
+            throw new Error(`You're not an active member of ${clean(orgId)} — or that isn't an org id.` +
+                (orgs.length ? `\nOrgs you can ask about:\n${list().join("\n")}` : ""));
+        }
+        return found;
+    }
+    if (orgs.length === 0)
+        throw new Error("You're not a member of any org yet.");
+    if (orgs.length > 1) {
+        throw new Error(`Several orgs — pass --org-id <id>:\n${list().join("\n")}`);
+    }
+    return orgs[0];
+}
+/** What to print once the loop is done. `join` prints nothing; this command must. */
+function report(outcome, orgLabel) {
+    switch (outcome) {
+        case "claimed":
+        case "unavailable":
+            // Both already said their piece, line by line, as they happened.
+            return;
+        case "none":
+            // The common answer, and a genuinely good one — say it plainly rather than exiting
+            // silently, which reads like the command failed to run.
+            console.log(`Nothing waiting for you in ${orgLabel}.`);
+            console.log("Run this again after a migration — each import brings its own people across.");
+            return;
+        case "answered":
+            // The permanent decline. Worth its own wording: from in here it is indistinguishable
+            // from "none", and someone who declined during an earlier import and now has a real
+            // placeholder from a NEW one would otherwise read "nothing waiting" as the truth.
+            console.log(`You've already said none of the imported people in ${orgLabel} are you.`);
+            console.log("That answer covers the whole org, including later migrations.");
+            console.log("If a newer import did carry you across, an owner can link it from the Team page.");
+            return;
+        case "declined":
+            console.log("Noted — you won't be asked again.");
+            return;
+        case "left":
+            console.log("Nothing linked. Run `retasc identity` again whenever you want to look.");
+            return;
+        case "skipped":
+            // Only reachable non-interactively; the interactive guard below catches that first.
+            return;
+    }
+}
+export async function identityAction(opts, deps = {}) {
+    const d = {
+        me: () => api.me(),
+        // One implementation of the irreversible question, shared with `join`. Two surfaces
+        // asking it in two different voices is how someone ends up answering the one they trust
+        // less — the same reason its wording already mirrors the Dash notice.
+        loop: (orgId, orgLabel) => identityLoop(orgId, {}, orgLabel),
+        interactive: isInteractive,
+        ...deps,
+    };
+    // Refuse up front rather than exiting 0 in silence. `identityLoop` returns "skipped"
+    // without a TTY — correct inside `join`, where the folder setup is the point and the
+    // question is optional, and wrong here, where the question IS the command.
+    if (!d.interactive()) {
+        throw new Error("`retasc identity` needs an interactive terminal — linking an imported person is irreversible, so it always asks first.");
+    }
+    const me = await d.me();
+    const org = resolveOrg(me.orgs, opts.orgId);
+    // The NAME alone, not "name (slug)". It lands mid-sentence in both surfaces — "When Acme
+    // migrated…" and "Nothing waiting for you in Acme." The slug only earns its place in the
+    // several-orgs error, where it is there to be copied.
+    const orgLabel = clean(org.name);
+    const outcome = await d.loop(org.id, orgLabel);
+    report(outcome, orgLabel);
+    return outcome;
+}

package/dist/commands/join.js

@@ -53,19 +53,28 @@ deps = {}) {
     // authorship AND their dispatch lane onto your account, irreversibly, and there is no
     // CLI path back. A scripted run has nobody to be wrong on behalf of.
     if (!d.interactive() || opts.yes)
-        return;
+        return "skipped";
+    // Whether anything was linked BEFORE the round that ends the loop. A claim is followed by
+    // another round (a second migrated tool may still be offerable), and that round normally
+    // ends in "nothing left" — which must not erase the claim that just happened.
+    let claimedAny = false;
     for (let round = 0; round < MAX_IDENTITY_ROUNDS; round++) {
         let ghosts;
         try {
             const res = await d.claimableGhosts({ orgId });
-            if (res.asked || !res.ghosts.length)
-                return;
+            // Two different endings the server returns on one shape. "Answered" is this human's
+            // permanent org-wide decline; "none" is simply an empty list, and they can be asked
+            // again after the next migration. `join` treats both as silence; `identity` does not.
+            if (res.asked)
+                return claimedAny ? "claimed" : "answered";
+            if (!res.ghosts.length)
+                return claimedAny ? "claimed" : "none";
             ghosts = res.ghosts;
         }
         catch (e) {
             const { message } = formatError(e);
             console.error(`  ! Couldn't check for imported history (${message}). Carrying on.`);
-            return;
+            return claimedAny ? "claimed" : "unavailable";
         }
         console.log(round === 0
             ? `\nWhen ${orgLabel ?? "this org"} migrated, some people were carried across.\n` +
@@ -87,8 +96,13 @@ deps = {}) {
             }
             catch (e) {
                 console.error(`  ! ${formatError(e).message}`);
+                // NOT "declined". A caller answers that with "you won't be asked again", and the
+                // write is the only thing that makes it true — the flag never landed, so they WILL
+                // be asked again. The error is already on stderr; `unavailable` adds no second
+                // sentence on top of it rather than a reassuring false one.
+                return "unavailable";
             }
-            return;
+            return "declined";
         }
         // Confirm before claiming — it is irreversible and it moves dispatch routing, so it
         // must not be a single keystroke on a row in a list. Same qualitative wording as the
@@ -106,6 +120,7 @@ deps = {}) {
         try {
             const res = await d.claimGhost({ orgId, memberId: chosen.id });
             console.log(`✓ Linked ${clean(res.name)}.`);
+            claimedAny = true;
         }
         catch (e) {
             // SOURCE_ALREADY_CLAIMED, IMPORT_RUNNING, NOT_CLAIMABLE — all readable, all reachable
@@ -114,11 +129,14 @@ deps = {}) {
             console.error(`  ✗ ${code ? `${code}: ` : ""}${message}`);
             if (hint)
                 console.error(`    → ${hint}`);
-            return;
+            return claimedAny ? "claimed" : "unavailable";
         }
         // Claiming one ClickUp identity removes EVERY remaining ClickUp row (`claimableGhosts`
         // filters by spent source), so the next round can only ever offer a different tool.
     }
+    // Round budget spent. Only reachable by declining individual rows over and over — the
+    // list is unchanged each time, so nothing was linked and nothing was answered for good.
+    return claimedAny ? "claimed" : "left";
 }
 export async function joinAction(link, opts) {
     // Client-side, before anything else: the code is what the server matches, and someone

package/dist/index.js

@@ -7,6 +7,7 @@ import { installGate } from "./commands/gate.js";
 import { claimAction } from "./commands/claim.js";
 import { bindAction } from "./commands/bind.js";
 import { joinAction } from "./commands/join.js";
+import { identityAction } from "./commands/identity.js";
 import { doctorAction } from "./commands/doctor.js";
 import { billingAction } from "./commands/billing.js";
 import { isNetworkError, readLocalBinding, resolveBinding } from "./lib/binding.js";
@@ -372,11 +373,30 @@ program
     .option("--project-id <id>", "Which project to bind to (skips the picker)")
     .option("--agent <name>", "Agent member name (default: auto)")
     .option("--runtime <runtime>", "Agent runtime", "claude-code")
-    .option("-y, --yes", "Don't prompt to replace an existing binding, and skip the identity question")
+    // RTSC-477 — name the way back. `--yes` skips the identity question and must never answer
+    // it, so the flag that causes the gap is the right place to say how to close it.
+    .option("-y, --yes", "Don't prompt to replace an existing binding, and skip the identity question (ask it later with `retasc identity`)")
     .allowExcessArguments(false)
     .action(async (link, opts) => {
     await joinAction(link, opts).catch(fail);
 });
+// RTSC-477 — the same question `join` asks, on demand. `join` fires once, at the moment you
+// accept an invite; placeholders arrive with EVERY migration, and claiming is per source, so
+// the question recurs and needed a surface that recurs with it.
+//
+// No `-y/--yes`, and no `identity claim <name>` subcommand, on purpose: a claim is
+// irreversible and moves dispatch routing, so it is never answered on a script's behalf.
+// `allowExcessArguments(false)` therefore rejects `retasc identity claim …` outright rather
+// than ignoring the words and prompting anyway.
+program
+    .command("identity")
+    .description("Link imported history to your account: shows the people a migration carried into this org and asks which one is you.")
+    .option("--org-id <id>", "Which org (defaults to your only one).")
+    .allowExcessArguments(false)
+    .action(async (opts) => {
+    requireLogin();
+    await identityAction({ orgId: opts.orgId }).catch(fail);
+});
 // --- mcp wiring ------------------------------------------------------------
 const mcp = program.command("mcp").description("Wire the Retasc MCP server into your agent.");
 mcp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Retasc CLI — sign in with GitHub, create projects, mint agent API keys, and wire your agent to the Retasc MCP server in one command.",
   "type": "module",
   "bin": {