@payloadcms/figma 0.0.1-alpha.9 → 0.1.0-alpha.1

package/dist/utils/formatter.js

@@ -1,47 +1,57 @@
-import { spawn } from 'child_process';
+import spawn from 'cross-spawn';
 import path from 'path';
+import * as log from './log.js';
 /**
  * Format file with Prettier
  * Returns warning if formatting fails but does not throw
  */ export async function formatFile(filePath, packageManager) {
+    const cmd = `${packageManager} exec prettier --write ${filePath}`;
+    const cwd = path.dirname(filePath);
+    log.debug(`Running formatter: ${cmd} (cwd: ${cwd})`);
     return new Promise((resolve)=>{
         try {
-            const args = [
+            const child = spawn(packageManager, [
                 'exec',
                 'prettier',
                 '--write',
                 filePath
-            ];
-            const child = spawn(packageManager, args, {
-                cwd: path.dirname(filePath),
-                shell: true,
+            ], {
+                cwd,
                 stdio: 'pipe'
             });
+            let stderr = '';
+            child.stderr?.on('data', (data)=>{
+                stderr += data.toString();
+            });
             child.on('close', (code)=>{
                 if (code === 0) {
+                    log.debug('Prettier formatting succeeded');
                     resolve({
                         success: true
                     });
                 } else {
+                    const detail = stderr.trim();
+                    log.debug(`Prettier exited with code ${code}${detail ? `: ${detail}` : ''}`);
                     resolve({
                         success: false,
-                        warning: 'Could not format file with Prettier'
+                        warning: `Could not format file with Prettier (exit code ${code})${detail ? `: ${detail}` : ''}`
                     });
                 }
             });
-            child.on('error', ()=>{
+            child.on('error', (err)=>{
+                log.debug(`Prettier spawn error: ${err.message}`);
                 resolve({
                     success: false,
-                    warning: 'Could not format file with Prettier'
+                    warning: `Could not format file with Prettier: ${err.message}`
                 });
             });
-        } catch  {
+        } catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            log.debug(`Prettier failed to spawn: ${message}`);
             resolve({
                 success: false,
-                warning: 'Could not format file with Prettier'
+                warning: `Could not format file with Prettier: ${message}`
             });
         }
     });
 }
-
-//# sourceMappingURL=formatter.js.map

package/dist/utils/fs-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Recursively collect all file paths under a directory,
+ * returned as forward-slash-separated paths relative to baseDir.
+ */
+export declare function collectFilesRecursive(dir: string, baseDir: string): Promise<string[]>;
+/**
+ * Recursively sum the byte size of all files under a directory.
+ * Returns 0 for a missing or unreadable directory. Symlinks are not
+ * followed. Files that disappear or become unreadable between readdir
+ * and stat are skipped (treated as 0 bytes).
+ */
+export declare function getDirectorySize(dir: string): Promise<number>;

package/dist/utils/fs-utils.js

@@ -0,0 +1,55 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Recursively collect all file paths under a directory,
+ * returned as forward-slash-separated paths relative to baseDir.
+ */ export async function collectFilesRecursive(dir, baseDir) {
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const subFiles = await collectFilesRecursive(fullPath, baseDir);
+                files.push(...subFiles);
+            } else if (entry.isFile()) {
+                files.push(path.relative(baseDir, fullPath).split(path.sep).join('/'));
+            }
+        }
+    } catch  {
+    // Not accessible
+    }
+    return files;
+}
+/**
+ * Recursively sum the byte size of all files under a directory.
+ * Returns 0 for a missing or unreadable directory. Symlinks are not
+ * followed. Files that disappear or become unreadable between readdir
+ * and stat are skipped (treated as 0 bytes).
+ */ export async function getDirectorySize(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+    } catch  {
+        return 0;
+    }
+    let total = 0;
+    for (const entry of entries){
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySize(fullPath);
+        } else if (entry.isFile()) {
+            try {
+                const stats = await fs.stat(fullPath);
+                total += stats.size;
+            } catch  {
+            // File vanished or is unreadable between readdir and stat — skip it.
+            }
+        }
+    }
+    return total;
+}

package/dist/utils/git.d.ts

@@ -12,4 +12,3 @@ export declare function isGitRepo(projectPath: string): boolean;
  * @returns True if successful, false otherwise
  */
 export declare function tryInitRepoAndCommit(projectPath: string): boolean;
-//# sourceMappingURL=git.d.ts.map

package/dist/utils/git.js

@@ -88,5 +88,3 @@ import { execSync } from 'child_process';
         return false;
     }
 }
-
-//# sourceMappingURL=git.js.map

package/dist/utils/handle-upgrade.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Walk up from a directory to find the nearest package.json with name "@payloadcms/figma".
+ */
+export declare function findPackageRoot(startDir: string): Promise<null | string>;
+/**
+ * Build and pack the local @payloadcms/figma package, returning the tgz path.
+ */
+export declare function packLocalPackage(pkgDir: string): string;

package/dist/utils/handle-upgrade.js

@@ -0,0 +1,39 @@
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Walk up from a directory to find the nearest package.json with name "@payloadcms/figma".
+ */ export async function findPackageRoot(startDir) {
+    let dir = startDir;
+    while(true){
+        const pkgPath = path.join(dir, 'package.json');
+        try {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+            if (pkg.name === '@payloadcms/figma') {
+                return dir;
+            }
+        } catch  {
+        // No package.json here
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+/**
+ * Build and pack the local @payloadcms/figma package, returning the tgz path.
+ */ export function packLocalPackage(pkgDir) {
+    execSync('pnpm build', {
+        cwd: pkgDir,
+        stdio: 'pipe'
+    });
+    const tgzOutput = execSync('pnpm pack', {
+        cwd: pkgDir,
+        stdio: 'pipe'
+    }).toString().trim();
+    const tgzName = tgzOutput.split('\n').pop();
+    const tgzPath = path.join(pkgDir, tgzName);
+    return tgzPath;
+}

package/dist/utils/is-debug.d.ts

@@ -3,4 +3,3 @@
  * @returns true if DEBUG environment variable is set to 'true'
  */
 export declare const isDebug: () => boolean;
-//# sourceMappingURL=is-debug.d.ts.map

package/dist/utils/is-debug.js

@@ -4,5 +4,3 @@
  */ export const isDebug = ()=>{
     return process.env.DEBUG === 'true';
 };
-
-//# sourceMappingURL=is-debug.js.map

package/dist/utils/lambda-config.d.ts

@@ -1,7 +1,8 @@
+import type { PackageManager } from './package-manager.js';
 /**
  * Apply Lambda-specific modifications to a Payload project
  *
  * @param projectPath - Path to project directory
+ * @param packageManager - Package manager to use in scripts (defaults to 'npm')
  */
-export declare function applyLambdaModifications(projectPath: string): Promise<void>;
-//# sourceMappingURL=lambda-config.d.ts.map
+export declare function applyLambdaModifications(projectPath: string, packageManager?: PackageManager): Promise<void>;

package/dist/utils/lambda-config.js

@@ -1,36 +1,25 @@
-import { parseModule, Syntax } from 'esprima-next';
 import fs from 'fs/promises';
 import path from 'path';
+import { IndentationText, Node, Project, SyntaxKind } from 'ts-morph';
 const RUN_SH_CONTENT = `#!/bin/bash -x
 
 [ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
 
 NODE_ENV=production exec node server.js
 `;
-const BUILD_FOR_LAMBDA_SH_CONTENT = `#!/bin/bash
-
-cp -r .next/static .next/standalone/.next/static
-cp run.sh .next/standalone/run.sh
-cd .next/standalone
-zip -r --symlinks lambda.zip .
-mv lambda.zip ../..
-`;
 /**
  * Apply Lambda-specific modifications to a Payload project
  *
  * @param projectPath - Path to project directory
- */ export async function applyLambdaModifications(projectPath) {
+ * @param packageManager - Package manager to use in scripts (defaults to 'npm')
+ */ export async function applyLambdaModifications(projectPath, packageManager = 'npm') {
     // 1. Create run.sh
     const runShPath = path.join(projectPath, 'run.sh');
     await fs.writeFile(runShPath, RUN_SH_CONTENT, 'utf-8');
-    await fs.chmod(runShPath, 0o755); // rwxr-xr-x
-    // 2. Create build_for_lambda.sh
-    const buildShPath = path.join(projectPath, 'build_for_lambda.sh');
-    await fs.writeFile(buildShPath, BUILD_FOR_LAMBDA_SH_CONTENT, 'utf-8');
-    await fs.chmod(buildShPath, 0o755);
-    // 3. Modify next config to add standalone output
-    await addStandaloneToNextConfig(projectPath);
-    // 4. Create/update .npmrc
+    await fs.chmod(runShPath, 0o755);
+    // 2. Modify next config to add standalone output
+    await addNextConfigProperties(projectPath);
+    // 3. Create/update .npmrc
     const npmrcPath = path.join(projectPath, '.npmrc');
     let npmrcContent = '';
     try {
@@ -43,15 +32,15 @@ mv lambda.zip ../..
         npmrcContent += 'node-linker=hoisted\n';
         await fs.writeFile(npmrcPath, npmrcContent, 'utf-8');
     }
-    // 5. Add lambda:buildzip script to package.json
-    await addLambdaBuildScript(projectPath);
+    // 4. Add lambda:buildzip script to package.json
+    await addLambdaBuildScript(projectPath, packageManager);
 }
 /**
- * Find the Next.js config file (next.config.js or next.config.mjs)
- *
- * @todo Support TypeScript config files in future
+ * Find the Next.js config file, checking TS extensions first
  */ async function findNextConfigPath(projectPath) {
     const configFiles = [
+        'next.config.ts',
+        'next.config.mts',
         'next.config.js',
         'next.config.mjs'
     ];
@@ -64,81 +53,87 @@ mv lambda.zip ../..
         // File doesn't exist, try next one
         }
     }
-    throw new Error('Could not find next.config.js or next.config.mjs');
+    throw new Error('Could not find next.config.ts, next.config.mts, next.config.js, or next.config.mjs');
 }
 /**
- * Add standalone output to Next.js config using AST parsing
- */ async function addStandaloneToNextConfig(projectPath) {
+ * Add required Next.js config properties using ts-morph AST parsing
+ * - output: 'standalone' (for Lambda deployment)
+ */ async function addNextConfigProperties(projectPath) {
     const nextConfigPath = await findNextConfigPath(projectPath);
-    const content = await fs.readFile(nextConfigPath, 'utf-8');
-    // Check if output already configured (quick check before parsing)
-    if (content.includes('output:')) {
-        return; // Already configured
+    const project = new Project({
+        compilerOptions: {
+            allowJs: true
+        },
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces
+        },
+        skipAddingFilesFromTsConfig: true
+    });
+    const sourceFile = project.addSourceFileAtPath(nextConfigPath);
+    // Find the config object to modify
+    const configObject = findConfigObject(sourceFile);
+    if (!configObject) {
+        throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
+    }
+    const hasOutput = configObject.getProperty('output') !== undefined;
+    if (hasOutput) {
+        return;
     }
-    const ast = parseModule(content, {
-        loc: true
+    configObject.addPropertyAssignment({
+        name: 'output',
+        initializer: "'standalone'"
     });
-    // Find export default declaration
-    const exportDefaultDeclaration = ast.body.find((p)=>p.type === Syntax.ExportDefaultDeclaration);
-    if (!exportDefaultDeclaration?.declaration?.loc) {
-        throw new Error(`Could not find export default declaration in ${path.basename(nextConfigPath)}`);
+    await sourceFile.save();
+}
+/**
+ * Find the config object literal from either:
+ * - Direct export: `export default { ... }`
+ * - Wrapped export: `export default withPayload(configVar, ...)`
+ *   where configVar is a variable declaration with an object literal
+ */ function findConfigObject(sourceFile) {
+    const exportDefault = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+    if (!exportDefault) {
+        return undefined;
     }
-    // Find the object expression to modify
-    let targetObjectExpression;
-    if (exportDefaultDeclaration.declaration.type === 'ObjectExpression') {
-        // Direct export: export default { ... }
-        targetObjectExpression = exportDefaultDeclaration.declaration;
-    } else if (exportDefaultDeclaration.declaration.type === 'CallExpression') {
-        // Wrapped export: export default withPayload(nextConfig, ...)
-        const callExpr = exportDefaultDeclaration.declaration;
-        const firstArg = callExpr.arguments?.[0];
-        if (firstArg?.type === 'Identifier') {
-            // Find the variable declaration for this identifier
-            const configVarName = firstArg.name;
-            const varDeclaration = ast.body.find((node)=>{
-                if (node.type === Syntax.VariableDeclaration) {
-                    const varNode = node;
-                    return varNode.declarations?.some((decl)=>decl.id?.type === 'Identifier' && decl.id.name === configVarName && decl.init?.type === 'ObjectExpression');
-                }
-                return false;
-            });
-            if (varDeclaration) {
-                const declarator = varDeclaration.declarations?.find((decl)=>decl.id?.type === 'Identifier' && decl.id.name === configVarName);
-                if (declarator?.init?.type === 'ObjectExpression') {
-                    targetObjectExpression = declarator.init;
+    const expression = exportDefault.getExpression();
+    // Direct export: export default { ... }
+    if (Node.isObjectLiteralExpression(expression)) {
+        return expression;
+    }
+    // Wrapped export: export default withPayload(configVar, ...)
+    if (Node.isCallExpression(expression)) {
+        const firstArg = expression.getArguments()[0];
+        // Variable reference: export default withPayload(configVar)
+        if (firstArg && Node.isIdentifier(firstArg)) {
+            const configVarName = firstArg.getText();
+            // Find the variable declaration
+            const varStatements = sourceFile.getVariableStatements();
+            for (const statement of varStatements){
+                for (const decl of statement.getDeclarations()){
+                    if (decl.getName() === configVarName) {
+                        const initializer = decl.getInitializer();
+                        if (initializer && Node.isObjectLiteralExpression(initializer)) {
+                            return initializer;
+                        }
+                    }
                 }
             }
         }
     }
-    if (!targetObjectExpression?.loc) {
-        throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
-    }
-    const { loc } = targetObjectExpression;
-    const lines = content.split('\n');
-    // Insert output: 'standalone' as first property
-    const insertLine = loc.start.line - 1;
-    const insertColumn = loc.start.column + 1 // After opening brace
-    ;
-    // Find the content of the line with the opening brace
-    const targetLine = lines[insertLine];
-    if (!targetLine) {
-        throw new Error(`Could not find target line in ${path.basename(nextConfigPath)}`);
-    }
-    lines[insertLine] = targetLine.slice(0, insertColumn) + "\n  output: 'standalone'," + targetLine.slice(insertColumn);
-    const modifiedContent = lines.join('\n');
-    await fs.writeFile(nextConfigPath, modifiedContent, 'utf-8');
+    return undefined;
 }
 /**
  * Add lambda:buildzip script to package.json
- */ async function addLambdaBuildScript(projectPath) {
+ */ async function addLambdaBuildScript(projectPath, packageManager) {
     const packageJsonPath = path.join(projectPath, 'package.json');
     const content = await fs.readFile(packageJsonPath, 'utf-8');
     const packageJson = JSON.parse(content);
     if (!packageJson.scripts) {
         packageJson.scripts = {};
     }
-    packageJson.scripts['lambda:buildzip'] = 'npm run build && ./build_for_lambda.sh';
+    // Use package manager's run and exec commands
+    const runCmd = packageManager === 'npm' ? 'npm run' : packageManager;
+    const execCmd = packageManager === 'npm' ? 'npx' : `${packageManager} exec`;
+    packageJson.scripts['lambda:buildzip'] = `${runCmd} build && ${execCmd} payloadcms-figma build-lambda-zip`;
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
 }
-
-//# sourceMappingURL=lambda-config.js.map

package/dist/utils/load-payload-config.d.ts

@@ -0,0 +1,9 @@
+import type { SanitizedConfig } from 'payload';
+/**
+ * Load a project's Payload config without initializing Payload or connecting to its database.
+ *
+ * Payload's CLI uses tsx to evaluate TypeScript config files. Resolve that same loader from the
+ * project's Payload installation so this also works with strict package-manager layouts where
+ * tsx is not a direct dependency of @payloadcms/figma.
+ */
+export declare function loadPayloadConfig(projectPath: string): Promise<SanitizedConfig>;

package/dist/utils/load-payload-config.js

@@ -0,0 +1,27 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { findPayloadConfig } from './payload-config-finder.js';
+/**
+ * Load a project's Payload config without initializing Payload or connecting to its database.
+ *
+ * Payload's CLI uses tsx to evaluate TypeScript config files. Resolve that same loader from the
+ * project's Payload installation so this also works with strict package-manager layouts where
+ * tsx is not a direct dependency of @payloadcms/figma.
+ */ export async function loadPayloadConfig(projectPath) {
+    const configPath = await findPayloadConfig(projectPath);
+    if (!configPath) {
+        throw new Error('Payload config not found.');
+    }
+    const absoluteConfigPath = path.resolve(projectPath, configPath);
+    const { loadEnv } = await import('payload/node');
+    loadEnv();
+    const requireFromProject = createRequire(path.join(projectPath, 'package.json'));
+    const payloadEntryPath = requireFromProject.resolve('payload');
+    const requireFromPayload = createRequire(payloadEntryPath);
+    const tsxApiPath = requireFromPayload.resolve('tsx/esm/api');
+    const { tsImport } = await import(pathToFileURL(tsxApiPath).href);
+    const parentURL = pathToFileURL(`${projectPath}${path.sep}`).href;
+    const imported = await tsImport(absoluteConfigPath, parentURL);
+    return await (imported.default ?? imported);
+}

package/dist/utils/log.d.ts

@@ -3,4 +3,3 @@ export declare const info: (message: string) => void;
 export declare const error: (message: string) => void;
 export declare const debug: (message: string) => void;
 export declare const log: (message: string) => void;
-//# sourceMappingURL=log.d.ts.map

package/dist/utils/log.js

@@ -18,5 +18,3 @@ export const debug = (message)=>{
 export const log = (message)=>{
     p.log.message(message);
 };
-
-//# sourceMappingURL=log.js.map

package/dist/utils/messages.d.ts

@@ -1,4 +1,4 @@
-import type { PackageManager } from '../types.js';
+import type { PackageManager } from './package-manager.js';
 export declare function helpMessage(): void;
 export declare function successMessage(projectDir: string, packageManager: PackageManager): string;
 export declare function successfulNextInit(): string;
@@ -6,5 +6,3 @@ export declare function moveMessage(args: {
     nextAppDir: string;
     projectDir: string;
 }): string;
-export declare function feedbackOutro(): string;
-//# sourceMappingURL=messages.d.ts.map

package/dist/utils/messages.js

@@ -14,31 +14,70 @@ export function helpMessage() {
       ${pc.cyan('logout')}           Clear all stored tokens
       ${pc.cyan('list-tokens')}      Show stored token information
       ${pc.cyan('init')}             Initialize a Figma CMS project
+      ${pc.cyan('bootstrap')}        Print bootstrap info (tenant IDs, OAuth creds) for a project
+      ${pc.cyan('debug')}            Show debug info for troubleshooting
+      ${pc.cyan('env')}              Switch active environment
       ${pc.cyan('deploy')}           Deploy your project to Figma
+      ${pc.cyan('upgrade')}          Run upgrade migrations
+      ${pc.cyan('upload-schema')}    Upload collection schema to the Content API
+      ${pc.cyan('build-lambda-zip')} Build Lambda deployment zip
 
   ${pc.bold('OPTIONS')}
 
       ${pc.dim('-h, --help          Show help')}
+      ${pc.dim('-v, --version       Show CLI version')}
       ${pc.dim('--debug             Enable debug logging')}
 
   ${pc.bold('AUTHENTICATION')}
 
       ${pc.cyan('@payloadcms/figma login')}                Authenticate with Figma
-      ${pc.cyan('@payloadcms/figma logout')}               Clear all tokens (with confirmation)
+      ${pc.cyan('@payloadcms/figma logout')}               Clear tokens for current environment
       ${pc.cyan('@payloadcms/figma list-tokens')}          Display stored OAuth and project tokens
 
   ${pc.bold('INIT COMMAND')}
 
-      ${pc.cyan('@payloadcms/figma init --id <cms-id>')}   Initialize project with CMS ID
-      ${pc.cyan('@payloadcms/figma init')}                 Initialize (prompts for CMS ID)
-      ${pc.cyan('@payloadcms/figma init --name my-cms')}   Specify project name for new projects
-      ${pc.cyan('@payloadcms/figma init --force')}         Force reconfiguration of existing project
-      ${pc.cyan('@payloadcms/figma init --skip-auth')}     Skip authentication (testing only)
+      ${pc.cyan('@payloadcms/figma init --id <cms-resource-id>')}     Initialize project
+      ${pc.cyan('@payloadcms/figma init --id <id> --env staging')}    Initialize for specific environment
+      ${pc.dim('--name, -n <name>')}                     Set project directory name (skips prompt)
+      ${pc.dim('--force')}                               Force reconfiguration of existing project
+      ${pc.dim('--no-skill')}                            Skip installing the Payload skill into .claude/skills/payload/
+      ${pc.dim('--template, -t <spec>')}                  Override scaffold template (e.g. main:website, owner/repo#ref:path)
+      ${pc.dim('--payload-version <tag|version>')}        Core Payload npm dist-tag or version (default canary; e.g. latest, 4.0.0-canary.16)
+
+  ${pc.bold('BOOTSTRAP COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma bootstrap --id <cms-resource-id>')}   Print bootstrap info
+      ${pc.dim('--env <environment>')}                   Filter to a single environment
+      ${pc.dim('--json')}                                 Output JSON instead of styled note
+
+  ${pc.bold('ENV COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma env')}                    List and switch environments
+      ${pc.cyan('@payloadcms/figma env production')}          Switch to a named environment
 
   ${pc.bold('DEPLOY COMMAND')}
 
-      ${pc.cyan('@payloadcms/figma deploy')}               Deploy your project to Figma
-      ${pc.dim('--yes, -y')}          Skip confirmation prompts
+      ${pc.cyan('@payloadcms/figma deploy')}             Deploy your project to Figma
+      ${pc.dim('--id <project-id>')}                     Override FIGMA_PROJECT_ID
+      ${pc.dim('--env <environment>')}                   Override FIGMA_ENVIRONMENT_NAME
+      ${pc.dim('--yes, -y')}                             Skip confirmation prompts
+      ${pc.dim('--skip-build')}                          Skip building and use existing build
+      ${pc.dim('--skip-size-check')}                     Skip the client-side bundle size check
+
+  ${pc.bold('UPGRADE COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma upgrade')}              Run all upgrade migrations
+      ${pc.dim('--dry-run')}                               Preview changes without applying
+
+  ${pc.bold('UPLOAD SCHEMA COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma upload-schema')}          Upload collection schema for the active environment
+      ${pc.dim('--id <project-id>')}                       Override FIGMA_PROJECT_ID
+      ${pc.dim('--env <environment>')}                     Override FIGMA_ENVIRONMENT_NAME
+
+  ${pc.bold('GLOBAL OPTIONS')}
+
+      ${pc.dim('--infra-env <env>')}                     Target infrastructure (production, staging, or devbox)
 
   ${pc.bold('DOCUMENTATION')}
 
@@ -89,8 +128,3 @@ It is recommended to do this from your IDE if your app has existing file referen
 Once moved, rerun the @payloadcms/figma command again.
 `;
 }
-export function feedbackOutro() {
-    return `${pc.bgCyan(pc.black(' Have feedback? '))} Visit us on ${createTerminalLink('GitHub', 'https://github.com/payloadcms/payload')}.`;
-}
-
-//# sourceMappingURL=messages.js.map

package/dist/utils/package-manager.d.ts

@@ -9,4 +9,27 @@ export type PackageManager = 'npm' | 'pnpm' | 'yarn';
  * @returns Detected package manager, defaults to npm
  */
 export declare function getPackageManager(projectDir: string): Promise<PackageManager>;
-//# sourceMappingURL=package-manager.d.ts.map
+/**
+ * Resolve package manager for a project directory.
+ * Checks lockfiles first, falls back to environment detection.
+ *
+ * @param projectDir - Project directory to check
+ * @returns Resolved package manager
+ */
+export declare function resolvePackageManager(projectDir: string): Promise<PackageManager>;
+/**
+ * Detect package manager from npm_config_user_agent environment variable.
+ * Set automatically by npm/pnpm/yarn when running via npx/pnpm dlx/yarn dlx.
+ *
+ * @returns Detected package manager, defaults to npm
+ */
+export declare function detectPackageManagerFromEnvironment(): PackageManager;
+/**
+ * Get the run command prefix for a package manager.
+ * npm needs "npm run", pnpm/yarn can run scripts directly.
+ */
+export declare function getRunCommand(packageManager: PackageManager): string;
+/**
+ * Get the add/install command for a package manager.
+ */
+export declare function getAddCommand(packageManager: PackageManager): string;