@indigoai-us/hq-cli 5.18.1 → 5.18.2

package/dist/commands/members.d.ts

@@ -20,13 +20,29 @@ export interface InviteOptions {
     callerUid: string;
     token: string;
 }
+/**
+ * Outcome of `hq members invite`. Two shapes depending on server schema:
+ *
+ *  - **schemaVersion ≤ 1** — server returns a random `inviteToken` the
+ *    invitee redeems via the `hq://accept/{token}` magic link. `magicLink`
+ *    is populated so the caller can print or paste it.
+ *  - **schemaVersion 2+** (current production) — membership row is
+ *    email-keyed and authoritative. There is no token; the invitee
+ *    accepts by signing into HQ with the same email. `inviteToken` +
+ *    `magicLink` are both `undefined`; the caller prints sign-in
+ *    instructions instead.
+ *
+ * `membership` is always populated when the server returned 2xx.
+ */
 export interface InviteResult {
-    inviteToken: string;
-    magicLink: string;
+    inviteToken?: string;
+    magicLink?: string;
     membership: {
+        membershipKey?: string;
         role: string;
         status: string;
         inviteToken?: string;
+        inviteeEmail?: string;
     };
 }
 export interface DetectedTarget {

package/dist/commands/members.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5f8b5b62-a00e-5ca3-b293-23906579a464")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="20c76490-0485-592f-856b-3b20e403a392")}catch(e){}}();
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
@@ -72,19 +72,26 @@ export async function inviteMember(options) {
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
     const data = (await res.json());
-    // The token may arrive at the response root OR nested on the membership row,
-    // depending on vault-service version. Resolve from either; never emit
-    // `hq://accept/undefined` (a broken link that looks like success).
-    const inviteToken = data.inviteToken ?? data.membership?.inviteToken;
-    if (!inviteToken) {
+    if (!data.membership) {
         const keys = Object.keys(data ?? {}).join(", ") || "<empty>";
-        throw new Error(`Invite was created but the server response did not include an invite token (response keys: ${keys}). ` +
-            "Run `hq members list` to retrieve the pending invite, or upgrade hq.");
+        throw new Error(`Invite endpoint returned 2xx with no membership row (response keys: ${keys}). ` +
+            "This is a server-side regression — file an issue.");
     }
+    // Two server schemas in the wild:
+    //   - Legacy (schemaVersion ≤ 1): response carries a random `inviteToken`
+    //     the invitee redeems via `hq://accept/{token}`.
+    //   - Current (schemaVersion 2+): membership row is email-keyed and
+    //     authoritative — there is no token. The invitee accepts by signing
+    //     into HQ with the invited email. The CLI must NOT throw here
+    //     (previously did: "response did not include an invite token") — the
+    //     invite IS successfully created on the server; the caller just gets
+    //     undefined for inviteToken/magicLink and prints sign-in instructions.
+    const inviteToken = data.inviteToken ?? data.membership.inviteToken;
     return {
-        inviteToken,
-        magicLink: `hq://accept/${inviteToken}`,
-        membership: data.membership ?? { role: options.role, status: "pending" },
+        ...(inviteToken
+            ? { inviteToken, magicLink: `hq://accept/${inviteToken}` }
+            : {}),
+        membership: data.membership,
     };
 }
 export class InviteHttpError extends Error {
@@ -122,8 +129,11 @@ export async function listPendingInvites(token, companyUid) {
         const err = (await res.json().catch(() => ({})));
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
+    // Server schema: `{ pending: [...] }`. Earlier dev branches used
+    // `{ invites: [...] }` which the CLI still accepts as a fallback for
+    // operators running staging stages that haven't caught up yet.
     const data = (await res.json());
-    return data?.invites ?? [];
+    return data?.pending ?? data?.invites ?? [];
 }
 export async function revokeInvite(token, tokenOrKey, companyUid) {
     const res = await vaultApiFetch({
@@ -163,10 +173,28 @@ export function registerMembersCommand(program) {
             });
             console.log(chalk.green(`Invited ${target} as ${result.membership.role} (status: ${result.membership.status})`));
             console.log();
-            console.log(chalk.bold("Magic link:"));
-            console.log(`  ${result.magicLink}`);
-            console.log();
-            console.log(chalk.dim("Share this link with the invitee. They can run `hq onboard join --invite-token <token>` to accept."));
+            if (result.magicLink) {
+                // Legacy server schema — magic-link redemption.
+                console.log(chalk.bold("Magic link:"));
+                console.log(`  ${result.magicLink}`);
+                console.log();
+                console.log(chalk.dim("Share this link with the invitee. They can run `hq onboard join --invite-token <token>` to accept."));
+            }
+            else {
+                // schemaVersion 2+ — email-keyed authoritative membership row.
+                // No magic link to share; invitee accepts by signing into HQ.
+                const inviteeEmail = result.membership.inviteeEmail ??
+                    (typeof target === "string" && target.includes("@")
+                        ? target
+                        : undefined);
+                console.log(chalk.bold("Next step:"));
+                console.log(`  Tell ${inviteeEmail ?? "the invitee"} to sign into HQ at https://hq.getindigo.ai with that email.`);
+                console.log(chalk.dim("  The pending membership row claims itself on first sign-in — no separate token redemption."));
+                if (result.membership.membershipKey) {
+                    console.log();
+                    console.log(chalk.dim(`  Membership key: ${result.membership.membershipKey}`));
+                }
+            }
         }
         catch (err) {
             if (err instanceof InviteHttpError) {
@@ -253,4 +281,4 @@ export function registerMembersCommand(program) {
     });
 }
 //# sourceMappingURL=members.js.map
-//# debugId=5f8b5b62-a00e-5ca3-b293-23906579a464
+//# debugId=20c76490-0485-592f-856b-3b20e403a392

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.18.1",
+  "version": "5.18.2",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {

package/src/commands/members.test.ts

@@ -246,13 +246,49 @@ describe("inviteMember", () => {
     expect(result.magicLink).toBe("hq://accept/tok_nested");
   });
 
-  it("throws instead of emitting hq://accept/undefined when no token is present", async () => {
+  it("schemaVersion 2: no inviteToken in response → success with undefined magicLink", async () => {
+    // 2026-05-21 fix: the server moved to email-keyed authoritative
+    // membership rows (schemaVersion 2) — the invite IS created, but
+    // there is no token to redeem. The CLI must NOT throw here; instead
+    // the action handler prints "sign in with the invited email"
+    // instructions. Previously this case threw "did not include an
+    // invite token" which produced false-failure UX on a working invite.
     fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        membership: { role: "admin", status: "pending" },
+      jsonResponse(201, {
+        membership: {
+          membershipKey: "email:alice@example.com#cmp_acme",
+          role: "member",
+          status: "pending",
+          inviteeEmail: "alice@example.com",
+          schemaVersion: 2,
+        },
       }),
     );
 
+    const result = await inviteMember({
+      target: "alice@example.com",
+      role: "member",
+      companyUid: "cmp_acme",
+      callerUid: "prs_admin",
+      token: "test-token",
+    });
+
+    expect(result.inviteToken).toBeUndefined();
+    expect(result.magicLink).toBeUndefined();
+    expect(result.membership.role).toBe("member");
+    expect(result.membership.status).toBe("pending");
+    expect(result.membership.membershipKey).toBe(
+      "email:alice@example.com#cmp_acme",
+    );
+    expect(result.membership.inviteeEmail).toBe("alice@example.com");
+  });
+
+  it("throws when the response has no membership row at all (server bug)", async () => {
+    // Belt-and-suspenders: a 2xx response with NO membership row is a
+    // server-side regression — surface it loudly so it doesn't silently
+    // succeed-but-do-nothing.
+    fetchSpy.mockResolvedValueOnce(jsonResponse(201, {}));
+
     await expect(
       inviteMember({
         target: "alice@example.com",
@@ -261,7 +297,7 @@ describe("inviteMember", () => {
         callerUid: "prs_admin",
         token: "test-token",
       }),
-    ).rejects.toThrow(/did not include an invite token/);
+    ).rejects.toThrow(/no membership row/);
   });
 });
 
@@ -313,6 +349,47 @@ describe("listPendingInvites", () => {
     fetchSpy.mockResolvedValueOnce(jsonResponse(200, {}));
     await expect(listPendingInvites("test-token", "cmp_acme")).resolves.toEqual([]);
   });
+
+  it("schemaVersion 2: reads `pending` key (the canonical server response)", async () => {
+    // 2026-05-21 fix: live server returns `{ pending: [...] }`, not
+    // `{ invites: [...] }`. The CLI must read `pending` as the primary
+    // and fall back to `invites` for older stages.
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        pending: [
+          {
+            membershipKey: "email:alice@example.com#cmp_acme",
+            inviteeEmail: "alice@example.com",
+            companyUid: "cmp_acme",
+            role: "member",
+            status: "pending",
+            invitedBy: "prs_admin",
+            invitedAt: "2026-05-21T12:00:00Z",
+            schemaVersion: 2,
+          },
+        ],
+      }),
+    );
+
+    const invites = await listPendingInvites("test-token", "cmp_acme");
+    expect(invites).toHaveLength(1);
+    expect(invites[0].membershipKey).toBe("email:alice@example.com#cmp_acme");
+    expect(invites[0].inviteeEmail).toBe("alice@example.com");
+  });
+
+  it("prefers `pending` over legacy `invites` when both present (server transition)", async () => {
+    // Defensive: an in-flight server deploy could briefly return BOTH
+    // fields. CLI takes the canonical `pending` key.
+    fetchSpy.mockResolvedValueOnce(
+      jsonResponse(200, {
+        pending: [{ membershipKey: "k_pending" } as never],
+        invites: [{ membershipKey: "k_legacy" } as never],
+      }),
+    );
+    const invites = await listPendingInvites("test-token", "cmp_acme");
+    expect(invites).toHaveLength(1);
+    expect(invites[0].membershipKey).toBe("k_pending");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/commands/members.ts

@@ -38,10 +38,30 @@ export interface InviteOptions {
   token: string;
 }
 
+/**
+ * Outcome of `hq members invite`. Two shapes depending on server schema:
+ *
+ *  - **schemaVersion ≤ 1** — server returns a random `inviteToken` the
+ *    invitee redeems via the `hq://accept/{token}` magic link. `magicLink`
+ *    is populated so the caller can print or paste it.
+ *  - **schemaVersion 2+** (current production) — membership row is
+ *    email-keyed and authoritative. There is no token; the invitee
+ *    accepts by signing into HQ with the same email. `inviteToken` +
+ *    `magicLink` are both `undefined`; the caller prints sign-in
+ *    instructions instead.
+ *
+ * `membership` is always populated when the server returned 2xx.
+ */
 export interface InviteResult {
-  inviteToken: string;
-  magicLink: string;
-  membership: { role: string; status: string; inviteToken?: string };
+  inviteToken?: string;
+  magicLink?: string;
+  membership: {
+    membershipKey?: string;
+    role: string;
+    status: string;
+    inviteToken?: string;
+    inviteeEmail?: string;
+  };
 }
 
 export interface DetectedTarget {
@@ -137,24 +157,38 @@ export async function inviteMember(
   }
 
   const data = (await res.json()) as {
-    membership?: { role: string; status: string; inviteToken?: string };
+    membership?: {
+      membershipKey?: string;
+      role: string;
+      status: string;
+      inviteToken?: string;
+      inviteeEmail?: string;
+      schemaVersion?: number;
+    };
     inviteToken?: string;
   };
-  // The token may arrive at the response root OR nested on the membership row,
-  // depending on vault-service version. Resolve from either; never emit
-  // `hq://accept/undefined` (a broken link that looks like success).
-  const inviteToken = data.inviteToken ?? data.membership?.inviteToken;
-  if (!inviteToken) {
+  if (!data.membership) {
     const keys = Object.keys(data ?? {}).join(", ") || "<empty>";
     throw new Error(
-      `Invite was created but the server response did not include an invite token (response keys: ${keys}). ` +
-        "Run `hq members list` to retrieve the pending invite, or upgrade hq.",
+      `Invite endpoint returned 2xx with no membership row (response keys: ${keys}). ` +
+        "This is a server-side regression — file an issue.",
     );
   }
+  // Two server schemas in the wild:
+  //   - Legacy (schemaVersion ≤ 1): response carries a random `inviteToken`
+  //     the invitee redeems via `hq://accept/{token}`.
+  //   - Current (schemaVersion 2+): membership row is email-keyed and
+  //     authoritative — there is no token. The invitee accepts by signing
+  //     into HQ with the invited email. The CLI must NOT throw here
+  //     (previously did: "response did not include an invite token") — the
+  //     invite IS successfully created on the server; the caller just gets
+  //     undefined for inviteToken/magicLink and prints sign-in instructions.
+  const inviteToken = data.inviteToken ?? data.membership.inviteToken;
   return {
-    inviteToken,
-    magicLink: `hq://accept/${inviteToken}`,
-    membership: data.membership ?? { role: options.role, status: "pending" },
+    ...(inviteToken
+      ? { inviteToken, magicLink: `hq://accept/${inviteToken}` }
+      : {}),
+    membership: data.membership,
   };
 }
 
@@ -204,8 +238,14 @@ export async function listPendingInvites(
       err.code,
     );
   }
-  const data = (await res.json()) as { invites?: PendingInvite[] | null };
-  return data?.invites ?? [];
+  // Server schema: `{ pending: [...] }`. Earlier dev branches used
+  // `{ invites: [...] }` which the CLI still accepts as a fallback for
+  // operators running staging stages that haven't caught up yet.
+  const data = (await res.json()) as {
+    pending?: PendingInvite[] | null;
+    invites?: PendingInvite[] | null;
+  };
+  return data?.pending ?? data?.invites ?? [];
 }
 
 export async function revokeInvite(
@@ -275,14 +315,40 @@ export function registerMembersCommand(program: Command): void {
             ),
           );
           console.log();
-          console.log(chalk.bold("Magic link:"));
-          console.log(`  ${result.magicLink}`);
-          console.log();
-          console.log(
-            chalk.dim(
-              "Share this link with the invitee. They can run `hq onboard join --invite-token <token>` to accept.",
-            ),
-          );
+          if (result.magicLink) {
+            // Legacy server schema — magic-link redemption.
+            console.log(chalk.bold("Magic link:"));
+            console.log(`  ${result.magicLink}`);
+            console.log();
+            console.log(
+              chalk.dim(
+                "Share this link with the invitee. They can run `hq onboard join --invite-token <token>` to accept.",
+              ),
+            );
+          } else {
+            // schemaVersion 2+ — email-keyed authoritative membership row.
+            // No magic link to share; invitee accepts by signing into HQ.
+            const inviteeEmail =
+              result.membership.inviteeEmail ??
+              (typeof target === "string" && target.includes("@")
+                ? target
+                : undefined);
+            console.log(chalk.bold("Next step:"));
+            console.log(
+              `  Tell ${inviteeEmail ?? "the invitee"} to sign into HQ at https://hq.getindigo.ai with that email.`,
+            );
+            console.log(
+              chalk.dim(
+                "  The pending membership row claims itself on first sign-in — no separate token redemption.",
+              ),
+            );
+            if (result.membership.membershipKey) {
+              console.log();
+              console.log(
+                chalk.dim(`  Membership key: ${result.membership.membershipKey}`),
+              );
+            }
+          }
         } catch (err) {
           if (err instanceof InviteHttpError) {
             console.error(