@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.61

package/dist/commands/init.js

@@ -2,30 +2,39 @@ import * as p from '@clack/prompts';
 import fs from 'fs/promises';
 import path from 'path';
 import pc from 'picocolors';
-import { ControlPlaneError, getTenantDetails } from '../api/control-plane.js';
+import { ControlPlaneError, getBootstrapInfo } from '../api/control-plane.js';
 import { FigmaApiError } from '../api/figma-api.js';
-import { getValidAccessToken } from '../auth/oauth-flow.js';
+import { tryGetCredential } from '../auth/oauth-flow.js';
 import { getValidProjectToken, ProjectTokenError } from '../auth/project-token.js';
-import { TokenStore } from '../auth/token-store.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment, getProjectNotFoundMessage } from '../constants.js';
+import { ensureGitignore } from '../utils/config.js';
+import { addOrUpdateEnvVar } from '../utils/env-management.js';
 import { isDebug } from '../utils/is-debug.js';
+import { applyLambdaModifications } from '../utils/lambda-config.js';
 import * as log from '../utils/log.js';
+import { detectPackageManagerFromEnvironment, getRunCommand, resolvePackageManager } from '../utils/package-manager.js';
 import { displayManualInstructions, ensurePayloadFigmaConfig } from '../utils/payload-config-modifier.js';
+import { runScript } from '../utils/payload-package-check.js';
 import { detectPayloadProject, hasRequiredDependencies, initializeGitRepo, installDependencies, isInProjectDirectory, scaffoldProject, validatePayloadVersion } from '../utils/project.js';
+import { resolveEnvironment } from '../utils/resolve-environment.js';
+import { checkForUpdates, getOwnVersion } from '../utils/version-check.js';
 import { loginCommand } from './login.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
 /**
- * Generate and store project token for a tenant
+ * Generate and store project token for a content system
  * Non-blocking - will show warning but not exit on failure
  * Only shows feedback if DEBUG mode is enabled, otherwise runs silently
  *
  * @param tokenStore - Token store instance
- * @param tenantId - Tenant ID to generate token for
+ * @param contentSystemId - Content System ID to generate token for
  * @param spinner - Clack spinner instance for status updates (only used in debug mode)
- */ async function generateProjectTokenWithFeedback(tokenStore, tenantId, spinner) {
+ */ async function generateProjectTokenWithFeedback(tokenStore, contentSystemId, spinner) {
     if (isDebug()) {
         spinner.start('Generating project token...');
     }
     try {
-        const projectToken = await getValidProjectToken(tokenStore, tenantId);
+        const projectToken = await getValidProjectToken(tokenStore, contentSystemId);
         if (isDebug()) {
             if (projectToken) {
                 spinner.stop(pc.green('✓ Project token generated'));
@@ -58,108 +67,80 @@ import { loginCommand } from './login.js';
  *
  * @param options - Command options
  */ export async function initCommand(options) {
+    // Check for outdated version (non-blocking)
+    const currentVersion = await getOwnVersion();
+    await checkForUpdates(currentVersion);
     // Check authentication
-    const tokenStore = new TokenStore();
+    const tokenStore = getTokenStore();
     const s = p.spinner();
-    let accessToken;
     if (options.skipAuth) {
         // Skip authentication for testing/development
         p.log.warn(pc.yellow('Skipping authentication (--skip-auth mode)'));
-        accessToken = 'mock-access-token';
     } else {
-        try {
-            // Check for valid cached tokens first (no API call needed)
-            if (tokenStore.hasValidTokens()) {
-                // Use cached token silently - no spinner needed
-                accessToken = tokenStore.getAccessToken();
-            } else {
-                // Need to refresh or authenticate - show spinner for API call
-                s.start('Checking authentication...');
-                const token = await getValidAccessToken(tokenStore);
-                if (!token) {
-                    s.stop(pc.yellow('⚠ Not authenticated'));
-                    p.log.info('Authentication required to continue');
-                    // Prompt user to authenticate now
-                    const shouldAuth = await p.confirm({
-                        initialValue: true,
-                        message: 'Would you like to authenticate now?'
-                    });
-                    if (p.isCancel(shouldAuth) || !shouldAuth) {
-                        p.cancel('Operation cancelled');
-                        process.exit(0);
-                    }
-                    // Run login command
-                    await loginCommand();
-                    // Get token after auth
-                    const newToken = await getValidAccessToken(tokenStore);
-                    if (!newToken) {
-                        p.log.error('Authentication failed');
-                        process.exit(1);
-                    }
-                    accessToken = newToken;
-                    p.log.success(pc.green('✓ Authenticated'));
-                } else {
-                    accessToken = token;
-                    s.stop(pc.green('✓ Authenticated'));
+        // Check for valid cached tokens first (no API call needed)
+        if (!tokenStore.hasValidTokens()) {
+            // Need to refresh or authenticate - show spinner for API call
+            s.start('Checking authentication...');
+            const credential = await tryGetCredential(tokenStore);
+            if (!credential) {
+                s.stop('Authentication required to continue');
+                await loginCommand({
+                    showNextSteps: false
+                });
+                const newCredential = await tryGetCredential(tokenStore);
+                if (!newCredential) {
+                    p.log.error('Authentication failed');
+                    process.exit(1);
                 }
+            } else {
+                s.stop(pc.green('✓ Authenticated'));
             }
-        } catch (error) {
-            s.stop(pc.red('✗ Authentication failed'));
-            log.error(error instanceof Error ? error.message : 'Unknown error');
-            p.note('Run `figma auth` to authenticate', 'Tip');
-            process.exit(1);
         }
     }
     // Note: We no longer check for figma.config.json here
     // Instead, the AST detection will check if figma object already exists in payload.config.ts
     // and skip modification if it does (unless --force is used)
-    // Step 3: Get CMS ID with retry loop
+    // Step 3: Get CMS Resource ID (required argument)
     log.debug('Configuring Project...');
-    let tenantId = options.id;
-    let selectedTenant;
-    while(!selectedTenant){
-        // Prompt for ID if not provided
-        if (!tenantId) {
-            const input = await p.text({
-                message: 'Enter your CMS ID:',
-                placeholder: 'tenant_abc123',
-                validate: (value)=>{
-                    if (!value || typeof value !== 'string') {
-                        return 'CMS ID is required';
-                    }
-                    return undefined;
+    if (!options.id) {
+        p.log.error('CMS Resource ID is required. Use --id <cms-resource-id>');
+        process.exit(1);
+    }
+    const cmsResourceId = options.id;
+    // Fetch bootstrap info (oauth creds + environments)
+    let bootstrapInfo = null;
+    let resolvedEnv = null;
+    let oauthClientId = null;
+    let oauthClientSecret = null;
+    if (!options.skipAuth) {
+        const credential = await tryGetCredential(tokenStore);
+        if (credential) {
+            try {
+                bootstrapInfo = await getBootstrapInfo(credential, cmsResourceId);
+            } catch (error) {
+                log.debug(`Control Plane Error: ${error.statusCode} - ${error.message}`);
+                if (error instanceof ControlPlaneError && (error.statusCode === 404 || error.statusCode === 410)) {
+                    p.log.error(pc.red(getProjectNotFoundMessage({
+                        environment: getInfraEnvironment(),
+                        projectId: cmsResourceId
+                    })));
+                    process.exit(1);
                 }
-            });
-            if (p.isCancel(input)) {
-                p.cancel('Operation cancelled');
-                process.exit(0);
-            }
-            tenantId = input;
-        }
-        // Try to fetch tenant details
-        try {
-            log.debug('Using mock Control Plane API (no real network calls)');
-            selectedTenant = await getTenantDetails(accessToken, tenantId);
-            log.debug(`Using: ${selectedTenant.domain}`);
-        } catch (error) {
-            p.log.error(pc.red('✗ Failed to fetch CMS details'));
-            // Check if permission error (403)
-            if (error instanceof ControlPlaneError && error.statusCode === 403) {
-                p.log.error('You do not have permission to access the provided CMS ID. Please try again.');
-            } else if (error instanceof ControlPlaneError && error.statusCode === 404) {
-                p.log.error('Tenant ID not found. Verify the ID is correct.');
-            } else {
-                p.log.error(error instanceof Error ? error.message : 'Unknown error');
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                p.log.error(pc.red(`✗ Unable to fetch project info for "${cmsResourceId}"`));
+                p.log.error(pc.dim(`Details: ${message}`));
+                process.exit(1);
             }
-            // Clear tenantId to prompt again
-            tenantId = undefined;
-            // Ask if they want to retry
-            const shouldRetry = await p.confirm({
-                initialValue: true,
-                message: 'Would you like to try a different CMS ID?'
-            });
-            if (p.isCancel(shouldRetry) || !shouldRetry) {
-                p.cancel('Operation cancelled');
+            try {
+                const envName = options.env ?? process.env.FIGMA_ENVIRONMENT_NAME ?? undefined;
+                resolvedEnv = resolveEnvironment({
+                    environmentName: envName,
+                    environments: bootstrapInfo.environments
+                });
+                oauthClientId = bootstrapInfo.oauthCredentials.oauthClientId;
+                oauthClientSecret = bootstrapInfo.oauthCredentials.oauthClientSecret;
+            } catch (error) {
+                p.log.error(pc.red(error instanceof Error ? error.message : 'Unknown error'));
                 process.exit(1);
             }
         }
@@ -171,6 +152,7 @@ import { loginCommand } from './login.js';
         log.debug('Project directory detected');
         // Detect Payload
         const projectInfo = await detectPayloadProject();
+        const packageManager = await resolvePackageManager(process.cwd());
         if (projectInfo.hasPayload) {
             // Validate existing Payload version
             if (projectInfo.payloadVersion && !validatePayloadVersion(projectInfo.payloadVersion)) {
@@ -190,19 +172,17 @@ import { loginCommand } from './login.js';
                 });
                 if (!p.isCancel(shouldInstall) && shouldInstall) {
                     s.start('Installing dependencies...');
-                    await installDependencies(process.cwd(), projectInfo.packageManager || 'pnpm');
+                    await installDependencies(process.cwd(), packageManager);
                     s.stop(pc.green('✓ Dependencies installed'));
                 }
             }
             s.start('Checking Payload configuration...');
-            const modResult = await ensurePayloadFigmaConfig(process.cwd(), projectInfo.packageManager || 'pnpm', {
-                region: options.region || 'us-east-1',
-                tenantId: selectedTenant.id,
-                useContentSystem: !options.noContentSystem
+            const modResult = await ensurePayloadFigmaConfig(process.cwd(), packageManager, {
+                contentSystemId: resolvedEnv?.contentSystemId ?? cmsResourceId
             });
             if (!modResult.success) {
                 s.stop(pc.red('✗ Configuration check failed'));
-                displayManualInstructions(modResult.error || 'Unknown error');
+                displayManualInstructions(modResult.error || 'Unknown error', packageManager);
                 process.exit(1);
             }
             if (modResult.modified) {
@@ -219,62 +199,79 @@ import { loginCommand } from './login.js';
                     p.log.warn(pc.yellow(`⚠ ${warning}`));
                 });
             }
-        } else {
-            // Has package.json but no Payload - offer to add Payload
-            p.log.warn(pc.yellow('⚠ No Payload detected in this project'));
-            const shouldAddPayload = await p.confirm({
-                initialValue: true,
-                message: 'Would you like to add Payload to this project?'
-            });
-            if (p.isCancel(shouldAddPayload)) {
-                p.cancel('Operation cancelled');
-                process.exit(0);
-            }
-            if (!shouldAddPayload) {
-                p.log.error('Payload is required to use Figma CMS');
-                process.exit(1);
+            // Write environment variables to .env file
+            try {
+                await addOrUpdateEnvVar(process.cwd(), 'FIGMA_PROJECT_ID', cmsResourceId);
+                await addOrUpdateEnvVar(process.cwd(), 'FIGMA_ENVIRONMENT_NAME', resolvedEnv?.name ?? 'production');
+                log.debug('Added FIGMA_PROJECT_ID and FIGMA_ENVIRONMENT_NAME to .env file');
+                const infraEnv = getInfraEnvironment();
+                if (infraEnv !== 'production') {
+                    await addOrUpdateEnvVar(process.cwd(), 'FIGMA_INFRA_ENV', infraEnv);
+                    log.debug(`Added FIGMA_INFRA_ENV=${infraEnv} to .env file`);
+                }
+                // Cache all environments in local encrypted store
+                if (bootstrapInfo && oauthClientId && oauthClientSecret) {
+                    cacheAllEnvironments(tokenStore, cmsResourceId, bootstrapInfo);
+                }
+            } catch (error) {
+                p.log.warn(pc.yellow(`⚠ Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`));
             }
-            // TODO: Add Payload to existing project (future enhancement)
-            p.log.error('Adding Payload to existing projects is not yet supported');
-            p.note('Create a new project or manually add Payload dependencies', 'Action Required');
+        } else {
+            p.log.warn(pc.yellow('⚠ Payload was not detected in this project'));
+            p.note('Run this command in a directory without an existing project or in an existing Payload project.', 'Action Required');
             process.exit(1);
         }
+        // Generate import map to prevent errors on first dev run
+        const importMapResult = await runScript(process.cwd(), 'generate:importmap', packageManager);
+        if (!importMapResult) {
+            p.log.warn(pc.yellow('⚠ Import map generation failed — it will be generated on first dev run'));
+        }
+        // Apply Lambda modifications (run.sh, standalone output, lambda:buildzip script)
+        await applyLambdaModifications(process.cwd(), packageManager);
+        // Ensure .gitignore has required entries
+        await ensureGitignore(process.cwd(), [
+            '.env',
+            '.env.local',
+            'lambda.zip'
+        ]);
         // Generate project token (unless skipping auth)
-        if (!options.skipAuth) {
-            await generateProjectTokenWithFeedback(tokenStore, selectedTenant.id, s);
+        if (!options.skipAuth && resolvedEnv) {
+            await generateProjectTokenWithFeedback(tokenStore, resolvedEnv.contentSystemId, s);
         }
         // Success message for existing project
         p.outro(pc.green('✓ Project initialized successfully!'));
         const nextSteps = [
-            selectedTenant.status === 'provisioning' ? 'Wait for CMS provisioning to complete (check status with `@payloadcms/figma list`)' : undefined,
-            'Start development server: `pnpm dev`',
-            `Access your CMS at: ${pc.cyan(`https://${selectedTenant.domain}`)}`
+            `Start development server: \`${getRunCommand(packageManager)} dev\``
         ].filter(Boolean);
         p.note(nextSteps.join('\n'), 'Next Steps');
     } else {
         // ===== NEW PROJECT FLOW =====
         // p.log.info('No project detected - Creating New Project')
-        // Prompt for path
-        const projectPathInput = await p.text({
-            initialValue: './',
-            message: 'Enter path to create project:',
-            placeholder: './my-cms-project',
-            validate: (value)=>{
-                if (!value) {
-                    return 'Path is required';
+        let projectPath;
+        if (options.name) {
+            projectPath = options.name;
+        } else {
+            const projectPathInput = await p.text({
+                initialValue: './',
+                message: 'Enter path to create project:',
+                placeholder: './my-cms-project',
+                validate: (value)=>{
+                    if (!value) {
+                        return 'Path is required';
+                    }
+                    // Allow relative or absolute paths
+                    return undefined;
                 }
-                // Allow relative or absolute paths
-                return undefined;
+            });
+            if (p.isCancel(projectPathInput)) {
+                p.cancel('Operation cancelled');
+                process.exit(0);
             }
-        });
-        if (p.isCancel(projectPathInput)) {
-            p.cancel('Operation cancelled');
-            process.exit(0);
+            projectPath = projectPathInput;
         }
-        const projectPath = projectPathInput;
         const fullPath = path.resolve(process.cwd(), projectPath);
-        // Get project name from path or prompt
-        const projectName = options.name || path.basename(fullPath);
+        const projectName = path.basename(fullPath);
+        const packageManager = detectPackageManagerFromEnvironment();
         // Create directory
         try {
             await fs.mkdir(fullPath, {
@@ -287,10 +284,10 @@ import { loginCommand } from './login.js';
         // Scaffold project
         s.start('Downloading template from GitHub...');
         try {
-            await scaffoldProject(fullPath, projectName);
+            await scaffoldProject(fullPath, projectName, packageManager);
             s.stop(pc.green('✓ Template downloaded'));
             s.start('Installing dependencies...');
-            await installDependencies(fullPath, 'pnpm');
+            await installDependencies(fullPath, packageManager);
             s.stop(pc.green('✓ Dependencies installed'));
         } catch (error) {
             s.stop(pc.red('✗ Failed'));
@@ -299,14 +296,12 @@ import { loginCommand } from './login.js';
         }
         // Modify Payload configuration
         s.start('Checking Payload configuration...');
-        const modResult = await ensurePayloadFigmaConfig(fullPath, 'pnpm', {
-            region: options.region || 'us-east-1',
-            tenantId: selectedTenant.id,
-            useContentSystem: !options.noContentSystem
+        const modResult = await ensurePayloadFigmaConfig(fullPath, packageManager, {
+            contentSystemId: resolvedEnv?.contentSystemId ?? cmsResourceId
         });
         if (!modResult.success) {
             s.stop(pc.red('✗ Configuration check failed'));
-            displayManualInstructions(modResult.error || 'Unknown error');
+            displayManualInstructions(modResult.error || 'Unknown error', packageManager);
             process.exit(1);
         }
         if (modResult.modified) {
@@ -323,9 +318,31 @@ import { loginCommand } from './login.js';
                 p.log.warn(pc.yellow(`⚠ ${warning}`));
             });
         }
+        // Write environment variables to .env file
+        try {
+            await addOrUpdateEnvVar(fullPath, 'FIGMA_PROJECT_ID', cmsResourceId);
+            await addOrUpdateEnvVar(fullPath, 'FIGMA_ENVIRONMENT_NAME', resolvedEnv?.name ?? 'production');
+            log.debug('Added FIGMA_PROJECT_ID and FIGMA_ENVIRONMENT_NAME to .env file');
+            const infraEnv = getInfraEnvironment();
+            if (infraEnv !== 'production') {
+                await addOrUpdateEnvVar(fullPath, 'FIGMA_INFRA_ENV', infraEnv);
+                log.debug(`Added FIGMA_INFRA_ENV=${infraEnv} to .env file`);
+            }
+            // Cache all environments in local encrypted store
+            if (bootstrapInfo && oauthClientId && oauthClientSecret) {
+                cacheAllEnvironments(tokenStore, cmsResourceId, bootstrapInfo);
+            }
+        } catch (error) {
+            p.log.warn(pc.yellow(`⚠ Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+        // Generate import map to prevent errors on first dev run
+        const importMapResult = await runScript(fullPath, 'generate:importmap', packageManager);
+        if (!importMapResult) {
+            p.log.warn(pc.yellow('⚠ Import map generation failed — it will be generated on first dev run'));
+        }
         // Generate project token (unless skipping auth)
-        if (!options.skipAuth) {
-            await generateProjectTokenWithFeedback(tokenStore, selectedTenant.id, s);
+        if (!options.skipAuth && resolvedEnv) {
+            await generateProjectTokenWithFeedback(tokenStore, resolvedEnv.contentSystemId, s);
         }
         // Initialize git repository (after all files including lock file are ready)
         initializeGitRepo(fullPath);
@@ -337,7 +354,7 @@ import { loginCommand } from './login.js';
         if (relativePath && relativePath !== '.') {
             nextSteps.push(`cd ${relativePath}`);
         }
-        nextSteps.push('pnpm dev or follow directions in README.md', '', 'Documentation:', '- Getting Started: https://payloadcms.com/docs/getting-started/what-is-payload', '- Configuration: https://payloadcms.com/docs/configuration/overview');
+        nextSteps.push(`${getRunCommand(packageManager)} dev or follow directions in README.md`, '', 'Documentation:', '- Getting Started: https://payloadcms.com/docs/getting-started/what-is-payload', '- Configuration: https://payloadcms.com/docs/configuration/overview');
         p.note(nextSteps.join('\n'), 'Next Steps');
         p.outro(pc.green('✓ Done'));
     }

package/dist/commands/list-tokens.d.ts

@@ -2,6 +2,8 @@
  * Options for list-tokens command
  */
 export interface ListTokensCommandOptions {
+    /** Show all environments */
+    all?: boolean;
     /** Enable debug mode */
     debug?: boolean;
 }
@@ -9,8 +11,6 @@ export interface ListTokensCommandOptions {
  * Handle the `@payloadcms/figma list-tokens` command
  *
  * Displays stored token information including OAuth and project tokens.
- *
- * @param _options - Command options (unused)
  */
-export declare function listTokensCommand(_options?: ListTokensCommandOptions): void;
+export declare function listTokensCommand(options?: ListTokensCommandOptions): void;
 //# sourceMappingURL=list-tokens.d.ts.map

package/dist/commands/list-tokens.js

@@ -1,25 +1,40 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { TokenStore } from '../auth/token-store.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment } from '../constants.js';
+import { formatEnvSuffix } from '../utils/format-env-suffix.js';
 import { isDebug } from '../utils/is-debug.js';
 import { formatTimestamp, maskToken, showProjectTokens } from '../utils/token-display.js';
+const ALL_ENVIRONMENTS = [
+    'production',
+    'staging'
+];
 /**
  * Handle the `@payloadcms/figma list-tokens` command
  *
  * Displays stored token information including OAuth and project tokens.
- *
- * @param _options - Command options (unused)
- */ export function listTokensCommand(_options = {}) {
-    const tokenStore = new TokenStore();
+ */ export function listTokensCommand(options = {}) {
+    if (options.all) {
+        // Show detailed info for all environments
+        for (const env of ALL_ENVIRONMENTS){
+            showTokenDetails(env);
+        }
+    } else {
+        // Show detailed info for current environment only
+        showTokenDetails(getInfraEnvironment());
+    }
+}
+function showTokenDetails(env) {
+    const tokenStore = getTokenStore(env);
     const tokens = tokenStore.getTokens();
     if (!tokens) {
-        p.log.warn(pc.yellow('No tokens found. Not authenticated.'));
+        p.log.warn(pc.yellow(`No tokens found${formatEnvSuffix(env, ' for ')}. Not authenticated.`));
         p.note(`Run ${pc.cyan('@payloadcms/figma login')} to authenticate`, 'Tip');
         return;
     }
     const isValid = tokenStore.hasValidTokens();
     const status = isValid ? pc.green('✓ Valid') : pc.red('✗ Expired');
-    p.log.step(pc.bold('Stored Tokens'));
+    p.log.step(pc.bold(`Token Status${formatEnvSuffix(env, ' (', ')')}`));
     // Build OAuth token info display
     const lines = [
         `Status:         ${status}`,

package/dist/commands/login.d.ts

@@ -1,8 +1,15 @@
+type LoginArgs = {
+    /** Set this to show next steps after login
+     * @default true
+     */
+    showNextSteps: boolean;
+};
 /**
  * Handle the `@payloadcms/figma login` command
  *
  * Authenticates the user with Figma OAuth2 and stores tokens locally.
  * If valid tokens already exist, shows an error message.
  */
-export declare function loginCommand(): Promise<void>;
+export declare function loginCommand(args?: LoginArgs): Promise<void>;
+export {};
 //# sourceMappingURL=login.d.ts.map

package/dist/commands/login.js

@@ -1,22 +1,29 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { executeOAuthFlow, getValidAccessToken, OAuthFlowError } from '../auth/oauth-flow.js';
-import { TokenStore } from '../auth/token-store.js';
-import { OAUTH_CONFIG } from '../config/oauth.js';
+import { CallbackError } from '../auth/callback-server.js';
+import { executeOAuthFlow, getValidCredential, OAuthFlowError } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getOAuthConfig } from '../config/oauth.js';
+import { getInfraEnvironment } from '../constants.js';
+import { formatEnvSuffix } from '../utils/format-env-suffix.js';
 import * as log from '../utils/log.js';
 /**
  * Handle the `@payloadcms/figma login` command
  *
  * Authenticates the user with Figma OAuth2 and stores tokens locally.
  * If valid tokens already exist, shows an error message.
- */ export async function loginCommand() {
-    const tokenStore = new TokenStore();
+ */ export async function loginCommand(args) {
+    const { showNextSteps } = args || {
+        showNextSteps: false
+    };
+    const env = getInfraEnvironment();
+    const tokenStore = getTokenStore(env);
     // Check for existing valid tokens
     try {
-        const existingToken = await getValidAccessToken(tokenStore);
-        if (existingToken) {
+        const existingCredential = await getValidCredential(tokenStore);
+        if (existingCredential) {
             const tokens = tokenStore.getTokens();
-            p.log.warn(pc.yellow('Already logged in'));
+            p.log.warn(pc.yellow(`Already logged in${formatEnvSuffix(env)}`));
             if (tokens?.userId) {
                 log.info(`User ID: ${tokens.userId}`);
             }
@@ -30,28 +37,39 @@ import * as log from '../utils/log.js';
     }
     // Start OAuth flow
     await handleAuthentication({
+        showNextSteps,
         tokenStore
     });
 }
 /**
  * Handle authentication flow
- */ async function handleAuthentication({ tokenStore }) {
+ */ async function handleAuthentication({ showNextSteps, tokenStore }) {
     try {
         // Execute OAuth flow
+        const oauthConfig = getOAuthConfig();
         const result = await executeOAuthFlow(tokenStore, {
-            clientId: OAUTH_CONFIG.clientId,
-            redirectUri: OAUTH_CONFIG.redirectUri,
-            scopes: OAUTH_CONFIG.scopes
+            clientId: oauthConfig.clientId,
+            redirectUri: oauthConfig.redirectUri,
+            scopes: oauthConfig.scopes
         });
-        p.log.success(pc.green('✓ You are now authenticated with Figma'));
+        const env = getInfraEnvironment();
+        p.log.success(pc.green(`✓ Logged in${formatEnvSuffix(env)}`));
         if (result.userId) {
             log.debug(`User ID: ${result.userId}`);
         }
         log.debug(`Token storage: ${pc.dim(tokenStore.getStoragePath())}`);
-        // Show next steps
-        p.note(`  ${pc.cyan('@payloadcms/figma init')}  Create a new CMS instance`, 'Next Steps');
+        // Show next steps unless disabled
+        if (showNextSteps !== false) {
+            p.note(`  ${pc.cyan('@payloadcms/figma init')}  Create a new CMS instance`, 'Next Steps');
+        }
     } catch (error) {
         if (error instanceof OAuthFlowError) {
+            const isTimeout = error.cause instanceof CallbackError && error.cause.code === 'timeout';
+            if (isTimeout) {
+                p.log.error(pc.red('✗ Authentication timed out.'));
+                p.note(`Run ${pc.cyan('@payloadcms/figma login')} to try again.`, 'Tip');
+                process.exit(1);
+            }
             log.error(error.message);
             if (error.cause) {
                 log.debug(`Cause: ${error.cause.message}`);

package/dist/commands/logout.d.ts

@@ -2,15 +2,16 @@
  * Options for logout command
  */
 export interface LogoutCommandOptions {
+    /** Logout from all environments */
+    all?: boolean;
     /** Enable debug mode */
     debug?: boolean;
 }
 /**
  * Handle the `@payloadcms/figma logout` command
  *
- * Clears all stored tokens (OAuth and project tokens) after confirmation.
- *
- * @param _options - Command options (unused)
+ * Clears stored tokens (OAuth and project tokens) after confirmation.
+ * By default clears only current environment. Use --all for all environments.
  */
-export declare function logoutCommand(_options?: LogoutCommandOptions): Promise<void>;
+export declare function logoutCommand(options?: LogoutCommandOptions): Promise<void>;
 //# sourceMappingURL=logout.d.ts.map