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

package/dist/utils/cache-bootstrap.d.ts

@@ -0,0 +1,8 @@
+import type { BootstrapInfo } from '../api/control-plane.js';
+import type { TokenStore } from '../auth/token-store.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */
+export declare function cacheAllEnvironments(tokenStore: TokenStore, projectId: string, bootstrapInfo: BootstrapInfo): void;
+//# sourceMappingURL=cache-bootstrap.d.ts.map

package/dist/utils/cache-bootstrap.js

@@ -0,0 +1,18 @@
+import * as log from './log.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */ export function cacheAllEnvironments(tokenStore, projectId, bootstrapInfo) {
+    const { oauthCredentials } = bootstrapInfo;
+    for (const env of bootstrapInfo.environments){
+        tokenStore.setBootstrapData(projectId, env.name, {
+            contentSystemId: env.contentSystemId,
+            oauthClientId: oauthCredentials.oauthClientId,
+            oauthClientSecret: oauthCredentials.oauthClientSecret,
+            tenantInstanceId: env.tenantInstanceId
+        });
+    }
+    log.debug(`Cached bootstrap data for environments: ${bootstrapInfo.environments.map((e)=>e.name).join(', ')}`);
+}
+
+//# sourceMappingURL=cache-bootstrap.js.map

package/dist/utils/config.js

@@ -19,7 +19,7 @@ const GITIGNORE_FILENAME = '.gitignore';
         }
     }
     // Parse existing entries
-    const existingLines = existingContent.split('\n').filter((line)=>line.trim());
+    const existingLines = existingContent.split(/\r?\n/).filter((line)=>line.trim());
     const existingSet = new Set(existingLines);
     // Add new entries that don't exist
     const newEntries = entries.filter((entry)=>!existingSet.has(entry));

package/dist/utils/deploy-adapter.d.ts

@@ -0,0 +1,40 @@
+export interface PageCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route → S3 upload keys for that route (e.g., { "/products": ["products.html", "products.rsc"] }) */
+    routeAssetMap: Record<string, string[]>;
+    /** Route paths for the manifest pages array (e.g., ["/products", "/blog"]) */
+    routes: string[];
+    /** S3 keys to upload (e.g., ["products.html", "products.rsc", "products.meta"]) */
+    uploadKeys: string[];
+}
+export interface AssetCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route paths for the manifest assets array (e.g., ["/favicon.ico"]) */
+    routes: string[];
+    /** S3 keys to upload (same as routes for assets, without leading slash) */
+    uploadKeys: string[];
+}
+export type AdapterName = 'nextjs' | 'nitro' | 'vite';
+export interface DeployAdapter {
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    /** SPA fallback path (e.g., "/index.html"). Undefined for SSR/SSG apps. */
+    fallback?: string;
+    name: AdapterName;
+    /** Assembles and zips the server bundle. Returns path to zip, or null if no server (e.g., Vite SPA). */
+    prepareLambdaBundle(projectPath: string): Promise<null | string>;
+}
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */
+export declare function detectAdapter(projectPath: string, override?: AdapterName): Promise<DeployAdapter>;
+//# sourceMappingURL=deploy-adapter.d.ts.map

package/dist/utils/deploy-adapter.js

@@ -0,0 +1,58 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */ export async function detectAdapter(projectPath, override) {
+    if (override) {
+        return loadAdapter(override);
+    }
+    const hasNext = await exists(path.join(projectPath, '.next'));
+    const hasNitro = await exists(path.join(projectPath, '.output', 'nitro.json'));
+    const hasViteDist = await exists(path.join(projectPath, 'dist', 'index.html'));
+    if (hasNext) {
+        return loadAdapter('nextjs');
+    }
+    if (hasNitro) {
+        return loadAdapter('nitro');
+    }
+    if (hasViteDist) {
+        return loadAdapter('vite');
+    }
+    throw new Error('Could not detect framework. Expected .next/ (NextJS), .output/nitro.json (Nitro), or dist/index.html (Vite). ' + 'Use --adapter to specify explicitly.');
+}
+async function loadAdapter(name) {
+    switch(name){
+        case 'nextjs':
+            {
+                const mod = await import('./adapters/nextjs.js');
+                return mod.nextjsAdapter;
+            }
+        case 'nitro':
+            {
+                const mod = await import('./adapters/nitro.js');
+                return mod.nitroAdapter;
+            }
+        case 'vite':
+            {
+                const mod = await import('./adapters/vite.js');
+                return mod.viteAdapter;
+            }
+    }
+}
+async function exists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=deploy-adapter.js.map

package/dist/utils/download-template.d.ts

@@ -5,11 +5,19 @@ export declare class TemplateDownloadError extends Error {
     cause?: Error | undefined;
     constructor(message: string, cause?: Error | undefined);
 }
+export type TemplateSource = {
+    owner: string;
+    ref: string;
+    repo: string;
+    templatePath: string;
+};
+export declare const DEFAULT_TEMPLATE_SOURCE: TemplateSource;
 /**
  * Download Payload template from GitHub with retry logic
  *
  * @param projectDir - Directory to extract template into
+ * @param source - Optional override of repo / ref / template path
  * @throws TemplateDownloadError if download fails
  */
-export declare function downloadTemplateFromGitHub(projectDir: string): Promise<void>;
+export declare function downloadTemplateFromGitHub(projectDir: string, source?: Partial<TemplateSource>): Promise<void>;
 //# sourceMappingURL=download-template.d.ts.map

package/dist/utils/download-template.js

@@ -11,22 +11,30 @@ import { x } from 'tar';
         this.name = 'TemplateDownloadError';
     }
 }
-const BRANCH_OR_TAG = 'main';
-const TEMPLATE_NAME = 'blank';
+export const DEFAULT_TEMPLATE_SOURCE = {
+    owner: 'payloadcms',
+    ref: 'v3.84.1',
+    repo: 'payload',
+    templatePath: 'blank'
+};
 const MAX_RETRIES = 3;
-const INITIAL_RETRY_DELAY = 1000 // 1 second
-;
+const INITIAL_RETRY_DELAY = 1000;
 /**
  * Download Payload template from GitHub with retry logic
  *
  * @param projectDir - Directory to extract template into
+ * @param source - Optional override of repo / ref / template path
  * @throws TemplateDownloadError if download fails
- */ export async function downloadTemplateFromGitHub(projectDir) {
+ */ export async function downloadTemplateFromGitHub(projectDir, source) {
+    const resolved = {
+        ...DEFAULT_TEMPLATE_SOURCE,
+        ...source
+    };
     let lastError;
     for(let attempt = 1; attempt <= MAX_RETRIES; attempt++){
         try {
-            await downloadTemplateAttempt(projectDir);
-            return; // Success
+            await downloadTemplateAttempt(projectDir, resolved);
+            return;
         } catch (error) {
             lastError = error instanceof Error ? error : new Error('Unknown error');
             if (attempt < MAX_RETRIES) {
@@ -36,31 +44,29 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
             }
         }
     }
-    // All retries failed
     throw new TemplateDownloadError(`Failed to download template after ${MAX_RETRIES} attempts`, lastError);
 }
-/**
- * Single attempt to download template (extracted for retry logic)
- */ async function downloadTemplateAttempt(projectDir) {
-    const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${BRANCH_OR_TAG}`;
-    const filter = `payload-${BRANCH_OR_TAG}/templates/${TEMPLATE_NAME}/`;
+async function downloadTemplateAttempt(projectDir, source) {
+    const url = `https://codeload.github.com/${source.owner}/${source.repo}/tar.gz/${source.ref}`;
+    // GitHub strips the leading 'v' and replaces '/' with '-' when naming the tarball root dir
+    const refSlug = source.ref.replace(/^v/, '').replace(/\//g, '-');
+    const tarballPrefix = `${source.repo}-${refSlug}`;
+    const filter = `${tarballPrefix}/templates/${source.templatePath}/`;
+    const strip = 2 + source.templatePath.split('/').length;
     try {
-        // Ensure target directory exists
         await fs.mkdir(projectDir, {
             recursive: true
         });
         await pipeline(await downloadTarStream(url), x({
             cwd: projectDir,
             filter: (p)=>p.includes(filter),
-            strip: 2 + TEMPLATE_NAME.split('/').length
+            strip
         }));
     } catch (error) {
         throw new TemplateDownloadError('Failed to download template from GitHub', error instanceof Error ? error : undefined);
     }
 }
-/**
- * Download tar stream from URL
- */ async function downloadTarStream(url) {
+async function downloadTarStream(url) {
     const res = await fetch(url);
     if (!res.ok) {
         throw new Error(`HTTP ${res.status}: ${res.statusText}`);

package/dist/utils/env-management.d.ts

@@ -1,16 +1,33 @@
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
+ * Get an environment variable value from .env file (async)
  *
- * @returns 24-character hexadecimal string
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */
+export declare function getEnvVar(projectPath: string, key: string): Promise<null | string>;
+/**
+ * Get an environment variable value from .env file (sync)
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
  */
-export declare function generateSecret(): string;
+export declare function getEnvVarSync(projectPath: string, key: string): null | string;
 /**
- * Manage environment files for a new project
+ * Add or update an environment variable in .env file
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name
+ * @param value - Environment variable value
+ */
+export declare function addOrUpdateEnvVar(projectPath: string, key: string, value: string): Promise<void>;
+/**
+ * Remove an environment variable from .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
  */
-export declare function manageEnvFiles(projectPath: string): Promise<string>;
+export declare function removeEnvVar(projectPath: string, key: string): Promise<boolean>;
 //# sourceMappingURL=env-management.d.ts.map

package/dist/utils/env-management.js

@@ -1,97 +1,152 @@
-import { randomBytes } from 'crypto';
 import fs from 'fs/promises';
+import fsSync from 'node:fs';
 import path from 'path';
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
- *
- * @returns 24-character hexadecimal string
- */ export function generateSecret() {
-    return randomBytes(32).toString('hex').slice(0, 24);
-}
-/**
- * Sanitize and process environment file contents
- *
- * @param contents - Raw .env file contents
- * @param payloadSecret - Secret to use for PAYLOAD_SECRET
- * @returns Processed .env contents
- */ function sanitizeEnv(contents, payloadSecret) {
-    const lines = contents.split('\n');
-    const seenKeys = new Set();
-    const processedLines = [];
+ * Parse .env file contents and extract value for a key
+ */ function parseEnvValue(contents, key) {
+    const lines = contents.split(/\r?\n/);
     for (const line of lines){
         // Skip empty lines and comments
         if (!line.trim() || line.trim().startsWith('#')) {
-            processedLines.push(line);
             continue;
         }
         // Skip lines without =
         if (!line.includes('=')) {
-            processedLines.push(line);
             continue;
         }
-        const [key] = line.split('=');
-        const trimmedKey = key.trim();
-        // Skip duplicate keys
-        if (seenKeys.has(trimmedKey)) {
-            continue;
-        }
-        seenKeys.add(trimmedKey);
-        // Replace PAYLOAD_SECRET with actual value
-        if (trimmedKey === 'PAYLOAD_SECRET' || trimmedKey === 'PAYLOAD_SECRET_KEY') {
-            processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
-        } else {
-            processedLines.push(line);
+        const equalsIndex = line.indexOf('=');
+        const lineKey = line.substring(0, equalsIndex).trim();
+        if (lineKey === key) {
+            return line.substring(equalsIndex + 1);
         }
     }
-    // Add PAYLOAD_SECRET if not present
-    if (!seenKeys.has('PAYLOAD_SECRET') && !seenKeys.has('PAYLOAD_SECRET_KEY')) {
-        processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
+    return null;
+}
+/**
+ * Get an environment variable value from .env file (async)
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export async function getEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
     }
-    return processedLines.join('\n');
 }
 /**
- * Manage environment files for a new project
+ * Get an environment variable value from .env file (sync)
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export function getEnvVarSync(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = fsSync.readFileSync(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
+    }
+}
+/**
+ * Add or update an environment variable in .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
- */ export async function manageEnvFiles(projectPath) {
-    const payloadSecret = generateSecret();
-    const envExamplePath = path.join(projectPath, '.env.example');
+ * @param key - Environment variable name
+ * @param value - Environment variable value
+ */ export async function addOrUpdateEnvVar(projectPath, key, value) {
     const envPath = path.join(projectPath, '.env');
     try {
-        // Check if .env.example exists
-        let envExampleContents = '';
-        try {
-            envExampleContents = await fs.readFile(envExamplePath, 'utf-8');
-        } catch  {
-            // No .env.example, create minimal .env
-            envExampleContents = '';
-        }
-        // Check if .env already exists
+        let contents = '';
         let envExists = false;
+        // Try to read existing .env file
         try {
-            await fs.access(envPath);
+            contents = await fs.readFile(envPath, 'utf-8');
             envExists = true;
         } catch  {
-        // .env doesn't exist
+        // .env doesn't exist, will create it
         }
-        if (!envExists) {
-            // Create .env from .env.example
-            const sanitized = sanitizeEnv(envExampleContents, payloadSecret);
-            await fs.writeFile(envPath, sanitized, 'utf-8');
-        } else {
-            // Update existing .env if it doesn't have PAYLOAD_SECRET
-            const existingContents = await fs.readFile(envPath, 'utf-8');
-            if (!existingContents.includes('PAYLOAD_SECRET=') && !existingContents.includes('PAYLOAD_SECRET_KEY=')) {
-                const sanitized = sanitizeEnv(existingContents, payloadSecret);
-                await fs.writeFile(envPath, sanitized, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const seenKeys = new Set();
+        const processedLines = [];
+        let keyUpdated = false;
+        for (const line of lines){
+            // Skip empty lines at start if file didn't exist
+            if (!envExists && !line.trim()) {
+                continue;
+            }
+            // Preserve empty lines and comments
+            if (!line.trim() || line.trim().startsWith('#')) {
+                processedLines.push(line);
+                continue;
+            }
+            // Skip lines without =
+            if (!line.includes('=')) {
+                processedLines.push(line);
+                continue;
+            }
+            const [lineKey] = line.split('=');
+            const trimmedKey = lineKey.trim();
+            // Skip duplicate keys (keep first occurrence)
+            if (seenKeys.has(trimmedKey)) {
+                continue;
+            }
+            seenKeys.add(trimmedKey);
+            // Update or keep the line
+            if (trimmedKey === key) {
+                processedLines.push(`${key}=${value}`);
+                keyUpdated = true;
+            } else {
+                processedLines.push(line);
             }
         }
-        return payloadSecret;
+        // Add key if not present
+        if (!keyUpdated) {
+            processedLines.push(`${key}=${value}`);
+        }
+        await fs.writeFile(envPath, processedLines.join('\n'), 'utf-8');
     } catch (error) {
-        throw new Error(`Failed to manage environment files: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw new Error(`Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Remove an environment variable from .env file
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
+ */ export async function removeEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const filteredLines = [];
+        let found = false;
+        for (const line of lines){
+            if (line.trim() && !line.trim().startsWith('#') && line.includes('=')) {
+                const equalsIndex = line.indexOf('=');
+                const lineKey = line.substring(0, equalsIndex).trim();
+                if (lineKey === key) {
+                    found = true;
+                    continue;
+                }
+            }
+            filteredLines.push(line);
+        }
+        if (found) {
+            // Collapse consecutive blank lines and trim leading/trailing blank lines
+            const collapsed = filteredLines.join('\n').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '');
+            await fs.writeFile(envPath, collapsed, 'utf-8');
+        }
+        return found;
+    } catch  {
+        return false;
     }
 }
 

package/dist/utils/format-env-suffix.d.ts

@@ -0,0 +1,12 @@
+import type { Environment } from '../constants.js';
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */
+export declare function formatEnvSuffix(env: Environment, prefix?: string, suffix?: string): string;
+//# sourceMappingURL=format-env-suffix.d.ts.map

package/dist/utils/format-env-suffix.js

@@ -0,0 +1,13 @@
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */ export function formatEnvSuffix(env, prefix = ' to ', suffix = '') {
+    return env !== 'production' ? `${prefix}${env}${suffix}` : '';
+}
+
+//# sourceMappingURL=format-env-suffix.js.map

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