@payloadcms/figma 0.0.1-alpha.7 → 0.0.1-alpha.70

package/dist/utils/payload-package-check.d.ts

@@ -1,15 +1,46 @@
 import type { PackageManager } from './package-manager.js';
+export type PackageSpec = {
+    name: string;
+    version?: string;
+};
+export type UninstallResult = {
+    failedPackages: string[];
+    success: boolean;
+};
 /**
  * Check if a package is installed in dependencies (not devDependencies)
  */
 export declare function checkPackageInstalled(projectPath: string, packageName: string): Promise<boolean>;
+/**
+ * Get the payload version from project's package.json (without range specifiers)
+ * Returns the clean version number (e.g., "3.71.1") or undefined if not found
+ */
+export declare function getPayloadVersion(projectPath: string): Promise<string | undefined>;
 /**
  * Install a package as a production dependency
+ * @param version - Version to install (without caret). Defaults to 'latest'.
+ */
+export declare function installPackage(projectPath: string, packageName: string, packageManager: PackageManager, version?: string): Promise<void>;
+/**
+ * Install multiple packages as production dependencies in a single package-manager call.
+ * No-op when packages is empty. Throws on failure with exit code and truncated stderr.
  */
-export declare function installPackage(projectPath: string, packageName: string, packageManager: PackageManager): Promise<void>;
+export declare function installPackages(projectPath: string, packages: PackageSpec[], packageManager: PackageManager): Promise<void>;
 /**
  * Uninstall a package
  * Does not throw on failure - orphaned package is better than broken config
  */
-export declare function uninstallPackage(projectPath: string, packageName: string, packageManager: PackageManager): Promise<void>;
+export declare function uninstallPackage(projectPath: string, packageName: string, packageManager: PackageManager): Promise<UninstallResult>;
+/**
+ * Uninstall multiple packages in a single package-manager call.
+ * No-op when packageNames is empty. Does not throw — orphaned packages are
+ * preferable to a crash mid-config-rewrite. Returns a success flag so callers
+ * can avoid claiming "Uninstalled X" when the package manager actually failed.
+ */
+export declare function uninstallPackages(projectPath: string, packageNames: string[], packageManager: PackageManager): Promise<UninstallResult>;
+/**
+ * Run an npm script from package.json
+ * Does not throw on failure - logs warning and continues
+ */
+export declare function runScript(projectPath: string, scriptName: string, packageManager: PackageManager): Promise<boolean>;
 //# sourceMappingURL=payload-package-check.d.ts.map

package/dist/utils/payload-package-check.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import spawn from 'cross-spawn';
 import fs from 'fs/promises';
 import path from 'path';
 import * as log from './log.js';
@@ -18,27 +18,58 @@ import * as log from './log.js';
         return false;
     }
 }
+/**
+ * Get the payload version from project's package.json (without range specifiers)
+ * Returns the clean version number (e.g., "3.71.1") or undefined if not found
+ */ export async function getPayloadVersion(projectPath) {
+    try {
+        const pkgJsonPath = path.join(projectPath, 'package.json');
+        const pkgJsonContent = await fs.readFile(pkgJsonPath, 'utf-8');
+        const pkgJson = JSON.parse(pkgJsonContent);
+        const rawVersion = pkgJson.dependencies?.payload || pkgJson.devDependencies?.payload;
+        if (!rawVersion) {
+            return undefined;
+        }
+        // Strip range specifiers (^, ~, >=, etc.) to get clean version
+        return rawVersion.replace(/^[\^~>=<]+/, '');
+    } catch  {
+        return undefined;
+    }
+}
 /**
  * Install a package as a production dependency
- */ export async function installPackage(projectPath, packageName, packageManager) {
+ * @param version - Version to install (without caret). Defaults to 'latest'.
+ */ export async function installPackage(projectPath, packageName, packageManager, version = 'latest') {
+    return installPackages(projectPath, [
+        {
+            name: packageName,
+            version
+        }
+    ], packageManager);
+}
+/**
+ * Install multiple packages as production dependencies in a single package-manager call.
+ * No-op when packages is empty. Throws on failure with exit code and truncated stderr.
+ */ export async function installPackages(projectPath, packages, packageManager) {
+    if (packages.length === 0) {
+        return;
+    }
     return new Promise((resolve, reject)=>{
         const command = packageManager;
+        const packageSpecs = packages.map(({ name, version })=>name.endsWith('.tgz') ? name : `${name}@${version ?? 'latest'}`);
+        const installVerb = packageManager === 'npm' ? 'install' : 'add';
+        // -E pins exact version
         const args = [
-            'add',
-            packageName
+            installVerb,
+            '-E',
+            ...packageSpecs
         ];
-        // npm uses 'install' instead of 'add'
-        if (packageManager === 'npm') {
-            args[0] = 'install';
-        }
         log.debug(`Running: ${command} ${args.join(' ')} in ${projectPath}`);
         let stderr = '';
         const child = spawn(command, args, {
             cwd: projectPath,
-            shell: true,
             stdio: 'pipe'
         });
-        // Capture stderr for debug logging
         if (child.stderr) {
             child.stderr.on('data', (data)=>{
                 stderr += data.toString();
@@ -50,15 +81,17 @@ import * as log from './log.js';
         });
         child.on('close', (code)=>{
             if (code === 0) {
-                log.debug(`Successfully installed ${packageName}`);
+                log.debug(`Successfully installed ${packageSpecs.join(', ')}`);
                 resolve();
-            } else {
-                log.debug(`Failed to install ${packageName} (exit code: ${code})`);
-                if (stderr) {
-                    log.debug(`stderr: ${stderr}`);
-                }
-                reject(new Error(`Failed to install ${packageName}`));
+                return;
+            }
+            log.debug(`Batched install failed (exit code: ${code})`);
+            if (stderr) {
+                log.debug(`stderr: ${stderr}`);
             }
+            const truncatedStderr = stderr.trim().slice(-500);
+            const detail = truncatedStderr ? `\n${truncatedStderr}` : '';
+            reject(new Error(`Failed to install: ${packageSpecs.join(', ')} (exit code ${code})${detail}`));
         });
     });
 }
@@ -66,30 +99,98 @@ import * as log from './log.js';
  * Uninstall a package
  * Does not throw on failure - orphaned package is better than broken config
  */ export async function uninstallPackage(projectPath, packageName, packageManager) {
+    return uninstallPackages(projectPath, [
+        packageName
+    ], packageManager);
+}
+/**
+ * Uninstall multiple packages in a single package-manager call.
+ * No-op when packageNames is empty. Does not throw — orphaned packages are
+ * preferable to a crash mid-config-rewrite. Returns a success flag so callers
+ * can avoid claiming "Uninstalled X" when the package manager actually failed.
+ */ export async function uninstallPackages(projectPath, packageNames, packageManager) {
+    if (packageNames.length === 0) {
+        return {
+            failedPackages: [],
+            success: true
+        };
+    }
     return new Promise((resolve)=>{
         const command = packageManager;
         const args = [
-            'remove',
-            packageName
+            packageManager === 'npm' ? 'uninstall' : 'remove',
+            ...packageNames
         ];
-        // npm uses 'uninstall' instead of 'remove'
-        if (packageManager === 'npm') {
-            args[0] = 'uninstall';
-        }
         log.debug(`Running: ${command} ${args.join(' ')} in ${projectPath}`);
         const child = spawn(command, args, {
             cwd: projectPath,
-            shell: true,
             stdio: 'pipe'
         });
+        child.on('error', (error)=>{
+            log.debug(`Spawn error for ${command}: ${error.message}`);
+            resolve({
+                failedPackages: [
+                    ...packageNames
+                ],
+                success: false
+            });
+        });
         child.on('close', (code)=>{
             if (code === 0) {
-                log.debug(`Successfully uninstalled ${packageName}`);
+                log.debug(`Successfully uninstalled ${packageNames.join(', ')}`);
+                resolve({
+                    failedPackages: [],
+                    success: true
+                });
+                return;
+            }
+            log.debug(`Batched uninstall failed (exit code: ${code}), continuing anyway`);
+            resolve({
+                failedPackages: [
+                    ...packageNames
+                ],
+                success: false
+            });
+        });
+    });
+}
+/**
+ * Run an npm script from package.json
+ * Does not throw on failure - logs warning and continues
+ */ export async function runScript(projectPath, scriptName, packageManager) {
+    return new Promise((resolve)=>{
+        const command = packageManager;
+        // yarn doesn't need 'run' prefix, but it works with it too
+        const args = [
+            'run',
+            scriptName
+        ];
+        log.debug(`Running script: ${command} ${args.join(' ')} in ${projectPath}`);
+        let stderr = '';
+        const child = spawn(command, args, {
+            cwd: projectPath,
+            stdio: 'pipe'
+        });
+        if (child.stderr) {
+            child.stderr.on('data', (data)=>{
+                stderr += data.toString();
+            });
+        }
+        child.on('error', (error)=>{
+            log.debug(`Failed to run script ${scriptName}: ${error.message}`);
+            resolve(false);
+        });
+        child.on('close', (code)=>{
+            if (code === 0) {
+                log.debug(`Successfully ran script: ${scriptName}`);
+                resolve(true);
             } else {
-                log.debug(`Failed to uninstall ${packageName} (exit code: ${code}), continuing anyway`);
+                log.debug(`Script ${scriptName} failed (exit code: ${code})`);
+                if (stderr) {
+                    log.debug(`stderr: ${stderr}`);
+                }
+                resolve(false);
             }
-            // Always resolve, even on error
-            resolve();
         });
     });
 }

package/dist/utils/project.d.ts

@@ -2,6 +2,8 @@
  * Project detection and scaffolding utilities
  */
 import type { ProjectInfo } from '../types/config.js';
+import type { TemplateSource } from './download-template.js';
+import type { PackageManager } from './package-manager.js';
 /**
  * Detect if current directory has a Payload project
  *
@@ -21,8 +23,11 @@ export declare function validatePayloadVersion(version: string): boolean;
  *
  * @param projectPath - Path where to create the project
  * @param projectName - Name for the project
+ * @param packageManager - Package manager to use
+ * @param templateSource - Optional template source override
+ * @param payloadVersion - npm dist-tag or explicit version for core payload packages (default 'latest')
  */
-export declare function scaffoldProject(projectPath: string, projectName: string): Promise<void>;
+export declare function scaffoldProject(projectPath: string, projectName: string, packageManager?: PackageManager, templateSource?: Partial<TemplateSource>, payloadVersion?: string): Promise<void>;
 /**
  * Initialize git repository after all setup is complete
  *
@@ -38,7 +43,7 @@ export declare function initializeGitRepo(projectPath: string): void;
  * @param packageManager - Package manager to use
  * @returns Promise that resolves when installation completes
  */
-export declare function installDependencies(projectPath: string, packageManager?: 'npm' | 'pnpm' | 'yarn'): Promise<void>;
+export declare function installDependencies(projectPath: string, packageManager?: PackageManager): Promise<void>;
 /**
  * Check if required dependencies are installed
  *

package/dist/utils/project.js

@@ -1,13 +1,15 @@
 /**
  * Project detection and scaffolding utilities
- */ import { spawn } from 'child_process';
+ */ import spawn from 'cross-spawn';
 import fs from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { ensureGitignore } from './config.js';
 import { downloadTemplateFromGitHub } from './download-template.js';
-import { manageEnvFiles } from './env-management.js';
 import { tryInitRepoAndCommit } from './git.js';
 import { applyLambdaModifications } from './lambda-config.js';
+import { getRunCommand } from './package-manager.js';
+import { getOwnVersion } from './version-check.js';
 /**
  * Detect if current directory has a Payload project
  *
@@ -65,49 +67,62 @@ import { applyLambdaModifications } from './lambda-config.js';
     return majorVersion === 3;
 }
 /**
- * Fetch the latest version of a package from npm registry
+ * Resolve a package version from an npm dist-tag or an explicit version.
  *
- * @param packageName - Package name to fetch version for
- * @returns Latest version string
- */ async function getLatestPackageVersion(packageName) {
-    const response = await fetch(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch version for ${packageName}: ${response.statusText}`);
+ * A value matching a published dist-tag (e.g. 'latest', 'canary') resolves to
+ * that tag's concrete version. Any other value is treated as an explicit version
+ * and verified against the registry.
+ *
+ * @param packageName - Package name to look up
+ * @param versionOrTag - npm dist-tag or explicit semver version; defaults to 'latest'
+ * @returns The concrete version string to pin
+ */ async function resolvePackageVersion(packageName, versionOrTag = 'latest') {
+    const distTagsResponse = await fetch(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`);
+    if (!distTagsResponse.ok) {
+        throw new Error(`Failed to fetch versions for ${packageName}: ${distTagsResponse.statusText}`);
+    }
+    const distTags = await distTagsResponse.json();
+    const tagged = distTags[versionOrTag];
+    if (typeof tagged === 'string') {
+        return tagged;
     }
-    const data = await response.json();
-    if (typeof data.latest !== 'string') {
-        throw new Error(`Invalid version data received for ${packageName}`);
+    // Not a dist-tag — treat as an explicit version and verify it's published.
+    const versionResponse = await fetch(`https://registry.npmjs.org/${packageName}/${versionOrTag}`);
+    if (versionResponse.ok) {
+        return versionOrTag;
     }
-    return data.latest;
+    throw new Error(`No "${versionOrTag}" version or dist-tag published for ${packageName}. Available dist-tags: ${Object.keys(distTags).join(', ')}`);
 }
 /**
  * Replace workspace versions in package.json with actual versions
  *
  * @param packageJson - Package JSON object to update
- * @param latestVersion - Latest Payload version to use
- */ function replaceWorkspaceVersions(packageJson, latestVersion) {
+ * @param coreVersion - Resolved core Payload version to use
+ */ function replaceWorkspaceVersions(packageJson, coreVersion, figmaVersion) {
     const deps = packageJson.dependencies;
     if (!deps) {
         return;
     }
     for (const [key, value] of Object.entries(deps)){
-        // Replace workspace:* or workspace:^ with actual version
-        if (typeof value === 'string' && value.startsWith('workspace:')) {
-            deps[key] = latestVersion;
+        if (key === '@payloadcms/figma') {
+            deps[key] = figmaVersion;
+        } else if (typeof value === 'string' && value.startsWith('workspace:')) {
+            deps[key] = coreVersion;
         } else if (key === 'payload' || key.startsWith('@payloadcms/')) {
-            deps[key] = latestVersion;
+            deps[key] = coreVersion;
         }
     }
-    // Also handle devDependencies if present
     const devDeps = packageJson.devDependencies;
     if (!devDeps) {
         return;
     }
     for (const [key, value] of Object.entries(devDeps)){
-        if (typeof value === 'string' && value.startsWith('workspace:')) {
-            devDeps[key] = latestVersion;
+        if (key === '@payloadcms/figma') {
+            devDeps[key] = figmaVersion;
+        } else if (typeof value === 'string' && value.startsWith('workspace:')) {
+            devDeps[key] = coreVersion;
         } else if (key === 'payload' || key.startsWith('@payloadcms/')) {
-            devDeps[key] = latestVersion;
+            devDeps[key] = coreVersion;
         }
     }
 }
@@ -116,18 +131,24 @@ import { applyLambdaModifications } from './lambda-config.js';
  *
  * @param projectPath - Path where to create the project
  * @param projectName - Name for the project
- */ export async function scaffoldProject(projectPath, projectName) {
+ * @param packageManager - Package manager to use
+ * @param templateSource - Optional template source override
+ * @param payloadVersion - npm dist-tag or explicit version for core payload packages (default 'latest')
+ */ export async function scaffoldProject(projectPath, projectName, packageManager = 'npm', templateSource, payloadVersion = 'latest') {
     // Create project directory if it doesn't exist
     await fs.mkdir(projectPath, {
         recursive: true
     });
     // Download template from GitHub
-    await downloadTemplateFromGitHub(projectPath);
+    await downloadTemplateFromGitHub(projectPath, templateSource);
     // Apply Lambda modifications BEFORE updating package.json
     // This ensures we don't overwrite version replacements
-    await applyLambdaModifications(projectPath);
-    // Get latest Payload version from npm
-    const latestVersion = await getLatestPackageVersion('payload');
+    await applyLambdaModifications(projectPath, packageManager);
+    // Resolve core Payload version from the selected dist-tag or version; figma uses CLI version
+    const [coreVersion, figmaVersion] = await Promise.all([
+        resolvePackageVersion('payload', payloadVersion),
+        getOwnVersion()
+    ]);
     // Delete any existing lock files from template (they reference workspace:* versions)
     // This ensures pnpm install creates a fresh lock file with actual versions
     const lockFiles = [
@@ -149,16 +170,24 @@ import { applyLambdaModifications } from './lambda-config.js';
     const packageJson = JSON.parse(packageJsonContent);
     packageJson.name = projectName;
     // Replace workspace:* versions with actual versions
-    replaceWorkspaceVersions(packageJson, latestVersion);
+    replaceWorkspaceVersions(packageJson, coreVersion, figmaVersion);
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
-    // Manage environment files (generate PAYLOAD_SECRET)
-    await manageEnvFiles(projectPath);
     // Ensure .gitignore has required entries
+    // Note: .env file is created by init command with FIGMA_CONTENT_API_CONTENT_SYSTEM_ID
     await ensureGitignore(projectPath, [
         '.env',
         '.env.local',
         'lambda.zip'
     ]);
+    // Replace README with Figma-specific version
+    const readmeTemplatePath = fileURLToPath(new URL('../templates/README.md', import.meta.url));
+    let readmeContent = await fs.readFile(readmeTemplatePath, 'utf-8');
+    readmeContent = readmeContent.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+    readmeContent = readmeContent.replace(/\{\{RUN_COMMAND\}\}/g, getRunCommand(packageManager));
+    await fs.writeFile(path.join(projectPath, 'README.md'), readmeContent, 'utf-8');
+    // Copy .env.example template
+    const envExampleTemplatePath = fileURLToPath(new URL('../templates/.env.example', import.meta.url));
+    await fs.copyFile(envExampleTemplatePath, path.join(projectPath, '.env.example'));
 }
 /**
  * Initialize git repository after all setup is complete
@@ -181,7 +210,6 @@ import { applyLambdaModifications } from './lambda-config.js';
             'install'
         ], {
             cwd: projectPath,
-            shell: true,
             stdio: 'pipe'
         });
         let stdout = '';

package/dist/utils/resolve-environment.d.ts

@@ -0,0 +1,14 @@
+import type { BootstrapEnvironment } from '../api/control-plane.js';
+/**
+ * Resolve which environment to use from the bootstrap response.
+ *
+ * - Single environment: auto-select (environmentName optional, validated if provided)
+ * - Multiple environments: environmentName required, must match
+ *
+ * @throws Error if resolution fails (with available environment names)
+ */
+export declare function resolveEnvironment(params: {
+    environmentName?: string;
+    environments: BootstrapEnvironment[];
+}): BootstrapEnvironment;
+//# sourceMappingURL=resolve-environment.d.ts.map

package/dist/utils/resolve-environment.js

@@ -0,0 +1,31 @@
+/**
+ * Resolve which environment to use from the bootstrap response.
+ *
+ * - Single environment: auto-select (environmentName optional, validated if provided)
+ * - Multiple environments: environmentName required, must match
+ *
+ * @throws Error if resolution fails (with available environment names)
+ */ export function resolveEnvironment(params) {
+    const { environmentName, environments } = params;
+    if (environments.length === 0) {
+        throw new Error('No environments found for this project.');
+    }
+    if (environments.length === 1) {
+        if (environmentName && environments[0].name !== environmentName) {
+            throw new Error(`Environment "${environmentName}" not found. Available: ${environments[0].name}`);
+        }
+        return environments[0];
+    }
+    // Multiple environments — name required
+    const availableNames = environments.map((e)=>e.name).join(', ');
+    if (!environmentName) {
+        throw new Error(`Multiple environments available. Use --env to specify one: ${availableNames}`);
+    }
+    const matched = environments.find((e)=>e.name === environmentName);
+    if (!matched) {
+        throw new Error(`Environment "${environmentName}" not found. Available: ${availableNames}`);
+    }
+    return matched;
+}
+
+//# sourceMappingURL=resolve-environment.js.map

package/dist/utils/s3-upload.d.ts

@@ -18,7 +18,6 @@ export interface UploadResults {
  *
  * @param filePath - Absolute path to file to upload
  * @param signedUrl - Signed S3 upload URL
- * @param contentType - MIME type (optional)
  * @throws Error if upload fails after retries
  */
 export declare function uploadFile(filePath: string, signedUrl: string, contentType?: string): Promise<void>;
@@ -39,5 +38,11 @@ export declare function uploadLambdaZip(zipPath: string, signedUrl: string): Pro
  * @param onProgress - Optional callback for progress updates (uploaded, total)
  * @returns Upload results with counts
  */
-export declare function uploadStaticAssets(projectPath: string, assetUrls: Record<string, string>, onProgress?: (uploaded: number, total: number) => void): Promise<UploadResults>;
+export declare function uploadStaticAssets(params: {
+    assetUrls: Record<string, string>;
+    onProgress?: (uploaded: number, total: number) => void;
+    /** Map of S3 key → relative filesystem path (overrides default _next/ → .next/ resolution) */
+    pathMap?: Record<string, string>;
+    projectPath: string;
+}): Promise<UploadResults>;
 //# sourceMappingURL=s3-upload.d.ts.map

package/dist/utils/s3-upload.js

@@ -11,6 +11,37 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  */ function sleep(ms) {
     return new Promise((resolve)=>setTimeout(resolve, ms));
 }
+/** Common MIME types for web assets, keyed by file extension */ const MIME_TYPES = {
+    '.avif': 'image/avif',
+    '.css': 'text/css',
+    '.csv': 'text/csv',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.gif': 'image/gif',
+    '.html': 'text/html',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.map': 'application/json',
+    '.meta': 'application/json',
+    '.mjs': 'application/javascript',
+    '.mp4': 'video/mp4',
+    '.otf': 'font/otf',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.rsc': 'text/x-component',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain',
+    '.wasm': 'application/wasm',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip'
+};
 /**
  * Check if a signed URL is a mock URL
  */ function isMockUrl(signedUrl) {
@@ -23,7 +54,6 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  *
  * @param filePath - Absolute path to file to upload
  * @param signedUrl - Signed S3 upload URL
- * @param contentType - MIME type (optional)
  * @throws Error if upload fails after retries
  */ export async function uploadFile(filePath, signedUrl, contentType) {
     // Skip actual upload for mock URLs
@@ -45,10 +75,12 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
     let lastError = null;
     for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
         try {
+            const ext = path.extname(filePath).toLowerCase();
+            const determinedContentType = contentType ?? MIME_TYPES[ext];
             const response = await fetch(signedUrl, {
                 body: fileBuffer,
-                headers: contentType ? {
-                    'Content-Type': contentType
+                headers: determinedContentType ? {
+                    'Content-Type': determinedContentType
                 } : {},
                 method: 'PUT'
             });
@@ -83,7 +115,8 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  * @param assetUrls - Map of asset paths to signed URLs
  * @param onProgress - Optional callback for progress updates (uploaded, total)
  * @returns Upload results with counts
- */ export async function uploadStaticAssets(projectPath, assetUrls, onProgress) {
+ */ export async function uploadStaticAssets(params) {
+    const { assetUrls, onProgress, pathMap, projectPath } = params;
     const results = {
         assetsFailed: 0,
         assetsUploaded: 0,
@@ -100,8 +133,8 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
         const batch = assetPaths.slice(i, i + CONCURRENCY);
         await Promise.all(batch.map(async (assetPath)=>{
             try {
-                // Convert _next back to .next for file system
-                const fsPath = assetPath.replace(/^_next\//, '.next/');
+                // Resolve filesystem path: use pathMap if available, else default _next/ → .next/
+                const fsPath = pathMap?.[assetPath] ?? assetPath.replace(/^_next\//, '.next/');
                 const fullPath = path.join(projectPath, fsPath);
                 const signedUrl = assetUrls[assetPath];
                 await uploadFile(fullPath, signedUrl);

package/dist/utils/token-display.d.ts

@@ -8,7 +8,11 @@ export declare function maskToken(token: string): string;
  */
 export declare function formatTimestamp(timestamp: number): string;
 /**
- * Show all stored project tokens
+ * Show the project token for the current project + environment scope.
+ *
+ * Resolves `projectId` and `environmentName` from env vars
+ * (`FIGMA_PROJECT_ID`, `FIGMA_ENVIRONMENT_NAME`) — the *user's* project
+ * environment, which is independent of the infra env (production/staging).
  */
 export declare function showProjectTokens(tokenStore: TokenStore): void;
 //# sourceMappingURL=token-display.d.ts.map