@payloadcms/figma 0.0.1-alpha.9 → 0.1.0-alpha.1

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

@@ -0,0 +1,90 @@
+import archiver from 'archiver';
+import { createWriteStream } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+import { getDirectorySize } from './fs-utils.js';
+/**
+ * AWS Lambda's hard limit on unzipped deployment code size (250 MB). The unzipped
+ * total must be strictly less than this value, so a bundle exactly equal to it is
+ * rejected. The server enforces this too and now returns a clear message, so a
+ * client-side check against this value is an early-exit convenience, not the
+ * source of truth.
+ */ export const LAMBDA_MAX_UNZIPPED_BYTES = 250 * 1024 * 1024;
+/**
+ * Build Lambda deployment zip using pure Node.js
+ *
+ * Cross-platform replacement for build_for_lambda.sh:
+ * 1. Copies .next/static to .next/standalone/.next/static
+ * 2. Copies run.sh to .next/standalone/run.sh
+ * 3. Creates lambda.zip from .next/standalone/
+ *
+ * Note: public/ is NOT included in the zip — those files are uploaded
+ * as static assets and served via CDN, not from the Lambda function.
+ *
+ * @param projectPath - Path to project root
+ * @returns The built bundle: its unzipped byte size and the absolute zip path.
+ * @throws Error if standalone directory missing or zip creation fails
+ */ export async function buildLambdaZip(projectPath) {
+    const standalonePath = path.join(projectPath, '.next', 'standalone');
+    const staticPath = path.join(projectPath, '.next', 'static');
+    const runShPath = path.join(projectPath, 'run.sh');
+    const zipPath = path.join(projectPath, 'lambda.zip');
+    if (!await isDirectory(standalonePath)) {
+        throw new Error('Standalone build not found at .next/standalone. ' + 'Ensure next.config has output: "standalone" and run build first.');
+    }
+    if (await isDirectory(staticPath)) {
+        const destStatic = path.join(standalonePath, '.next', 'static');
+        await copyDirectory(staticPath, destStatic);
+    }
+    try {
+        await fs.copyFile(runShPath, path.join(standalonePath, 'run.sh'));
+    } catch  {
+    // run.sh may not exist in all setups
+    }
+    const unzippedBytes = await getDirectorySize(standalonePath);
+    await createZip(standalonePath, zipPath);
+    return {
+        unzippedBytes,
+        zipPath
+    };
+}
+async function isDirectory(dirPath) {
+    try {
+        const stats = await fs.stat(dirPath);
+        return stats.isDirectory();
+    } catch  {
+        return false;
+    }
+}
+async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, {
+        recursive: true
+    });
+    const entries = await fs.readdir(src, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        } else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+function createZip(sourceDir, zipPath) {
+    return new Promise((resolve, reject)=>{
+        const output = createWriteStream(zipPath);
+        const archive = archiver('zip', {
+            zlib: {
+                level: 9
+            }
+        });
+        output.on('close', ()=>resolve());
+        archive.on('error', (err)=>reject(err));
+        archive.pipe(output);
+        archive.directory(sourceDir, false);
+        void archive.finalize();
+    });
+}

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

@@ -0,0 +1,7 @@
+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;

package/dist/utils/cache-bootstrap.js

@@ -0,0 +1,16 @@
+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(', ')}`);
+}

package/dist/utils/config.d.ts

@@ -8,4 +8,3 @@
  * @param entries - Optional entries to add to .gitignore
  */
 export declare function ensureGitignore(projectPath: string, entries?: string[]): Promise<void>;
-//# sourceMappingURL=config.d.ts.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));
@@ -28,5 +28,3 @@ const GITIGNORE_FILENAME = '.gitignore';
         await fs.writeFile(gitignorePath, newContent, 'utf-8');
     }
 }
-
-//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,45 @@
+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 LambdaBundle {
+    /** Total size in bytes of the bundle contents before compression. */
+    unzippedBytes: number;
+    /** Absolute path to the built lambda.zip. */
+    zipPath: string;
+}
+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 the bundle, or null if no server (e.g., Vite SPA). */
+    prepareLambdaBundle(projectPath: string): Promise<LambdaBundle | null>;
+}
+/**
+ * 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>;

package/dist/utils/deploy-adapter.js

@@ -0,0 +1,56 @@
+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;
+    }
+}

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

@@ -5,11 +5,18 @@ 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>;
-//# sourceMappingURL=download-template.d.ts.map
+export declare function downloadTemplateFromGitHub(projectDir: string, source?: Partial<TemplateSource>): Promise<void>;

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: 'main',
+    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}`);
@@ -70,5 +76,3 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
     }
     return Readable.from(res.body);
 }
-
-//# sourceMappingURL=download-template.js.map

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

@@ -1,16 +1,32 @@
 /**
- * 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>;
-//# sourceMappingURL=env-management.d.ts.map
+export declare function removeEnvVar(projectPath: string, key: string): Promise<boolean>;

package/dist/utils/env-management.js

@@ -1,98 +1,151 @@
-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;
     }
 }
-
-//# sourceMappingURL=env-management.js.map

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

@@ -0,0 +1,11 @@
+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;

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

@@ -0,0 +1,11 @@
+/**
+ * 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}` : '';
+}

package/dist/utils/format.d.ts

@@ -20,4 +20,3 @@ export declare function getTimeUntilExpiry(expiresAt: number): string;
  * @returns Masked token string (e.g., "eyJh********************************mFbc")
  */
 export declare function maskToken(token: string): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.js

@@ -45,5 +45,3 @@
     }
     return `${token.slice(0, 4)}${'*'.repeat(Math.min(token.length - 8, 32))}${token.slice(-4)}`;
 }
-
-//# sourceMappingURL=format.js.map

package/dist/utils/formatter.d.ts

@@ -8,4 +8,3 @@ export type FormatResult = {
  * Returns warning if formatting fails but does not throw
  */
 export declare function formatFile(filePath: string, packageManager: PackageManager): Promise<FormatResult>;
-//# sourceMappingURL=formatter.d.ts.map