@payloadcms/figma 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/commands/deploy.d.ts

@@ -7,16 +7,26 @@ export interface DeployCommandOptions {
     adapter?: AdapterName;
     /** Enable debug mode */
     debug?: boolean;
+    /** Description used when creating an uninitialized project */
+    description?: string;
     /** Figma environment name (e.g. 'production', 'staging') */
     env?: string;
     /** CMS Resource ID (overrides FIGMA_PROJECT_ID) */
     id?: string;
+    /** Name used when creating an uninitialized project */
+    name?: string;
     /** Exact framework build output root */
     output?: string;
+    /** Region used when creating an uninitialized project */
+    region?: string;
     /** Skip the build step (use existing build) */
     skipBuild?: boolean;
     /** Skip the client-side unzipped bundle size pre-flight check */
     skipSizeCheck?: boolean;
+    /** Subdomain used when creating an uninitialized project */
+    subdomain?: string;
+    /** Workspace plan key used when creating an uninitialized project */
+    workspace?: string;
     /** Skip confirmation prompts */
     yes?: boolean;
 }

package/dist/commands/deploy.js

@@ -2,7 +2,8 @@ import * as p from '@clack/prompts';
 import spawn from 'cross-spawn';
 import path from 'path';
 import pc from 'picocolors';
-import { ControlPlaneError, createDeployment, getBootstrapInfo, performDeployment } from '../api/control-plane.js';
+import { createDeployment, getBootstrapInfo, performDeployment } from '../api/control-plane.js';
+import { ControlPlaneError } from '../api/control-plane-error.js';
 import { tryGetCredential } from '../auth/oauth-flow.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getInfraEnvironment, getProjectNotFoundMessage } from '../constants.js';
@@ -16,7 +17,10 @@ import { getPackageManager } from '../utils/package-manager.js';
 import { isInProjectDirectory } from '../utils/project.js';
 import { resolveEnvironment } from '../utils/resolve-environment.js';
 import { uploadLambdaZip, uploadStaticAssets } from '../utils/s3-upload.js';
+import { detectProjectResourceType } from './detect-project-resource-type.js';
 import { loginCommand } from './login.js';
+import { promptToCreateProject } from './prompt-to-create-project.js';
+import { writeProjectConfiguration } from './write-project-configuration.js';
 /**
  * Format bytes to human-readable string
  */ function formatBytes(bytes) {
@@ -52,15 +56,6 @@ import { loginCommand } from './login.js';
  */ export async function deployCommand(options) {
     const projectPath = process.cwd();
     const spinner = p.spinner();
-    // Resolve project ID
-    let projectId = options.id;
-    if (!projectId) {
-        projectId = await getEnvVar(projectPath, 'FIGMA_PROJECT_ID') ?? undefined;
-    }
-    if (!projectId) {
-        p.log.error(pc.red('✗ Project ID not found. Run `@payloadcms/figma init` first, or use --id.'));
-        process.exit(1);
-    }
     // Resolve environment name
     const environmentName = options.env ?? await getEnvVar(projectPath, 'FIGMA_ENVIRONMENT_NAME') ?? undefined;
     try {
@@ -76,13 +71,38 @@ import { loginCommand } from './login.js';
         let credential = await tryGetCredential(tokenStore);
         if (!credential) {
             p.log.message('Please log in to continue');
-            await loginCommand();
+            await loginCommand({
+                openBrowserWithoutPrompt: options.yes
+            });
             credential = await tryGetCredential(tokenStore);
             if (!credential) {
                 p.log.error(pc.red('✗ Authentication failed'));
                 process.exit(1);
             }
         }
+        // Resolve or create the CMS project.
+        let projectId = options.id;
+        if (!projectId) {
+            projectId = await getEnvVar(projectPath, 'FIGMA_PROJECT_ID') ?? undefined;
+        }
+        const isProjectCreated = !projectId;
+        if (!projectId) {
+            const resourceType = options.adapter === 'vite' ? 'vite' : options.adapter ? 'payload' : await detectProjectResourceType(projectPath);
+            const project = await promptToCreateProject({
+                credential,
+                inputs: {
+                    name: options.name,
+                    description: options.description,
+                    region: options.region,
+                    subdomain: options.subdomain,
+                    workspacePlanKey: options.workspace
+                },
+                nonInteractive: options.yes,
+                projectPath,
+                resourceType
+            });
+            projectId = project.id;
+        }
         // Resolve tenant instance ID via bootstrap
         spinner.start('Resolving deployment target...');
         let tenantInstanceId;
@@ -93,6 +113,14 @@ import { loginCommand } from './login.js';
                 environments: bootstrapInfo.environments
             });
             tenantInstanceId = resolvedEnv.tenantInstanceId;
+            await writeProjectConfiguration({
+                bootstrapInfo,
+                environmentName: resolvedEnv.name,
+                projectDir: projectPath,
+                projectId,
+                shouldWriteEnvironmentVariables: isProjectCreated,
+                tokenStore
+            });
             spinner.stop(pc.green(`✓ Target: ${resolvedEnv.name}`));
         } catch (error) {
             if (error instanceof ControlPlaneError && (error.statusCode === 404 || error.statusCode === 410)) {

package/dist/commands/detect-project-resource-type.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectResourceType } from '../api/project-resource-type.js';
+/** Detect whether project provisioning should use static Vite or Payload infrastructure. */
+export declare function detectProjectResourceType(projectPath?: string): Promise<ProjectResourceType>;

package/dist/commands/detect-project-resource-type.js

@@ -0,0 +1,28 @@
+import fs from 'fs/promises';
+import path from 'path';
+/** Detect whether project provisioning should use static Vite or Payload infrastructure. */ export async function detectProjectResourceType(projectPath = process.cwd()) {
+    try {
+        const content = await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8');
+        const packageJson = JSON.parse(content);
+        const dependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        if (dependencies.payload) {
+            return 'payload';
+        }
+        if (dependencies.vite || Object.values(packageJson.scripts ?? {}).some((script)=>/\bvite\b/.test(script))) {
+            return 'vite';
+        }
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            return 'payload';
+        }
+    }
+    try {
+        await fs.access(path.join(projectPath, 'index.html'));
+        return 'vite';
+    } catch  {
+        return 'payload';
+    }
+}

package/dist/commands/init.d.ts

@@ -12,8 +12,8 @@ export interface InitCommandOptions {
     id?: string;
     /** Project name (for scaffolding) */
     name?: string;
-    /** Skip Payload skill installation */
-    noSkill?: boolean;
+    /** Skip writing AI agent config files (AGENTS.md, CLAUDE.md) */
+    noAgent?: boolean;
     /** npm dist-tag or explicit version for core payload packages (e.g. 'canary', 'latest', '4.0.0-canary.16'); defaults to 'canary' */
     payloadVersion?: string;
     /** Skip authentication check (for testing/development) */

package/dist/commands/init.js

@@ -2,13 +2,14 @@ import * as p from '@clack/prompts';
 import fs from 'fs/promises';
 import path from 'path';
 import pc from 'picocolors';
-import { ControlPlaneError, getBootstrapInfo } from '../api/control-plane.js';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { ControlPlaneError } from '../api/control-plane-error.js';
 import { FigmaApiError } from '../api/figma-api.js';
 import { tryGetCredential } from '../auth/oauth-flow.js';
 import { getValidProjectToken, ProjectTokenError } from '../auth/project-token.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getInfraEnvironment, getProjectNotFoundMessage } from '../constants.js';
-import { downloadSkill } from '../lib/download-skill.js';
+import { writeAgentConfigFiles } from '../lib/write-agent-config.js';
 import { ensureGitignore } from '../utils/config.js';
 import { addOrUpdateEnvVar } from '../utils/env-management.js';
 import { isDebug } from '../utils/is-debug.js';
@@ -16,27 +17,54 @@ import { applyLambdaModifications } from '../utils/lambda-config.js';
 import * as log from '../utils/log.js';
 import { detectPackageManagerFromEnvironment, getRunCommand, resolvePackageManager } from '../utils/package-manager.js';
 import { displayManualInstructions, ensurePayloadFigmaConfig } from '../utils/payload-config-modifier.js';
+import { generateImportMap, generateTypes } from '../utils/payload-generate.js';
+import { ensurePnpmWorkspace } from '../utils/pnpm-builds.js';
 import { detectPayloadProject, hasRequiredDependencies, initializeGitRepo, installDependencies, isInProjectDirectory, scaffoldProject, validatePayloadVersion } from '../utils/project.js';
 import { resolveEnvironment } from '../utils/resolve-environment.js';
 import { checkForUpdates, getOwnVersion } from '../utils/version-check.js';
+import { detectProjectResourceType } from './detect-project-resource-type.js';
 import { loginCommand } from './login.js';
+import { promptToCreateProject } from './prompt-to-create-project.js';
+import { writeProjectConfiguration } from './write-project-configuration.js';
 import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
 import { DEFAULT_TEMPLATE_SOURCE } from '../utils/download-template.js';
 import { parseTemplateSpec, TemplateSpecParseError } from '../utils/parse-template-spec.js';
-async function maybeInstallPayloadSkill(args) {
-    if (args.noSkill) {
+async function maybeWriteAgentConfigFiles(args) {
+    if (args.noAgent) {
         return;
     }
-    const result = await downloadSkill({
-        projectDir: args.projectDir
+    try {
+        await writeAgentConfigFiles({
+            projectDir: args.projectDir
+        });
+    } catch (err) {
+        p.log.warn(pc.yellow(`⚠ Could not write AI agent config (${err instanceof Error ? err.message : String(err)}). Continuing.`));
+    }
+}
+/** Generate the admin import map and Payload types so the scaffold builds clean. */ async function runProjectCodegen(args) {
+    await runPayloadGenerate({
+        ...args,
+        artifact: 'import map',
+        command: 'generate:importmap',
+        generate: generateImportMap
     });
+    await runPayloadGenerate({
+        ...args,
+        artifact: 'types',
+        command: 'generate:types',
+        generate: generateTypes
+    });
+}
+/** Non-fatal: on failure, warn with the command to run later. */ async function runPayloadGenerate(args) {
+    args.spinner.start(`Generating ${args.artifact}...`);
+    const result = await args.generate(args.projectDir);
+    const capitalized = args.artifact.charAt(0).toUpperCase() + args.artifact.slice(1);
     if (result.ok) {
+        args.spinner.stop(pc.green(`✓ ${capitalized} generated`));
         return;
     }
-    if (result.reason === 'already-installed') {
-        return;
-    }
-    p.log.warn(pc.yellow(`⚠ Could not install Payload skill (${result.reason}${result.detail ? `: ${result.detail}` : ''}). Continuing.`));
+    args.spinner.stop(pc.yellow(`⚠ Could not generate ${args.artifact}`));
+    p.log.warn(pc.yellow(`Run '${getRunCommand(args.packageManager)} ${args.command}' later. ${result.error}`));
 }
 /**
  * Generate and store project token for a content system
@@ -94,6 +122,7 @@ async function maybeInstallPayloadSkill(args) {
     // Check authentication
     const tokenStore = getTokenStore();
     const s = p.spinner();
+    let credential = null;
     if (options.skipAuth) {
         // Skip authentication for testing/development
         p.log.warn(pc.yellow('Skipping authentication (--skip-auth mode)'));
@@ -102,14 +131,14 @@ async function maybeInstallPayloadSkill(args) {
         if (!tokenStore.hasValidOauthToken()) {
             // Need to refresh or authenticate - show spinner for API call
             s.start('Checking authentication...');
-            const credential = await tryGetCredential(tokenStore);
+            credential = await tryGetCredential(tokenStore);
             if (!credential) {
                 s.stop('Authentication required to continue');
                 await loginCommand({
                     showNextSteps: false
                 });
-                const newCredential = await tryGetCredential(tokenStore);
-                if (!newCredential) {
+                credential = await tryGetCredential(tokenStore);
+                if (!credential) {
                     p.log.error('Authentication failed');
                     process.exit(1);
                 }
@@ -118,16 +147,12 @@ async function maybeInstallPayloadSkill(args) {
             }
         }
     }
+    if (!options.skipAuth && !credential) {
+        credential = await tryGetCredential(tokenStore);
+    }
     // Note: We no longer check for figma.config.json here
     // Instead, the AST detection will check if figma object already exists in payload.config.ts
     // and skip modification if it does (unless --force is used)
-    // Step 3: Get CMS Resource ID (required argument)
-    log.debug('Configuring Project...');
-    if (!options.id) {
-        p.log.error('CMS Resource ID is required. Use --id <cms-resource-id>');
-        process.exit(1);
-    }
-    const cmsResourceId = options.id;
     // Parse --template spec early so malformed values abort before any I/O
     let templateSource;
     if (options.template) {
@@ -140,13 +165,95 @@ async function maybeInstallPayloadSkill(args) {
             process.exit(1);
         }
     }
+    // Step 3: Resolve or create the CMS project
+    log.debug('Configuring Project...');
+    const hasPackageJson = await isInProjectDirectory();
+    const resourceType = await detectProjectResourceType();
+    const isInProject = hasPackageJson || resourceType === 'vite';
+    let projectDirectory = process.cwd();
+    if (isInProject && resourceType !== 'vite' && !options.id) {
+        const projectInfo = await detectPayloadProject();
+        if (!projectInfo.hasPayload) {
+            p.log.warn(pc.yellow('⚠ Payload was not detected in this project'));
+            p.note('Run this command in a directory without an existing project or in an existing Payload project.', 'Action Required');
+            process.exit(1);
+        }
+        if (projectInfo.payloadVersion && !validatePayloadVersion(projectInfo.payloadVersion)) {
+            p.log.warn(pc.yellow(`Payload version ${projectInfo.payloadVersion} detected. Version 4.x or newer is required.`));
+            p.note('Upgrade to Payload 4.x or newer before continuing', 'Action Required');
+            process.exit(1);
+        }
+    }
+    if (!isInProject) {
+        let projectPath;
+        if (options.name) {
+            projectPath = options.name;
+        } else {
+            const projectPathInput = await p.text({
+                initialValue: './',
+                message: 'Enter path to create project:',
+                placeholder: './my-cms-project',
+                validate: (value)=>{
+                    if (!value) {
+                        return 'Path is required';
+                    }
+                    return undefined;
+                }
+            });
+            if (p.isCancel(projectPathInput)) {
+                p.cancel('Operation cancelled');
+                process.exit(0);
+            }
+            projectPath = projectPathInput;
+        }
+        projectDirectory = path.resolve(process.cwd(), projectPath);
+        const projectName = path.basename(projectDirectory);
+        const packageManager = detectPackageManagerFromEnvironment();
+        try {
+            await fs.mkdir(projectDirectory, {
+                recursive: true
+            });
+        } catch (error) {
+            p.log.error(`Failed to create directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+        const resolvedSource = {
+            ...DEFAULT_TEMPLATE_SOURCE,
+            ...templateSource
+        };
+        s.start(`Downloading template "${resolvedSource.templatePath}" from ` + `${resolvedSource.owner}/${resolvedSource.repo}@${resolvedSource.ref}...`);
+        try {
+            await scaffoldProject(projectDirectory, projectName, packageManager, templateSource, options.payloadVersion);
+            s.stop(pc.green('✓ Template downloaded'));
+            s.start('Installing dependencies...');
+            await installDependencies(projectDirectory, packageManager);
+            s.stop(pc.green('✓ Dependencies installed'));
+        } catch (error) {
+            s.stop(pc.red('✗ Failed'));
+            log.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    }
+    let cmsResourceId = options.id;
+    if (!cmsResourceId) {
+        if (!credential) {
+            p.log.error('Authentication is required to create a project');
+            process.exit(1);
+        }
+        const createdProject = await promptToCreateProject({
+            credential,
+            projectPath: projectDirectory,
+            resourceType
+        });
+        cmsResourceId = createdProject.id;
+        await addOrUpdateEnvVar(projectDirectory, 'FIGMA_PROJECT_ID', cmsResourceId);
+    }
     // Fetch bootstrap info (oauth creds + environments)
     let bootstrapInfo = null;
     let resolvedEnv = null;
     let oauthClientId = null;
     let oauthClientSecret = null;
     if (!options.skipAuth) {
-        const credential = await tryGetCredential(tokenStore);
         if (credential) {
             try {
                 bootstrapInfo = await getBootstrapInfo(credential, cmsResourceId);
@@ -178,8 +285,23 @@ async function maybeInstallPayloadSkill(args) {
             }
         }
     }
-    // Step 4: Detect or scaffold Payload project
-    const isInProject = await isInProjectDirectory();
+    // Step 4: Detect or scaffold project
+    if (isInProject && resourceType === 'vite') {
+        try {
+            await writeProjectConfiguration({
+                bootstrapInfo,
+                environmentName: resolvedEnv?.name ?? 'production',
+                projectDir: process.cwd(),
+                projectId: cmsResourceId,
+                tokenStore
+            });
+        } catch (error) {
+            p.log.error(error instanceof Error ? error.message : 'Failed to configure project');
+            process.exit(1);
+        }
+        p.outro(pc.green('✓ Vite project initialized successfully!'));
+        return;
+    }
     if (isInProject) {
         // ===== EXISTING PROJECT FLOW =====
         log.debug('Project directory detected');
@@ -194,6 +316,9 @@ async function maybeInstallPayloadSkill(args) {
                 process.exit(1);
             }
             p.log.success(pc.green(`✓ Payload ${projectInfo.payloadVersion || 'detected'}`));
+            // Approvals must exist before any install: pnpm v11 aborts on unapproved
+            // build scripts, and re-init runs against an existing install.
+            await ensurePnpmWorkspace(process.cwd());
             // Check dependencies
             s.start('Checking dependencies...');
             const hasDeps = await hasRequiredDependencies(process.cwd());
@@ -274,8 +399,13 @@ async function maybeInstallPayloadSkill(args) {
             '.env.local',
             'lambda.zip'
         ]);
-        await maybeInstallPayloadSkill({
-            noSkill: options.noSkill,
+        await runProjectCodegen({
+            packageManager,
+            projectDir: process.cwd(),
+            spinner: s
+        });
+        await maybeWriteAgentConfigFiles({
+            noAgent: options.noAgent,
             projectDir: process.cwd()
         });
         // Generate project token (unless skipping auth)
@@ -293,58 +423,8 @@ async function maybeInstallPayloadSkill(args) {
         p.note(nextSteps.join('\n'), 'Next Steps');
     } else {
         // ===== NEW PROJECT FLOW =====
-        // p.log.info('No project detected - Creating New Project')
-        let projectPath;
-        if (options.name) {
-            projectPath = options.name;
-        } else {
-            const projectPathInput = await p.text({
-                initialValue: './',
-                message: 'Enter path to create project:',
-                placeholder: './my-cms-project',
-                validate: (value)=>{
-                    if (!value) {
-                        return 'Path is required';
-                    }
-                    // Allow relative or absolute paths
-                    return undefined;
-                }
-            });
-            if (p.isCancel(projectPathInput)) {
-                p.cancel('Operation cancelled');
-                process.exit(0);
-            }
-            projectPath = projectPathInput;
-        }
-        const fullPath = path.resolve(process.cwd(), projectPath);
-        const projectName = path.basename(fullPath);
+        const fullPath = projectDirectory;
         const packageManager = detectPackageManagerFromEnvironment();
-        // Create directory
-        try {
-            await fs.mkdir(fullPath, {
-                recursive: true
-            });
-        } catch (error) {
-            p.log.error(`Failed to create directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            process.exit(1);
-        }
-        // Scaffold project
-        const resolvedSource = {
-            ...DEFAULT_TEMPLATE_SOURCE,
-            ...templateSource
-        };
-        s.start(`Downloading template "${resolvedSource.templatePath}" from ` + `${resolvedSource.owner}/${resolvedSource.repo}@${resolvedSource.ref}...`);
-        try {
-            await scaffoldProject(fullPath, projectName, packageManager, templateSource, options.payloadVersion);
-            s.stop(pc.green('✓ Template downloaded'));
-            s.start('Installing dependencies...');
-            await installDependencies(fullPath, packageManager);
-            s.stop(pc.green('✓ Dependencies installed'));
-        } catch (error) {
-            s.stop(pc.red('✗ Failed'));
-            log.error(error instanceof Error ? error.message : 'Unknown error');
-            process.exit(1);
-        }
         // Modify Payload configuration
         s.start('Checking Payload configuration...');
         const modResult = await ensurePayloadFigmaConfig(fullPath, packageManager, {
@@ -398,8 +478,13 @@ async function maybeInstallPayloadSkill(args) {
             log.error(error instanceof Error ? error.message : 'Unknown error');
             process.exit(1);
         }
-        await maybeInstallPayloadSkill({
-            noSkill: options.noSkill,
+        await runProjectCodegen({
+            packageManager,
+            projectDir: fullPath,
+            spinner: s
+        });
+        await maybeWriteAgentConfigFiles({
+            noAgent: options.noAgent,
             projectDir: fullPath
         });
         // Generate project token (unless skipping auth)

package/dist/commands/login.d.ts

@@ -1,8 +1,18 @@
 type LoginArgs = {
+    /** Redirect URL returned by the browser for resumable login completion. */
+    callbackUrl?: string;
+    /** Pending resumable login session to complete. */
+    completeSessionId?: string;
+    /** Start a resumable login without waiting on stdin or a callback server. */
+    headless?: boolean;
+    /** Emit machine-readable output for resumable login. */
+    json?: boolean;
+    /** Open the browser without asking for confirmation. */
+    openBrowserWithoutPrompt?: boolean;
     /** Set this to show next steps after login
      * @default true
      */
-    showNextSteps: boolean;
+    showNextSteps?: boolean;
 };
 /**
  * Handle the `@payloadcms/figma login` command

package/dist/commands/login.js

@@ -1,6 +1,7 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { CallbackError } from '../auth/callback-server.js';
+import { completeHeadlessOAuthFlow, startHeadlessOAuthFlow } from '../auth/headless-oauth-flow.js';
 import { executeOAuthFlow, getValidCredential, OAuthFlowError } from '../auth/oauth-flow.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getOAuthConfig } from '../config/oauth.js';
@@ -13,11 +14,47 @@ import * as log from '../utils/log.js';
  * Authenticates the user with Figma OAuth2 and stores tokens locally.
  * If valid tokens already exist, shows an error message.
  */ export async function loginCommand(args) {
-    const { showNextSteps } = args || {
-        showNextSteps: false
-    };
+    const { callbackUrl, completeSessionId, headless = false, json = false, openBrowserWithoutPrompt = false, showNextSteps = false } = args ?? {};
     const env = getInfraEnvironment();
     const tokenStore = getTokenStore(env);
+    if (headless && completeSessionId) {
+        throw new Error('Use either --headless or --complete, not both.');
+    }
+    if (completeSessionId) {
+        if (!callbackUrl) {
+            throw new Error('--callback-url is required with --complete.');
+        }
+        const result = await completeHeadlessOAuthFlow({
+            callbackUrl,
+            sessionId: completeSessionId,
+            tokenStore
+        });
+        reportHeadlessLoginCompleted({
+            json,
+            userId: result.userId
+        });
+        return;
+    }
+    if (headless) {
+        try {
+            const credential = await getValidCredential(tokenStore);
+            if (credential) {
+                reportHeadlessLoginCompleted({
+                    json,
+                    userId: tokenStore.getOauthInfo()?.userId
+                });
+                return;
+            }
+        } catch  {
+        // Invalid cached credentials should start a new login session.
+        }
+        const result = startHeadlessOAuthFlow(tokenStore);
+        reportHeadlessLoginStarted({
+            json,
+            ...result
+        });
+        return;
+    }
     // Check for existing valid tokens
     try {
         const existingCredential = await getValidCredential(tokenStore);
@@ -37,18 +74,43 @@ import * as log from '../utils/log.js';
     }
     // Start OAuth flow
     await handleAuthentication({
+        openBrowserWithoutPrompt,
         showNextSteps,
         tokenStore
     });
 }
+function reportHeadlessLoginStarted({ authorizationUrl, expiresAt, json, sessionId }) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify({
+            authorizationUrl,
+            expiresAt,
+            sessionId,
+            status: 'authorization_required'
+        })}\n`);
+        return;
+    }
+    p.log.step(`Open this URL to authenticate:\n\n  ${authorizationUrl}`);
+    p.note(`After approving, copy the full redirected URL and run:\n` + `@payloadcms/figma login --complete ${sessionId} --callback-url '<redirect-url>'`, 'Complete login');
+}
+function reportHeadlessLoginCompleted({ json, userId }) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify({
+            status: 'authenticated',
+            userId
+        })}\n`);
+        return;
+    }
+    p.log.success(pc.green('✓ Logged in'));
+}
 /**
  * Handle authentication flow
- */ async function handleAuthentication({ showNextSteps, tokenStore }) {
+ */ async function handleAuthentication({ openBrowserWithoutPrompt, showNextSteps, tokenStore }) {
     try {
         // Execute OAuth flow
         const oauthConfig = getOAuthConfig();
         const result = await executeOAuthFlow(tokenStore, {
             clientId: oauthConfig.clientId,
+            openBrowserWithoutPrompt,
             redirectUri: oauthConfig.redirectUri,
             scopes: oauthConfig.scopes
         });

package/dist/commands/prompt-to-create-project/format-project-subdomain.d.ts

@@ -0,0 +1 @@
+export declare function formatProjectSubdomain(value: string): string;

package/dist/commands/prompt-to-create-project/format-project-subdomain.js

@@ -0,0 +1,3 @@
+export function formatProjectSubdomain(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60).replace(/^-|-$/g, '') || 'figma-project';
+}

package/dist/commands/prompt-to-create-project/format-unavailable-subdomain-reason.d.ts

@@ -0,0 +1 @@
+export declare function formatUnavailableSubdomainReason(reason: string): string;

package/dist/commands/prompt-to-create-project/format-unavailable-subdomain-reason.js

@@ -0,0 +1,7 @@
+export function formatUnavailableSubdomainReason(reason) {
+    if (reason === 'already_taken') {
+        return 'Subdomain is already taken. Choose another.';
+    }
+    const reasonDetail = reason ? `: ${reason.replaceAll('_', ' ')}` : '';
+    return `Subdomain is unavailable${reasonDetail}. Choose another.`;
+}

package/dist/commands/prompt-to-create-project/get-default-project-name.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultProjectName(projectPath: string): Promise<string>;