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

package/dist/commands/deploy.js

@@ -1,19 +1,19 @@
 import * as p from '@clack/prompts';
-import { spawn } from 'child_process';
-import path from 'path';
+import spawn from 'cross-spawn';
 import pc from 'picocolors';
-import { Project } from 'ts-morph';
-import { createDeployment, getTenantDetails, performDeployment } from '../api/control-plane.js';
-import { getValidAccessToken } from '../auth/oauth-flow.js';
-import { getValidProjectToken } from '../auth/project-token.js';
-import { TokenStore } from '../auth/token-store.js';
-import { collectStaticAssets, createLambdaZip, getFileSize } from '../utils/asset-collection.js';
+import { ControlPlaneError, createDeployment, getBootstrapInfo, performDeployment } from '../api/control-plane.js';
+import { tryGetCredential } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment, getProjectNotFoundMessage } from '../constants.js';
+import { getFileSize } from '../utils/asset-collection.js';
 import { detectBuild, getBuildCommand } from '../utils/build-detection.js';
+import { LAMBDA_MAX_UNZIPPED_BYTES } from '../utils/build-lambda-zip.js';
+import { detectAdapter } from '../utils/deploy-adapter.js';
+import { getEnvVar } from '../utils/env-management.js';
 import * as log from '../utils/log.js';
 import { getPackageManager } from '../utils/package-manager.js';
-import { readFigmaConfig } from '../utils/payload-config-ast.js';
-import { findPayloadConfig } from '../utils/payload-config-finder.js';
 import { isInProjectDirectory } from '../utils/project.js';
+import { resolveEnvironment } from '../utils/resolve-environment.js';
 import { uploadLambdaZip, uploadStaticAssets } from '../utils/s3-upload.js';
 import { loginCommand } from './login.js';
 /**
@@ -51,6 +51,17 @@ import { loginCommand } from './login.js';
  */ export async function deployCommand(options) {
     const projectPath = process.cwd();
     const spinner = p.spinner();
+    // Resolve project ID
+    let projectId = options.id;
+    if (!projectId) {
+        projectId = await getEnvVar(projectPath, 'FIGMA_PROJECT_ID') ?? undefined;
+    }
+    if (!projectId) {
+        p.log.error(pc.red('✗ Project ID not found. Run `@payloadcms/figma init` first, or use --id.'));
+        process.exit(1);
+    }
+    // Resolve environment name
+    const environmentName = options.env ?? await getEnvVar(projectPath, 'FIGMA_ENVIRONMENT_NAME') ?? undefined;
     try {
         // ===== PRE-FLIGHT CHECKS =====
         // Check if in project directory
@@ -59,71 +70,71 @@ import { loginCommand } from './login.js';
             p.note('Create a project or connect an existing one to Figma: npx @payloadcms/figma init', 'Tip');
             process.exit(1);
         }
-        // Find and read payload config
-        const configPath = await findPayloadConfig(projectPath);
-        if (!configPath) {
-            p.log.error(pc.red('✗ payload.config.ts not found'));
-            p.note('Run npx @payloadcms/figma init to configure your project.', 'Tip');
-            process.exit(1);
-        }
-        // Parse config with ts-morph
-        const project = new Project({
-            skipAddingFilesFromTsConfig: true
-        });
-        const sourceFile = project.addSourceFileAtPath(configPath);
-        // Read figma configuration from buildConfig
-        const config = readFigmaConfig(sourceFile);
-        if (!config || !config.tenantId) {
-            p.log.error(pc.red('✗ No figma configuration found in payload.config.ts'));
-            p.note('Run npx @payloadcms/figma init to configure your project.', 'Tip');
-            process.exit(1);
-        }
         // Check authentication
-        const tokenStore = new TokenStore();
-        let accessToken = await getValidAccessToken(tokenStore);
-        if (!accessToken) {
+        const tokenStore = getTokenStore();
+        let credential = await tryGetCredential(tokenStore);
+        if (!credential) {
             p.log.message('Please log in to continue');
             await loginCommand();
-            accessToken = await getValidAccessToken(tokenStore);
-            if (!accessToken) {
+            credential = await tryGetCredential(tokenStore);
+            if (!credential) {
                 p.log.error(pc.red('✗ Authentication failed'));
                 process.exit(1);
             }
         }
-        // Get project token
+        // Resolve tenant instance ID via bootstrap
+        spinner.start('Resolving deployment target...');
+        let tenantInstanceId;
         try {
-            await getValidProjectToken(tokenStore, config.tenantId);
+            const bootstrapInfo = await getBootstrapInfo(credential, projectId);
+            const resolvedEnv = resolveEnvironment({
+                environmentName,
+                environments: bootstrapInfo.environments
+            });
+            tenantInstanceId = resolvedEnv.tenantInstanceId;
+            spinner.stop(pc.green(`✓ Target: ${resolvedEnv.name}`));
         } catch (error) {
-            p.log.error(pc.yellow('⚠ Project token invalid'));
-            throw error;
+            if (error instanceof ControlPlaneError && (error.statusCode === 404 || error.statusCode === 410)) {
+                spinner.stop(pc.red('✗ Project not found'));
+                p.log.error(pc.red(getProjectNotFoundMessage({
+                    environment: getInfraEnvironment(),
+                    projectId
+                })));
+                process.exit(1);
+            }
+            spinner.stop(pc.red('✗ Failed to resolve deployment target'));
+            p.log.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
         }
-        // ===== BUILD VALIDATION =====
-        spinner.start('Checking for build...');
-        let buildInfo = await detectBuild(projectPath);
-        if (!buildInfo) {
-            spinner.stop(pc.yellow('⚠ No build found for this project.'));
-            // Try to find build command
+        // Signal buildFigmaConfig to extract schedules during build
+        process.env.FIGMA_EXTRACT_SCHEDULES = 'true';
+        // ===== BUILD =====
+        let buildInfo;
+        if (options.skipBuild) {
+            // User asserts build exists - verify it
+            spinner.start('Checking for build...');
+            buildInfo = await detectBuild(projectPath);
+            if (!buildInfo) {
+                spinner.stop(pc.red('✗ No build found'));
+                p.log.error('Use deploy without --skip-build to build first.');
+                process.exit(1);
+            }
+            spinner.stop(pc.green('✓ Build found'));
+            p.note([
+                `${pc.cyan('Build ID:')} ${buildInfo.buildId}`,
+                `${pc.cyan('Date:')} ${formatDate(buildInfo.timestamp)}`
+            ].join('\n'), 'Build Details');
+        } else {
+            // Always build (no prompt)
             const buildCmd = await getBuildCommand(projectPath);
             if (!buildCmd) {
                 p.log.error('No build script found in package.json');
                 p.note('Add a build script to package.json: "build": "next build"', 'Tip');
                 process.exit(1);
             }
-            // Prompt to run build
-            if (!options.yes) {
-                const shouldBuild = await p.confirm({
-                    initialValue: true,
-                    message: `Build command found in package.json. Run it?`
-                });
-                if (p.isCancel(shouldBuild) || !shouldBuild) {
-                    p.log.message('Cancelling deployment...');
-                    process.exit(0);
-                }
-            }
-            // Run build
             const packageManager = await getPackageManager(projectPath);
             const buildCommand = `${packageManager} run build`;
-            spinner.stop(`Running ${buildCommand}...\n`);
+            p.log.step(`Running ${buildCommand}...\n`);
             try {
                 // Stream build output to user with formatting
                 const buildProcess = spawn(packageManager, [
@@ -139,20 +150,20 @@ import { loginCommand } from './login.js';
                 });
                 // Indent and dim output
                 buildProcess.stdout?.on('data', (data)=>{
-                    const lines = data.toString().split('\n');
+                    const lines = data.toString().split(/\r?\n/);
                     lines.forEach((line)=>{
                         if (line.trim()) {
                             // eslint-disable-next-line no-console
-                            console.log(pc.dim(`      ${line}`)); // Standard output
+                            console.log(pc.dim(`      ${line}`));
                         }
                     });
                 });
                 buildProcess.stderr?.on('data', (data)=>{
-                    const lines = data.toString().split('\n');
+                    const lines = data.toString().split(/\r?\n/);
                     lines.forEach((line)=>{
                         if (line.trim()) {
                             // eslint-disable-next-line no-console
-                            console.log(pc.dim(`      ${line}`)); // Standard error
+                            console.log(pc.dim(`      ${line}`));
                         }
                     });
                 });
@@ -170,135 +181,164 @@ import { loginCommand } from './login.js';
                 }
                 process.exit(1);
             }
-            // Re-check for build
+            // Verify build output
             buildInfo = await detectBuild(projectPath);
             if (!buildInfo) {
-                p.log.error(pc.red('✗ Build completed but standalone build not found'));
-                p.note('Ensure next.config.js has output: "standalone"', 'Check Lambda Configuration');
+                p.log.error(pc.red('✗ Build completed but build output not found'));
+                p.note('Ensure your build produces a valid output directory.', 'Check Build Configuration');
                 process.exit(1);
             }
-        } else {
-            spinner.stop(pc.green('✓ Build found'));
-            p.note([
-                `${pc.cyan('Build ID:')} ${buildInfo.buildId}`,
-                `${pc.cyan('Date:')} ${formatDate(buildInfo.timestamp)}`
-            ].join('\n'), 'Build Details');
         }
         // ===== DEPLOYMENT PREPARATION =====
-        // Create Lambda zip
+        // Detect framework adapter
+        spinner.start('Detecting framework...');
+        const adapter = await detectAdapter(projectPath, options.adapter);
+        spinner.stop(pc.green(`✓ Detected ${adapter.name} adapter`));
+        // Collect pages and assets
+        spinner.start('Collecting assets...');
+        const pages = await adapter.collectPages(projectPath);
+        const assets = await adapter.collectAssets(projectPath);
+        spinner.stop(pc.green(`✓ ${pages.routes.length} pages, ${assets.routes.length} assets detected`));
+        // Create deployment package (if server adapter)
+        let zipPath = null;
+        let zipSize = 0;
+        let unzippedBytes = 0;
         spinner.start('Creating deployment package...');
         try {
-            await createLambdaZip(projectPath);
-            spinner.stop(pc.green('✓ Deployment package created'));
+            const bundle = await adapter.prepareLambdaBundle(projectPath);
+            if (bundle) {
+                zipPath = bundle.zipPath;
+                unzippedBytes = bundle.unzippedBytes;
+                zipSize = await getFileSize(zipPath);
+                spinner.stop(pc.green(`✓ Deployment package created (${formatBytes(zipSize)} zipped, ${formatBytes(unzippedBytes)} unzipped)`));
+            } else {
+                spinner.stop(pc.green('✓ Static site — no server package needed'));
+            }
         } catch (error) {
             spinner.stop(pc.red('✗ Failed to create deployment package'));
             throw error;
         }
-        // Collect static assets
-        spinner.start('Collecting static assets...');
-        const staticAssets = await collectStaticAssets(projectPath);
-        const zipPath = path.join(projectPath, 'lambda.zip');
-        const zipSize = await getFileSize(zipPath);
-        spinner.stop(pc.green(`✓ ${staticAssets.length} static assets detected`));
-        log.debug(`Lambda zip size: ${formatBytes(zipSize)}`);
-        log.debug(`Static assets: ${staticAssets.length} files`);
+        // Pre-flight: fail fast before the long upload when the unzipped bundle exceeds
+        // AWS Lambda's limit. The server enforces this too (and now returns a clear
+        // message), so --skip-size-check is a safe escape hatch if this client-side
+        // value ever drifts below the real limit.
+        if (zipPath && !options.skipSizeCheck && unzippedBytes >= LAMBDA_MAX_UNZIPPED_BYTES) {
+            spinner.stop(pc.red(`✗ Unzipped deployment size (${formatBytes(unzippedBytes)}) is at or over the ${formatBytes(LAMBDA_MAX_UNZIPPED_BYTES)} limit.`));
+            p.note('Reduce your deployment size (remove unused dependencies or large assets) and try again.\n' + 'To bypass this client-side check, re-run with --skip-size-check.', 'Deployment too large');
+            process.exit(1);
+        }
+        log.debug(`Adapter: ${adapter.name}`);
+        if (zipPath) {
+            log.debug(`Lambda zip size: ${formatBytes(zipSize)}`);
+        }
+        log.debug(`Pages: ${pages.routes.length} routes (${pages.uploadKeys.length} files)`);
+        log.debug(`Assets: ${assets.routes.length} files`);
         // ===== DEPLOYMENT CONFIRMATION =====
         if (!options.yes) {
             p.note([
+                `${pc.cyan('Adapter:')} ${adapter.name}`,
                 `${pc.cyan('Build ID:')} ${buildInfo.buildId}`,
-                `${pc.cyan('Date:')} ${formatDate(buildInfo.timestamp)}`,
-                `${pc.cyan('Code size:')} ${formatBytes(zipSize)}`,
-                `${pc.cyan('Static assets:')} ${staticAssets.length} files`
+                zipPath ? `${pc.cyan('Code size:')} ${formatBytes(zipSize)} zipped, ${formatBytes(unzippedBytes)} unzipped` : `${pc.cyan('Code:')} No server`,
+                `${pc.cyan('Pages:')} ${pages.routes.length} routes (${pages.uploadKeys.length} files)`,
+                `${pc.cyan('Assets:')} ${assets.uploadKeys.length} files`
             ].join('\n'), 'Details');
-            const shouldDeploy = await p.confirm({
-                initialValue: true,
-                message: 'Deploy this build to Figma?'
-            });
-            if (p.isCancel(shouldDeploy) || !shouldDeploy) {
-                p.log.message('Cancelling deployment...');
-                process.exit(0);
-            }
         }
         // ===== DEPLOYMENT EXECUTION =====
         // Step 1: Create deployment
         spinner.start('Creating deployment...');
-        let deploymentId;
-        let codeUploadUrl;
-        let staticAssetUploadUrls;
-        try {
-            const createResponse = await createDeployment(accessToken, config.tenantId, {
-                staticAssets
-            });
-            deploymentId = createResponse.deploymentId;
-            codeUploadUrl = createResponse.codeUploadUrl;
-            staticAssetUploadUrls = createResponse.staticAssetUploadUrls;
-            log.debug(`Deployment ID: ${deploymentId}`);
-        } catch (error) {
-            spinner.stop(pc.red('✗ Failed to create deployment'));
-            throw error;
+        // Build pages payload from route → asset keys mapping
+        const pagesPayload = {};
+        for (const [route, assetKeys] of Object.entries(pages.routeAssetMap)){
+            pagesPayload[route] = {
+                assets: assetKeys
+            };
         }
-        // Step 2: Upload code
-        spinner.message(`Uploading code (${formatBytes(zipSize)})...`);
-        try {
+        const createResponse = await createDeployment(credential, tenantInstanceId, {
+            adapter: adapter.name,
+            fallback: adapter.fallback,
+            pages: pagesPayload,
+            staticAssets: assets.uploadKeys
+        });
+        const deploymentId = createResponse.deploymentId;
+        const codeUploadUrl = createResponse.codeUploadUrl;
+        const staticAssetUploadUrls = createResponse.staticAssetUploadUrls;
+        const pageUploadUrls = createResponse.pageUploadUrls;
+        log.debug(`Deployment ID: ${deploymentId}`);
+        // Step 2: Upload code (skip for static sites)
+        if (zipPath) {
+            spinner.message(`Uploading code (${formatBytes(zipSize)})...`);
             await uploadLambdaZip(zipPath, codeUploadUrl);
             spinner.stop(pc.green(`✓ Code uploaded (${formatBytes(zipSize)})`));
-        } catch (error) {
-            spinner.stop(pc.red('✗ Failed to upload code'));
-            throw error;
         }
-        // Step 3: Upload static assets
-        if (staticAssets.length > 0) {
-            spinner.start('Uploading static assets...');
-            try {
-                const uploadResults = await uploadStaticAssets(projectPath, staticAssetUploadUrls, (uploaded, total)=>{
-                    spinner.message(`Uploading static assets (${uploaded}/${total})...`);
-                });
-                if (uploadResults.assetsFailed > 0) {
-                    spinner.stop(pc.yellow(`⚠ ${uploadResults.assetsUploaded}/${staticAssets.length} assets uploaded (${uploadResults.assetsFailed} failed)`));
-                    p.log.warning(`${uploadResults.assetsFailed} assets failed to upload. Deployment may be incomplete.`);
-                } else {
-                    spinner.stop(pc.green(`✓ Static assets uploaded (${uploadResults.assetsUploaded} files, ${formatBytes(uploadResults.totalBytesUploaded)})`));
-                }
-            } catch (error) {
-                spinner.stop(pc.red('✗ Failed to upload assets'));
-                throw error;
-            }
+        // Step 3: Upload page assets
+        const totalUploadCount = pages.uploadKeys.length + assets.uploadKeys.length;
+        let totalUploaded = 0;
+        let totalFailed = 0;
+        let totalBytes = 0;
+        if (pages.uploadKeys.length > 0) {
+            spinner.start('Uploading pages...');
+            const pageResults = await uploadStaticAssets({
+                assetUrls: pageUploadUrls,
+                onProgress: (uploaded, total)=>{
+                    spinner.message(`Uploading pages (${uploaded}/${total})...`);
+                },
+                pathMap: pages.pathMap,
+                projectPath
+            });
+            totalUploaded += pageResults.assetsUploaded;
+            totalFailed += pageResults.assetsFailed;
+            totalBytes += pageResults.totalBytesUploaded;
+            spinner.stop(pc.green(`✓ ${pageResults.assetsUploaded} page files uploaded`));
         }
-        // Step 4: Perform deployment
-        spinner.start('Performing deployment...');
-        try {
-            await performDeployment(accessToken, config.tenantId, {
-                deploymentId
+        // Step 4: Upload static assets
+        if (assets.uploadKeys.length > 0) {
+            spinner.start('Uploading assets...');
+            const assetResults = await uploadStaticAssets({
+                assetUrls: staticAssetUploadUrls,
+                onProgress: (uploaded, total)=>{
+                    spinner.message(`Uploading assets (${uploaded}/${total})...`);
+                },
+                pathMap: assets.pathMap,
+                projectPath
             });
-            spinner.stop(pc.green('✓ Deployment initiated'));
-        } catch (error) {
-            spinner.stop(pc.red('✗ Failed to perform deployment'));
-            throw error;
+            totalUploaded += assetResults.assetsUploaded;
+            totalFailed += assetResults.assetsFailed;
+            totalBytes += assetResults.totalBytesUploaded;
+            spinner.stop(pc.green(`✓ ${assetResults.assetsUploaded} asset files uploaded`));
+        }
+        if (totalFailed > 0) {
+            p.log.warning(`${totalFailed}/${totalUploadCount} files failed to upload. Deployment may be incomplete.`);
+        } else if (totalUploaded > 0) {
+            p.log.success(pc.green(`✓ All files uploaded (${totalUploaded} files, ${formatBytes(totalBytes)})`));
         }
+        // Step 4: Perform deployment
+        spinner.start('Performing deployment...');
+        const result = await performDeployment(credential, tenantInstanceId, {
+            deploymentId
+        });
+        const tenantDomains = result.tenantDomains ?? [];
+        spinner.stop(pc.green('✓ Deployment initiated'));
         // TODO: Add deployment progress tracking
         // Future: Poll deployment status and show progress
         // API endpoint: GET /v1/tenant/{tenant_id}/deploy/{deployment_id}/status
         // Success output
-        p.log.message('This usually takes 2-3 minutes to complete.');
-        // Get tenant details for URL
-        try {
-            const tenant = await getTenantDetails(accessToken, config.tenantId);
-            if (tenant.domain) {
-                p.log.message(`View: ${pc.cyan(`https://${tenant.domain}/`)}`);
-            }
-        } catch  {
-        // Non-critical - just skip URL display
+        if (tenantDomains.length > 0) {
+            p.log.step(`URL: ${pc.cyan(`https://${tenantDomains[0]}`)}`);
         }
-        p.note(`Manage your deployment at:\n${pc.cyan(`https://cms.figma.com/manage/tenants/${config.tenantId}`)}`, 'Next Steps');
+        p.log.step('This usually takes 2-3 minutes to complete.');
     } catch (error) {
-        spinner.stop(pc.red('✗ Failed'));
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        p.log.error(pc.red(`✗ ${message}`));
+        if (error instanceof ControlPlaneError) {
+            spinner.stop(pc.red(`✗ ${error.message}`));
+            if (error.statusCode) {
+                p.log.message(pc.dim(`  HTTP ${error.statusCode}`));
+            }
+        } else {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            spinner.stop(pc.red(`✗ ${message}`));
+        }
         if (options.debug && error instanceof Error && error.stack) {
             log.error(`Stack trace: ${error.stack}`);
         }
         process.exit(1);
     }
 }
-
-//# sourceMappingURL=deploy.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Handle the `@payloadcms/figma dump-tokens` command
+ *
+ * Exports decrypted versions of encrypted token store files in
+ * `oauth/` and `projects/` subdirectories (new structure) plus any legacy
+ * per-env directories from older package versions. Creates
+ * `.decrypted.json` files next to each encrypted `.json` file.
+ *
+ * Skips the `payloadcms-figma-crypto.json` salt file at the root.
+ */
+export declare function dumpTokensCommand(): Promise<void>;

package/dist/commands/dump-tokens.js

@@ -0,0 +1,67 @@
+import * as p from '@clack/prompts';
+import envPaths from 'env-paths';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { deriveEncryptionKey, exportDecryptedStoreFiles } from '../auth/crypto-utils.js';
+/**
+ * Handle the `@payloadcms/figma dump-tokens` command
+ *
+ * Exports decrypted versions of encrypted token store files in
+ * `oauth/` and `projects/` subdirectories (new structure) plus any legacy
+ * per-env directories from older package versions. Creates
+ * `.decrypted.json` files next to each encrypted `.json` file.
+ *
+ * Skips the `payloadcms-figma-crypto.json` salt file at the root.
+ */ export async function dumpTokensCommand() {
+    const encryptionKey = deriveEncryptionKey();
+    const newRoot = envPaths('payloadcms-figma').config;
+    const stagingLegacyRoot = envPaths('payloadcms-figma-staging').config;
+    const candidateDirs = [
+        path.join(newRoot, 'oauth'),
+        path.join(newRoot, 'projects'),
+        stagingLegacyRoot
+    ];
+    const targetDirs = Array.from(new Set(candidateDirs)).filter((dir)=>fsSync.existsSync(dir));
+    if (targetDirs.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log('No token store directories found.');
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(pc.yellow('⚠  dump-tokens writes DECRYPTED token files to disk.'));
+    // eslint-disable-next-line no-console
+    console.log('Target directories:');
+    for (const dir of targetDirs){
+        // eslint-disable-next-line no-console
+        console.log(`  ${dir}`);
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+    const confirmed = await p.confirm({
+        initialValue: false,
+        message: 'Continue? Remember to delete the decrypted files after use.'
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+        // eslint-disable-next-line no-console
+        console.log('Cancelled.');
+        return;
+    }
+    const decryptedFiles = [];
+    for (const dir of targetDirs){
+        decryptedFiles.push(...exportDecryptedStoreFiles(dir, encryptionKey));
+    }
+    if (decryptedFiles.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log('No encrypted files could be decrypted with the current machine key.');
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(`\nCreated ${decryptedFiles.length} decrypted file(s):`);
+    for (const file of decryptedFiles){
+        // eslint-disable-next-line no-console
+        console.log(`  ${file}`);
+    }
+    // eslint-disable-next-line no-console
+    console.log('\nNote: These files contain sensitive tokens. Delete after use.');
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,12 @@
+export interface EnvCommandOptions {
+    /** Environment name to switch to (skips interactive prompt) */
+    name?: string;
+}
+/**
+ * Handle the `@payloadcms/figma env [name]` command
+ *
+ * If name is provided, switches directly. Otherwise lists available
+ * environments with an interactive picker.
+ * Updates FIGMA_ENVIRONMENT_NAME in .env and caches all bootstrap data.
+ */
+export declare function envCommand(options: EnvCommandOptions): Promise<void>;

package/dist/commands/env.js

@@ -0,0 +1,86 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { getValidCredential } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import { addOrUpdateEnvVar, getEnvVar } from '../utils/env-management.js';
+import * as log from '../utils/log.js';
+/**
+ * Handle the `@payloadcms/figma env [name]` command
+ *
+ * If name is provided, switches directly. Otherwise lists available
+ * environments with an interactive picker.
+ * Updates FIGMA_ENVIRONMENT_NAME in .env and caches all bootstrap data.
+ */ export async function envCommand(options) {
+    const cwd = process.cwd();
+    const projectId = await getEnvVar(cwd, 'FIGMA_PROJECT_ID');
+    if (!projectId) {
+        p.log.error(pc.red('No project configured. Run `@payloadcms/figma init` first.'));
+        process.exit(1);
+    }
+    const currentEnv = await getEnvVar(cwd, 'FIGMA_ENVIRONMENT_NAME');
+    // Authenticate
+    const tokenStore = getTokenStore();
+    const credential = await getValidCredential(tokenStore);
+    if (!credential) {
+        p.log.error(pc.red('Not authenticated. Run `@payloadcms/figma login` first.'));
+        process.exit(1);
+    }
+    // Fetch available environments
+    const spinner = p.spinner();
+    spinner.start('Fetching environments...');
+    let environments;
+    try {
+        const bootstrapInfo = await getBootstrapInfo(credential, projectId);
+        environments = bootstrapInfo.environments;
+        cacheAllEnvironments(tokenStore, projectId, bootstrapInfo);
+    } catch (error) {
+        spinner.stop(pc.red('✗ Failed to fetch environments'));
+        p.log.error(pc.dim(`Details: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        process.exit(1);
+    }
+    if (environments.length === 0) {
+        spinner.stop(pc.red('✗ No environments found'));
+        process.exit(1);
+    }
+    spinner.stop(pc.green(`✓ ${environments.length} environment(s) available`));
+    // Resolve target environment
+    let targetName;
+    if (options.name) {
+        const match = environments.find((e)=>e.name === options.name);
+        if (!match) {
+            const available = environments.map((e)=>e.name).join(', ');
+            p.log.error(pc.red(`Unknown environment: ${options.name}`));
+            p.log.message(`Available: ${available}`);
+            process.exit(1);
+        }
+        targetName = match.name;
+    } else if (environments.length === 1) {
+        targetName = environments[0].name;
+        p.log.message(`Only one environment available: ${pc.cyan(targetName)}`);
+    } else {
+        const selected = await p.select({
+            message: 'Select an environment',
+            options: environments.map((env)=>({
+                    hint: env.name === currentEnv ? 'current' : undefined,
+                    label: env.name,
+                    value: env.name
+                }))
+        });
+        if (p.isCancel(selected)) {
+            p.cancel('Cancelled');
+            process.exit(0);
+        }
+        targetName = selected;
+    }
+    if (targetName === currentEnv) {
+        p.log.message(`Already on ${pc.cyan(targetName)}`);
+        return;
+    }
+    // Update .env
+    await addOrUpdateEnvVar(cwd, 'FIGMA_ENVIRONMENT_NAME', targetName);
+    log.debug(`Updated FIGMA_ENVIRONMENT_NAME to ${targetName}`);
+    p.log.success(pc.green(`✓ Switched to ${pc.cyan(targetName)}`));
+    p.log.message(pc.dim('Restart your dev server to apply the change.'));
+}