@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.61

package/dist/utils/formatter.js

@@ -1,44 +1,56 @@
-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}`
             });
         }
     });

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

@@ -0,0 +1,6 @@
+/**
+ * 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[]>;
+//# sourceMappingURL=fs-utils.d.ts.map

package/dist/utils/fs-utils.js

@@ -0,0 +1,27 @@
+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;
+}
+
+//# sourceMappingURL=fs-utils.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * 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;
+//# sourceMappingURL=handle-upgrade.d.ts.map

package/dist/utils/handle-upgrade.js

@@ -0,0 +1,41 @@
+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;
+}
+
+//# sourceMappingURL=handle-upgrade.js.map

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

@@ -1,7 +1,9 @@
+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>;
+export declare function applyLambdaModifications(projectPath: string, packageManager?: PackageManager): Promise<void>;
 //# sourceMappingURL=lambda-config.d.ts.map

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,80 +53,88 @@ 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');
 }
 

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,4 @@ 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,52 @@ 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('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('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.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.bold('UPGRADE COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma upgrade')}              Run all upgrade migrations
+      ${pc.dim('--dry-run')}                               Preview changes without applying
+
+  ${pc.bold('GLOBAL OPTIONS')}
+
+      ${pc.dim('--infra-env <env>')}                     Target infrastructure (production or staging)
 
   ${pc.bold('DOCUMENTATION')}
 
@@ -89,8 +110,5 @@ 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,28 @@ export type PackageManager = 'npm' | 'pnpm' | 'yarn';
  * @returns Detected package manager, defaults to npm
  */
 export declare function getPackageManager(projectDir: string): Promise<PackageManager>;
+/**
+ * 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;
 //# sourceMappingURL=package-manager.d.ts.map

package/dist/utils/package-manager.js

@@ -23,6 +23,59 @@ import path from 'path';
         return 'npm';
     }
 }
+/**
+ * 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 async function resolvePackageManager(projectDir) {
+    const fromLockfile = await getPackageManager(projectDir);
+    if (fromLockfile !== 'npm') {
+        return fromLockfile;
+    }
+    // Check if there's actually a package-lock.json (explicit npm choice)
+    if (await fileExists(path.join(projectDir, 'package-lock.json'))) {
+        return 'npm';
+    }
+    // No lockfile found — check environment
+    return detectPackageManagerFromEnvironment();
+}
+/**
+ * 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 function detectPackageManagerFromEnvironment() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent) {
+        return 'npm';
+    }
+    if (userAgent.startsWith('pnpm/')) {
+        return 'pnpm';
+    }
+    if (userAgent.startsWith('yarn/')) {
+        return 'yarn';
+    }
+    return 'npm';
+}
+/**
+ * Get the run command prefix for a package manager.
+ * npm needs "npm run", pnpm/yarn can run scripts directly.
+ */ export function getRunCommand(packageManager) {
+    return packageManager === 'npm' ? 'npm run' : packageManager;
+}
+/**
+ * Get the add/install command for a package manager.
+ */ export function getAddCommand(packageManager) {
+    if (packageManager === 'npm') {
+        return 'npm install';
+    }
+    if (packageManager === 'pnpm') {
+        return 'pnpm add';
+    }
+    return 'yarn add';
+}
 /**
  * Check if file exists
  */ async function fileExists(filePath) {

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

@@ -1,19 +1,39 @@
 import type { SourceFile } from 'ts-morph';
+/**
+ * Result of detecting what changes are needed in a payload config file
+ */
 export type DetectionResult = {
+    /** Database adapter configuration if present */
     dbProperty?: {
+        /** Name of the adapter function (e.g., 'mongooseAdapter', 'postgresAdapter') */
         adapter: string;
+        /** NPM package the adapter is imported from (e.g., '@payloadcms/db-mongodb') */
         importSource: string;
     };
+    /** Editor configuration if present */
     editorProperty?: {
+        /** NPM package the editor is imported from (e.g., '@payloadcms/richtext-lexical') */
         importSource: string;
+        /** Whether this is a default editor with no custom configuration */
         isDefault: boolean;
     };
+    /** Whether the config already has a `figma` property */
     figmaObjectExists: boolean;
+    /** Whether buildConfig/buildFigmaConfig uses an import alias (e.g., 'buildConfig as createConfig') */
     hasAlias: boolean;
+    /** Whether a buildConfig or buildFigmaConfig call was found (undefined if not checked) */
     hasBuildConfig?: boolean;
+    /** Whether there are other imports from 'payload' besides buildConfig (e.g., types) */
     hasOtherPayloadImports: boolean;
+    /** Whether the import needs to be changed from 'payload' to '@payloadcms/figma' */
     needsImportChange: boolean;
+    /** Whether a `secret` property exists in the config */
     secretProperty?: boolean;
+    /** Sharp configuration if present */
+    sharpProperty?: {
+        /** NPM package sharp is imported from (always 'sharp') */
+        importSource: string;
+    };
 };
 /**
  * Detect what changes are needed in the payload config file
@@ -29,9 +49,8 @@ export type ASTModificationResult = {
  */
 export declare function applyModifications(sourceFile: SourceFile, detection: DetectionResult): ASTModificationResult;
 export type FigmaPropertyConfig = {
-    region: string;
-    tenantId: string;
-    useContentSystem: boolean;
+    contentSystemId: string;
+    useContentSystem?: boolean;
 };
 /**
  * Add figma property to buildConfig if it doesn't exist
@@ -39,8 +58,10 @@ export type FigmaPropertyConfig = {
  */
 export declare function addFigmaProperty(sourceFile: SourceFile, config: FigmaPropertyConfig): ASTModificationResult;
 /**
- * Read figma configuration from payload.config.ts
- * Returns the figma object if it exists, null otherwise
+ * Remove the contentSystemId property from figma config object.
+ * Used during upgrade migration — contentSystemId is now resolved from bootstrap data.
+ *
+ * @returns true if the property was found and removed
  */
-export declare function readFigmaConfig(sourceFile: SourceFile): FigmaPropertyConfig | null;
+export declare function removeFigmaContentSystemId(sourceFile: SourceFile): boolean;
 //# sourceMappingURL=payload-config-ast.d.ts.map