@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.51

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 { getValidProjectToken, ProjectTokenError } from '../auth/project-token.js';
-import { TokenStore } from '../auth/token-store.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { CONTENT_SYSTEM_NOT_FOUND_MESSAGE, getInfraEnvironment } 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,48 +67,35 @@ 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 {
+            if (!tokenStore.hasValidTokens()) {
                 // 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);
-                    }
+                    s.stop('Authentication required to continue');
                     // Run login command
-                    await loginCommand();
+                    await loginCommand({
+                        showNextSteps: false
+                    });
                     // 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'));
                 }
             }
@@ -113,53 +109,39 @@ import { loginCommand } from './login.js';
     // 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 accessToken = await getValidAccessToken(tokenStore);
+        if (accessToken) {
+            try {
+                bootstrapInfo = await getBootstrapInfo(accessToken, cmsResourceId);
+                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) {
+                log.debug(`Control Plane Error: ${error.statusCode} - ${error.message}`);
+                if (error instanceof ControlPlaneError && (error.statusCode === 404 || error.statusCode === 410)) {
+                    p.log.error(pc.red(CONTENT_SYSTEM_NOT_FOUND_MESSAGE));
+                    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');
-            }
-            // 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');
+                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);
             }
         }
@@ -171,6 +153,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 +173,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,6 +200,23 @@ import { loginCommand } from './login.js';
                     p.log.warn(pc.yellow(`⚠ ${warning}`));
                 });
             }
+            // 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'}`));
+            }
         } else {
             // Has package.json but no Payload - offer to add Payload
             p.log.warn(pc.yellow('⚠ No Payload detected in this project'));
@@ -239,16 +237,24 @@ import { loginCommand } from './login.js';
             p.note('Create a new project or manually add Payload dependencies', 'Action Required');
             process.exit(1);
         }
+        // Generate import map to prevent errors on first dev run
+        await runScript(process.cwd(), 'generate:importmap', packageManager);
+        // 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 {
@@ -275,6 +281,7 @@ import { loginCommand } from './login.js';
         const fullPath = path.resolve(process.cwd(), projectPath);
         // Get project name from path or prompt
         const projectName = options.name || path.basename(fullPath);
+        const packageManager = detectPackageManagerFromEnvironment();
         // Create directory
         try {
             await fs.mkdir(fullPath, {
@@ -287,10 +294,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 +306,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 +328,28 @@ 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
+        await runScript(fullPath, 'generate:importmap', packageManager);
         // 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 +361,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 { CallbackError } from '../auth/callback-server.js';
 import { executeOAuthFlow, getValidAccessToken, OAuthFlowError } from '../auth/oauth-flow.js';
-import { TokenStore } from '../auth/token-store.js';
-import { OAUTH_CONFIG } from '../config/oauth.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 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

package/dist/commands/logout.js

@@ -1,24 +1,36 @@
 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 * as log from '../utils/log.js';
+const ALL_ENVIRONMENTS = [
+    'production',
+    'staging'
+];
 /**
  * Handle the `@payloadcms/figma logout` command
  *
- * Clears all stored tokens (OAuth and project tokens) after confirmation.
- *
- * @param _options - Command options (unused)
- */ export async function logoutCommand(_options = {}) {
-    const tokenStore = new TokenStore();
+ * Clears stored tokens (OAuth and project tokens) after confirmation.
+ * By default clears only current environment. Use --all for all environments.
+ */ export async function logoutCommand(options = {}) {
+    const currentEnv = getInfraEnvironment();
+    if (options.all) {
+        await logoutAllEnvironments();
+    } else {
+        await logoutSingleEnvironment(currentEnv);
+    }
+}
+async function logoutSingleEnvironment(env) {
+    const tokenStore = getTokenStore(env);
     const hasTokens = tokenStore.getTokens() !== null;
     if (!hasTokens) {
-        p.log.warn(pc.yellow('No tokens found. Already logged out.'));
+        p.log.warn(pc.yellow(`No tokens found${formatEnvSuffix(env, ' for ')}. Already logged out.`));
         return;
     }
-    // Confirm logout
     const confirmed = await p.confirm({
         initialValue: false,
-        message: 'This will clear all OAuth and project tokens. Continue?'
+        message: `This will clear all OAuth and project tokens${formatEnvSuffix(env, ' for ')}. Continue?`
     });
     if (p.isCancel(confirmed) || !confirmed) {
         p.log.info('Logout cancelled');
@@ -27,12 +39,43 @@ import * as log from '../utils/log.js';
     const s = p.spinner();
     s.start('Clearing tokens...');
     try {
-        // Clear OAuth tokens
         tokenStore.clearTokens();
-        // Clear all project tokens
         tokenStore.clearAllProjectTokens();
-        s.stop(pc.green('✓ Logged out successfully'));
-        p.log.step('All OAuth and project tokens have been cleared');
+        s.stop(pc.green(`✓ Logged out${formatEnvSuffix(env, ' from ')}`));
+    } catch (error) {
+        s.stop(pc.red('✗ Failed to clear tokens'));
+        log.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+async function logoutAllEnvironments() {
+    // Check which environments have tokens
+    const envsWithTokens = ALL_ENVIRONMENTS.filter((env)=>{
+        const store = getTokenStore(env);
+        return store.getTokens() !== null;
+    });
+    if (envsWithTokens.length === 0) {
+        p.log.warn(pc.yellow('No tokens found in any environment. Already logged out.'));
+        return;
+    }
+    const envList = envsWithTokens.join(' and ');
+    const confirmed = await p.confirm({
+        initialValue: false,
+        message: `This will clear all OAuth and project tokens for ${envList}. Continue?`
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+        p.log.info('Logout cancelled');
+        return;
+    }
+    const s = p.spinner();
+    s.start('Clearing tokens...');
+    try {
+        for (const env of envsWithTokens){
+            const store = getTokenStore(env);
+            store.clearTokens();
+            store.clearAllProjectTokens();
+        }
+        s.stop(pc.green('✓ Logged out from all environments'));
     } catch (error) {
         s.stop(pc.red('✗ Failed to clear tokens'));
         log.error(error instanceof Error ? error.message : 'Unknown error');