@mod-computer/cli 0.1.0 → 0.2.1

package/dist/commands/members.js

@@ -0,0 +1,687 @@
+// glassware[type="implementation", id="impl-cli-members-command--9bf91cf6", specifications="specification-spec-cli-members-list--16a2b152,specification-spec-cli-members-invite--1f4fbec5,specification-spec-cli-members-invite-role--09fe52ee,specification-spec-cli-members-remove--f5ff40de,specification-spec-cli-members-leave--9e394f51,specification-spec-cli-members-persist--e2cb6ec5"]
+// spec: packages/mod-cli/specs/members.md
+import { MemberService, createModUser } from '@mod/mod-core';
+import { readWorkspaceConnection, readConfig, writeConfig, } from '../lib/storage.js';
+import { confirm } from '../lib/prompts.js';
+import { fetchAuthProfile } from './auth.js';
+const AUTH_WORKER_URL = process.env.MOD_AUTH_WORKER_URL || 'https://auth.mod.dev';
+// glassware[type="implementation", id="impl-cli-members-handler--f38bbfd8", specifications="specification-spec-cli-members-list--16a2b152,specification-spec-cli-members-invite--1f4fbec5,specification-spec-cli-members-remove--f5ff40de,specification-spec-cli-members-leave--9e394f51"]
+export async function membersCommand(args, repo) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case 'list':
+            await handleListMembers(rest, repo);
+            break;
+        case 'invite':
+            await handleInviteMember(rest, repo);
+            break;
+        case 'remove':
+            await handleRemoveMember(rest, repo);
+            break;
+        case 'join':
+            await handleJoinWorkspace(rest, repo);
+            break;
+        case 'leave':
+            await handleLeaveWorkspace(rest, repo);
+            break;
+        default:
+            if (!subcommand) {
+                // Default to list
+                await handleListMembers([], repo);
+            }
+            else {
+                printUsage();
+                process.exit(1);
+            }
+    }
+    process.exit(0);
+}
+// glassware[type="implementation", id="impl-cli-members-persist--bc16a9bc", specifications="specification-spec-cli-members-persist--e2cb6ec5"]
+async function flushRepo(repo, documentIds) {
+    const flush = repo.flush;
+    if (!flush)
+        return;
+    try {
+        await flush.call(repo, documentIds);
+    }
+    catch (error) {
+        console.error('Error: Failed to persist member changes');
+        process.exit(1);
+    }
+}
+function printUsage() {
+    console.error('Usage: mod members <subcommand>');
+    console.error('');
+    console.error('Subcommands:');
+    console.error('  list      List workspace members');
+    console.error('  invite    Generate an invite link for the workspace');
+    console.error('  remove    Remove a member from the workspace');
+    console.error('  join      Join a workspace via invite link');
+    console.error('  leave     Leave the current workspace');
+    console.error('');
+    console.error("Run 'mod members <subcommand> --help' for usage details.");
+}
+// glassware[type="implementation", id="impl-cli-list-members--638745e1", specifications="specification-spec-cli-members-list--16a2b152,specification-spec-cli-table-format--66d8b9df,specification-spec-cli-json-format--ef8c7089,specification-spec-cli-error-no-workspace--c8207c72"]
+async function handleListMembers(args, repo) {
+    const isJson = args.includes('--json');
+    const isHelp = args.includes('--help');
+    if (isHelp) {
+        console.log('mod members list [options]');
+        console.log('');
+        console.log('List all members of the current workspace.');
+        console.log('');
+        console.log('Options:');
+        console.log('  --json     Output as JSON');
+        console.log('  --help     Show help');
+        return;
+    }
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not connected to a workspace.' }));
+        }
+        else {
+            console.error('Error: Not connected to a workspace.');
+            console.error("Run 'mod workspace connect <workspace-id>' to connect to a workspace.");
+        }
+        process.exit(1);
+    }
+    const config = readConfig();
+    if (!config.auth) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not signed in.' }));
+        }
+        else {
+            console.error('Error: Not signed in.');
+            console.error('Run `mod auth login` to sign in.');
+        }
+        process.exit(1);
+    }
+    const currentUserId = await ensureAuthUserId(config);
+    const memberService = new MemberService(repo);
+    try {
+        const members = await memberService.getMembers(connection.workspaceId);
+        if (isJson) {
+            const output = {
+                workspace: {
+                    id: connection.workspaceId,
+                    name: connection.workspaceName,
+                },
+                members: members.map((m) => ({
+                    userId: m.userId,
+                    name: m.name || 'Unknown',
+                    email: m.email,
+                    role: m.role,
+                    isCurrentUser: m.userId === currentUserId,
+                })),
+                totalCount: members.length,
+            };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            printMemberTable(members, connection.workspaceName, currentUserId);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            console.error('Error:', error.message);
+        }
+        process.exit(1);
+    }
+}
+// glassware[type="implementation", id="impl-cli-print-member-table--e87b3149", specifications="specification-spec-cli-table-format--66d8b9df"]
+function printMemberTable(members, workspaceName, currentUserId) {
+    console.log(`Members of "${workspaceName}":`);
+    console.log('');
+    // Calculate column widths
+    const nameWidth = Math.max(16, ...members.map((m) => (m.name || 'Unknown').length + 4));
+    const emailWidth = Math.max(24, ...members.map((m) => m.email.length));
+    // Print header
+    console.log(`  ${'NAME'.padEnd(nameWidth)}${'EMAIL'.padEnd(emailWidth)}ROLE`);
+    // Print members
+    for (const member of members) {
+        const isCurrentUser = member.userId === currentUserId;
+        const prefix = isCurrentUser ? '* ' : '  ';
+        const displayName = isCurrentUser ? 'You' : member.name || 'Unknown';
+        console.log(`${prefix}${displayName.padEnd(nameWidth)}${member.email.padEnd(emailWidth)}${member.role}`);
+    }
+    console.log('');
+    console.log(`${members.length} member${members.length === 1 ? '' : 's'} total`);
+}
+// glassware[type="implementation", id="impl-cli-invite-member--ab9b9ea3", specifications="specification-spec-cli-members-invite--1f4fbec5,specification-spec-cli-members-invite-role--09fe52ee,specification-spec-cli-error-no-workspace--c8207c72,specification-spec-cli-error-permission--356d06c7"]
+async function handleInviteMember(args, repo) {
+    const isJson = args.includes('--json');
+    const isHelp = args.includes('--help');
+    // Parse --role option
+    let role = 'editor';
+    const roleIndex = args.indexOf('--role');
+    if (roleIndex !== -1 && args[roleIndex + 1]) {
+        const specifiedRole = args[roleIndex + 1];
+        if (specifiedRole === 'owner') {
+            if (isJson) {
+                console.log(JSON.stringify({ error: "Cannot create invite link for 'owner' role." }));
+            }
+            else {
+                console.error("Error: Cannot create invite link for 'owner' role.");
+                console.error("Valid roles: 'editor', 'viewer'");
+            }
+            process.exit(1);
+        }
+        if (specifiedRole !== 'editor' && specifiedRole !== 'viewer') {
+            if (isJson) {
+                console.log(JSON.stringify({ error: `Invalid role: ${specifiedRole}` }));
+            }
+            else {
+                console.error(`Error: Invalid role '${specifiedRole}'.`);
+                console.error("Valid roles: 'editor', 'viewer'");
+            }
+            process.exit(1);
+        }
+        role = specifiedRole;
+    }
+    if (isHelp) {
+        console.log('mod members invite [options]');
+        console.log('');
+        console.log('Generate a shareable invite link for the workspace.');
+        console.log('');
+        console.log('Options:');
+        console.log('  --role     Role for invitees: editor (default), viewer');
+        console.log('  --json     Output as JSON');
+        console.log('  --help     Show help');
+        return;
+    }
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not connected to a workspace.' }));
+        }
+        else {
+            console.error('Error: Not connected to a workspace.');
+            console.error("Run 'mod workspace connect <workspace-id>' to connect to a workspace.");
+        }
+        process.exit(1);
+    }
+    const config = readConfig();
+    if (!config.auth) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not signed in.' }));
+        }
+        else {
+            console.error('Error: Not signed in.');
+            console.error('Run `mod auth login` to sign in.');
+        }
+        process.exit(1);
+    }
+    // Check if user is owner
+    const memberService = new MemberService(repo);
+    const currentUserId = await ensureAuthUserId(config);
+    const isOwner = await memberService.isWorkspaceOwner(connection.workspaceId, currentUserId);
+    if (!isOwner) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Permission denied. Only workspace owners can create invite links.' }));
+        }
+        else {
+            console.error('Error: Permission denied.');
+            console.error('Only workspace owners can create invite links.');
+        }
+        process.exit(1);
+    }
+    try {
+        // Call auth-worker to create invite link
+        const response = await fetch(`${AUTH_WORKER_URL}/auth/invite`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.auth.googleIdToken}`,
+            },
+            body: JSON.stringify({
+                workspaceId: connection.workspaceId,
+                workspaceName: connection.workspaceName,
+                role,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json().catch(() => ({})));
+            throw new Error(errorData.error || `Failed to create invite link: ${response.status}`);
+        }
+        const { token, url, expiresAt } = (await response.json());
+        if (isJson) {
+            console.log(JSON.stringify({
+                token,
+                url,
+                role,
+                expiresAt,
+                workspace: {
+                    id: connection.workspaceId,
+                    name: connection.workspaceName,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log(`Invite link created for "${connection.workspaceName}":`);
+            console.log('');
+            console.log(`  ${url}`);
+            console.log('');
+            console.log(`Role: ${role}${role === 'editor' ? ' (default)' : ''}`);
+            console.log('Share this link with collaborators to invite them.');
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            console.error('Error:', error.message);
+        }
+        process.exit(1);
+    }
+}
+// glassware[type="implementation", id="impl-cli-remove-member--0985711d", specifications="specification-spec-cli-members-remove--f5ff40de,specification-spec-cli-error-no-workspace--c8207c72,specification-spec-cli-error-permission--356d06c7,specification-spec-cli-error-not-found--eb727feb"]
+async function handleRemoveMember(args, repo) {
+    const isJson = args.includes('--json');
+    const isForce = args.includes('--force');
+    const isHelp = args.includes('--help');
+    // Find email argument (first non-flag argument)
+    const email = args.find((arg) => !arg.startsWith('--'));
+    if (isHelp) {
+        console.log('mod members remove <email> [options]');
+        console.log('');
+        console.log('Remove a member from the workspace.');
+        console.log('');
+        console.log('Arguments:');
+        console.log('  email      Email address of the member to remove');
+        console.log('');
+        console.log('Options:');
+        console.log('  --force    Skip confirmation prompt');
+        console.log('  --json     Output as JSON');
+        console.log('  --help     Show help');
+        return;
+    }
+    if (!email) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Email address required.' }));
+        }
+        else {
+            console.error('Error: Email address required.');
+            console.error('Usage: mod members remove <email>');
+        }
+        process.exit(1);
+    }
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not connected to a workspace.' }));
+        }
+        else {
+            console.error('Error: Not connected to a workspace.');
+            console.error("Run 'mod workspace connect <workspace-id>' to connect to a workspace.");
+        }
+        process.exit(1);
+    }
+    const config = readConfig();
+    if (!config.auth) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not signed in.' }));
+        }
+        else {
+            console.error('Error: Not signed in.');
+            console.error('Run `mod auth login` to sign in.');
+        }
+        process.exit(1);
+    }
+    const memberService = new MemberService(repo);
+    const currentUserId = await ensureAuthUserId(config);
+    const workspaceId = connection.workspaceId;
+    // Check if user is owner
+    const isOwner = await memberService.isWorkspaceOwner(workspaceId, currentUserId);
+    if (!isOwner) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Permission denied. Only workspace owners can remove members.' }));
+        }
+        else {
+            console.error('Error: Permission denied.');
+            console.error('Only workspace owners can remove members.');
+        }
+        process.exit(1);
+    }
+    // Find member by email
+    const members = await memberService.getMembers(workspaceId);
+    const member = members.find((m) => m.email === email);
+    if (!member) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: `${email} is not a member of this workspace.` }));
+        }
+        else {
+            console.error(`Error: ${email} is not a member of this workspace.`);
+        }
+        process.exit(1);
+    }
+    // Cannot remove self (use leave instead)
+    if (member.userId === currentUserId) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Cannot remove yourself. Use `mod members leave` instead.' }));
+        }
+        else {
+            console.error('Error: Cannot remove yourself. Use `mod members leave` instead.');
+        }
+        process.exit(1);
+    }
+    // Confirm removal (unless --force)
+    if (!isForce && !isJson) {
+        const confirmed = await confirm(`Remove ${email} from "${connection.workspaceName}"?`, { default: false });
+        if (!confirmed) {
+            console.log('Cancelled.');
+            return;
+        }
+    }
+    try {
+        await memberService.removeMember(workspaceId, member.userId, currentUserId);
+        await flushRepo(repo, [workspaceId]);
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                message: `${email} has been removed from the workspace.`,
+                removedUser: {
+                    userId: member.userId,
+                    email: member.email,
+                    name: member.name,
+                },
+            }));
+        }
+        else {
+            console.log('');
+            console.log(`${email} has been removed from the workspace.`);
+            console.log('They no longer have access to workspace documents.');
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            console.error('Error:', error.message);
+        }
+        process.exit(1);
+    }
+}
+// glassware[type="implementation", id="impl-cli-leave-workspace--1ae0fcc8", specifications="specification-spec-cli-members-leave--9e394f51,specification-spec-cli-error-no-workspace--c8207c72,specification-spec-cli-error-owner-leave--b733604c"]
+async function handleLeaveWorkspace(args, repo) {
+    const isJson = args.includes('--json');
+    const isForce = args.includes('--force');
+    const isHelp = args.includes('--help');
+    if (isHelp) {
+        console.log('mod members leave [options]');
+        console.log('');
+        console.log('Leave the current workspace.');
+        console.log('');
+        console.log('Options:');
+        console.log('  --force    Skip confirmation prompt');
+        console.log('  --json     Output as JSON');
+        console.log('  --help     Show help');
+        return;
+    }
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not connected to a workspace.' }));
+        }
+        else {
+            console.error('Error: Not connected to a workspace.');
+            console.error("Run 'mod workspace connect <workspace-id>' to connect to a workspace.");
+        }
+        process.exit(1);
+    }
+    const config = readConfig();
+    if (!config.auth) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not signed in.' }));
+        }
+        else {
+            console.error('Error: Not signed in.');
+            console.error('Run `mod auth login` to sign in.');
+        }
+        process.exit(1);
+    }
+    const memberService = new MemberService(repo);
+    const currentUserId = await ensureAuthUserId(config);
+    const workspaceId = connection.workspaceId;
+    // Check if user is sole owner (cannot leave)
+    const isOwner = await memberService.isWorkspaceOwner(workspaceId, currentUserId);
+    if (isOwner) {
+        const ownerCount = await memberService.getOwnerCount(workspaceId);
+        if (ownerCount <= 1) {
+            if (isJson) {
+                console.log(JSON.stringify({
+                    error: 'Workspace owners cannot leave. Transfer ownership first or delete the workspace.',
+                }));
+            }
+            else {
+                console.error('Error: Workspace owners cannot leave.');
+                console.error('Transfer ownership first or delete the workspace.');
+            }
+            process.exit(1);
+        }
+    }
+    // Confirm leaving (unless --force)
+    if (!isForce && !isJson) {
+        const confirmed = await confirm(`Leave workspace "${connection.workspaceName}"? You will lose access to all documents.`, { default: false });
+        if (!confirmed) {
+            console.log('Cancelled.');
+            return;
+        }
+    }
+    try {
+        await memberService.leaveWorkspace(workspaceId, currentUserId);
+        // Note: We don't clear the local workspace connection here.
+        // The connection is per-directory, not per-user, so other users
+        // working in this directory should retain their connection.
+        // Users can run `mod workspace disconnect` to clear it manually.
+        await flushRepo(repo, [workspaceId]);
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                message: `You have left "${connection.workspaceName}".`,
+                workspaceId: connection.workspaceId,
+            }));
+        }
+        else {
+            console.log('');
+            console.log(`You have left "${connection.workspaceName}".`);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            console.error('Error:', error.message);
+        }
+        process.exit(1);
+    }
+}
+// glassware[type="implementation", id="impl-cli-join-member--c5082b11", specifications="specification-spec-cli-members-join--4244a5d3,specification-spec-cli-error-not-authenticated--24136da7"]
+async function handleJoinWorkspace(args, repo) {
+    const isJson = args.includes('--json');
+    const isHelp = args.includes('--help');
+    if (isHelp) {
+        console.log('mod members join <invite-url> [options]');
+        console.log('');
+        console.log('Join a workspace using an invite link.');
+        console.log('');
+        console.log('Options:');
+        console.log('  --json     Output as JSON');
+        console.log('  --help     Show help');
+        return;
+    }
+    const inviteUrl = args.find((arg) => !arg.startsWith('--'));
+    if (!inviteUrl) {
+        console.error('Usage: mod members join <invite-url>');
+        process.exit(1);
+    }
+    const config = readConfig();
+    if (!config.auth) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Not signed in.' }));
+        }
+        else {
+            console.error('Error: Not signed in.');
+            console.error('Run `mod auth login` to sign in.');
+        }
+        process.exit(1);
+    }
+    const token = extractInviteToken(inviteUrl);
+    if (!token) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: 'Invalid invite URL.' }));
+        }
+        else {
+            console.error('Error: Invalid invite URL.');
+        }
+        process.exit(1);
+    }
+    try {
+        const previewResponse = await fetch(`${AUTH_WORKER_URL}/auth/invite/${encodeURIComponent(token)}/preview`, {
+            method: 'GET',
+        });
+        const preview = (await previewResponse.json());
+        if (!preview.isValid) {
+            if (isJson) {
+                console.log(JSON.stringify({ error: preview.reason || 'Invalid invite link.' }));
+            }
+            else {
+                console.error('Error: Invalid invite link.');
+            }
+            process.exit(1);
+        }
+        const validateResponse = await fetch(`${AUTH_WORKER_URL}/auth/invite/${encodeURIComponent(token)}/validate`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${config.auth.googleIdToken}`,
+            },
+        });
+        if (!validateResponse.ok) {
+            const errorData = (await validateResponse.json().catch(() => ({})));
+            throw new Error(errorData.error || 'Invalid invite link.');
+        }
+        const validated = (await validateResponse.json());
+        if (!validated.valid || !validated.workspaceId) {
+            throw new Error(validated.error || 'Invalid invite link.');
+        }
+        const memberService = new MemberService(repo);
+        const authUserId = await ensureAuthUserId(config);
+        await memberService.addMember(validated.workspaceId, {
+            userId: authUserId,
+            email: config.auth.email,
+            name: config.auth.name,
+            role: validated.role || 'editor',
+            joinedAt: new Date().toISOString(),
+        });
+        await waitForMembership(memberService, validated.workspaceId, authUserId, 10000);
+        const userDocId = await ensureUserDocId(config);
+        const documentsToFlush = [validated.workspaceId];
+        if (userDocId) {
+            const modUser = createModUser(repo);
+            const userDoc = await modUser.findOrCreate({
+                email: config.auth.email,
+                name: config.auth.name,
+                googleId: config.auth.googleId,
+                avatar: null,
+            });
+            await modUser.addWorkspace(userDoc.id, validated.workspaceId);
+            documentsToFlush.push(userDoc.id);
+        }
+        await flushRepo(repo, documentsToFlush);
+        if (isJson) {
+            console.log(JSON.stringify({ workspaceId: validated.workspaceId, workspaceName: validated.workspaceName, role: validated.role }, null, 2));
+        }
+        else {
+            console.log(`Joined "${validated.workspaceName || 'workspace'}".`);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ error: error.message || 'Failed to join workspace.' }));
+        }
+        else {
+            console.error('Error:', error.message || 'Failed to join workspace.');
+        }
+        process.exit(1);
+    }
+}
+function extractInviteToken(inviteUrl) {
+    if (!inviteUrl)
+        return null;
+    if (!inviteUrl.includes('/'))
+        return inviteUrl;
+    try {
+        const parsed = new URL(inviteUrl);
+        const parts = parsed.pathname.split('/');
+        const token = parts[parts.length - 1];
+        return token || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureUserDocId(config) {
+    if (config.auth?.userDocId)
+        return config.auth.userDocId;
+    try {
+        const profile = await fetchAuthProfile(config.auth.googleIdToken);
+        if (profile.userDocId) {
+            config.auth.userDocId = profile.userDocId;
+            if (!config.auth.userId && profile.userId) {
+                config.auth.userId = profile.userId;
+            }
+            writeConfig(config);
+            return profile.userDocId;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+async function ensureAuthUserId(config) {
+    if (config.auth?.userId) {
+        return config.auth.userId;
+    }
+    if (config.auth?.googleIdToken === 'dev-token') {
+        config.auth.userId = 'dev-user';
+        writeConfig(config);
+        return config.auth.userId;
+    }
+    if (config.auth?.googleIdToken) {
+        try {
+            const profile = await fetchAuthProfile(config.auth.googleIdToken);
+            if (profile.userId) {
+                config.auth.userId = profile.userId;
+                if (!config.auth.userDocId && profile.userDocId) {
+                    config.auth.userDocId = profile.userDocId;
+                }
+                writeConfig(config);
+                return profile.userId;
+            }
+        }
+        catch { }
+    }
+    throw new Error('Unable to determine user identity. Run `mod auth login`.');
+}
+async function waitForMembership(memberService, workspaceId, userId, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const members = await memberService.getMembers(workspaceId);
+        if (members.some((m) => m.userId === userId)) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error('Membership did not appear in workspace before timeout.');
+}