@payloadcms/figma 0.0.1-alpha.8 → 0.1.0-alpha.0

package/dist/commands/init.d.ts

@@ -4,18 +4,22 @@
 export interface InitCommandOptions {
     /** Enable debug mode */
     debug?: boolean;
+    /** Figma environment name (e.g. 'production', 'staging') */
+    env?: string;
     /** Force reconfiguration of existing project */
     force?: boolean;
-    /** Tenant ID to use (optional - will prompt if not provided) */
+    /** Content System ID to use */
     id?: string;
     /** Project name (for scaffolding) */
     name?: string;
-    /** Disable Content System (defaults to enabled) */
-    noContentSystem?: boolean;
-    /** AWS region for deployment (defaults to us-east-1) */
-    region?: string;
+    /** Skip Payload skill installation */
+    noSkill?: boolean;
+    /** npm dist-tag or explicit version for core payload packages (e.g. 'canary', 'latest', '4.0.0-canary.16'); defaults to 'canary' */
+    payloadVersion?: string;
     /** Skip authentication check (for testing/development) */
     skipAuth?: boolean;
+    /** GitHub template override, e.g. "main:website" or "owner/repo#ref:template-path" */
+    template?: string;
     /** Skip prompts and use defaults where possible */
     yes?: boolean;
 }
@@ -31,4 +35,3 @@ export interface InitCommandOptions {
  * @param options - Command options
  */
 export declare function initCommand(options: InitCommandOptions): Promise<void>;
-//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -2,30 +2,60 @@ 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 { downloadSkill } from '../lib/download-skill.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 { 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';
+import { DEFAULT_TEMPLATE_SOURCE } from '../utils/download-template.js';
+import { parseTemplateSpec, TemplateSpecParseError } from '../utils/parse-template-spec.js';
+async function maybeInstallPayloadSkill(args) {
+    if (args.noSkill) {
+        return;
+    }
+    const result = await downloadSkill({
+        projectDir: args.projectDir
+    });
+    if (result.ok) {
+        return;
+    }
+    if (result.reason === 'already-installed') {
+        return;
+    }
+    p.log.warn(pc.yellow(`⚠ Could not install Payload skill (${result.reason}${result.detail ? `: ${result.detail}` : ''}). Continuing.`));
+}
 /**
- * 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, projectInfo) {
     if (isDebug()) {
         spinner.start('Generating project token...');
     }
     try {
-        const projectToken = await getValidProjectToken(tokenStore, tenantId);
+        const projectToken = await getValidProjectToken({
+            projectInfo,
+            tenantId: contentSystemId,
+            tokenStore
+        });
         if (isDebug()) {
             if (projectToken) {
                 spinner.stop(pc.green('✓ Project token generated'));
@@ -58,108 +88,92 @@ import { loginCommand } from './login.js';
  *
  * @param options - Command options
  */ export async function initCommand(options) {
+    // Check for mismatched 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.hasValidOauthToken()) {
+            // 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 (p.isCancel(input)) {
-                p.cancel('Operation cancelled');
-                process.exit(0);
-            }
-            tenantId = input;
-        }
-        // Try to fetch tenant details
+    if (!options.id) {
+        p.log.error('CMS Resource ID is required. Use --id <cms-resource-id>');
+        process.exit(1);
+    }
+    const cmsResourceId = options.id;
+    // Parse --template spec early so malformed values abort before any I/O
+    let templateSource;
+    if (options.template) {
         try {
-            log.debug('Using mock Control Plane API (no real network calls)');
-            selectedTenant = await getTenantDetails(accessToken, tenantId);
-            log.debug(`Using: ${selectedTenant.domain}`);
+            templateSource = parseTemplateSpec(options.template);
         } 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 TemplateSpecParseError ? error.message : 'Invalid --template value';
+            p.log.error(pc.red(`✗ ${message}`));
+            p.note('Format: [<owner>/<repo>#]<ref>:<template-path>\n' + 'Examples:\n' + '  blank\n' + '  main:website\n' + '  myorg/payload-fork#feat-x:templates/custom', 'Template spec');
+            process.exit(1);
+        }
+    }
+    // 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);
+                }
+                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,11 +185,12 @@ 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)) {
-                p.log.warn(pc.yellow(`Payload version ${projectInfo.payloadVersion} detected. Version 3.x is required.`));
-                p.note('Upgrade to Payload 3.x before continuing', 'Action Required');
+                p.log.warn(pc.yellow(`Payload version ${projectInfo.payloadVersion} detected. Version 4.x or newer is required.`));
+                p.note('Upgrade to Payload 4.x or newer before continuing', 'Action Required');
                 process.exit(1);
             }
             p.log.success(pc.green(`✓ Payload ${projectInfo.payloadVersion || 'detected'}`));
@@ -190,19 +205,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 +232,93 @@ 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);
         }
+        // npm leaves node_modules in a transient state after a sequence of
+        // add/remove calls; a final install reconciles it so the project is
+        // immediately buildable.
+        s.start('Reconciling dependencies...');
+        try {
+            await installDependencies(process.cwd(), packageManager);
+            s.stop(pc.green('✓ Dependencies reconciled'));
+        } catch (error) {
+            s.stop(pc.red('✗ Failed to reconcile dependencies'));
+            log.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+        // 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'
+        ]);
+        await maybeInstallPayloadSkill({
+            noSkill: options.noSkill,
+            projectDir: process.cwd()
+        });
         // 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, {
+                environmentName: resolvedEnv.name,
+                projectId: cmsResourceId
+            });
         }
         // 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, {
@@ -285,12 +329,16 @@ import { loginCommand } from './login.js';
             process.exit(1);
         }
         // Scaffold project
-        s.start('Downloading template from GitHub...');
+        const resolvedSource = {
+            ...DEFAULT_TEMPLATE_SOURCE,
+            ...templateSource
+        };
+        s.start(`Downloading template "${resolvedSource.templatePath}" from ` + `${resolvedSource.owner}/${resolvedSource.repo}@${resolvedSource.ref}...`);
         try {
-            await scaffoldProject(fullPath, projectName);
+            await scaffoldProject(fullPath, projectName, packageManager, templateSource, options.payloadVersion);
             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 +347,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 +369,45 @@ 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'}`));
+        }
+        // npm leaves node_modules in a transient state after a sequence of
+        // add/remove calls; a final install reconciles it so the project is
+        // immediately buildable.
+        s.start('Reconciling dependencies...');
+        try {
+            await installDependencies(fullPath, packageManager);
+            s.stop(pc.green('✓ Dependencies reconciled'));
+        } catch (error) {
+            s.stop(pc.red('✗ Failed to reconcile dependencies'));
+            log.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+        await maybeInstallPayloadSkill({
+            noSkill: options.noSkill,
+            projectDir: fullPath
+        });
         // 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, {
+                environmentName: resolvedEnv.name,
+                projectId: cmsResourceId
+            });
         }
         // Initialize git repository (after all files including lock file are ready)
         initializeGitRepo(fullPath);
@@ -337,10 +419,8 @@ 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'));
     }
 }
-
-//# sourceMappingURL=init.js.map

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,5 @@ 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;
-//# sourceMappingURL=list-tokens.d.ts.map
+export declare function listTokensCommand(options?: ListTokensCommandOptions): void;

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();
-    const tokens = tokenStore.getTokens();
+ */ 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.getOauthInfo();
     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 isValid = tokenStore.hasValidOauthToken();
     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}`,
@@ -41,5 +56,3 @@ import { formatTimestamp, maskToken, showProjectTokens } from '../utils/token-di
     // Show project tokens if any exist
     showProjectTokens(tokenStore);
 }
-
-//# sourceMappingURL=list-tokens.js.map

package/dist/commands/login.d.ts

@@ -1,8 +1,14 @@
+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>;
-//# sourceMappingURL=login.d.ts.map
+export declare function loginCommand(args?: LoginArgs): Promise<void>;
+export {};