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

package/dist/commands/debug.js

@@ -0,0 +1,161 @@
+import fsSync from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment } from '../constants.js';
+import { getEnvVarSync } from '../utils/env-management.js';
+import { maskToken } from '../utils/token-display.js';
+import { getOwnVersion } from '../utils/version-check.js';
+/**
+ * Handle the `@payloadcms/figma debug` command
+ *
+ * Outputs environment, auth, project, and package info for debugging.
+ * All data is local — no network calls are made.
+ */ export async function debugCommand() {
+    const env = getInfraEnvironment();
+    const tokenStore = getTokenStore(env);
+    const cwd = process.cwd();
+    const lines = [
+        'Debug Info:',
+        ''
+    ];
+    appendSystemSection(lines, env);
+    appendAuthSection(lines, tokenStore, cwd);
+    appendProjectSection(lines, tokenStore, cwd);
+    await appendPackagesSection(lines);
+    // eslint-disable-next-line no-console
+    console.log(lines.join('\n'));
+}
+function appendSystemSection(lines, env) {
+    lines.push(`Infra Environment:  ${env}`);
+    lines.push(`Node:               ${process.version}`);
+    lines.push(`OS:                 ${os.platform()} ${os.arch()}`);
+    lines.push('');
+}
+function appendAuthSection(lines, tokenStore, cwd) {
+    const tokens = tokenStore.getTokens();
+    lines.push('Auth:');
+    if (!tokens) {
+        lines.push('  Status:           Not authenticated');
+        lines.push('');
+        return;
+    }
+    const isValid = tokenStore.hasValidTokens();
+    lines.push(`  Status:           ${isValid ? 'Authenticated' : 'Token expired'}`);
+    const email = getEmailFromClaims(tokenStore, cwd);
+    if (email) {
+        lines.push(`  Email:            ${email}`);
+    } else if (tokens.userId) {
+        lines.push(`  User ID:          ${tokens.userId}`);
+    }
+    lines.push(`  Token Expires:    ${formatExpiryTime(tokens.expiresAt)}`);
+    lines.push('');
+}
+function appendProjectSection(lines, tokenStore, cwd) {
+    const projectId = getEnvVarSync(cwd, 'FIGMA_PROJECT_ID');
+    const environmentName = getEnvVarSync(cwd, 'FIGMA_ENVIRONMENT_NAME');
+    lines.push('Project:');
+    if (!projectId) {
+        lines.push("  Not initialized (run 'init' first)");
+        lines.push('');
+        return;
+    }
+    lines.push(`  Project ID:         ${projectId}`);
+    lines.push(`  Environment:        ${environmentName ?? '(not set)'}`);
+    // Show bootstrap data from local store
+    if (projectId && environmentName) {
+        const bootstrapData = tokenStore.getBootstrapData(projectId, environmentName);
+        if (bootstrapData) {
+            lines.push(`  Content System ID:  ${bootstrapData.contentSystemId}`);
+            lines.push(`  Tenant Instance ID: ${bootstrapData.tenantInstanceId}`);
+            lines.push(`  OAuth Client ID:    ${maskToken(bootstrapData.oauthClientId)}`);
+            const projectToken = tokenStore.getProjectToken(bootstrapData.contentSystemId);
+            if (projectToken) {
+                lines.push(`  Project Token:      ${formatExpiryTime(projectToken.expiresAt)}`);
+            }
+        } else {
+            lines.push('  Bootstrap Data:     (not cached)');
+        }
+    }
+    lines.push('');
+}
+async function appendPackagesSection(lines) {
+    lines.push('Packages:');
+    const cliVersion = await getOwnVersion();
+    lines.push(`  @payloadcms/figma:  ${cliVersion}`);
+    const payloadVersion = getPayloadVersion();
+    lines.push(`  payload:            ${payloadVersion}`);
+}
+/**
+ * Try resolving email from bootstrap data, then iterate all stored project tokens.
+ */ function getEmailFromClaims(tokenStore, cwd) {
+    const projectId = getEnvVarSync(cwd, 'FIGMA_PROJECT_ID');
+    const environmentName = getEnvVarSync(cwd, 'FIGMA_ENVIRONMENT_NAME');
+    if (projectId && environmentName) {
+        const bootstrapData = tokenStore.getBootstrapData(projectId, environmentName);
+        if (bootstrapData) {
+            const email = tokenStore.getProjectTokenClaims(bootstrapData.contentSystemId)?.email;
+            if (email) {
+                return email;
+            }
+        }
+    }
+    for (const id of tokenStore.getAllProjectTokenTenantIds()){
+        const email = tokenStore.getProjectTokenClaims(id)?.email;
+        if (email) {
+            return email;
+        }
+    }
+    return null;
+}
+function getPayloadVersion() {
+    try {
+        const require = createRequire(path.join(process.cwd(), 'noop.js'));
+        const resolved = require.resolve('payload');
+        const packageJsonPath = findPackageJson(path.dirname(resolved));
+        if (!packageJsonPath) {
+            return 'not found';
+        }
+        const content = fsSync.readFileSync(packageJsonPath, 'utf-8');
+        return JSON.parse(content).version;
+    } catch  {
+        return 'not found';
+    }
+}
+function findPackageJson(dir) {
+    const { root } = path.parse(dir);
+    while(dir !== root){
+        const candidate = path.join(dir, 'package.json');
+        if (fsSync.existsSync(candidate)) {
+            return candidate;
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Format expiry timestamp as ISO string with relative time
+ * e.g. "2026-02-11T10:30:00.000Z (in 23h 15m)" or "2026-02-10T08:00:00.000Z (expired 2h ago)"
+ */ function formatExpiryTime(expiresAt) {
+    const iso = new Date(expiresAt).toISOString();
+    const diff = expiresAt - Date.now();
+    if (diff < 0) {
+        return `${iso} (expired ${formatDuration(Math.abs(diff))} ago)`;
+    }
+    return `${iso} (in ${formatDuration(diff)})`;
+}
+function formatDuration(ms) {
+    const minutes = Math.floor(ms / 60000);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d ${hours % 24}h`;
+    }
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    return `${minutes}m`;
+}
+
+//# sourceMappingURL=debug.js.map

package/dist/commands/deploy.d.ts

@@ -4,6 +4,12 @@
 export interface DeployCommandOptions {
     /** Enable debug mode */
     debug?: boolean;
+    /** Figma environment name (e.g. 'production', 'staging') */
+    env?: string;
+    /** CMS Resource ID (overrides FIGMA_PROJECT_ID) */
+    id?: string;
+    /** Skip the build step (use existing build) */
+    skipBuild?: boolean;
     /** Skip confirmation prompts */
     yes?: boolean;
 }

package/dist/commands/deploy.js

@@ -1,19 +1,18 @@
 import * as p from '@clack/prompts';
-import { spawn } from 'child_process';
+import spawn from 'cross-spawn';
 import path from 'path';
 import pc from 'picocolors';
-import { Project } from 'ts-morph';
-import { createDeployment, getTenantDetails, performDeployment } from '../api/control-plane.js';
+import { ControlPlaneError, createDeployment, getBootstrapInfo, 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 { getTokenStore } from '../auth/token-store.js';
+import { CONTENT_SYSTEM_NOT_FOUND_MESSAGE } from '../constants.js';
 import { collectStaticAssets, createLambdaZip, getFileSize } from '../utils/asset-collection.js';
 import { detectBuild, getBuildCommand } from '../utils/build-detection.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 +50,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,27 +69,8 @@ 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();
+        const tokenStore = getTokenStore();
         let accessToken = await getValidAccessToken(tokenStore);
         if (!accessToken) {
             p.log.message('Please log in to continue');
@@ -90,40 +81,54 @@ import { loginCommand } from './login.js';
                 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(accessToken, 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('✗ Content system not found'));
+                p.log.error(pc.red(CONTENT_SYSTEM_NOT_FOUND_MESSAGE));
+                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
+        // ===== 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 +144,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,19 +175,13 @@ 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');
                 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
@@ -210,90 +209,59 @@ import { loginCommand } from './login.js';
                 `${pc.cyan('Code size:')} ${formatBytes(zipSize)}`,
                 `${pc.cyan('Static assets:')} ${staticAssets.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;
-        }
+        const createResponse = await createDeployment(accessToken, tenantInstanceId, {
+            staticAssets
+        });
+        const deploymentId = createResponse.deploymentId;
+        const codeUploadUrl = createResponse.codeUploadUrl;
+        const staticAssetUploadUrls = createResponse.staticAssetUploadUrls;
+        log.debug(`Deployment ID: ${deploymentId}`);
         // Step 2: Upload code
         spinner.message(`Uploading code (${formatBytes(zipSize)})...`);
-        try {
-            await uploadLambdaZip(zipPath, codeUploadUrl);
-            spinner.stop(pc.green(`✓ Code uploaded (${formatBytes(zipSize)})`));
-        } catch (error) {
-            spinner.stop(pc.red('✗ Failed to upload code'));
-            throw error;
-        }
+        await uploadLambdaZip(zipPath, codeUploadUrl);
+        spinner.stop(pc.green(`✓ Code uploaded (${formatBytes(zipSize)})`));
         // 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;
+            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)})`));
             }
         }
         // Step 4: Perform deployment
         spinner.start('Performing deployment...');
-        try {
-            await performDeployment(accessToken, config.tenantId, {
-                deploymentId
-            });
-            spinner.stop(pc.green('✓ Deployment initiated'));
-        } catch (error) {
-            spinner.stop(pc.red('✗ Failed to perform deployment'));
-            throw error;
-        }
+        const result = await performDeployment(accessToken, 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}`);
         }

package/dist/commands/env.d.ts

@@ -0,0 +1,13 @@
+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>;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.js

@@ -0,0 +1,88 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { getValidAccessToken } 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 accessToken = await getValidAccessToken(tokenStore);
+    if (!accessToken) {
+        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(accessToken, 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.'));
+}
+
+//# sourceMappingURL=env.js.map

package/dist/commands/init.d.ts

@@ -4,16 +4,14 @@
 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 authentication check (for testing/development) */
     skipAuth?: boolean;
     /** Skip prompts and use defaults where possible */