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

package/dist/commands/login.js

@@ -1,22 +1,29 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { executeOAuthFlow, getValidAccessToken, OAuthFlowError } from '../auth/oauth-flow.js';
-import { TokenStore } from '../auth/token-store.js';
-import { OAUTH_CONFIG } from '../config/oauth.js';
+import { CallbackError } from '../auth/callback-server.js';
+import { executeOAuthFlow, getValidCredential, OAuthFlowError } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getOAuthConfig } from '../config/oauth.js';
+import { getInfraEnvironment } from '../constants.js';
+import { formatEnvSuffix } from '../utils/format-env-suffix.js';
 import * as log from '../utils/log.js';
 /**
  * Handle the `@payloadcms/figma login` command
  *
  * Authenticates the user with Figma OAuth2 and stores tokens locally.
  * If valid tokens already exist, shows an error message.
- */ export async function loginCommand() {
-    const tokenStore = new TokenStore();
+ */ export async function loginCommand(args) {
+    const { showNextSteps } = args || {
+        showNextSteps: false
+    };
+    const env = getInfraEnvironment();
+    const tokenStore = getTokenStore(env);
     // Check for existing valid tokens
     try {
-        const existingToken = await getValidAccessToken(tokenStore);
-        if (existingToken) {
-            const tokens = tokenStore.getTokens();
-            p.log.warn(pc.yellow('Already logged in'));
+        const existingCredential = await getValidCredential(tokenStore);
+        if (existingCredential) {
+            const tokens = tokenStore.getOauthInfo();
+            p.log.warn(pc.yellow(`Already logged in${formatEnvSuffix(env)}`));
             if (tokens?.userId) {
                 log.info(`User ID: ${tokens.userId}`);
             }
@@ -30,28 +37,39 @@ import * as log from '../utils/log.js';
     }
     // Start OAuth flow
     await handleAuthentication({
+        showNextSteps,
         tokenStore
     });
 }
 /**
  * Handle authentication flow
- */ async function handleAuthentication({ tokenStore }) {
+ */ async function handleAuthentication({ showNextSteps, tokenStore }) {
     try {
         // Execute OAuth flow
+        const oauthConfig = getOAuthConfig();
         const result = await executeOAuthFlow(tokenStore, {
-            clientId: OAUTH_CONFIG.clientId,
-            redirectUri: OAUTH_CONFIG.redirectUri,
-            scopes: OAUTH_CONFIG.scopes
+            clientId: oauthConfig.clientId,
+            redirectUri: oauthConfig.redirectUri,
+            scopes: oauthConfig.scopes
         });
-        p.log.success(pc.green('✓ You are now authenticated with Figma'));
+        const env = getInfraEnvironment();
+        p.log.success(pc.green(`✓ Logged in${formatEnvSuffix(env)}`));
         if (result.userId) {
             log.debug(`User ID: ${result.userId}`);
         }
         log.debug(`Token storage: ${pc.dim(tokenStore.getStoragePath())}`);
-        // Show next steps
-        p.note(`  ${pc.cyan('@payloadcms/figma init')}  Create a new CMS instance`, 'Next Steps');
+        // Show next steps unless disabled
+        if (showNextSteps !== false) {
+            p.note(`  ${pc.cyan('@payloadcms/figma init')}  Create a new CMS instance`, 'Next Steps');
+        }
     } catch (error) {
         if (error instanceof OAuthFlowError) {
+            const isTimeout = error.cause instanceof CallbackError && error.cause.code === 'timeout';
+            if (isTimeout) {
+                p.log.error(pc.red('✗ Authentication timed out.'));
+                p.note(`Run ${pc.cyan('@payloadcms/figma login')} to try again.`, 'Tip');
+                process.exit(1);
+            }
             log.error(error.message);
             if (error.cause) {
                 log.debug(`Cause: ${error.cause.message}`);
@@ -62,5 +80,3 @@ import * as log from '../utils/log.js';
         process.exit(1);
     }
 }
-
-//# sourceMappingURL=login.js.map

package/dist/commands/logout.d.ts

@@ -2,15 +2,15 @@
  * Options for logout command
  */
 export interface LogoutCommandOptions {
+    /** Logout from all environments */
+    all?: boolean;
     /** Enable debug mode */
     debug?: boolean;
 }
 /**
  * Handle the `@payloadcms/figma logout` command
  *
- * Clears all stored tokens (OAuth and project tokens) after confirmation.
- *
- * @param _options - Command options (unused)
+ * Clears stored tokens (OAuth and project tokens) after confirmation.
+ * By default clears only current environment. Use --all for all environments.
  */
-export declare function logoutCommand(_options?: LogoutCommandOptions): Promise<void>;
-//# sourceMappingURL=logout.d.ts.map
+export declare function logoutCommand(options?: LogoutCommandOptions): Promise<void>;

package/dist/commands/logout.js

@@ -1,24 +1,37 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { TokenStore } from '../auth/token-store.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment } from '../constants.js';
+import { getEnvVarSync } from '../utils/env-management.js';
+import { formatEnvSuffix } from '../utils/format-env-suffix.js';
 import * as log from '../utils/log.js';
+const ALL_ENVIRONMENTS = [
+    'production',
+    'staging'
+];
 /**
  * Handle the `@payloadcms/figma logout` command
  *
- * Clears all stored tokens (OAuth and project tokens) after confirmation.
- *
- * @param _options - Command options (unused)
- */ export async function logoutCommand(_options = {}) {
-    const tokenStore = new TokenStore();
-    const hasTokens = tokenStore.getTokens() !== null;
+ * Clears stored tokens (OAuth and project tokens) after confirmation.
+ * By default clears only current environment. Use --all for all environments.
+ */ export async function logoutCommand(options = {}) {
+    const currentEnv = getInfraEnvironment();
+    if (options.all) {
+        await logoutAllEnvironments();
+    } else {
+        await logoutSingleEnvironment(currentEnv);
+    }
+}
+async function logoutSingleEnvironment(env) {
+    const tokenStore = getTokenStore(env);
+    const hasTokens = tokenStore.getOauthInfo() !== null;
     if (!hasTokens) {
-        p.log.warn(pc.yellow('No tokens found. Already logged out.'));
+        p.log.warn(pc.yellow(`No tokens found${formatEnvSuffix(env, ' for ')}. Already logged out.`));
         return;
     }
-    // Confirm logout
     const confirmed = await p.confirm({
         initialValue: false,
-        message: 'This will clear all OAuth and project tokens. Continue?'
+        message: `This will clear all OAuth and project tokens${formatEnvSuffix(env, ' for ')}. Continue?`
     });
     if (p.isCancel(confirmed) || !confirmed) {
         p.log.info('Logout cancelled');
@@ -27,17 +40,64 @@ import * as log from '../utils/log.js';
     const s = p.spinner();
     s.start('Clearing tokens...');
     try {
-        // Clear OAuth tokens
         tokenStore.clearTokens();
-        // Clear all project tokens
-        tokenStore.clearAllProjectTokens();
-        s.stop(pc.green('✓ Logged out successfully'));
-        p.log.step('All OAuth and project tokens have been cleared');
+        clearCurrentProjectToken(tokenStore, env);
+        s.stop(pc.green(`✓ Logged out${formatEnvSuffix(env, ' from ')}`));
+    } catch (error) {
+        s.stop(pc.red('✗ Failed to clear tokens'));
+        log.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+async function logoutAllEnvironments() {
+    // Check which environments have tokens
+    const envsWithTokens = ALL_ENVIRONMENTS.filter((env)=>{
+        const store = getTokenStore(env);
+        return store.getOauthInfo() !== null;
+    });
+    if (envsWithTokens.length === 0) {
+        p.log.warn(pc.yellow('No tokens found in any environment. Already logged out.'));
+        return;
+    }
+    const envList = envsWithTokens.join(' and ');
+    const confirmed = await p.confirm({
+        initialValue: false,
+        message: `This will clear all OAuth and project tokens for ${envList}. Continue?`
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+        p.log.info('Logout cancelled');
+        return;
+    }
+    const s = p.spinner();
+    s.start('Clearing tokens...');
+    try {
+        for (const env of envsWithTokens){
+            const store = getTokenStore(env);
+            store.clearTokens();
+            clearCurrentProjectToken(store, env);
+        }
+        s.stop(pc.green('✓ Logged out from all environments'));
     } catch (error) {
         s.stop(pc.red('✗ Failed to clear tokens'));
         log.error(error instanceof Error ? error.message : 'Unknown error');
         process.exit(1);
     }
 }
-
-//# sourceMappingURL=logout.js.map
+function clearCurrentProjectToken(store, env) {
+    const projectId = getEnvVarSync(process.cwd(), 'FIGMA_PROJECT_ID');
+    if (!projectId) {
+        return;
+    }
+    const bootstrapData = store.getBootstrapData(projectId, env);
+    if (!bootstrapData?.contentSystemId) {
+        return;
+    }
+    const projectInfo = {
+        environmentName: env,
+        projectId
+    };
+    // Clear scoped token for this tenant.
+    store.clearProjectToken({
+        projectInfo
+    });
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,4 @@
+export type UpgradeCommandOptions = {
+    isDryRun?: boolean;
+};
+export declare function upgradeCommand(options?: UpgradeCommandOptions): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,329 @@
+import * as p from '@clack/prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import pc from 'picocolors';
+import { Project } from 'ts-morph';
+import { fileURLToPath } from 'url';
+import { getBootstrapInfo, getCmsResourceId } from '../api/control-plane.js';
+import { getValidCredential } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import { addOrUpdateEnvVar, getEnvVar, removeEnvVar } from '../utils/env-management.js';
+import { formatFile } from '../utils/formatter.js';
+import { getPackageManager } from '../utils/package-manager.js';
+import { removeFigmaContentSystemId } from '../utils/payload-config-ast.js';
+import { findPayloadConfig } from '../utils/payload-config-finder.js';
+import { checkPackageInstalled, installPackage } from '../utils/payload-package-check.js';
+import { getOwnVersion } from '../utils/version-check.js';
+export async function upgradeCommand(options = {}) {
+    const cwd = process.cwd();
+    const { isDryRun = false } = options;
+    const changes = [];
+    const warnings = [];
+    const spinner = p.spinner();
+    spinner.start('Checking for needed migrations...');
+    spinner.stop('Checking for needed migrations...');
+    await migrateEnvRename({
+        changes,
+        cwd,
+        isDryRun
+    });
+    await migrateProjectId({
+        changes,
+        cwd,
+        isDryRun,
+        warnings
+    });
+    await ensureBootstrapCached({
+        changes,
+        cwd,
+        isDryRun
+    });
+    await migrateRemoveDeprecatedEnvVars({
+        changes,
+        cwd,
+        isDryRun,
+        warnings
+    });
+    await migrateConfigAst({
+        changes,
+        cwd,
+        isDryRun
+    });
+    await migratePackageVersion({
+        changes,
+        cwd,
+        isDryRun
+    });
+    for (const warning of warnings){
+        p.log.warning(warning);
+    }
+    if (changes.length === 0) {
+        p.log.success('Everything is up to date.');
+        return;
+    }
+    if (isDryRun) {
+        p.log.info(`Dry run: ${changes.length} change(s) detected.`);
+    } else {
+        p.log.success(`${changes.length} change(s) applied.`);
+    }
+}
+const DEPRECATED_ENV_VARS = [
+    'FIGMA_CONTENT_API_CONTENT_SYSTEM_ID',
+    'FIGMA_TENANT_ID',
+    'FIGMA_OAUTH_CLIENT_ID',
+    'FIGMA_OAUTH_CLIENT_SECRET'
+];
+async function migrateEnvRename({ changes, cwd, isDryRun }) {
+    try {
+        const oldValue = await getEnvVar(cwd, 'FIGMA_ENV');
+        if (oldValue === null) {
+            return;
+        }
+        if (isDryRun) {
+            p.log.message(`${pc.dim('○')} Would rename FIGMA_ENV → FIGMA_INFRA_ENV`);
+            changes.push('Rename FIGMA_ENV → FIGMA_INFRA_ENV');
+            return;
+        }
+        await addOrUpdateEnvVar(cwd, 'FIGMA_INFRA_ENV', oldValue);
+        await removeEnvVar(cwd, 'FIGMA_ENV');
+        p.log.message(`${pc.green('●')} Env: Renamed FIGMA_ENV → FIGMA_INFRA_ENV`);
+        changes.push('Renamed FIGMA_ENV → FIGMA_INFRA_ENV');
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        p.log.warning(`Env rename migration failed: ${msg}`);
+    }
+}
+async function migrateProjectId({ changes, cwd, isDryRun, warnings = [] }) {
+    try {
+        const existingProjectId = await getEnvVar(cwd, 'FIGMA_PROJECT_ID');
+        if (existingProjectId) {
+            return;
+        }
+        const oldContentSystemId = await getEnvVar(cwd, 'FIGMA_CONTENT_API_CONTENT_SYSTEM_ID');
+        if (!oldContentSystemId) {
+            return;
+        }
+        if (isDryRun) {
+            p.log.message(`${pc.dim('○')} Would resolve FIGMA_PROJECT_ID from content system ID`);
+            changes.push('Resolve FIGMA_PROJECT_ID from content system ID');
+            return;
+        }
+        const store = getTokenStore();
+        const credential = await getValidCredential(store);
+        if (!credential) {
+            warnings.push('Not authenticated — could not resolve FIGMA_PROJECT_ID. Run `npx @payloadcms/figma login` first.');
+            return;
+        }
+        const cmsResourceId = await getCmsResourceId(credential, oldContentSystemId);
+        await addOrUpdateEnvVar(cwd, 'FIGMA_PROJECT_ID', cmsResourceId);
+        // Resolve actual environment name from bootstrap API
+        try {
+            const bootstrapInfo = await getBootstrapInfo(credential, cmsResourceId);
+            cacheAllEnvironments(store, cmsResourceId, bootstrapInfo);
+            const envName = bootstrapInfo.environments[0]?.name ?? 'production';
+            await addOrUpdateEnvVar(cwd, 'FIGMA_ENVIRONMENT_NAME', envName);
+        } catch  {
+            await addOrUpdateEnvVar(cwd, 'FIGMA_ENVIRONMENT_NAME', 'production');
+        }
+        p.log.message(`${pc.green('●')} Env: Resolved FIGMA_PROJECT_ID from content system ID`);
+        changes.push('Resolved FIGMA_PROJECT_ID from content system ID');
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        p.log.warning(`Project ID migration failed: ${msg}`);
+    }
+}
+async function ensureBootstrapCached(params) {
+    try {
+        const projectId = await getEnvVar(params.cwd, 'FIGMA_PROJECT_ID');
+        if (!projectId) {
+            return;
+        }
+        const environmentName = await getEnvVar(params.cwd, 'FIGMA_ENVIRONMENT_NAME') ?? 'production';
+        const store = getTokenStore();
+        if (store.getBootstrapData(projectId, environmentName)) {
+            return;
+        }
+        const credential = await getValidCredential(store);
+        if (!credential) {
+            return;
+        }
+        const bootstrapInfo = await getBootstrapInfo(credential, projectId);
+        cacheAllEnvironments(store, projectId, bootstrapInfo);
+        // Fix FIGMA_ENVIRONMENT_NAME if it doesn't match any actual environment
+        const envNames = bootstrapInfo.environments.map((e)=>e.name);
+        if (!envNames.includes(environmentName) && envNames.length > 0) {
+            const correctName = envNames[0];
+            if (params.isDryRun) {
+                p.log.message(`${pc.dim('○')} Would fix FIGMA_ENVIRONMENT_NAME: ${environmentName} → ${correctName}`);
+                params.changes.push(`Fix FIGMA_ENVIRONMENT_NAME`);
+                return;
+            }
+            await addOrUpdateEnvVar(params.cwd, 'FIGMA_ENVIRONMENT_NAME', correctName);
+            p.log.message(`${pc.green('●')} Env: Fixed FIGMA_ENVIRONMENT_NAME: ${environmentName} → ${correctName}`);
+            params.changes.push(`Fixed FIGMA_ENVIRONMENT_NAME: ${environmentName} → ${correctName}`);
+        }
+    } catch  {
+    // Best-effort — runtime will retry if needed
+    }
+}
+async function migrateRemoveDeprecatedEnvVars({ changes, cwd, isDryRun, warnings = [] }) {
+    try {
+        const presentVars = [];
+        for (const key of DEPRECATED_ENV_VARS){
+            const value = await getEnvVar(cwd, key);
+            if (value !== null) {
+                presentVars.push(key);
+            }
+        }
+        if (presentVars.length === 0) {
+            return;
+        }
+        // Only remove when bootstrap data is available (proves the project is set up correctly)
+        const projectId = await getEnvVar(cwd, 'FIGMA_PROJECT_ID');
+        if (!projectId) {
+            warnings.push('Cannot remove deprecated env vars without FIGMA_PROJECT_ID. Run upgrade again after project ID migration.');
+            return;
+        }
+        const environmentName = await getEnvVar(cwd, 'FIGMA_ENVIRONMENT_NAME') ?? 'production';
+        const store = getTokenStore();
+        const bootstrapData = store.getBootstrapData(projectId, environmentName);
+        if (!bootstrapData) {
+            // Try fetching from API
+            const credential = await getValidCredential(store);
+            if (credential) {
+                try {
+                    const bootstrapInfo = await getBootstrapInfo(credential, projectId);
+                    cacheAllEnvironments(store, projectId, bootstrapInfo);
+                } catch  {
+                    warnings.push('Could not verify bootstrap data — keeping deprecated env vars. Run `npx @payloadcms/figma init` to complete migration.');
+                    return;
+                }
+            } else {
+                warnings.push('Not authenticated — keeping deprecated env vars. Run `npx @payloadcms/figma login` first.');
+                return;
+            }
+        }
+        if (isDryRun) {
+            p.log.message(`${pc.dim('○')} Would remove deprecated env vars: ${presentVars.join(', ')}`);
+            changes.push(`Remove deprecated env vars: ${presentVars.join(', ')}`);
+            return;
+        }
+        const removed = [];
+        for (const key of presentVars){
+            await removeEnvVar(cwd, key);
+            removed.push(key);
+        }
+        p.log.message(`${pc.green('●')} Env: Removed deprecated env vars: ${removed.join(', ')}`);
+        changes.push(`Removed deprecated env vars: ${removed.join(', ')}`);
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        p.log.warning(`Deprecated env var removal failed: ${msg}`);
+    }
+}
+async function migrateConfigAst({ changes, cwd, isDryRun }) {
+    try {
+        const configPath = await findPayloadConfig(cwd);
+        if (!configPath) {
+            return;
+        }
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true
+        });
+        const sourceFile = project.addSourceFileAtPath(configPath);
+        const wouldRemove = removeFigmaContentSystemId(sourceFile);
+        if (!wouldRemove) {
+            return;
+        }
+        if (isDryRun) {
+            p.log.message(`${pc.dim('○')} Would remove contentSystemId from payload.config.ts`);
+            changes.push('Remove contentSystemId from payload.config.ts');
+            return;
+        }
+        // Re-parse fresh since the detection already mutated the AST
+        const freshProject = new Project({
+            skipAddingFilesFromTsConfig: true
+        });
+        const freshSourceFile = freshProject.addSourceFileAtPath(configPath);
+        removeFigmaContentSystemId(freshSourceFile);
+        await freshSourceFile.save();
+        try {
+            const packageManager = await getPackageManager(cwd);
+            await formatFile(configPath, packageManager);
+        } catch  {
+        // Formatting is best-effort
+        }
+        p.log.message(`${pc.green('●')} Config: Removed contentSystemId from payload.config.ts`);
+        changes.push('Removed contentSystemId from payload.config.ts');
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        p.log.warning(`Config AST migration failed: ${msg}`);
+    }
+}
+async function migratePackageVersion({ changes, cwd, isDryRun }) {
+    try {
+        const isInstalled = await checkPackageInstalled(cwd, '@payloadcms/figma');
+        if (!isInstalled) {
+            return;
+        }
+        const cliDir = path.dirname(fileURLToPath(import.meta.url));
+        const isFromRegistry = cliDir.includes('node_modules') || cliDir.includes('.npm');
+        if (isFromRegistry) {
+            await migrateRegistryPackageVersion({
+                changes,
+                cliDir,
+                cwd,
+                isDryRun
+            });
+        } else {
+            await migrateLocalPackageVersion({
+                changes,
+                cliDir,
+                cwd,
+                isDryRun
+            });
+        }
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        p.log.warning(`Package version sync failed: ${msg}`);
+    }
+}
+async function migrateRegistryPackageVersion({ changes, cliDir: _cliDir, cwd, isDryRun }) {
+    const cliVersion = await getOwnVersion();
+    const pkgJsonPath = path.join(cwd, 'package.json');
+    const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, 'utf-8'));
+    const installedVersion = pkgJson.dependencies?.['@payloadcms/figma']?.replace(/^[\^~>=<]+/, '');
+    if (!installedVersion || installedVersion === cliVersion) {
+        return;
+    }
+    if (isDryRun) {
+        p.log.message(`${pc.dim('○')} Would update @payloadcms/figma ${installedVersion} → ${cliVersion}`);
+        changes.push(`Update @payloadcms/figma ${installedVersion} → ${cliVersion}`);
+        return;
+    }
+    const packageManager = await getPackageManager(cwd);
+    await installPackage(cwd, '@payloadcms/figma', packageManager, cliVersion);
+    p.log.message(`${pc.green('●')} Package: Updated @payloadcms/figma ${installedVersion} → ${cliVersion}`);
+    changes.push(`Updated @payloadcms/figma ${installedVersion} → ${cliVersion}`);
+}
+async function migrateLocalPackageVersion({ changes, cliDir, cwd, isDryRun }) {
+    if (isDryRun) {
+        p.log.message(`${pc.dim('○')} Would install @payloadcms/figma from local build`);
+        changes.push('Install @payloadcms/figma from local build');
+        return;
+    }
+    // Dynamic import — findPackageRoot and packLocalPackage will be exported in a later task
+    const { findPackageRoot, packLocalPackage } = await import('../utils/handle-upgrade.js');
+    const pkgDir = await findPackageRoot(cliDir);
+    if (!pkgDir) {
+        return;
+    }
+    const packageManager = await getPackageManager(cwd);
+    const tgzPath = packLocalPackage(pkgDir);
+    const destTgz = path.join(cwd, path.basename(tgzPath));
+    await fs.rename(tgzPath, destTgz);
+    await installPackage(cwd, destTgz, packageManager);
+    await fs.unlink(destTgz).catch(()=>{});
+    p.log.message(`${pc.green('●')} Package: Installed @payloadcms/figma from local build`);
+    changes.push('Installed @payloadcms/figma from local build');
+}

package/dist/commands/upload-schema.d.ts

@@ -0,0 +1,8 @@
+export interface UploadSchemaCommandOptions {
+    /** Environment name (overrides FIGMA_ENVIRONMENT_NAME). */
+    env?: string;
+    /** CMS Resource ID (overrides FIGMA_PROJECT_ID). */
+    id?: string;
+}
+/** Upload the current Payload collection schema for Content API migration tooling. */
+export declare function uploadSchemaCommand(options?: UploadSchemaCommandOptions): Promise<void>;

package/dist/commands/upload-schema.js

@@ -0,0 +1,91 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { tryGetCredential } from '../auth/oauth-flow.js';
+import { getValidProjectToken } from '../auth/project-token.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getEnvConfig } from '../constants.js';
+import { buildDocumentSchema } from '../db-content-api/utilities/schema/buildDocumentSchema.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import { getEnvVar } from '../utils/env-management.js';
+import { loadPayloadConfig } from '../utils/load-payload-config.js';
+import { resolveEnvironment } from '../utils/resolve-environment.js';
+import { loginCommand } from './login.js';
+/** Upload the current Payload collection schema for Content API migration tooling. */ export async function uploadSchemaCommand(options = {}) {
+    const projectPath = process.cwd();
+    const projectId = options.id ?? await getEnvVar(projectPath, 'FIGMA_PROJECT_ID') ?? undefined;
+    const environmentName = options.env ?? await getEnvVar(projectPath, 'FIGMA_ENVIRONMENT_NAME') ?? undefined;
+    if (!projectId) {
+        p.log.error(pc.red('Project ID not found. Run `@payloadcms/figma init` first, or use --id.'));
+        process.exit(1);
+    }
+    // Bootstrap still requires a CLI login when the upload uses the Content API key.
+    const tokenStore = getTokenStore();
+    let credential = await tryGetCredential(tokenStore);
+    if (!credential) {
+        p.log.message('Please log in to continue');
+        await loginCommand();
+        credential = await tryGetCredential(tokenStore);
+    }
+    if (!credential) {
+        p.log.error(pc.red('Authentication failed'));
+        process.exit(1);
+    }
+    const spinner = p.spinner();
+    spinner.start('Resolving schema upload target...');
+    try {
+        const bootstrapInfo = await getBootstrapInfo(credential, projectId);
+        const environment = resolveEnvironment({
+            environmentName,
+            environments: bootstrapInfo.environments
+        });
+        cacheAllEnvironments(tokenStore, projectId, bootstrapInfo);
+        spinner.message('Loading Payload config...');
+        // --id/--env select the upload target only. Collections conditionally configured from
+        // FIGMA_ENVIRONMENT_NAME still use process.env/.env and may not match that upload target.
+        const config = await loadPayloadConfig(projectPath);
+        const documentSchema = buildDocumentSchema(config);
+        spinner.message('Uploading collection schema...');
+        const apiKey = process.env.FIGMA_CONTENT_API_ACCESS_KEY;
+        const projectToken = apiKey ? null : await getValidProjectToken({
+            projectInfo: {
+                environmentName: environment.name,
+                projectId
+            },
+            tenantId: environment.contentSystemId,
+            tokenStore
+        });
+        if (!apiKey && !projectToken) {
+            throw new Error('Could not get a project token. Run `@payloadcms/figma login` and retry.');
+        }
+        // --infra-env is applied by the CLI before this fallback selects the Content API URL.
+        const contentApiUrl = process.env.FIGMA_CONTENT_API_URL || getEnvConfig().contentApiUrl;
+        if (!contentApiUrl) {
+            throw new Error('FIGMA_CONTENT_API_URL is required for this infrastructure environment.');
+        }
+        const response = await fetch(`${contentApiUrl}/api/v0/content_systems/${encodeURIComponent(environment.contentSystemId)}/jsonb_to_index_migration_schema`, {
+            body: JSON.stringify({
+                documentSchema
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+                ...apiKey ? {
+                    'X-Api-Key': apiKey
+                } : {
+                    Authorization: `Bearer ${projectToken}`
+                }
+            },
+            method: 'PUT'
+        });
+        if (!response.ok) {
+            const responseBody = await response.text();
+            throw new Error(`Content API returned ${response.status}${responseBody ? `: ${responseBody}` : ''}`);
+        }
+        const collectionCount = Object.keys(documentSchema.collections).length;
+        spinner.stop(pc.green(`Uploaded ${collectionCount} collection schema${collectionCount === 1 ? '' : 's'} to ${environment.name}`));
+    } catch (error) {
+        spinner.stop(pc.red('Failed to upload collection schema'));
+        p.log.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}