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

package/dist/cli.js

@@ -1,12 +1,19 @@
 import * as p from '@clack/prompts';
 import arg from 'arg';
 import pc from 'picocolors';
+import { bootstrapCommand } from './commands/bootstrap.js';
+import { buildLambdaZipCommand } from './commands/build-lambda-zip.js';
+import { debugCommand } from './commands/debug.js';
 import { deployCommand } from './commands/deploy.js';
+import { dumpTokensCommand } from './commands/dump-tokens.js';
+import { envCommand } from './commands/env.js';
 import { initCommand } from './commands/init.js';
 import { listTokensCommand } from './commands/list-tokens.js';
 import { loginCommand } from './commands/login.js';
 import { logoutCommand } from './commands/logout.js';
-import { feedbackOutro, helpMessage } from './utils/messages.js';
+import { upgradeCommand } from './commands/upgrade.js';
+import { setInfraEnvironment } from './constants.js';
+import { helpMessage } from './utils/messages.js';
 /**
  * Entrypoint for bin/cli.js
  */ export async function main() {
@@ -24,16 +31,35 @@ class Main {
     constructor(){
         // @ts-expect-error bad typings
         this.args = arg({
+            // Hidden flag — intentionally not displayed in help output yet.
+            // Auto-detection covers most cases; this is an escape hatch for testing.
+            // May expose in help text once multi-framework support is public.
+            '--adapter': String,
+            '--all': Boolean,
             '--debug': Boolean,
+            '--dry-run': Boolean,
+            '--env': String,
             '--force': Boolean,
             '--help': Boolean,
             '--id': String,
+            '--infra-env': String,
+            '--json': Boolean,
             '--name': String,
+            '--no-skill': Boolean,
+            '--payload-version': String,
             '--skip-auth': Boolean,
+            '--skip-build': Boolean,
+            '--template': String,
+            '--version': Boolean,
             '--yes': Boolean,
             // Aliases
+            '--environment': '--env',
+            '-e': '--env',
             '-f': '--force',
             '-h': '--help',
+            '-n': '--name',
+            '-t': '--template',
+            '-v': '--version',
             '-y': '--yes'
         }, {
             permissive: true
@@ -42,6 +68,21 @@ class Main {
         if (this.args['--debug']) {
             process.env.DEBUG = 'true';
         }
+        // Handle --infra-env flag for infrastructure environment switching
+        if (this.args['--infra-env']) {
+            const infraEnvArg = this.args['--infra-env'].toLowerCase();
+            if (infraEnvArg === 'prod' || infraEnvArg === 'production') {
+                setInfraEnvironment('production');
+            } else if (infraEnvArg === 'staging') {
+                setInfraEnvironment('staging');
+            } else if (infraEnvArg === 'devbox') {
+                setInfraEnvironment('devbox');
+            } else {
+                // eslint-disable-next-line no-console
+                console.error(`Invalid --infra-env value: ${this.args['--infra-env']}. Use 'production', 'staging', or 'devbox'.`);
+                process.exit(1);
+            }
+        }
     }
     async init() {
         try {
@@ -49,30 +90,75 @@ class Main {
                 helpMessage();
                 process.exit(0);
             }
+            if (this.args['--version']) {
+                const { getOwnVersion } = await import('./utils/version-check.js');
+                const version = await getOwnVersion();
+                // eslint-disable-next-line no-console
+                console.log(version);
+                process.exit(0);
+            }
             // Get the subcommand (first non-flag argument)
             const subcommand = this.args._[0];
+            if (!subcommand) {
+                helpMessage();
+                process.exit(0);
+            }
+            // Debug command outputs plain text for copy-paste — skip styled intro
+            if (subcommand === 'debug') {
+                await debugCommand();
+                process.exit(0);
+            }
+            // dump-tokens outputs plain text
+            if (subcommand === 'dump-tokens') {
+                await dumpTokensCommand();
+                process.exit(0);
+            }
             // eslint-disable-next-line no-console
             console.log('\n');
             p.intro(pc.bgCyan(pc.black(' @payloadcms/figma ')));
             // Route to appropriate command handler
             switch(subcommand){
+                case 'bootstrap':
+                    await bootstrapCommand({
+                        id: this.args['--id'],
+                        env: this.args['--env'],
+                        json: this.args['--json']
+                    });
+                    break;
+                case 'build-lambda-zip':
+                    await buildLambdaZipCommand();
+                    break;
                 case 'deploy':
                     await deployCommand({
+                        id: this.args['--id'],
+                        adapter: this.args['--adapter'],
                         debug: this.args['--debug'],
+                        env: this.args['--env'],
+                        skipBuild: this.args['--skip-build'],
                         yes: this.args['--yes']
                     });
                     break;
+                case 'env':
+                    await envCommand({
+                        name: this.args._[1]
+                    });
+                    break;
                 case 'init':
                     await initCommand({
                         id: this.args['--id'],
                         name: this.args['--name'],
                         debug: this.args['--debug'],
+                        env: this.args['--env'],
                         force: this.args['--force'],
-                        skipAuth: this.args['--skip-auth']
+                        noSkill: this.args['--no-skill'],
+                        payloadVersion: this.args['--payload-version'],
+                        skipAuth: this.args['--skip-auth'],
+                        template: this.args['--template']
                     });
                     break;
                 case 'list-tokens':
                     listTokensCommand({
+                        all: this.args['--all'],
                         debug: this.args['--debug']
                     });
                     break;
@@ -81,13 +167,14 @@ class Main {
                     break;
                 case 'logout':
                     await logoutCommand({
+                        all: this.args['--all'],
                         debug: this.args['--debug']
                     });
                     break;
-                case undefined:
-                    // No subcommand - show default message
-                    p.note("Let's create a new CMS!");
-                    p.outro(feedbackOutro());
+                case 'upgrade':
+                    await upgradeCommand({
+                        isDryRun: this.args['--dry-run']
+                    });
                     break;
                 default:
                     p.log.error(pc.red(`Unknown command: ${subcommand}`));

package/dist/commands/bootstrap.d.ts

@@ -0,0 +1,18 @@
+export type BootstrapCommandOptions = {
+    /** Filter to a single environment (e.g. "production", "staging"). */
+    env?: string;
+    /** CMS Resource ID (FIGMA_PROJECT_ID, e.g. cms_…). */
+    id?: string;
+    /** Emit plain JSON instead of a styled note (handy for piping into jq). */
+    json?: boolean;
+};
+/**
+ * Fetch and display bootstrap info for a CMS resource.
+ *
+ * Calls the Control Plane bootstrap endpoint with the current OAuth credential
+ * and prints the resulting environments (`contentSystemId`, `tenantInstanceId`)
+ * plus OAuth client credentials. Useful for grabbing a tenant ID without having
+ * to `init` a project.
+ */
+export declare function bootstrapCommand(options?: BootstrapCommandOptions): Promise<void>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/commands/bootstrap.js

@@ -0,0 +1,90 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { ControlPlaneError, getBootstrapInfo } from '../api/control-plane.js';
+import { getValidCredential } from '../auth/oauth-flow.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment } from '../constants.js';
+import { isDebug } from '../utils/is-debug.js';
+import { maskToken } from '../utils/token-display.js';
+/**
+ * Fetch and display bootstrap info for a CMS resource.
+ *
+ * Calls the Control Plane bootstrap endpoint with the current OAuth credential
+ * and prints the resulting environments (`contentSystemId`, `tenantInstanceId`)
+ * plus OAuth client credentials. Useful for grabbing a tenant ID without having
+ * to `init` a project.
+ */ export async function bootstrapCommand(options = {}) {
+    if (!options.id) {
+        p.log.error(pc.red('--id <project-id> is required'));
+        p.note('The CMS Resource ID (FIGMA_PROJECT_ID), e.g. cms_abc123', 'Tip');
+        process.exit(1);
+    }
+    const tokenStore = getTokenStore(getInfraEnvironment());
+    let credential;
+    try {
+        credential = await getValidCredential(tokenStore);
+    } catch (error) {
+        p.log.error(pc.red(`Failed to read stored credentials: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        p.note(`Run ${pc.cyan(`@payloadcms/figma logout --infra-env ${getInfraEnvironment()} -y`)} ` + `then ${pc.cyan(`@payloadcms/figma login --infra-env ${getInfraEnvironment()}`)} and retry.`, 'Re-authenticate');
+        if (isDebug() && error instanceof Error) {
+            // eslint-disable-next-line no-console
+            console.error(error);
+        }
+        process.exit(1);
+    }
+    if (!credential) {
+        p.log.error(pc.red('Not authenticated.'));
+        p.note(`Run ${pc.cyan('@payloadcms/figma login')} first`, 'Tip');
+        process.exit(1);
+    }
+    let info;
+    try {
+        info = await getBootstrapInfo(credential, options.id, options.env);
+    } catch (error) {
+        if (error instanceof ControlPlaneError) {
+            p.log.error(pc.red(`Bootstrap fetch failed: ${error.statusCode} ${error.message}`));
+            if (error.statusCode === 401) {
+                p.note(`Stored credentials for infra env ${pc.bold(getInfraEnvironment())} were rejected.\n` + `Run ${pc.cyan(`@payloadcms/figma logout --infra-env ${getInfraEnvironment()} -y`)} ` + `then ${pc.cyan(`@payloadcms/figma login --infra-env ${getInfraEnvironment()}`)} and retry.`, 'Re-authenticate');
+            } else if (error.statusCode === 404) {
+                p.note(`Resource ${pc.bold(options.id)} was not found in infra env ${pc.bold(getInfraEnvironment())}.\n` + `Try ${pc.cyan('--infra-env staging')} (or production) to target a different infra.`, 'Wrong infra environment?');
+            }
+        } else if (error instanceof Error) {
+            const causeMessage = error.cause instanceof Error ? `: ${error.cause.message}` : '';
+            p.log.error(pc.red(`${error.name}: ${error.message}${causeMessage}`));
+            if (isDebug()) {
+                // eslint-disable-next-line no-console
+                console.error(error);
+            }
+        } else {
+            p.log.error(pc.red('Unknown error'));
+        }
+        process.exit(1);
+    }
+    if (options.json) {
+        const showSecretsInJson = isDebug();
+        const payload = showSecretsInJson ? info : {
+            ...info,
+            oauthCredentials: {
+                ...info.oauthCredentials,
+                oauthClientSecret: maskToken(info.oauthCredentials.oauthClientSecret)
+            }
+        };
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    const showSecret = isDebug();
+    const lines = [
+        `Project ID:        ${options.id}`,
+        `OAuth Client ID:   ${info.oauthCredentials.oauthClientId}`,
+        `OAuth Client Secret: ${showSecret ? info.oauthCredentials.oauthClientSecret : maskToken(info.oauthCredentials.oauthClientSecret)}`,
+        '',
+        'Environments:'
+    ];
+    for (const env of info.environments){
+        lines.push(`  ${pc.bold(env.name)}`, `    Tenant ID (contentSystemId): ${env.contentSystemId}`, `    Tenant Instance ID:          ${env.tenantInstanceId}`);
+    }
+    p.note(lines.join('\n'), 'Bootstrap Info');
+}
+
+//# sourceMappingURL=bootstrap.js.map

package/dist/commands/build-lambda-zip.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build Lambda deployment zip from current directory
+ */
+export declare function buildLambdaZipCommand(): Promise<void>;
+//# sourceMappingURL=build-lambda-zip.d.ts.map

package/dist/commands/build-lambda-zip.js

@@ -0,0 +1,19 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { buildLambdaZip } from '../utils/build-lambda-zip.js';
+/**
+ * Build Lambda deployment zip from current directory
+ */ export async function buildLambdaZipCommand() {
+    const projectPath = process.cwd();
+    const s = p.spinner();
+    s.start('Creating lambda.zip');
+    try {
+        await buildLambdaZip(projectPath);
+        s.stop(pc.green('✓ Created lambda.zip'));
+    } catch (error) {
+        s.stop(pc.red('✗ Failed to create lambda.zip'));
+        throw error;
+    }
+}
+
+//# sourceMappingURL=build-lambda-zip.js.map

package/dist/commands/debug.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Handle the `@payloadcms/figma debug` command
+ *
+ * Outputs environment, auth, project, and package info for debugging.
+ * All data is local — no network calls are made.
+ */
+export declare function debugCommand(): Promise<void>;
+//# sourceMappingURL=debug.d.ts.map

package/dist/commands/debug.js

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

package/dist/commands/deploy.d.ts

@@ -1,9 +1,18 @@
+import type { AdapterName } from '../utils/deploy-adapter.js';
 /**
  * Options for deploy command
  */
 export interface DeployCommandOptions {
+    /** Framework adapter (nextjs, nitro, vite). Auto-detected if omitted. */
+    adapter?: AdapterName;
     /** Enable debug mode */
     debug?: boolean;
+    /** Figma environment name (e.g. 'production', 'staging') */
+    env?: string;
+    /** CMS Resource ID (overrides FIGMA_PROJECT_ID) */
+    id?: string;
+    /** Skip the build step (use existing build) */
+    skipBuild?: boolean;
     /** Skip confirmation prompts */
     yes?: boolean;
 }