sentron-cli 1.0.23 → 1.0.24

package/dist/commands/org.js

@@ -0,0 +1,1406 @@
+/**
+ * Organization Commands
+ */
+import * as crypto from 'crypto';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { api } from '../api.js';
+import { getStoredToken } from '../utils/storage.js';
+import { printSection, printSuccess, printError, printErrorWithAction, printInfo, printBox, printLoading, printLoadingComplete, printLoadingError, printPrompt, brand, } from '../utils/styling.js';
+/**
+ * Prompt for input
+ */
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export function setupOrgCommands(program) {
+    const orgCmd = program
+        .command('org')
+        .alias('organization')
+        .description('Manage organizations');
+    // List organizations
+    orgCmd
+        .command('list')
+        .alias('ls')
+        .description('List your organizations')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching organizations');
+            const orgs = await api.organizations.list();
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(orgs, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Organizations');
+                if (orgs.length === 0) {
+                    printInfo('No organizations found. Create one with "sentron org create"');
+                }
+                else {
+                    orgs.forEach((org) => {
+                        printBox([
+                            `Name:      ${brand.accent(org.name)}`,
+                            `Slug:      ${org.slug}`,
+                            `Role:      ${org.role}`,
+                            `Members:   ${org.memberCount}`,
+                            `Apps:      ${org.appCount}`,
+                            org.description ? `Desc:      ${org.description}` : '',
+                            `ID:        ${brand.muted(org.id)}`,
+                        ].filter(Boolean));
+                        console.log();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to list organizations');
+            process.exit(1);
+        }
+    });
+    // Create organization
+    orgCmd
+        .command('create')
+        .description('Create a new organization (slug is auto-generated from name)')
+        .option('-n, --name <name>', 'Organization name')
+        .option('-d, --description <description>', 'Organization description')
+        .action(async (options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const rawName = options.name || await prompt(printPrompt('Organization Name'));
+            const name = rawName?.trim();
+            if (!name) {
+                printError('Name is required and cannot be empty or whitespace only');
+                process.exit(1);
+            }
+            printLoading('Creating organization');
+            const org = await api.organizations.create({
+                name,
+                description: options.description,
+            });
+            printLoadingComplete();
+            console.log();
+            printSection('Organization Created');
+            printBox([
+                `Name:  ${brand.accent(org.name)}`,
+                `Slug:  ${org.slug}`,
+                `URL:   sentron.dev/organizations/${org.slug}`,
+                `ID:    ${brand.muted(org.id)}`,
+            ]);
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create organization');
+            process.exit(1);
+        }
+    });
+    // Get organization details
+    orgCmd
+        .command('get <id>')
+        .alias('show')
+        .description('Get organization details (accepts UUID or slug)')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching organization');
+            const org = await api.organizations.get(id);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(org, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Organization Details');
+                printBox([
+                    `Name:       ${brand.accent(org.name)}`,
+                    `Slug:       ${org.slug}`,
+                    org.description ? `Desc:       ${org.description}` : '',
+                    org.website ? `Website:    ${org.website}` : '',
+                    `Billing:    ${org.billingStatus}`,
+                    `Members:    ${org.memberCount}`,
+                    `Apps:       ${org.appCount}`,
+                    `Created:    ${new Date(org.createdAt).toLocaleDateString()}`,
+                    `ID:         ${brand.muted(org.id)}`,
+                ].filter(Boolean));
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printErrorWithAction(error, 'Failed to get organization');
+            process.exit(1);
+        }
+    });
+    // Update organization
+    orgCmd
+        .command('update <id>')
+        .description('Update organization details')
+        .option('-n, --name <name>', 'New name')
+        .option('-d, --description <description>', 'New description')
+        .option('-w, --website <website>', 'New website')
+        .action(async (id, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            if (!options.name && !options.description && !options.website) {
+                printError('At least one field to update is required');
+                process.exit(1);
+            }
+            printLoading('Updating organization');
+            const org = await api.organizations.update(id, {
+                name: options.name,
+                description: options.description,
+                website: options.website,
+            });
+            printLoadingComplete();
+            console.log();
+            printSection('Organization Updated');
+            printSuccess(`Updated: ${org.name}`);
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to update organization');
+            process.exit(1);
+        }
+    });
+    // Delete organization
+    orgCmd
+        .command('delete <id>')
+        .description('Delete an organization')
+        .option('-f, --force', 'Skip confirmation')
+        .action(async (id, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            if (!options.force) {
+                const confirm = await prompt(printPrompt('Type "DELETE" to confirm'));
+                if (confirm !== 'DELETE') {
+                    printInfo('Cancelled');
+                    return;
+                }
+            }
+            printLoading('Deleting organization');
+            await api.organizations.delete(id);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Organization deleted successfully');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to delete organization');
+            process.exit(1);
+        }
+    });
+    // Members subcommand
+    const membersCmd = orgCmd
+        .command('members')
+        .description('Manage organization members');
+    // List members
+    membersCmd
+        .command('list <orgId>')
+        .alias('ls')
+        .description('List organization members')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching members');
+            const members = await api.organizations.listMembers(orgId);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(members, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Organization Members');
+                if (members.length === 0) {
+                    printInfo('No members found');
+                }
+                else {
+                    members.forEach((member) => {
+                        const name = [member.firstName, member.lastName].filter(Boolean).join(' ') || 'N/A';
+                        printBox([
+                            `Email:   ${member.email}`,
+                            `Name:    ${name}`,
+                            `Role:    ${brand.accent(member.role)}`,
+                            `Joined:  ${new Date(member.joinedAt).toLocaleDateString()}`,
+                            `ID:      ${brand.muted(member.userId)}`,
+                        ]);
+                        console.log();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printErrorWithAction(error, 'Failed to list members');
+            process.exit(1);
+        }
+    });
+    // Update member role
+    membersCmd
+        .command('update-role <orgId> <userId> <role>')
+        .description('Update member role (owner, admin, manager, member)')
+        .action(async (orgId, userId, role) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const validRoles = ['owner', 'admin', 'manager', 'member'];
+            if (!validRoles.includes(role)) {
+                printError(`Invalid role. Must be one of: ${validRoles.join(', ')}`);
+                process.exit(1);
+            }
+            printLoading('Updating member role');
+            await api.organizations.updateMemberRole(orgId, userId, role);
+            printLoadingComplete();
+            console.log();
+            printSuccess(`Member role updated to: ${role}`);
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printErrorWithAction(error, 'Failed to update member role');
+            process.exit(1);
+        }
+    });
+    // Remove member
+    membersCmd
+        .command('remove <orgId> <userId>')
+        .description('Remove a member from the organization')
+        .action(async (orgId, userId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Removing member');
+            await api.organizations.removeMember(orgId, userId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Member removed successfully');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to remove member');
+            process.exit(1);
+        }
+    });
+    // Invitations subcommand
+    const invitesCmd = orgCmd
+        .command('invites')
+        .alias('invitations')
+        .description('Manage organization invitations');
+    // List invitations
+    invitesCmd
+        .command('list <orgId>')
+        .alias('ls')
+        .description('List pending invitations')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching invitations');
+            const invites = await api.organizations.listInvitations(orgId);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(invites, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Invitations');
+                if (invites.length === 0) {
+                    printInfo('No pending invitations');
+                }
+                else {
+                    invites.forEach((inv) => {
+                        printBox([
+                            `Email:    ${inv.email}`,
+                            `Role:     ${inv.role}`,
+                            `Status:   ${inv.status}`,
+                            `Expires:  ${new Date(inv.expiresAt).toLocaleDateString()}`,
+                            `ID:       ${brand.muted(inv.id)}`,
+                        ]);
+                        console.log();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to list invitations');
+            process.exit(1);
+        }
+    });
+    // Create invitation
+    invitesCmd
+        .command('create <orgId>')
+        .description('Invite someone to the organization')
+        .option('-e, --email <email>', 'Email to invite')
+        .option('-r, --role <role>', 'Role to assign (default: member)')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const email = options.email || await prompt(printPrompt('Email to invite'));
+            if (!email) {
+                printError('Email is required');
+                process.exit(1);
+            }
+            printLoading('Creating invitation');
+            const inv = await api.organizations.createInvitation(orgId, email, options.role);
+            printLoadingComplete();
+            console.log();
+            printSection('Invitation Sent');
+            printBox([
+                `Email:    ${inv.email}`,
+                `Role:     ${inv.role}`,
+                `Expires:  ${new Date(inv.expiresAt).toLocaleDateString()}`,
+            ]);
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create invitation');
+            process.exit(1);
+        }
+    });
+    // Batch invite
+    invitesCmd
+        .command('batch <orgId>')
+        .description('Invite multiple people to the organization (max 50)')
+        .option('-e, --emails <emails>', 'Comma-separated list of emails')
+        .option('-f, --file <path>', 'CSV file with columns: email,role')
+        .option('-r, --role <role>', 'Default role for all (admin, manager, member)', 'member')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            // Validate role
+            const validRoles = ['admin', 'manager', 'member'];
+            if (!validRoles.includes(options.role)) {
+                printError(`Invalid role. Must be one of: ${validRoles.join(', ')}`);
+                process.exit(1);
+            }
+            // Get invitations from either --emails or --file
+            let invitations = [];
+            if (options.file) {
+                // Read from CSV file
+                const filePath = path.resolve(options.file);
+                if (!fs.existsSync(filePath)) {
+                    printError(`File not found: ${options.file}`);
+                    process.exit(1);
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const lines = content.trim().split('\n');
+                // Check if first line is header
+                const firstLine = lines[0].toLowerCase();
+                const hasHeader = firstLine.includes('email') || firstLine.includes('role');
+                const dataLines = hasHeader ? lines.slice(1) : lines;
+                for (const line of dataLines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    const parts = trimmed.split(',').map(s => s.trim());
+                    const email = parts[0];
+                    const role = parts[1] || options.role;
+                    if (!email)
+                        continue;
+                    if (!validRoles.includes(role)) {
+                        printError(`Invalid role "${role}" for email ${email}. Must be one of: ${validRoles.join(', ')}`);
+                        process.exit(1);
+                    }
+                    invitations.push({ email, role });
+                }
+            }
+            else if (options.emails) {
+                // Parse from comma-separated string
+                const emails = options.emails.split(',').map((e) => e.trim()).filter(Boolean);
+                invitations = emails.map((email) => ({ email, role: options.role }));
+            }
+            else {
+                // Interactive mode - prompt for emails
+                const input = await prompt(printPrompt('Enter emails (comma-separated)'));
+                if (!input) {
+                    printError('No emails provided');
+                    process.exit(1);
+                }
+                const emails = input.split(',').map(e => e.trim()).filter(Boolean);
+                invitations = emails.map(email => ({ email, role: options.role }));
+            }
+            if (invitations.length === 0) {
+                printError('No invitations to send');
+                process.exit(1);
+            }
+            if (invitations.length > 50) {
+                printError('Maximum 50 invitations per batch. Split into multiple batches.');
+                process.exit(1);
+            }
+            printLoading(`Creating ${invitations.length} invitation(s)`);
+            const result = await api.organizations.batchInvite(orgId, invitations);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Batch Invite Results');
+                // Summary
+                printBox([
+                    `Total:      ${result.summary.total}`,
+                    `Successful: ${brand.success(result.summary.successful.toString())}`,
+                    `Failed:     ${result.summary.failed > 0 ? brand.error(result.summary.failed.toString()) : result.summary.failed}`,
+                ]);
+                // Show failures if any
+                if (result.failed.length > 0) {
+                    console.log();
+                    printSection('Failed Invitations');
+                    for (const failed of result.failed) {
+                        console.log(`  ${brand.error('✗')} ${failed.email}`);
+                        console.log(`    ${brand.muted(failed.error?.message || 'Unknown error')}`);
+                    }
+                }
+                // Show successes
+                if (result.created.length > 0) {
+                    console.log();
+                    printSection('Invitations Sent');
+                    for (const created of result.created) {
+                        console.log(`  ${brand.success('✓')} ${created.email}`);
+                    }
+                }
+                console.log();
+                printInfo(`Run "sentron org invites list ${orgId}" to see all pending invitations`);
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create batch invitations');
+            process.exit(1);
+        }
+    });
+    // Cancel invitation
+    invitesCmd
+        .command('cancel <orgId> <invitationId>')
+        .description('Cancel a pending invitation')
+        .action(async (orgId, invitationId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Cancelling invitation');
+            await api.organizations.cancelInvitation(orgId, invitationId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Invitation cancelled');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to cancel invitation');
+            process.exit(1);
+        }
+    });
+    // Resend invitation
+    invitesCmd
+        .command('resend <orgId> <invitationId>')
+        .description('Resend a pending invitation (resets expiration)')
+        .action(async (orgId, invitationId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Resending invitation');
+            await api.organizations.resendInvitation(orgId, invitationId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Invitation resent');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to resend invitation');
+            process.exit(1);
+        }
+    });
+    // Join requests subcommand
+    const requestsCmd = orgCmd
+        .command('requests')
+        .alias('join-requests')
+        .description('Manage join requests');
+    // List join requests
+    requestsCmd
+        .command('list <orgId>')
+        .alias('ls')
+        .description('List pending join requests')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching join requests');
+            const requests = await api.organizations.listJoinRequests(orgId);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(requests, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Join Requests');
+                if (requests.length === 0) {
+                    printInfo('No pending join requests');
+                }
+                else {
+                    requests.forEach((req) => {
+                        printBox([
+                            `Email:    ${req.email}`,
+                            `Status:   ${req.status}`,
+                            req.message ? `Message:  ${req.message}` : '',
+                            `Created:  ${new Date(req.createdAt).toLocaleDateString()}`,
+                            `ID:       ${brand.muted(req.id)}`,
+                        ].filter(Boolean));
+                        console.log();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to list join requests');
+            process.exit(1);
+        }
+    });
+    // Approve join request
+    requestsCmd
+        .command('approve <orgId> <requestId>')
+        .description('Approve a join request')
+        .action(async (orgId, requestId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Approving join request');
+            await api.organizations.handleJoinRequest(orgId, requestId, 'approve');
+            printLoadingComplete();
+            console.log();
+            printSuccess('Join request approved');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to approve join request');
+            process.exit(1);
+        }
+    });
+    // Reject join request
+    requestsCmd
+        .command('reject <orgId> <requestId>')
+        .description('Reject a join request')
+        .action(async (orgId, requestId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Rejecting join request');
+            await api.organizations.handleJoinRequest(orgId, requestId, 'reject');
+            printLoadingComplete();
+            console.log();
+            printSuccess('Join request rejected');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to reject join request');
+            process.exit(1);
+        }
+    });
+    // Create join request
+    requestsCmd
+        .command('create <orgId>')
+        .description('Request to join an organization')
+        .option('-m, --message <message>', 'Optional message with the request')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Submitting join request');
+            const request = await api.organizations.createJoinRequest(orgId, options.message);
+            printLoadingComplete();
+            console.log();
+            printSection('Join Request Submitted');
+            printSuccess(`Status: ${request.status}`);
+            printInfo('An admin will review your request');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create join request');
+            process.exit(1);
+        }
+    });
+    // Transfer ownership
+    orgCmd
+        .command('transfer <orgId> <newOwnerId>')
+        .description('Transfer organization ownership to another member')
+        .option('-f, --force', 'Skip confirmation')
+        .action(async (orgId, newOwnerId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            if (!options.force) {
+                const confirm = await prompt(printPrompt('Type "TRANSFER" to confirm'));
+                if (confirm !== 'TRANSFER') {
+                    printInfo('Cancelled');
+                    return;
+                }
+            }
+            printLoading('Transferring ownership');
+            await api.organizations.transfer(orgId, newOwnerId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Ownership transferred successfully');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to transfer ownership');
+            process.exit(1);
+        }
+    });
+    // Billing subcommand
+    const billingCmd = orgCmd
+        .command('billing')
+        .description('Manage organization billing');
+    // Get billing status
+    billingCmd
+        .command('status <orgId>')
+        .alias('get')
+        .description('Get billing status')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching billing status');
+            const status = await api.organizations.getBillingStatus(orgId);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(status, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Billing Status');
+                printBox([
+                    `Status:           ${status.billingStatus === 'active' ? brand.success('Active') : status.billingStatus === 'past_due' ? brand.error('Past Due') : status.billingStatus === 'canceled' ? brand.error('Canceled') : brand.muted('No subscription')}`,
+                    `Payment Method:   ${status.hasPaymentMethod ? brand.success('Yes') : brand.muted('No')}`,
+                    status.stripeCustomerId ? `Stripe Customer:  ${brand.muted(status.stripeCustomerId)}` : '',
+                ].filter(Boolean));
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to get billing status');
+            process.exit(1);
+        }
+    });
+    // Add payment method (get checkout URL)
+    billingCmd
+        .command('add-payment <orgId>')
+        .description('Get URL to add payment method')
+        .action(async (orgId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Creating checkout session');
+            const result = await api.organizations.createCheckoutSession(orgId, 'https://sentron.dev/billing/success', 'https://sentron.dev/billing/cancel');
+            printLoadingComplete();
+            console.log();
+            printSection('Add Payment Method');
+            printInfo('Open this URL to add a payment method:');
+            console.log();
+            console.log(`  ${brand.accent(result.url)}`);
+            console.log();
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create checkout session');
+            process.exit(1);
+        }
+    });
+    // Manage billing (get portal URL)
+    billingCmd
+        .command('portal <orgId>')
+        .alias('manage')
+        .description('Get URL to billing portal')
+        .action(async (orgId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Creating portal session');
+            const result = await api.organizations.createPortalSession(orgId, 'https://sentron.dev/organizations');
+            printLoadingComplete();
+            console.log();
+            printSection('Billing Portal');
+            printInfo('Open this URL to manage billing:');
+            console.log();
+            console.log(`  ${brand.accent(result.url)}`);
+            console.log();
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create portal session');
+            process.exit(1);
+        }
+    });
+    // Get subscription for app type
+    billingCmd
+        .command('subscription <orgId> <appType>')
+        .alias('sub')
+        .description('Get subscription details for an app type')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, appType, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching subscription');
+            const sub = await api.organizations.getSubscription(orgId, appType);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(sub, null, 2));
+            }
+            else {
+                console.log();
+                printSection(`${sub.appTypeDisplayName} Subscription`);
+                printBox([
+                    `Tier:         ${brand.accent(sub.tierDisplayName)} (${sub.tier})`,
+                    `Status:       ${sub.status === 'active' ? brand.success('Active') : sub.status === 'past_due' ? brand.error('Past Due') : brand.muted(sub.status)}`,
+                    `Interval:     ${sub.billingInterval || 'N/A'}`,
+                    sub.currentPeriodEnd ? `Renews:       ${new Date(sub.currentPeriodEnd).toLocaleDateString()}` : '',
+                    sub.cancelAtPeriodEnd ? `Cancels:      At period end` : '',
+                    '',
+                    `App Limit:    ${sub.currentUsage.apps} / ${sub.enforcedLimits.apps ?? '∞'}`,
+                    '',
+                    `Features:     ${sub.features.join(', ')}`,
+                ].filter(line => line !== ''));
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to get subscription');
+            process.exit(1);
+        }
+    });
+    // Subscribe to a tier
+    billingCmd
+        .command('subscribe <orgId> <appType> <tier>')
+        .description('Subscribe to a paid tier (starter, team, platform)')
+        .option('-i, --interval <interval>', 'Billing interval (monthly, annual)', 'annual')
+        .action(async (orgId, appType, tier, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const validTiers = ['starter', 'team', 'platform'];
+            if (!validTiers.includes(tier)) {
+                printError(`Invalid tier. Must be one of: ${validTiers.join(', ')}`);
+                process.exit(1);
+            }
+            const validIntervals = ['monthly', 'annual'];
+            if (!validIntervals.includes(options.interval)) {
+                printError(`Invalid interval. Must be one of: ${validIntervals.join(', ')}`);
+                process.exit(1);
+            }
+            printLoading('Creating checkout session');
+            const requestId = crypto.randomUUID();
+            const result = await api.organizations.subscribe(orgId, appType, tier, options.interval, 'https://sentron.dev/billing/success', 'https://sentron.dev/billing/cancel', requestId);
+            printLoadingComplete();
+            console.log();
+            printSection('Subscribe');
+            printInfo('Open this URL to complete your subscription:');
+            console.log();
+            console.log(`  ${brand.accent(result.checkoutUrl)}`);
+            console.log();
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to create checkout session');
+            process.exit(1);
+        }
+    });
+    // Preview plan change
+    billingCmd
+        .command('preview <orgId> <appType> <tier>')
+        .description('Preview what happens when you change plans')
+        .option('-i, --interval <interval>', 'Billing interval (monthly, annual)', 'annual')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, appType, tier, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const validTiers = ['starter', 'team', 'platform'];
+            if (!validTiers.includes(tier)) {
+                printError(`Invalid tier. Must be one of: ${validTiers.join(', ')}`);
+                process.exit(1);
+            }
+            printLoading('Calculating preview');
+            const preview = await api.organizations.previewPlanChange(orgId, appType, tier, options.interval);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(preview, null, 2));
+            }
+            else {
+                console.log();
+                printSection('Plan Change Preview');
+                const formatPrice = (cents) => `$${(cents / 100).toFixed(2)}`;
+                const direction = preview.isUpgrade ? brand.success('↑ UPGRADE') : brand.error('↓ DOWNGRADE');
+                printBox([
+                    `${preview.currentTier} → ${preview.newTier}  ${direction}`,
+                    ``,
+                    `Current Price:   ${formatPrice(preview.currentPrice)} / ${preview.currentInterval || 'month'}`,
+                    `New Price:       ${formatPrice(preview.newPrice)} / ${preview.newInterval}`,
+                    ``,
+                    preview.proratedAmount > 0
+                        ? `Amount Due Now:  ${brand.accent(formatPrice(preview.proratedAmount))}`
+                        : preview.proratedAmount < 0
+                            ? `Credit Applied:  ${brand.success(formatPrice(Math.abs(preview.proratedAmount)))}`
+                            : `Amount Due Now:  ${brand.muted('$0.00')}`,
+                    ``,
+                    `Effective:       ${new Date(preview.effectiveDate).toLocaleDateString()}`,
+                    `Next Billing:    ${new Date(preview.nextBillingDate).toLocaleDateString()}`,
+                ]);
+                console.log();
+                printInfo('To apply this change, run:');
+                console.log(`  sentron org billing change ${orgId} ${appType} ${tier} -i ${options.interval}`);
+                console.log();
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to preview plan change');
+            process.exit(1);
+        }
+    });
+    // Confirm plan change
+    billingCmd
+        .command('change <orgId> <appType> <tier>')
+        .description('Change your plan (upgrade or downgrade)')
+        .option('-i, --interval <interval>', 'Billing interval (monthly, annual)', 'annual')
+        .option('-f, --force', 'Skip confirmation')
+        .action(async (orgId, appType, tier, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            const validTiers = ['starter', 'team', 'platform'];
+            if (!validTiers.includes(tier)) {
+                printError(`Invalid tier. Must be one of: ${validTiers.join(', ')}`);
+                process.exit(1);
+            }
+            // Show preview first
+            printLoading('Calculating preview');
+            const preview = await api.organizations.previewPlanChange(orgId, appType, tier, options.interval);
+            printLoadingComplete();
+            console.log();
+            const formatPrice = (cents) => `$${(cents / 100).toFixed(2)}`;
+            printSection('Plan Change');
+            printInfo(`${preview.currentTier} → ${preview.newTier}`);
+            if (preview.proratedAmount > 0) {
+                printInfo(`You will be charged ${brand.accent(formatPrice(preview.proratedAmount))} now`);
+            }
+            else if (preview.proratedAmount < 0) {
+                printInfo(`You will receive a ${brand.success(formatPrice(Math.abs(preview.proratedAmount)))} credit`);
+            }
+            console.log();
+            if (!options.force) {
+                const confirm = await prompt(printPrompt('Type "CONFIRM" to proceed'));
+                if (confirm !== 'CONFIRM') {
+                    printInfo('Cancelled');
+                    return;
+                }
+            }
+            printLoading('Changing plan');
+            const requestId = crypto.randomUUID();
+            const result = await api.organizations.confirmPlanChange(orgId, appType, tier, options.interval, requestId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Plan changed successfully!');
+            printBox([
+                `New Tier:     ${brand.accent(result.subscription.tier)}`,
+                `Status:       ${result.subscription.status}`,
+                `Interval:     ${result.subscription.billingInterval}`,
+                result.chargedAmount > 0 ? `Charged:      ${formatPrice(result.chargedAmount)}` : '',
+                result.creditAmount > 0 ? `Credit:       ${formatPrice(result.creditAmount)}` : '',
+            ].filter(Boolean));
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to change plan');
+            process.exit(1);
+        }
+    });
+    // Cancel subscription
+    billingCmd
+        .command('cancel <orgId> <appType>')
+        .description('Cancel a subscription (keeps access until end of billing period)')
+        .option('--immediate', 'Cancel immediately with prorated refund')
+        .option('--force', 'Skip confirmation prompt')
+        .action(async (orgId, appType, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            // Get current subscription first
+            printLoading('Fetching subscription');
+            const sub = await api.organizations.getSubscription(orgId, appType);
+            printLoadingComplete();
+            if (sub.tier === 'free') {
+                printError('Already on free tier');
+                process.exit(1);
+            }
+            console.log();
+            printSection('Cancel Subscription');
+            printInfo(`Current tier: ${brand.accent(sub.tier)}`);
+            if (options.immediate) {
+                printInfo('Mode: Immediate cancellation with prorated refund');
+            }
+            else {
+                printInfo(`Mode: Cancel at end of period (${sub.currentPeriodEnd ? new Date(sub.currentPeriodEnd).toLocaleDateString() : 'end of period'})`);
+            }
+            console.log();
+            if (!options.force) {
+                const confirm = await prompt(printPrompt('Type "CANCEL" to confirm'));
+                if (confirm !== 'CANCEL') {
+                    printInfo('Cancelled');
+                    return;
+                }
+            }
+            printLoading('Cancelling subscription');
+            const result = await api.organizations.cancelSubscription(orgId, appType, options.immediate || false);
+            printLoadingComplete();
+            console.log();
+            if (options.immediate) {
+                printSuccess('Subscription cancelled immediately');
+                printInfo('Prorated refund will be applied to your account');
+            }
+            else {
+                printSuccess('Subscription set to cancel');
+                printInfo(`You will keep access until ${new Date(result.effectiveDate).toLocaleDateString()}`);
+                printInfo('You can reactivate anytime before that date');
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to cancel subscription');
+            process.exit(1);
+        }
+    });
+    // Reactivate subscription
+    billingCmd
+        .command('reactivate <orgId> <appType>')
+        .description('Reactivate a subscription that was set to cancel')
+        .action(async (orgId, appType) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Reactivating subscription');
+            await api.organizations.reactivateSubscription(orgId, appType);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Subscription reactivated!');
+            printInfo('Pending cancellation has been removed');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to reactivate subscription');
+            process.exit(1);
+        }
+    });
+    // Check if can create app
+    billingCmd
+        .command('can-create-app <orgId> <appType>')
+        .description('Check if you can create a new app (tier limits)')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, appType, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Checking limits');
+            const result = await api.organizations.canCreateApp(orgId, appType);
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log();
+                if (result.allowed) {
+                    printSuccess('✓ You can create a new app');
+                }
+                else {
+                    printError('✗ App limit reached');
+                    printInfo(`Current: ${result.current} / ${result.limit}`);
+                    printInfo(`Reason: ${result.reason}`);
+                    if (result.upgradeUrl) {
+                        printInfo(`Upgrade: ${result.upgradeUrl}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to check limits');
+            process.exit(1);
+        }
+    });
+    // Default billing action - show status
+    billingCmd
+        .action(async () => {
+        console.log();
+        printSection('Billing Commands');
+        printInfo('Usage: sentron org billing <command> <orgId> [options]');
+        console.log();
+        printInfo('General:');
+        printInfo('  status <orgId>                    Get billing status');
+        printInfo('  add-payment <orgId>               Get URL to add payment method');
+        printInfo('  portal <orgId>                    Get URL to billing portal');
+        console.log();
+        printInfo('Subscriptions (per app type):');
+        printInfo('  subscription <orgId> <appType>    Get subscription details');
+        printInfo('  subscribe <orgId> <appType> <tier>  Subscribe to a tier');
+        printInfo('  preview <orgId> <appType> <tier>  Preview plan change');
+        printInfo('  change <orgId> <appType> <tier>   Change plan (upgrade/downgrade)');
+        console.log();
+        printInfo('Limits:');
+        printInfo('  can-create-app <orgId> <appType>      Check app creation limit');
+        console.log();
+        printInfo('Tiers: free, starter, team, platform');
+        printInfo('App Types: data_studio');
+        console.log();
+    });
+    // Logo subcommand
+    const logoCmd = orgCmd
+        .command('logo')
+        .description('Manage organization logo');
+    // Upload logo
+    logoCmd
+        .command('upload <orgId> <filepath>')
+        .description('Upload a logo for the organization')
+        .action(async (orgId, filepath) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            // Resolve and validate file path
+            const absolutePath = path.resolve(filepath);
+            if (!fs.existsSync(absolutePath)) {
+                printError(`File not found: ${filepath}`);
+                process.exit(1);
+            }
+            // Check file size (2MB max)
+            const stats = fs.statSync(absolutePath);
+            if (stats.size > 2 * 1024 * 1024) {
+                printError('File too large. Maximum size is 2MB');
+                process.exit(1);
+            }
+            // Check file extension
+            const ext = path.extname(filepath).toLowerCase();
+            const validExts = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'];
+            if (!validExts.includes(ext)) {
+                printError(`Invalid file type. Supported: ${validExts.join(', ')}`);
+                process.exit(1);
+            }
+            printLoading('Uploading logo');
+            const result = await api.organizations.uploadLogo(orgId, absolutePath);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Logo uploaded successfully');
+            if (result.logoUrl) {
+                printInfo(`Logo URL: ${brand.muted(result.logoUrl.substring(0, 50) + '...')}`);
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to upload logo');
+            process.exit(1);
+        }
+    });
+    // Remove logo
+    logoCmd
+        .command('remove <orgId>')
+        .alias('delete')
+        .description('Remove the organization logo')
+        .action(async (orgId) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Removing logo');
+            await api.organizations.removeLogo(orgId);
+            printLoadingComplete();
+            console.log();
+            printSuccess('Logo removed successfully');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to remove logo');
+            process.exit(1);
+        }
+    });
+    // Default logo action
+    logoCmd
+        .action(() => {
+        console.log();
+        printSection('Logo Commands');
+        printInfo('Usage: sentron org logo <command> <orgId>');
+        console.log();
+        printInfo('Commands:');
+        printInfo('  upload <orgId> <filepath>  Upload a logo image');
+        printInfo('  remove <orgId>             Remove the logo');
+        console.log();
+    });
+    // Default action - list organizations
+    orgCmd
+        .action(async () => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching organizations');
+            const orgs = await api.organizations.list();
+            printLoadingComplete();
+            console.log();
+            printSection('Your Organizations');
+            if (orgs.length === 0) {
+                printInfo('No organizations found. Create one with "sentron org create"');
+            }
+            else {
+                orgs.forEach((org) => {
+                    printBox([
+                        `Name:      ${brand.accent(org.name)}`,
+                        `Slug:      ${org.slug}`,
+                        `Role:      ${org.role}`,
+                        `Members:   ${org.memberCount}`,
+                        `Apps:      ${org.appCount}`,
+                    ]);
+                    console.log();
+                });
+            }
+            console.log();
+            printInfo('Run "sentron org --help" for more commands');
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            printError(error instanceof Error ? error.message : 'Failed to list organizations');
+            process.exit(1);
+        }
+    });
+    // ============================================================================
+    // AUDIT LOGS
+    // ============================================================================
+    const auditCmd = orgCmd
+        .command('audit-logs')
+        .alias('activity')
+        .description('View organization activity logs');
+    auditCmd
+        .command('list <orgId>')
+        .alias('ls')
+        .description('List audit logs for an organization')
+        .option('--limit <number>', 'Number of logs to return (default 50, max 100)', '50')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--action <action>', 'Filter by action type (e.g., org.member.added)')
+        .option('--user <userId>', 'Filter by actor user ID')
+        .option('--from <date>', 'Filter from date (ISO 8601 format)')
+        .option('--to <date>', 'Filter to date (ISO 8601 format)')
+        .option('--json', 'Output as JSON')
+        .action(async (orgId, options) => {
+        try {
+            const token = await getStoredToken();
+            if (!token) {
+                printError('Not signed in. Run "sentron auth signin" first.');
+                process.exit(1);
+            }
+            printLoading('Fetching audit logs');
+            const logs = await api.organizations.listAuditLogs(orgId, {
+                limit: parseInt(options.limit, 10),
+                offset: parseInt(options.offset, 10),
+                action: options.action,
+                userId: options.user,
+                startDate: options.from,
+                endDate: options.to,
+            });
+            printLoadingComplete();
+            if (options.json) {
+                console.log(JSON.stringify(logs, null, 2));
+                return;
+            }
+            console.log();
+            printSection('Audit Logs');
+            if (logs.length === 0) {
+                printInfo('No audit logs found matching your criteria.');
+            }
+            else {
+                logs.forEach((log) => {
+                    const date = new Date(log.createdAt).toLocaleString();
+                    const action = formatAuditAction(log.action);
+                    const resource = log.resourceType + (log.resourceId ? ` (${log.resourceId.substring(0, 8)}...)` : '');
+                    printBox([
+                        `Action:    ${brand.accent(action)}`,
+                        `Resource:  ${resource}`,
+                        `Actor:     ${log.userId.substring(0, 12)}...`,
+                        `Date:      ${date}`,
+                        log.metadata ? `Details:   ${JSON.stringify(log.metadata)}` : null,
+                    ].filter(Boolean));
+                    console.log();
+                });
+            }
+        }
+        catch (error) {
+            printLoadingError();
+            console.log();
+            if (error.action) {
+                printErrorWithAction(error.message, error.action);
+            }
+            else {
+                printError(error.message || 'Failed to fetch audit logs');
+            }
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Format audit action for display
+ */
+function formatAuditAction(action) {
+    // Convert action like "org.member.added" to "Member Added"
+    const parts = action.split('.');
+    if (parts.length >= 2) {
+        const subject = parts[parts.length - 2];
+        const verb = parts[parts.length - 1];
+        return `${capitalize(subject)} ${capitalize(verb)}`;
+    }
+    return action;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//# sourceMappingURL=org.js.map