primitive-admin 1.1.0-alpha.9 → 1.1.0

package/dist/src/commands/users.js

@@ -1,6 +1,10 @@
 import { ApiClient } from "../lib/api-client.js";
 import { resolveAppId } from "../lib/config.js";
 import { success, error, info, keyValue, formatTable, formatId, formatDate, json, } from "../lib/output.js";
+import { confirmPrompt } from "../lib/confirm-prompt.js";
+import { warnDeprecated } from "../lib/deprecation.js";
+import { pageCursorOption, pageLimitOption, parsePageLimit, printEmptyPage, printPageHint, } from "../lib/list-options.js";
+import { normalizeCliListEnvelope, wholeListEnvelope, } from "../lib/paginate.js";
 export function registerUsersCommands(program) {
     const users = program
         .command("users")
@@ -8,27 +12,51 @@ export function registerUsersCommands(program) {
         .addHelpText("after", `
 Examples:
   $ primitive users list
+  $ primitive users create user@example.com --role admin
   $ primitive users invite user@example.com --role admin
   $ primitive users set-role 01HXY... member
+  $ primitive users mint-jwt <user-id>
 `);
     // List users
     users
         .command("list")
-        .description("List users in an app")
+        .description("List users in an app, optionally filtered by --search")
         .argument("[app-id]", "App ID (uses current app if not specified)")
         .option("--app <app-id>", "App ID")
+        .option("--search <query>", "Filter users. ULID -> userId lookup; contains '@' -> email lookup; otherwise substring name search.")
+        .addOption(pageLimitOption())
+        .addOption(pageCursorOption())
         .option("--json", "Output as JSON")
         .action(async (appId, options) => {
+        const limit = parsePageLimit(options.limit);
         const resolvedAppId = resolveAppId(appId, options);
         const client = new ApiClient();
+        const params = {};
+        if (limit !== undefined)
+            params.limit = limit;
+        if (options.cursor)
+            params.cursor = options.cursor;
+        if (options.search) {
+            const q = String(options.search).trim();
+            // ULID is exactly 26 chars from Crockford's base32 alphabet (excludes I,L,O,U).
+            // Match case-insensitively because users paste IDs from various sources.
+            const isUlid = /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(q);
+            if (isUlid)
+                params.userId = q;
+            else if (q.includes("@"))
+                params.email = q;
+            else
+                params.name = q;
+        }
         try {
-            const usersList = await client.listUsers(resolvedAppId);
+            const page = normalizeCliListEnvelope(await client.listUsers(resolvedAppId, params));
+            const usersList = page.items;
             if (options.json) {
-                json(usersList);
+                json(page);
                 return;
             }
             if (!usersList || usersList.length === 0) {
-                info("No users found.");
+                printEmptyPage(page, "users");
                 return;
             }
             console.log(formatTable(usersList, [
@@ -36,8 +64,96 @@ Examples:
                 { header: "EMAIL", key: "email" },
                 { header: "NAME", key: "name" },
                 { header: "ROLE", key: "role" },
+                // #2803 — a disabled user rendered exactly like an active one, so
+                // the list said nothing about the state the console could put them
+                // in. `disabled` reads plainly next to the role.
+                {
+                    header: "STATUS",
+                    key: "status",
+                    format: (value) => String(value || "active") === "disabled" ? "disabled" : "active",
+                },
                 { header: "ADDED", key: "addedAt", format: formatDate },
             ]));
+            printPageHint(page);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create user (add by email)
+    users
+        .command("create")
+        .description("Create a user in an app (or add an existing user by email)")
+        .argument("<email>", "Email address")
+        .option("--role <role>", "Role: admin or member", "member")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (email, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.addUserByEmail(resolvedAppId, {
+                email,
+                role: options.role,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(result.message || `User ${email} added.`);
+            if (result.userId)
+                keyValue("User ID", result.userId);
+            if (result.email)
+                keyValue("Email", result.email);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Mint test JWT
+    users
+        .command("mint-jwt")
+        .description("Mint a test JWT for a user (dev/test environments only)")
+        .argument("<user-id>", "User ID")
+        .option("--role <role>", "Role override for the JWT")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (userId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.mintTestJwt(resolvedAppId, userId, options.role);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("JWT minted.");
+            console.log(result.token);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Rebuild User._searchText (super-admin only)
+    users
+        .command("rebuild-search-text")
+        .description("Re-save every user in an app to repopulate User._searchText")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.rebuildUserSearchText(resolvedAppId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Reindexed ${result.count} user(s) in ${resolvedAppId}.`);
         }
         catch (err) {
             error(err.message);
@@ -54,6 +170,7 @@ Examples:
         .option("--role <role>", "Role: admin or member", "member")
         .option("--send-email", "Send invitation email")
         .option("--expires-days <days>", "Days until invitation expires", "7")
+        .option("--note <note>", "Personal note to include in the invitation email")
         .option("--json", "Output as JSON")
         .action(async (appIdOrEmail, emailOrUndefined, options) => {
         // Handle argument flexibility
@@ -79,11 +196,17 @@ Examples:
         }
         const client = new ApiClient();
         try {
+            // When inviting as admin, create the console admin first — the backend
+            // enforces the 3-admin limit (single source of truth)
+            if (options.role === "admin") {
+                await client.addAppAdmin(resolvedAppId, { adminEmail: email });
+            }
             const result = await client.createInvitation(resolvedAppId, {
                 email,
                 role: options.role,
                 expiresInDays: parseInt(options.expiresDays),
                 sendEmail: options.sendEmail || false,
+                ...(options.note ? { note: options.note } : {}),
             });
             if (options.json) {
                 json(result);
@@ -101,12 +224,13 @@ Examples:
     // Remove user
     users
         .command("remove")
-        .description("Remove a user from an app")
+        .description("(deprecated: use users disable) Remove a user's membership of an app. To block sign-in without removing them, use `users disable`.")
         .argument("[app-id]", "App ID (uses current app if not specified)")
         .argument("<user-id>", "User ID to remove")
         .option("--app <app-id>", "App ID")
         .option("-y, --yes", "Skip confirmation prompt")
         .action(async (appIdOrUserId, userIdOrUndefined, options) => {
+        warnDeprecated("primitive users remove", "`primitive users disable`", 518);
         // Handle argument flexibility
         let resolvedAppId;
         let userId;
@@ -123,15 +247,14 @@ Examples:
             process.exit(1);
         }
         if (!options.yes) {
-            const inquirer = await import("inquirer");
-            const { confirm } = await inquirer.default.prompt([
-                {
-                    type: "confirm",
-                    name: "confirm",
-                    message: `Remove user ${userId} from app?`,
-                    default: false,
-                },
-            ]);
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Remove user ${userId} from app?`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
             if (!confirm) {
                 info("Cancelled.");
                 return;
@@ -147,6 +270,89 @@ Examples:
             process.exit(1);
         }
     });
+    // #2803 — an app user could be disabled from the console but not from the
+    // CLI, and the console could not undo it. Both routes already existed; the
+    // operational control just was not reachable. Deliberately distinct from
+    // `users remove`, which detaches the membership: disabling blocks the
+    // person's auth in this app and is reversible.
+    users
+        .command("disable")
+        .description("Block a user from signing in to an app. Revokes their sessions and API tokens; reversible with `users enable`.")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .argument("<user-id>", "User ID to disable")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (appIdOrUserId, userIdOrUndefined, options) => {
+        let resolvedAppId;
+        let userId;
+        if (userIdOrUndefined) {
+            resolvedAppId = resolveAppId(appIdOrUserId, options);
+            userId = userIdOrUndefined;
+        }
+        else {
+            resolvedAppId = resolveAppId(undefined, options);
+            userId = appIdOrUserId;
+        }
+        if (!userId) {
+            error("User ID is required.");
+            process.exit(1);
+        }
+        if (!options.yes) {
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Disable user ${userId}? They will be signed out and unable to sign in.`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.setUserAvailability(resolvedAppId, userId, "disable");
+            success(`User ${userId} disabled.`);
+            info("Their membership is unchanged — `primitive users enable` restores access.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    users
+        .command("enable")
+        .description("Restore a disabled user's access to an app.")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .argument("<user-id>", "User ID to enable")
+        .option("--app <app-id>", "App ID")
+        .action(async (appIdOrUserId, userIdOrUndefined, options) => {
+        let resolvedAppId;
+        let userId;
+        if (userIdOrUndefined) {
+            resolvedAppId = resolveAppId(appIdOrUserId, options);
+            userId = userIdOrUndefined;
+        }
+        else {
+            resolvedAppId = resolveAppId(undefined, options);
+            userId = appIdOrUserId;
+        }
+        if (!userId) {
+            error("User ID is required.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            await client.setUserAvailability(resolvedAppId, userId, "enable");
+            success(`User ${userId} enabled.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
     // Set user role
     users
         .command("set-role")
@@ -218,15 +424,14 @@ Examples:
             process.exit(1);
         }
         if (!options.yes) {
-            const inquirer = await import("inquirer");
-            const { confirm } = await inquirer.default.prompt([
-                {
-                    type: "confirm",
-                    name: "confirm",
-                    message: `Transfer ownership of app to ${target}? This cannot be undone.`,
-                    default: false,
-                },
-            ]);
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Transfer ownership of app to ${target}? This cannot be undone.`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
             if (!confirm) {
                 info("Cancelled.");
                 return;
@@ -260,7 +465,8 @@ Examples:
         const resolvedAppId = resolveAppId(appId, options);
         const client = new ApiClient();
         try {
-            const invitations = await client.listInvitations(resolvedAppId);
+            const result = await client.listInvitations(resolvedAppId);
+            const invitations = result.items;
             if (options.json) {
                 json(invitations);
                 return;
@@ -281,5 +487,317 @@ Examples:
             process.exit(1);
         }
     });
+    // --- Console admins subcommands ---
+    const admins = users
+        .command("admins")
+        .description("Manage console admins for an app");
+    // List console admins
+    admins
+        .command("list")
+        .description("List console admins for an app")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const adminsList = await client.listAppAdmins(resolvedAppId);
+            if (options.json) {
+                json(wholeListEnvelope(adminsList));
+                return;
+            }
+            if (!adminsList || adminsList.length === 0) {
+                info("No console admins found.");
+                return;
+            }
+            console.log(formatTable(adminsList, [
+                { header: "ADMIN ID", key: "adminId", format: formatId },
+                { header: "EMAIL", key: "email" },
+                { header: "NAME", key: "name" },
+                { header: "ROLE", key: "role" },
+                { header: "ASSIGNED", key: "assignedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Add console admin
+    admins
+        .command("add")
+        .description("Add a console admin to an app (creates invitation if admin account doesn't exist)")
+        .argument("[app-id-or-email]", "App ID or admin email")
+        .argument("[email]", "Admin email address (if first arg is app ID)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (appIdOrEmail, emailOrUndefined, options) => {
+        let resolvedAppId;
+        let email;
+        if (emailOrUndefined && !emailOrUndefined.startsWith("-")) {
+            resolvedAppId = resolveAppId(appIdOrEmail, options);
+            email = emailOrUndefined;
+        }
+        else if (appIdOrEmail?.includes("@")) {
+            resolvedAppId = resolveAppId(undefined, options);
+            email = appIdOrEmail;
+        }
+        else {
+            resolvedAppId = resolveAppId(appIdOrEmail, options);
+            email = emailOrUndefined;
+        }
+        if (!email) {
+            error("Email is required.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.addAppAdmin(resolvedAppId, {
+                adminEmail: email,
+            });
+            // Also create an app-level invitation with role "admin"
+            try {
+                await client.createInvitation(resolvedAppId, {
+                    email,
+                    role: "admin",
+                    expiresInDays: 7,
+                    sendEmail: false,
+                });
+            }
+            catch {
+                // Non-fatal: console admin was created, app invitation may already exist
+            }
+            if (options.json) {
+                json(result);
+                return;
+            }
+            if (result.status === "invited") {
+                success(`Invitation sent to ${email}`);
+                if (result.invitation) {
+                    keyValue("Invitation ID", result.invitation.invitationId);
+                    if (result.invitation.expiresAt) {
+                        keyValue("Expires", formatDate(result.invitation.expiresAt));
+                    }
+                }
+            }
+            else {
+                success(result.message || `Admin ${email} added.`);
+                if (result.admin) {
+                    keyValue("Admin ID", result.admin.adminId);
+                }
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Remove console admin
+    admins
+        .command("remove")
+        .description("Remove a console admin from an app")
+        .argument("[app-id-or-admin-id]", "App ID or admin ID")
+        .argument("[admin-id]", "Admin ID (if first arg is app ID)")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (appIdOrAdminId, adminIdOrUndefined, options) => {
+        let resolvedAppId;
+        let adminId;
+        if (adminIdOrUndefined && !adminIdOrUndefined.startsWith("-")) {
+            resolvedAppId = resolveAppId(appIdOrAdminId, options);
+            adminId = adminIdOrUndefined;
+        }
+        else {
+            resolvedAppId = resolveAppId(undefined, options);
+            adminId = appIdOrAdminId;
+        }
+        if (!adminId) {
+            error("Admin ID is required.");
+            process.exit(1);
+        }
+        if (!options.yes) {
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Remove admin ${adminId} from app?`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.removeAppAdmin(resolvedAppId, adminId);
+            success(`Admin ${adminId} removed.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Transfer ownership
+    admins
+        .command("transfer-owner")
+        .description("Transfer app ownership to another admin")
+        .argument("[app-id-or-target]", "App ID or new owner's email/admin ID")
+        .argument("[email-or-admin-id]", "New owner's email or admin ID (if first arg is app ID)")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (appIdOrTarget, targetOrUndefined, options) => {
+        let resolvedAppId;
+        let target;
+        if (targetOrUndefined && !targetOrUndefined.startsWith("-")) {
+            resolvedAppId = resolveAppId(appIdOrTarget, options);
+            target = targetOrUndefined;
+        }
+        else {
+            resolvedAppId = resolveAppId(undefined, options);
+            target = appIdOrTarget;
+        }
+        if (!target) {
+            error("New owner email or admin ID is required.");
+            process.exit(1);
+        }
+        if (!options.yes) {
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Transfer ownership of app to ${target}? This cannot be undone.`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            if (target.includes("@")) {
+                await client.transferOwnership(resolvedAppId, target);
+            }
+            else {
+                await client.transferAdminOwnership(resolvedAppId, target);
+            }
+            success(`Ownership transferred to ${target}`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // --- Admin invitations subcommands ---
+    const adminInvitations = users
+        .command("admin-invitations")
+        .description("Manage console admin invitations for an app");
+    // List admin invitations
+    adminInvitations
+        .command("list")
+        .description("List pending console admin invitations")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const invitationsList = await client.listAppAdminInvitations(resolvedAppId);
+            if (options.json) {
+                json(wholeListEnvelope(invitationsList));
+                return;
+            }
+            if (!invitationsList || invitationsList.length === 0) {
+                info("No pending admin invitations.");
+                return;
+            }
+            console.log(formatTable(invitationsList, [
+                { header: "ID", key: "invitationId", format: formatId },
+                { header: "EMAIL", key: "email" },
+                { header: "ROLE", key: "role" },
+                { header: "INVITED", key: "invitedAt", format: formatDate },
+                { header: "EXPIRES", key: "expiresAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete admin invitation
+    adminInvitations
+        .command("delete")
+        .description("Delete a pending console admin invitation")
+        .argument("[app-id-or-inv-id]", "App ID or invitation ID")
+        .argument("[invitation-id]", "Invitation ID (if first arg is app ID)")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (appIdOrInvId, invIdOrUndefined, options) => {
+        let resolvedAppId;
+        let invitationId;
+        if (invIdOrUndefined && !invIdOrUndefined.startsWith("-")) {
+            resolvedAppId = resolveAppId(appIdOrInvId, options);
+            invitationId = invIdOrUndefined;
+        }
+        else {
+            resolvedAppId = resolveAppId(undefined, options);
+            invitationId = appIdOrInvId;
+        }
+        if (!invitationId) {
+            error("Invitation ID is required.");
+            process.exit(1);
+        }
+        if (!options.yes) {
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Delete admin invitation ${invitationId}?`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            // Look up the admin invitation's email before deleting, so we can cross-delete
+            let invEmail;
+            try {
+                const adminInvitations = await client.listAppAdminInvitations(resolvedAppId);
+                const match = adminInvitations.find((inv) => inv.invitationId === invitationId);
+                invEmail = match?.email;
+            }
+            catch {
+                // Non-fatal
+            }
+            await client.deleteAppAdminInvitation(resolvedAppId, invitationId);
+            // Cross-delete matching app-level invitations by email
+            if (invEmail) {
+                try {
+                    const appInvitations = await client.listInvitations(resolvedAppId);
+                    const matching = appInvitations.items.filter((inv) => inv.email === invEmail && !inv.accepted);
+                    for (const inv of matching) {
+                        await client.deleteInvitation(resolvedAppId, inv.invitationId);
+                    }
+                }
+                catch {
+                    // Non-fatal
+                }
+            }
+            success(`Invitation ${invitationId} deleted.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
 }
 //# sourceMappingURL=users.js.map