@popoverai/dotrequirements 0.11.0

package/dist/commands/init.js

@@ -0,0 +1,355 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { detectProjectName } from '../utils/project-name.js';
+import { ensureGitignore } from '../utils/gitignore.js';
+import { generateRequirementsReadme } from '../templates/requirements-readme.js';
+import { generateExampleRequirements } from '../templates/example-requirements.js';
+import { promptChoice, promptConfirm } from '../utils/prompts.js';
+import { pullCommand } from './pull.js';
+import { LOCAL_PROJECT_CREDENTIALS } from '../utils/local-project.js';
+import { loadEnvFile } from '../utils/env.js';
+import { hasValidTokens, getTokens } from '../utils/token-storage.js';
+import { executeOAuthFlow } from '../utils/oauth-flow.js';
+import { ConvexHttpClient } from 'convex/browser';
+import { getConvexUrl } from '../config.js';
+import { api } from '../convex.js';
+import { brand } from '../utils/brand.js';
+import { selectTeam as selectTeamFromList, selectProject, getOrCreateProjectSecret } from '../utils/project-selector.js';
+export async function initCommand(options = {}) {
+    try {
+        console.log(`Initializing ${brand} project...\n`);
+        const cwd = process.cwd();
+        const envPath = path.join(cwd, '.env.local');
+        // 1. Pre-flight check: already initialized?
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, 'utf-8');
+            if (content.includes('DOTREQUIREMENTS_PROJECT_ID')) {
+                const shouldReinit = await promptConfirm('Project already initialized. Reinitialize?', false);
+                if (!shouldReinit) {
+                    console.log('Aborted.');
+                    return;
+                }
+            }
+        }
+        // 2. Ask user to choose between creating new or connecting to existing
+        const flow = await promptChoice('What would you like to do?', [
+            { title: 'Create a new project', value: 'create' },
+            { title: 'Connect to an existing project', value: 'connect' },
+        ]);
+        if (!flow) {
+            console.log('Aborted.');
+            return;
+        }
+        // 3. Execute the appropriate flow
+        if (flow === 'create') {
+            await createNewProjectFlow(cwd, envPath, options);
+        }
+        else {
+            await connectExistingProjectFlow(cwd, envPath);
+        }
+        console.log('\nDocumentation: https://docs.dotrequirements.io/getting-started');
+    }
+    catch (error) {
+        console.error(`\n✗ Error: ${error instanceof Error ? error.message : String(error)}`);
+        if (error instanceof Error && error.message.includes('fetch')) {
+            console.error('\nCheck your internet connection and try again.');
+            console.error('If the problem persists, visit https://status.convex.dev');
+        }
+        process.exit(1);
+    }
+}
+/**
+ * INIT-13: Prompt user to select a team for the new project
+ * Returns:
+ * - teamId string if user selected a team
+ * - null if no teams exist (auto-create flow)
+ * - undefined if user cancelled
+ */
+async function selectTeam(client) {
+    console.log('Fetching your teams...\n');
+    // INIT-13.0: Query all teams for the authenticated user
+    const teams = await client.query(api.teams.queries.listForUserWithUsage);
+    if (teams.length === 0) {
+        console.log('\nYou are not a member of any teams.');
+        console.log('To create a new team, visit: https://app.dotrequirements.io/teams/new');
+        console.log('After creating your team, run "dotrequirements init" again.\n');
+        process.exit(0);
+    }
+    // INIT-13.1 & INIT-13.3: Build team selection options with usage display
+    const teamChoices = teams.map((team) => {
+        const limitDisplay = team.projectLimit === -1
+            ? 'unlimited'
+            : `${team.projectCount}/${team.projectLimit}`;
+        // INIT-13.2: Mark teams at capacity
+        const capacityMarker = team.isAtCapacity ? ' [at capacity]' : '';
+        return {
+            title: `${team.name} (${team.tierName} - ${limitDisplay} projects)${capacityMarker}`,
+            value: team.teamId,
+            disabled: team.isAtCapacity, // Make at-capacity teams unselectable
+        };
+    });
+    // INIT-13.3: Add "Create new team" option
+    teamChoices.push({
+        title: 'Create new team',
+        value: 'CREATE_NEW_TEAM',
+        disabled: false,
+    });
+    const selectedTeamId = await promptChoice('Select a team for this project:', teamChoices);
+    if (!selectedTeamId) {
+        // User cancelled
+        return undefined;
+    }
+    // INIT-14: Handle selection of at-capacity team (should not happen due to disabled flag, but defensive check)
+    const selectedTeam = teams.find((t) => t.teamId === selectedTeamId);
+    if (selectedTeam && selectedTeam.isAtCapacity) {
+        console.error('\n✗ This team is at its project limit. Please select a different team or create a new one.\n');
+        // Retry selection
+        return await selectTeam(client);
+    }
+    // INIT-15: Handle "Create new team" selection
+    if (selectedTeamId === 'CREATE_NEW_TEAM') {
+        console.log('\nTo create a new team, visit: https://app.dotrequirements.io/teams/new');
+        console.log('After creating your team, run "dotrequirements init" again.\n');
+        process.exit(0);
+    }
+    // INIT-13.4: Return selected team ID
+    return selectedTeamId;
+}
+/**
+ * Create a new project flow (INIT-3, INIT-4, INIT-13)
+ */
+async function createNewProjectFlow(cwd, envPath, options) {
+    // 1. Detect/prompt for project name
+    const projectName = await detectProjectName({ name: options.name });
+    console.log(`Project name: ${projectName}\n`);
+    // 2. Check if user is authenticated
+    const isAuthenticated = await hasValidTokens();
+    let projectId; // Can be slug (new) or Convex ID (old/local)
+    let secret;
+    if (isAuthenticated) {
+        // INIT-4: Authenticated user - create cloud project
+        const tokens = await getTokens();
+        if (!tokens) {
+            throw new Error('Authentication tokens not found');
+        }
+        const client = new ConvexHttpClient(getConvexUrl());
+        client.setAuth(tokens.accessToken);
+        // INIT-13: Select team for the project (returns null if no teams exist, undefined if cancelled)
+        const selectedTeamId = await selectTeam(client);
+        if (selectedTeamId === undefined) {
+            // User cancelled (note: "Create new team" exits in selectTeam)
+            console.log('Aborted.');
+            return;
+        }
+        console.log('Creating cloud project...');
+        const result = await client.mutation(api.projects.mutations.create, {
+            name: projectName,
+            teamId: selectedTeamId ?? undefined, // null becomes undefined for auto-create
+        });
+        // Use slug as the user-facing project identifier
+        projectId = result.slug;
+        secret = result.secret;
+        console.log(`✓ Cloud project created: ${projectId}`);
+    }
+    else {
+        // INIT-3: Unauthenticated user - create local-only project with placeholder credentials
+        console.log('Initializing local project...');
+        projectId = LOCAL_PROJECT_CREDENTIALS.projectId;
+        secret = LOCAL_PROJECT_CREDENTIALS.secret;
+        console.log(`✓ Project initialized locally`);
+    }
+    // 3. Write .env.local
+    const shouldContinue = await writeEnvFile(envPath, projectId, secret);
+    if (!shouldContinue) {
+        // User declined to continue - abort init
+        return;
+    }
+    // Reload env file so newly written credentials are available to subsequent commands
+    loadEnvFile(cwd);
+    // 4. Create .requirements/ directory
+    await createRequirementsDirectory(cwd, projectId);
+    // 5. Update .gitignore
+    ensureGitignore(cwd);
+    console.log('✓ Updated .gitignore\n');
+    // 6. Show next steps
+    console.log('Next steps:');
+    console.log('  1. Create requirements in .requirements/ directory');
+    console.log('  2. Add the test harness to your test setup (see README)');
+    if (!isAuthenticated) {
+        // INIT-3.1: Local-only guidance
+        console.log('  3. Run "dotrequirements login" for cloud features (push/pull, coverage, AI)');
+    }
+}
+/**
+ * Connect to existing project flow
+ */
+async function connectExistingProjectFlow(cwd, envPath) {
+    // INIT-6.0: Check if user is authenticated, prompt to log in if not
+    let isAuthenticated = await hasValidTokens();
+    if (!isAuthenticated) {
+        const shouldLogin = await promptConfirm('You need to authenticate to connect to an existing project. Log in now?', true);
+        if (!shouldLogin) {
+            console.log('Aborted.');
+            return;
+        }
+        // INIT-6.1: Initiate OAuth login flow inline
+        try {
+            console.log();
+            await executeOAuthFlow();
+            console.log();
+            isAuthenticated = true;
+        }
+        catch (error) {
+            console.error('\nAuthentication failed:', error instanceof Error ? error.message : String(error));
+            console.log('Please try running "dotrequirements login" separately.\n');
+            return;
+        }
+    }
+    // Set up authenticated client
+    const tokens = await getTokens();
+    if (!tokens) {
+        throw new Error('Authentication tokens not found');
+    }
+    const client = new ConvexHttpClient(getConvexUrl());
+    client.setAuth(tokens.accessToken);
+    // INIT-6.2: Select team
+    const selectedTeamId = await selectTeamFromList(client);
+    if (!selectedTeamId) {
+        console.log('Aborted.');
+        return;
+    }
+    // INIT-6.3: Select project
+    const selectedProject = await selectProject(client, selectedTeamId);
+    if (!selectedProject) {
+        console.log('Aborted.');
+        return;
+    }
+    // INIT-6.4: Get or create secret for this project
+    console.log('\nGetting project credentials...');
+    const secretResult = await getOrCreateProjectSecret(client, selectedProject.projectId);
+    const projectId = selectedProject.projectSlug || selectedProject.projectId;
+    const secret = secretResult.secret;
+    if (secretResult.created) {
+        console.log('✓ Created new project secret');
+    }
+    else {
+        console.log('✓ Retrieved existing project secret');
+    }
+    // Write .env.local
+    const shouldContinue = await writeEnvFile(envPath, projectId, secret);
+    if (!shouldContinue) {
+        // User declined to continue - abort init
+        return;
+    }
+    // Reload env file so newly written credentials are available to pullCommand
+    loadEnvFile(cwd);
+    // Create .requirements/ directory
+    await createRequirementsDirectory(cwd, projectId);
+    // Update .gitignore
+    ensureGitignore(cwd);
+    console.log('✓ Updated .gitignore\n');
+    // Pull existing requirements from cloud
+    console.log('Pulling requirements from cloud...');
+    await pullCommand({ project: projectId });
+    console.log(`\n✓ Successfully connected to project: ${selectedProject.projectName}`);
+    console.log(`  Project ID: ${projectId}`);
+    console.log('\nNext steps:');
+    console.log('  1. Review the requirements in .requirements/');
+    console.log('  2. Add the test harness to your test setup (see README)');
+}
+/**
+ * Write .env.local file with confirmation if it already exists
+ * Returns true if credentials were written or user chose to continue with existing
+ * Returns false if user aborted
+ */
+async function writeEnvFile(envPath, projectId, secret) {
+    const newEnvLines = [
+        '# dot•requirements configuration',
+        `DOTREQUIREMENTS_PROJECT_ID=${projectId}`,
+        `DOTREQUIREMENTS_PROJECT_SECRET=${secret}`,
+    ];
+    if (fs.existsSync(envPath)) {
+        // Read existing content
+        const existingContent = fs.readFileSync(envPath, 'utf-8');
+        // Check if dotrequirements variables already exist
+        const hasProjectId = existingContent.includes('DOTREQUIREMENTS_PROJECT_ID');
+        const hasProjectSecret = existingContent.includes('DOTREQUIREMENTS_PROJECT_SECRET');
+        if (hasProjectId || hasProjectSecret) {
+            // INIT-2.0: Ask if user wants to update existing values
+            const shouldUpdate = await promptConfirm(`.env.local already contains ${brand} configuration. Update it?`, false);
+            if (!shouldUpdate) {
+                // INIT-2.1: Ask if user wants to continue with existing credentials
+                const shouldContinue = await promptConfirm('Continue with existing credentials?', true);
+                if (!shouldContinue) {
+                    // INIT-2.3: User declined to continue - abort
+                    console.log('Aborted.');
+                    return false;
+                }
+                // INIT-2.2: User wants to continue with existing credentials
+                console.log('Continuing with existing credentials...');
+                return true;
+            }
+            // Remove old dotrequirements lines
+            const lines = existingContent.split('\n');
+            const filteredLines = lines.filter(line => !line.includes('DOTREQUIREMENTS_PROJECT_ID') &&
+                !line.includes('DOTREQUIREMENTS_PROJECT_SECRET') &&
+                !(line.trim() === '# dotrequirements configuration') &&
+                !(line.trim() === '# dot•requirements configuration'));
+            // Append new configuration
+            const updatedContent = filteredLines.join('\n').trimEnd() + '\n\n' + newEnvLines.join('\n') + '\n';
+            fs.writeFileSync(envPath, updatedContent);
+            console.log(`✓ Updated ${brand} configuration in .env.local`);
+            return true;
+        }
+        else {
+            // File exists but doesn't have dotrequirements config - just append
+            const shouldAppend = await promptConfirm(`.env.local already exists. Add ${brand} configuration to it?`, true);
+            if (!shouldAppend) {
+                console.log('\nSkipped writing to .env.local. Please add these values manually:');
+                console.log(`  DOTREQUIREMENTS_PROJECT_ID=${projectId}`);
+                console.log(`  DOTREQUIREMENTS_PROJECT_SECRET=${secret}\n`);
+                return true; // Continue with init even though we didn't write the file
+            }
+            // Append to existing file
+            const appendContent = '\n' + newEnvLines.join('\n') + '\n';
+            fs.appendFileSync(envPath, appendContent);
+            console.log(`✓ Added ${brand} configuration to .env.local`);
+            return true;
+        }
+    }
+    else {
+        // File doesn't exist - create it
+        const envContent = newEnvLines.join('\n') + '\n';
+        fs.writeFileSync(envPath, envContent);
+        console.log('✓ Wrote configuration to .env.local');
+        return true;
+    }
+}
+/**
+ * Create .requirements/ directory with confirmation if it already exists
+ */
+async function createRequirementsDirectory(cwd, projectId) {
+    const requirementsDir = path.join(cwd, '.requirements');
+    if (fs.existsSync(requirementsDir)) {
+        const shouldOverwrite = await promptConfirm('.requirements/ directory already exists. Continue?', true);
+        if (!shouldOverwrite) {
+            console.log('Skipped creating .requirements/ directory');
+            return;
+        }
+    }
+    else {
+        fs.mkdirSync(requirementsDir, { recursive: true });
+        console.log('✓ Created .requirements/ directory');
+    }
+    // Always create/update README
+    const readmePath = path.join(requirementsDir, 'README.md');
+    fs.writeFileSync(readmePath, generateRequirementsReadme());
+    console.log('✓ Created .requirements/README.md');
+    // Create example.requirements.md (INIT-5.1)
+    const examplePath = path.join(requirementsDir, 'example.requirements.md');
+    if (!fs.existsSync(examplePath)) {
+        fs.writeFileSync(examplePath, generateExampleRequirements(projectId));
+        console.log('✓ Created .requirements/example.requirements.md');
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/link.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Link command - connect local environment to an existing project.
+ *
+ * Flow:
+ * 1. Check authentication (prompt to login if not)
+ * 2. Fetch user's teams with usage info
+ * 3. Let user select a team
+ * 4. Fetch projects for that team
+ * 5. Let user select a project
+ * 6. Get or create user's secret for that project
+ * 7. Write credentials to .env.local
+ * 8. Optionally pull requirements
+ */
+export declare function linkCommand(): Promise<void>;
+//# sourceMappingURL=link.d.ts.map

package/dist/commands/link.js

@@ -0,0 +1,156 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { promptConfirm } from '../utils/prompts.js';
+import { pullCommand } from './pull.js';
+import { hasValidTokens, getTokens } from '../utils/token-storage.js';
+import { executeOAuthFlow } from '../utils/oauth-flow.js';
+import { ConvexHttpClient } from 'convex/browser';
+import { getConvexUrl } from '../config.js';
+import { brand } from '../utils/brand.js';
+import { selectTeam, selectProject, getOrCreateProjectSecret } from '../utils/project-selector.js';
+/**
+ * Link command - connect local environment to an existing project.
+ *
+ * Flow:
+ * 1. Check authentication (prompt to login if not)
+ * 2. Fetch user's teams with usage info
+ * 3. Let user select a team
+ * 4. Fetch projects for that team
+ * 5. Let user select a project
+ * 6. Get or create user's secret for that project
+ * 7. Write credentials to .env.local
+ * 8. Optionally pull requirements
+ */
+export async function linkCommand() {
+    try {
+        console.log(`Linking to existing ${brand} project...\n`);
+        const cwd = process.cwd();
+        const envPath = path.join(cwd, '.env.local');
+        // 1. Check authentication
+        let isAuthenticated = await hasValidTokens();
+        if (!isAuthenticated) {
+            const shouldLogin = await promptConfirm('You need to authenticate to link to a project. Log in now?', true);
+            if (!shouldLogin) {
+                console.log('Aborted.');
+                return;
+            }
+            try {
+                console.log();
+                await executeOAuthFlow();
+                console.log();
+                isAuthenticated = true;
+            }
+            catch (error) {
+                console.error('\nAuthentication failed:', error instanceof Error ? error.message : String(error));
+                console.log('Please try running "dotrequirements login" separately.\n');
+                return;
+            }
+        }
+        // 2. Set up authenticated client
+        const tokens = await getTokens();
+        if (!tokens) {
+            throw new Error('Authentication tokens not found');
+        }
+        const client = new ConvexHttpClient(getConvexUrl());
+        client.setAuth(tokens.accessToken);
+        // 3. Select team
+        const selectedTeamId = await selectTeam(client);
+        if (!selectedTeamId) {
+            console.log('Aborted.');
+            return;
+        }
+        // 4. Select project
+        const selectedProject = await selectProject(client, selectedTeamId);
+        if (!selectedProject) {
+            console.log('Aborted.');
+            return;
+        }
+        // 5. Get or create secret for this project
+        console.log('\nGetting project credentials...');
+        const secretResult = await getOrCreateProjectSecret(client, selectedProject.projectId);
+        const projectSlug = selectedProject.projectSlug || selectedProject.projectId;
+        const secret = secretResult.secret;
+        if (secretResult.created) {
+            console.log('✓ Created new project secret');
+        }
+        else {
+            console.log('✓ Retrieved existing project secret');
+        }
+        // 6. Write .env.local
+        const shouldContinue = await writeEnvFile(envPath, projectSlug, secret);
+        if (!shouldContinue) {
+            return;
+        }
+        // 7. Optionally pull requirements
+        const shouldPull = await promptConfirm('Pull requirements from cloud now?', true);
+        if (shouldPull) {
+            console.log('\nPulling requirements...');
+            await pullCommand({ project: projectSlug });
+        }
+        console.log(`\n✓ Successfully linked to project: ${selectedProject.projectName}`);
+        console.log(`  Project ID: ${projectSlug}`);
+        console.log('\nDocumentation: https://docs.dotrequirements.io/getting-started');
+    }
+    catch (error) {
+        console.error(`\n✗ Error: ${error instanceof Error ? error.message : String(error)}`);
+        if (error instanceof Error && error.message.includes('fetch')) {
+            console.error('\nCheck your internet connection and try again.');
+            console.error('If the problem persists, visit https://status.convex.dev');
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Write .env.local file with confirmation if it already exists
+ * Returns true if credentials were written or user chose to continue
+ * Returns false if user aborted
+ */
+async function writeEnvFile(envPath, projectId, secret) {
+    const newEnvLines = [
+        '# dot•requirements configuration',
+        `DOTREQUIREMENTS_PROJECT_ID=${projectId}`,
+        `DOTREQUIREMENTS_PROJECT_SECRET=${secret}`,
+    ];
+    if (fs.existsSync(envPath)) {
+        const existingContent = fs.readFileSync(envPath, 'utf-8');
+        const hasProjectId = existingContent.includes('DOTREQUIREMENTS_PROJECT_ID');
+        const hasProjectSecret = existingContent.includes('DOTREQUIREMENTS_PROJECT_SECRET');
+        if (hasProjectId || hasProjectSecret) {
+            const shouldUpdate = await promptConfirm(`.env.local already contains ${brand} configuration. Update it?`, true);
+            if (!shouldUpdate) {
+                console.log('Aborted.');
+                return false;
+            }
+            // Remove old dotrequirements lines
+            const lines = existingContent.split('\n');
+            const filteredLines = lines.filter(line => !line.includes('DOTREQUIREMENTS_PROJECT_ID') &&
+                !line.includes('DOTREQUIREMENTS_PROJECT_SECRET') &&
+                !(line.trim() === '# dotrequirements configuration') &&
+                !(line.trim() === '# dot•requirements configuration'));
+            const updatedContent = filteredLines.join('\n').trimEnd() + '\n\n' + newEnvLines.join('\n') + '\n';
+            fs.writeFileSync(envPath, updatedContent);
+            console.log(`✓ Updated ${brand} configuration in .env.local`);
+            return true;
+        }
+        else {
+            const shouldAppend = await promptConfirm(`.env.local already exists. Add ${brand} configuration to it?`, true);
+            if (!shouldAppend) {
+                console.log('\nSkipped writing to .env.local. Please add these values manually:');
+                console.log(`  DOTREQUIREMENTS_PROJECT_ID=${projectId}`);
+                console.log(`  DOTREQUIREMENTS_PROJECT_SECRET=${secret}\n`);
+                return true;
+            }
+            const appendContent = '\n' + newEnvLines.join('\n') + '\n';
+            fs.appendFileSync(envPath, appendContent);
+            console.log(`✓ Added ${brand} configuration to .env.local`);
+            return true;
+        }
+    }
+    else {
+        const envContent = newEnvLines.join('\n') + '\n';
+        fs.writeFileSync(envPath, envContent);
+        console.log('✓ Wrote configuration to .env.local');
+        return true;
+    }
+}
+//# sourceMappingURL=link.js.map

package/dist/commands/login.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Login command - authenticate with WorkOS and manage project credentials.
+ *
+ * Implements:
+ * - LOGIN-1: CLI OAuth implementation
+ * - LOGIN-2: Upgrade from placeholder to real credentials
+ * - LOGIN-3: Refresh existing project credentials
+ * - LOGIN-4: Already logged in detection
+ * - LOGIN-6: Handle missing .env.local
+ */
+export declare function loginCommand(): Promise<void>;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.js

@@ -0,0 +1,117 @@
+/**
+ * Login command - authenticate with WorkOS and manage project credentials.
+ *
+ * Implements:
+ * - LOGIN-1: CLI OAuth implementation
+ * - LOGIN-2: Upgrade from placeholder to real credentials
+ * - LOGIN-3: Refresh existing project credentials
+ * - LOGIN-4: Already logged in detection
+ * - LOGIN-6: Handle missing .env.local
+ */
+import { executeOAuthFlow } from '../utils/oauth-flow.js';
+import { getConvexUrl } from '../config.js';
+import { hasValidTokens } from '../utils/token-storage.js';
+import { isLocalOnlyProject } from '../utils/local-project.js';
+import * as fs from 'fs';
+import { ConvexHttpClient } from 'convex/browser';
+import { findUp } from 'find-up';
+import { brand } from '../utils/brand.js';
+export async function loginCommand() {
+    console.log(`Logging in to ${brand}...\n`);
+    // LOGIN-4: Check if already logged in
+    if (await hasValidTokens()) {
+        console.log('✓ Already logged in');
+        console.log('Run "dotrequirements logout" to log in as a different user.');
+        return;
+    }
+    // LOGIN-1: Execute OAuth flow
+    const result = await executeOAuthFlow();
+    console.log('\n✓ Logged in successfully!');
+    // LOGIN-6: Check if there's a .env.local in the current directory
+    const envPath = await findUp('.env.local');
+    if (envPath) {
+        await handleExistingProject(envPath, result.accessToken);
+    }
+    else {
+        // LOGIN-6.1: No project in current directory
+        console.log('\nNo project found in this directory.');
+        console.log('Run "dotrequirements init" to create a new project in the current directory.');
+    }
+}
+/**
+ * Handle existing project based on credential type (placeholder vs real)
+ */
+async function handleExistingProject(envPath, accessToken) {
+    try {
+        // Read .env.local to get project ID and secret
+        const envContent = fs.readFileSync(envPath, 'utf-8');
+        const projectIdMatch = envContent.match(/DOTREQUIREMENTS_PROJECT_ID=(.+)/);
+        const secretMatch = envContent.match(/DOTREQUIREMENTS_PROJECT_SECRET=(.+)/);
+        if (!projectIdMatch || !secretMatch) {
+            console.log('\n.env.local found but missing project credentials.');
+            return;
+        }
+        const projectId = projectIdMatch[1].trim();
+        const projectSecret = secretMatch[1].trim();
+        const convexUrl = getConvexUrl();
+        const client = new ConvexHttpClient(convexUrl);
+        client.setAuth(accessToken);
+        // LOGIN-2: Check if placeholder credentials
+        if (isLocalOnlyProject(projectId)) {
+            await upgradeFromPlaceholder(envPath, envContent, client);
+        }
+        else {
+            // LOGIN-3: Refresh existing project credentials
+            await refreshCredentials(envPath, envContent, projectId, client);
+        }
+    }
+    catch (error) {
+        console.error('\nFailed to update project credentials:');
+        console.error(error instanceof Error ? error.message : String(error));
+        console.log('\nYour authentication was successful.');
+        console.log('You can continue using the project with its existing credentials.');
+    }
+}
+/**
+ * LOGIN-2: Upgrade from placeholder credentials to real project
+ */
+async function upgradeFromPlaceholder(envPath, envContent, client) {
+    console.log('\nUpgrading from local-only mode to cloud access...');
+    // LOGIN-2.0, LOGIN-2.1: Create team and project
+    const result = await client.mutation('lib/authMutations:createProjectForAuthenticatedUser', {});
+    if (!result.success) {
+        throw new Error(result.error || 'Unknown error');
+    }
+    console.log('✓ Created new project in your team');
+    // LOGIN-2.3: Update .env.local with real credentials
+    const updatedEnv = envContent
+        .replace(/DOTREQUIREMENTS_PROJECT_ID=.+/, `DOTREQUIREMENTS_PROJECT_ID=${result.projectId}`)
+        .replace(/DOTREQUIREMENTS_PROJECT_SECRET=.+/, `DOTREQUIREMENTS_PROJECT_SECRET=${result.projectSecret}`);
+    fs.writeFileSync(envPath, updatedEnv);
+    console.log('✓ Updated .env.local with cloud credentials');
+    // LOGIN-2.4: Display next steps
+    console.log('\nYour project is now connected to the cloud!');
+    console.log('Run "dotrequirements push" to sync your requirements.');
+}
+/**
+ * LOGIN-3: Refresh existing project credentials
+ */
+async function refreshCredentials(envPath, envContent, projectId, client) {
+    console.log('\nRefreshing your project credentials...');
+    // LOGIN-3.0: Verify access and generate new secret
+    const result = await client.mutation('lib/authMutations:refreshProjectSecret', {
+        projectId: projectId, // Cast to Id<"projects">
+    });
+    if (!result.success) {
+        // LOGIN-3.4: User doesn't have access
+        throw new Error(result.error || 'Unknown error');
+    }
+    // LOGIN-3.2: Update .env.local with new secret
+    const updatedEnv = envContent.replace(/DOTREQUIREMENTS_PROJECT_SECRET=.+/, `DOTREQUIREMENTS_PROJECT_SECRET=${result.projectSecret}`);
+    fs.writeFileSync(envPath, updatedEnv);
+    // LOGIN-3.3: Confirm access extended
+    const expiryDate = new Date(result.expiresAt).toLocaleDateString();
+    console.log(`✓ Access extended until ${expiryDate}`);
+    console.log('✓ Updated .env.local with new credentials');
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/logout.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Logout command - clear stored authentication tokens.
+ */
+export declare function logoutCommand(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map