@payloadcms/figma 0.0.1-alpha.0

package/dist/utils/s3-upload.js

@@ -0,0 +1,128 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { isDebug } from './is-debug.js';
+/**
+ * Retry configuration
+ */ const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY = 1000 // 1 second
+;
+/**
+ * Sleep for specified milliseconds
+ */ function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+/**
+ * Check if a signed URL is a mock URL
+ */ function isMockUrl(signedUrl) {
+    return signedUrl.includes('X-Amz-Signature=mock');
+}
+/**
+ * Upload a file to S3 using a signed URL
+ *
+ * Retries up to 3 times with exponential backoff
+ *
+ * @param filePath - Absolute path to file to upload
+ * @param signedUrl - Signed S3 upload URL
+ * @param contentType - MIME type (optional)
+ * @throws Error if upload fails after retries
+ */ export async function uploadFile(filePath, signedUrl, contentType) {
+    // Skip actual upload for mock URLs
+    if (isMockUrl(signedUrl)) {
+        if (isDebug()) {
+            console.log(`Mock upload: ${path.basename(filePath)}`);
+        }
+        // Verify file exists
+        const stats = await fs.stat(filePath);
+        // Simulate upload latency based on file size
+        // lambda.zip: ~1-2 seconds, small files: 50-150ms
+        const isLargeFile = stats.size > 1024 * 1024 // > 1MB
+        ;
+        const latency = isLargeFile ? 1000 + Math.random() * 1000 // 1-2 seconds for large files
+         : 50 + Math.random() * 100 // 50-150ms for small files
+        ;
+        await sleep(latency);
+        return;
+    }
+    const fileBuffer = await fs.readFile(filePath);
+    let lastError = null;
+    for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
+        try {
+            const response = await fetch(signedUrl, {
+                body: fileBuffer,
+                headers: contentType ? {
+                    'Content-Type': contentType
+                } : {},
+                method: 'PUT'
+            });
+            if (response.ok) {
+                return; // Success
+            }
+            lastError = new Error(`Upload failed: ${response.status} ${response.statusText}`);
+        } catch (error) {
+            lastError = error instanceof Error ? error : new Error('Unknown error');
+        }
+        // Wait before retry (exponential backoff)
+        if (attempt < MAX_RETRIES - 1) {
+            await sleep(INITIAL_RETRY_DELAY * Math.pow(2, attempt));
+        }
+    }
+    throw lastError || new Error('Upload failed after retries');
+}
+/**
+ * Upload Lambda code zip to S3
+ *
+ * @param zipPath - Path to lambda.zip
+ * @param signedUrl - Signed S3 upload URL
+ */ export async function uploadLambdaZip(zipPath, signedUrl) {
+    await uploadFile(zipPath, signedUrl, 'application/zip');
+}
+/**
+ * Upload static assets to S3 in parallel
+ *
+ * Uploads up to 5 files concurrently
+ *
+ * @param projectPath - Path to project root
+ * @param assetUrls - Map of asset paths to signed URLs
+ * @param onProgress - Optional callback for progress updates (uploaded, total)
+ * @returns Upload results with counts
+ */ export async function uploadStaticAssets(projectPath, assetUrls, onProgress) {
+    const results = {
+        assetsFailed: 0,
+        assetsUploaded: 0,
+        lambdaUploaded: false,
+        totalBytesUploaded: 0
+    };
+    const assetPaths = Object.keys(assetUrls);
+    if (assetPaths.length === 0) {
+        return results;
+    }
+    // Upload assets with limited concurrency
+    const CONCURRENCY = 5;
+    for(let i = 0; i < assetPaths.length; i += CONCURRENCY){
+        const batch = assetPaths.slice(i, i + CONCURRENCY);
+        await Promise.all(batch.map(async (assetPath)=>{
+            try {
+                // Convert _next back to .next for file system
+                const fsPath = assetPath.replace(/^_next\//, '.next/');
+                const fullPath = path.join(projectPath, fsPath);
+                const signedUrl = assetUrls[assetPath];
+                await uploadFile(fullPath, signedUrl);
+                results.assetsUploaded++;
+                // Track bytes uploaded
+                const stats = await fs.stat(fullPath);
+                results.totalBytesUploaded += stats.size;
+                // Report progress
+                onProgress?.(results.assetsUploaded, assetPaths.length);
+            } catch (error) {
+                results.assetsFailed++;
+                if (isDebug()) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    console.error(`Failed to upload ${assetPath}: ${message}`);
+                }
+            }
+        }));
+    }
+    return results;
+}
+
+//# sourceMappingURL=s3-upload.js.map

package/dist/utils/s3-upload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/s3-upload.ts"],"sourcesContent":["import fs from 'fs/promises'\nimport path from 'path'\n\nimport { isDebug } from './is-debug.js'\n\n/**\n * Results from uploading assets\n */\nexport interface UploadResults {\n  /** Number of static assets that failed to upload */\n  assetsFailed: number\n  /** Number of static assets successfully uploaded */\n  assetsUploaded: number\n  /** Whether Lambda code was uploaded */\n  lambdaUploaded: boolean\n  /** Total bytes uploaded */\n  totalBytesUploaded: number\n}\n\n/**\n * Retry configuration\n */\nconst MAX_RETRIES = 3\nconst INITIAL_RETRY_DELAY = 1000 // 1 second\n\n/**\n * Sleep for specified milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\n/**\n * Check if a signed URL is a mock URL\n */\nfunction isMockUrl(signedUrl: string): boolean {\n  return signedUrl.includes('X-Amz-Signature=mock')\n}\n\n/**\n * Upload a file to S3 using a signed URL\n *\n * Retries up to 3 times with exponential backoff\n *\n * @param filePath - Absolute path to file to upload\n * @param signedUrl - Signed S3 upload URL\n * @param contentType - MIME type (optional)\n * @throws Error if upload fails after retries\n */\nexport async function uploadFile(\n  filePath: string,\n  signedUrl: string,\n  contentType?: string,\n): Promise<void> {\n  // Skip actual upload for mock URLs\n  if (isMockUrl(signedUrl)) {\n    if (isDebug()) {\n      console.log(`Mock upload: ${path.basename(filePath)}`)\n    }\n    // Verify file exists\n    const stats = await fs.stat(filePath)\n\n    // Simulate upload latency based on file size\n    // lambda.zip: ~1-2 seconds, small files: 50-150ms\n    const isLargeFile = stats.size > 1024 * 1024 // > 1MB\n    const latency = isLargeFile\n      ? 1000 + Math.random() * 1000 // 1-2 seconds for large files\n      : 50 + Math.random() * 100 // 50-150ms for small files\n    await sleep(latency)\n    return\n  }\n\n  const fileBuffer = await fs.readFile(filePath)\n\n  let lastError: Error | null = null\n\n  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {\n    try {\n      const response = await fetch(signedUrl, {\n        body: fileBuffer,\n        headers: contentType ? { 'Content-Type': contentType } : {},\n        method: 'PUT',\n      })\n\n      if (response.ok) {\n        return // Success\n      }\n\n      lastError = new Error(`Upload failed: ${response.status} ${response.statusText}`)\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error('Unknown error')\n    }\n\n    // Wait before retry (exponential backoff)\n    if (attempt < MAX_RETRIES - 1) {\n      await sleep(INITIAL_RETRY_DELAY * Math.pow(2, attempt))\n    }\n  }\n\n  throw lastError || new Error('Upload failed after retries')\n}\n\n/**\n * Upload Lambda code zip to S3\n *\n * @param zipPath - Path to lambda.zip\n * @param signedUrl - Signed S3 upload URL\n */\nexport async function uploadLambdaZip(zipPath: string, signedUrl: string): Promise<void> {\n  await uploadFile(zipPath, signedUrl, 'application/zip')\n}\n\n/**\n * Upload static assets to S3 in parallel\n *\n * Uploads up to 5 files concurrently\n *\n * @param projectPath - Path to project root\n * @param assetUrls - Map of asset paths to signed URLs\n * @param onProgress - Optional callback for progress updates (uploaded, total)\n * @returns Upload results with counts\n */\nexport async function uploadStaticAssets(\n  projectPath: string,\n  assetUrls: Record<string, string>,\n  onProgress?: (uploaded: number, total: number) => void,\n): Promise<UploadResults> {\n  const results: UploadResults = {\n    assetsFailed: 0,\n    assetsUploaded: 0,\n    lambdaUploaded: false,\n    totalBytesUploaded: 0,\n  }\n\n  const assetPaths = Object.keys(assetUrls)\n\n  if (assetPaths.length === 0) {\n    return results\n  }\n\n  // Upload assets with limited concurrency\n  const CONCURRENCY = 5\n  for (let i = 0; i < assetPaths.length; i += CONCURRENCY) {\n    const batch = assetPaths.slice(i, i + CONCURRENCY)\n\n    await Promise.all(\n      batch.map(async (assetPath) => {\n        try {\n          // Convert _next back to .next for file system\n          const fsPath = assetPath.replace(/^_next\\//, '.next/')\n          const fullPath = path.join(projectPath, fsPath)\n          const signedUrl = assetUrls[assetPath]\n\n          await uploadFile(fullPath, signedUrl)\n\n          results.assetsUploaded++\n\n          // Track bytes uploaded\n          const stats = await fs.stat(fullPath)\n          results.totalBytesUploaded += stats.size\n\n          // Report progress\n          onProgress?.(results.assetsUploaded, assetPaths.length)\n        } catch (error) {\n          results.assetsFailed++\n          if (isDebug()) {\n            const message = error instanceof Error ? error.message : 'Unknown error'\n            console.error(`Failed to upload ${assetPath}: ${message}`)\n          }\n        }\n      }),\n    )\n  }\n\n  return results\n}\n"],"names":["fs","path","isDebug","MAX_RETRIES","INITIAL_RETRY_DELAY","sleep","ms","Promise","resolve","setTimeout","isMockUrl","signedUrl","includes","uploadFile","filePath","contentType","console","log","basename","stats","stat","isLargeFile","size","latency","Math","random","fileBuffer","readFile","lastError","attempt","response","fetch","body","headers","method","ok","Error","status","statusText","error","pow","uploadLambdaZip","zipPath","uploadStaticAssets","projectPath","assetUrls","onProgress","results","assetsFailed","assetsUploaded","lambdaUploaded","totalBytesUploaded","assetPaths","Object","keys","length","CONCURRENCY","i","batch","slice","all","map","assetPath","fsPath","replace","fullPath","join","message"],"mappings":"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"}

package/dist/utils/s3-upload.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=s3-upload.spec.d.ts.map

package/dist/utils/s3-upload.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-upload.spec.d.ts","sourceRoot":"","sources":["../../src/utils/s3-upload.spec.ts"],"names":[],"mappings":""}

package/dist/utils/s3-upload.spec.js

@@ -0,0 +1,140 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { uploadFile, uploadLambdaZip, uploadStaticAssets } from './s3-upload.js';
+describe('s3-upload', ()=>{
+    const testDir = path.join(process.cwd(), 'test-fixtures', 's3-upload');
+    beforeEach(async ()=>{
+        await fs.mkdir(testDir, {
+            recursive: true
+        });
+        vi.clearAllMocks();
+    });
+    afterEach(async ()=>{
+        await fs.rm(testDir, {
+            force: true,
+            recursive: true
+        });
+        vi.restoreAllMocks();
+    });
+    describe('uploadFile', ()=>{
+        it('should upload file to signed URL', async ()=>{
+            const testFile = path.join(testDir, 'test.txt');
+            await fs.writeFile(testFile, 'test content');
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200
+            });
+            global.fetch = mockFetch;
+            await uploadFile(testFile, 'https://s3.example.com/upload?signature=abc');
+            expect(mockFetch).toHaveBeenCalledWith('https://s3.example.com/upload?signature=abc', expect.objectContaining({
+                body: expect.any(Buffer),
+                method: 'PUT'
+            }));
+        });
+        it('should retry on failure', async ()=>{
+            const testFile = path.join(testDir, 'test.txt');
+            await fs.writeFile(testFile, 'test');
+            const mockFetch = vi.fn().mockResolvedValueOnce({
+                ok: false,
+                status: 500
+            }).mockResolvedValueOnce({
+                ok: false,
+                status: 500
+            }).mockResolvedValueOnce({
+                ok: true,
+                status: 200
+            });
+            global.fetch = mockFetch;
+            await uploadFile(testFile, 'https://s3.example.com/upload');
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+        });
+        it('should throw after max retries', async ()=>{
+            const testFile = path.join(testDir, 'test.txt');
+            await fs.writeFile(testFile, 'test');
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500
+            });
+            global.fetch = mockFetch;
+            await expect(uploadFile(testFile, 'https://s3.example.com/upload')).rejects.toThrow();
+        });
+        it('should throw error for non-existent file', async ()=>{
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true
+            });
+            await expect(uploadFile(path.join(testDir, 'missing.txt'), 'https://s3.example.com')).rejects.toThrow();
+        });
+    });
+    describe('uploadLambdaZip', ()=>{
+        it('should upload zip file', async ()=>{
+            const zipPath = path.join(testDir, 'lambda.zip');
+            await fs.writeFile(zipPath, 'mock zip content');
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200
+            });
+            global.fetch = mockFetch;
+            await uploadLambdaZip(zipPath, 'https://s3.example.com/lambda.zip');
+            expect(mockFetch).toHaveBeenCalledWith('https://s3.example.com/lambda.zip', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/zip'
+                }),
+                method: 'PUT'
+            }));
+        });
+    });
+    describe('uploadStaticAssets', ()=>{
+        it('should upload multiple assets', async ()=>{
+            // Files are on disk at .next/static (filesystem structure)
+            const staticDir = path.join(testDir, '.next', 'static');
+            await fs.mkdir(staticDir, {
+                recursive: true
+            });
+            await fs.writeFile(path.join(staticDir, 'file1.js'), 'code1');
+            await fs.writeFile(path.join(staticDir, 'file2.css'), 'styles');
+            // Asset paths use _next prefix (S3 convention)
+            const assetUrls = {
+                '_next/static/file1.js': 'https://s3.example.com/file1.js',
+                '_next/static/file2.css': 'https://s3.example.com/file2.css'
+            };
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200
+            });
+            global.fetch = mockFetch;
+            const result = await uploadStaticAssets(testDir, assetUrls);
+            expect(result.lambdaUploaded).toBe(false);
+            expect(result.assetsUploaded).toBe(2);
+            expect(result.assetsFailed).toBe(0);
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        it('should track failed uploads', async ()=>{
+            // Files on disk at .next/static
+            const staticDir = path.join(testDir, '.next', 'static');
+            await fs.mkdir(staticDir, {
+                recursive: true
+            });
+            await fs.writeFile(path.join(staticDir, 'file1.js'), 'code');
+            // Asset paths use _next prefix
+            const assetUrls = {
+                '_next/static/file1.js': 'https://s3.example.com/file1.js'
+            };
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500
+            });
+            global.fetch = mockFetch;
+            const result = await uploadStaticAssets(testDir, assetUrls);
+            expect(result.assetsUploaded).toBe(0);
+            expect(result.assetsFailed).toBe(1);
+        });
+        it('should handle empty asset list', async ()=>{
+            const result = await uploadStaticAssets(testDir, {});
+            expect(result.assetsUploaded).toBe(0);
+            expect(result.assetsFailed).toBe(0);
+        });
+    });
+});
+
+//# sourceMappingURL=s3-upload.spec.js.map

package/dist/utils/s3-upload.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/s3-upload.spec.ts"],"sourcesContent":["import fs from 'fs/promises'\nimport path from 'path'\nimport { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'\n\nimport { uploadFile, uploadLambdaZip, uploadStaticAssets } from './s3-upload.js'\n\ndescribe('s3-upload', () => {\n  const testDir = path.join(process.cwd(), 'test-fixtures', 's3-upload')\n\n  beforeEach(async () => {\n    await fs.mkdir(testDir, { recursive: true })\n    vi.clearAllMocks()\n  })\n\n  afterEach(async () => {\n    await fs.rm(testDir, { force: true, recursive: true })\n    vi.restoreAllMocks()\n  })\n\n  describe('uploadFile', () => {\n    it('should upload file to signed URL', async () => {\n      const testFile = path.join(testDir, 'test.txt')\n      await fs.writeFile(testFile, 'test content')\n\n      const mockFetch = vi.fn().mockResolvedValue({\n        ok: true,\n        status: 200,\n      })\n      global.fetch = mockFetch\n\n      await uploadFile(testFile, 'https://s3.example.com/upload?signature=abc')\n\n      expect(mockFetch).toHaveBeenCalledWith(\n        'https://s3.example.com/upload?signature=abc',\n        expect.objectContaining({\n          body: expect.any(Buffer),\n          method: 'PUT',\n        }),\n      )\n    })\n\n    it('should retry on failure', async () => {\n      const testFile = path.join(testDir, 'test.txt')\n      await fs.writeFile(testFile, 'test')\n\n      const mockFetch = vi\n        .fn()\n        .mockResolvedValueOnce({ ok: false, status: 500 })\n        .mockResolvedValueOnce({ ok: false, status: 500 })\n        .mockResolvedValueOnce({ ok: true, status: 200 })\n\n      global.fetch = mockFetch\n\n      await uploadFile(testFile, 'https://s3.example.com/upload')\n\n      expect(mockFetch).toHaveBeenCalledTimes(3)\n    })\n\n    it('should throw after max retries', async () => {\n      const testFile = path.join(testDir, 'test.txt')\n      await fs.writeFile(testFile, 'test')\n\n      const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 500 })\n      global.fetch = mockFetch\n\n      await expect(uploadFile(testFile, 'https://s3.example.com/upload')).rejects.toThrow()\n    })\n\n    it('should throw error for non-existent file', async () => {\n      global.fetch = vi.fn().mockResolvedValue({ ok: true })\n\n      await expect(\n        uploadFile(path.join(testDir, 'missing.txt'), 'https://s3.example.com'),\n      ).rejects.toThrow()\n    })\n  })\n\n  describe('uploadLambdaZip', () => {\n    it('should upload zip file', async () => {\n      const zipPath = path.join(testDir, 'lambda.zip')\n      await fs.writeFile(zipPath, 'mock zip content')\n\n      const mockFetch = vi.fn().mockResolvedValue({ ok: true, status: 200 })\n      global.fetch = mockFetch\n\n      await uploadLambdaZip(zipPath, 'https://s3.example.com/lambda.zip')\n\n      expect(mockFetch).toHaveBeenCalledWith(\n        'https://s3.example.com/lambda.zip',\n        expect.objectContaining({\n          headers: expect.objectContaining({\n            'Content-Type': 'application/zip',\n          }),\n          method: 'PUT',\n        }),\n      )\n    })\n  })\n\n  describe('uploadStaticAssets', () => {\n    it('should upload multiple assets', async () => {\n      // Files are on disk at .next/static (filesystem structure)\n      const staticDir = path.join(testDir, '.next', 'static')\n      await fs.mkdir(staticDir, { recursive: true })\n      await fs.writeFile(path.join(staticDir, 'file1.js'), 'code1')\n      await fs.writeFile(path.join(staticDir, 'file2.css'), 'styles')\n\n      // Asset paths use _next prefix (S3 convention)\n      const assetUrls = {\n        '_next/static/file1.js': 'https://s3.example.com/file1.js',\n        '_next/static/file2.css': 'https://s3.example.com/file2.css',\n      }\n\n      const mockFetch = vi.fn().mockResolvedValue({ ok: true, status: 200 })\n      global.fetch = mockFetch\n\n      const result = await uploadStaticAssets(testDir, assetUrls)\n\n      expect(result.lambdaUploaded).toBe(false)\n      expect(result.assetsUploaded).toBe(2)\n      expect(result.assetsFailed).toBe(0)\n      expect(mockFetch).toHaveBeenCalledTimes(2)\n    })\n\n    it('should track failed uploads', async () => {\n      // Files on disk at .next/static\n      const staticDir = path.join(testDir, '.next', 'static')\n      await fs.mkdir(staticDir, { recursive: true })\n      await fs.writeFile(path.join(staticDir, 'file1.js'), 'code')\n\n      // Asset paths use _next prefix\n      const assetUrls = {\n        '_next/static/file1.js': 'https://s3.example.com/file1.js',\n      }\n\n      const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 500 })\n      global.fetch = mockFetch\n\n      const result = await uploadStaticAssets(testDir, assetUrls)\n\n      expect(result.assetsUploaded).toBe(0)\n      expect(result.assetsFailed).toBe(1)\n    })\n\n    it('should handle empty asset list', async () => {\n      const result = await uploadStaticAssets(testDir, {})\n\n      expect(result.assetsUploaded).toBe(0)\n      expect(result.assetsFailed).toBe(0)\n    })\n  })\n})\n"],"names":["fs","path","afterEach","beforeEach","describe","expect","it","vi","uploadFile","uploadLambdaZip","uploadStaticAssets","testDir","join","process","cwd","mkdir","recursive","clearAllMocks","rm","force","restoreAllMocks","testFile","writeFile","mockFetch","fn","mockResolvedValue","ok","status","global","fetch","toHaveBeenCalledWith","objectContaining","body","any","Buffer","method","mockResolvedValueOnce","toHaveBeenCalledTimes","rejects","toThrow","zipPath","headers","staticDir","assetUrls","result","lambdaUploaded","toBe","assetsUploaded","assetsFailed"],"mappings":"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"}

package/dist/utils/token-display.d.ts

@@ -0,0 +1,14 @@
+import type { TokenStore } from '../auth/token-store.js';
+/**
+ * Mask token for display (show first 4 and last 4 characters)
+ */
+export declare function maskToken(token: string): string;
+/**
+ * Format timestamp as human-readable string with color coding
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Show all stored project tokens
+ */
+export declare function showProjectTokens(tokenStore: TokenStore): void;
+//# sourceMappingURL=token-display.d.ts.map

package/dist/utils/token-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-display.d.ts","sourceRoot":"","sources":["../../src/utils/token-display.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAsBzD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAgC9D"}

package/dist/utils/token-display.js

@@ -0,0 +1,62 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+/**
+ * Mask token for display (show first 4 and last 4 characters)
+ */ export function maskToken(token) {
+    if (token.length <= 8) {
+        return '***';
+    }
+    return `${token.slice(0, 4)}${'*'.repeat(Math.min(token.length - 8, 32))}${token.slice(-4)}`;
+}
+/**
+ * Format timestamp as human-readable string with color coding
+ */ export function formatTimestamp(timestamp) {
+    const now = Date.now();
+    const diff = timestamp - now;
+    if (diff < 0) {
+        return pc.red('Expired');
+    }
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return pc.green(`${days}d ${hours % 24}h`);
+    }
+    if (hours > 0) {
+        return pc.green(`${hours}h ${minutes % 60}m`);
+    }
+    if (minutes > 5) {
+        return pc.yellow(`${minutes}m`);
+    }
+    return pc.red(`${minutes}m`);
+}
+/**
+ * Show all stored project tokens
+ */ export function showProjectTokens(tokenStore) {
+    // Get all tenant IDs that have project tokens
+    const tenantIds = tokenStore.getAllProjectTokenTenantIds();
+    if (tenantIds.length === 0) {
+        p.log.step(pc.dim('No project tokens stored.'));
+        p.note(`Run ${pc.cyan('payloadcms-figma init')} to create a CMS instance`, 'Tip');
+        return;
+    }
+    const projectTokenLines = [];
+    tenantIds.forEach((tenantId, index)=>{
+        const projectToken = tokenStore.getProjectToken(tenantId);
+        if (!projectToken) {
+            return;
+        }
+        const isValid = tokenStore.hasValidProjectToken(tenantId);
+        const status = isValid ? pc.green('✓ Valid') : pc.red('✗ Expired');
+        if (index > 0) {
+            projectTokenLines.push(''); // Blank line between tokens
+        }
+        projectTokenLines.push(`Tenant ID:      ${tenantId}`);
+        projectTokenLines.push(`Status:         ${status}`);
+        projectTokenLines.push(`Token:          ${maskToken(projectToken.token)}`);
+        projectTokenLines.push(`Expires:        ${formatTimestamp(projectToken.expiresAt)}`);
+    });
+    p.note(projectTokenLines.join('\n'), `Project Tokens (${tenantIds.length})`);
+}
+
+//# sourceMappingURL=token-display.js.map

package/dist/utils/token-display.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/token-display.ts"],"sourcesContent":["import * as p from '@clack/prompts'\nimport pc from 'picocolors'\n\nimport type { TokenStore } from '../auth/token-store.js'\n\n/**\n * Mask token for display (show first 4 and last 4 characters)\n */\nexport function maskToken(token: string): string {\n  if (token.length <= 8) {\n    return '***'\n  }\n  return `${token.slice(0, 4)}${'*'.repeat(Math.min(token.length - 8, 32))}${token.slice(-4)}`\n}\n\n/**\n * Format timestamp as human-readable string with color coding\n */\nexport function formatTimestamp(timestamp: number): string {\n  const now = Date.now()\n  const diff = timestamp - now\n\n  if (diff < 0) {\n    return pc.red('Expired')\n  }\n\n  const minutes = Math.floor(diff / 60000)\n  const hours = Math.floor(minutes / 60)\n  const days = Math.floor(hours / 24)\n\n  if (days > 0) {\n    return pc.green(`${days}d ${hours % 24}h`)\n  }\n  if (hours > 0) {\n    return pc.green(`${hours}h ${minutes % 60}m`)\n  }\n  if (minutes > 5) {\n    return pc.yellow(`${minutes}m`)\n  }\n  return pc.red(`${minutes}m`)\n}\n\n/**\n * Show all stored project tokens\n */\nexport function showProjectTokens(tokenStore: TokenStore): void {\n  // Get all tenant IDs that have project tokens\n  const tenantIds = tokenStore.getAllProjectTokenTenantIds()\n\n  if (tenantIds.length === 0) {\n    p.log.step(pc.dim('No project tokens stored.'))\n    p.note(`Run ${pc.cyan('payloadcms-figma init')} to create a CMS instance`, 'Tip')\n    return\n  }\n  const projectTokenLines: string[] = []\n\n  tenantIds.forEach((tenantId, index) => {\n    const projectToken = tokenStore.getProjectToken(tenantId)\n\n    if (!projectToken) {\n      return\n    }\n\n    const isValid = tokenStore.hasValidProjectToken(tenantId)\n    const status = isValid ? pc.green('✓ Valid') : pc.red('✗ Expired')\n\n    if (index > 0) {\n      projectTokenLines.push('') // Blank line between tokens\n    }\n\n    projectTokenLines.push(`Tenant ID:      ${tenantId}`)\n    projectTokenLines.push(`Status:         ${status}`)\n    projectTokenLines.push(`Token:          ${maskToken(projectToken.token)}`)\n    projectTokenLines.push(`Expires:        ${formatTimestamp(projectToken.expiresAt)}`)\n  })\n\n  p.note(projectTokenLines.join('\\n'), `Project Tokens (${tenantIds.length})`)\n}\n"],"names":["p","pc","maskToken","token","length","slice","repeat","Math","min","formatTimestamp","timestamp","now","Date","diff","red","minutes","floor","hours","days","green","yellow","showProjectTokens","tokenStore","tenantIds","getAllProjectTokenTenantIds","log","step","dim","note","cyan","projectTokenLines","forEach","tenantId","index","projectToken","getProjectToken","isValid","hasValidProjectToken","status","push","expiresAt","join"],"mappings":"AAAA,YAAYA,OAAO,iBAAgB;AACnC,OAAOC,QAAQ,aAAY;AAI3B;;CAEC,GACD,OAAO,SAASC,UAAUC,KAAa;IACrC,IAAIA,MAAMC,MAAM,IAAI,GAAG;QACrB,OAAO;IACT;IACA,OAAO,GAAGD,MAAME,KAAK,CAAC,GAAG,KAAK,IAAIC,MAAM,CAACC,KAAKC,GAAG,CAACL,MAAMC,MAAM,GAAG,GAAG,OAAOD,MAAME,KAAK,CAAC,CAAC,IAAI;AAC9F;AAEA;;CAEC,GACD,OAAO,SAASI,gBAAgBC,SAAiB;IAC/C,MAAMC,MAAMC,KAAKD,GAAG;IACpB,MAAME,OAAOH,YAAYC;IAEzB,IAAIE,OAAO,GAAG;QACZ,OAAOZ,GAAGa,GAAG,CAAC;IAChB;IAEA,MAAMC,UAAUR,KAAKS,KAAK,CAACH,OAAO;IAClC,MAAMI,QAAQV,KAAKS,KAAK,CAACD,UAAU;IACnC,MAAMG,OAAOX,KAAKS,KAAK,CAACC,QAAQ;IAEhC,IAAIC,OAAO,GAAG;QACZ,OAAOjB,GAAGkB,KAAK,CAAC,GAAGD,KAAK,EAAE,EAAED,QAAQ,GAAG,CAAC,CAAC;IAC3C;IACA,IAAIA,QAAQ,GAAG;QACb,OAAOhB,GAAGkB,KAAK,CAAC,GAAGF,MAAM,EAAE,EAAEF,UAAU,GAAG,CAAC,CAAC;IAC9C;IACA,IAAIA,UAAU,GAAG;QACf,OAAOd,GAAGmB,MAAM,CAAC,GAAGL,QAAQ,CAAC,CAAC;IAChC;IACA,OAAOd,GAAGa,GAAG,CAAC,GAAGC,QAAQ,CAAC,CAAC;AAC7B;AAEA;;CAEC,GACD,OAAO,SAASM,kBAAkBC,UAAsB;IACtD,8CAA8C;IAC9C,MAAMC,YAAYD,WAAWE,2BAA2B;IAExD,IAAID,UAAUnB,MAAM,KAAK,GAAG;QAC1BJ,EAAEyB,GAAG,CAACC,IAAI,CAACzB,GAAG0B,GAAG,CAAC;QAClB3B,EAAE4B,IAAI,CAAC,CAAC,IAAI,EAAE3B,GAAG4B,IAAI,CAAC,yBAAyB,yBAAyB,CAAC,EAAE;QAC3E;IACF;IACA,MAAMC,oBAA8B,EAAE;IAEtCP,UAAUQ,OAAO,CAAC,CAACC,UAAUC;QAC3B,MAAMC,eAAeZ,WAAWa,eAAe,CAACH;QAEhD,IAAI,CAACE,cAAc;YACjB;QACF;QAEA,MAAME,UAAUd,WAAWe,oBAAoB,CAACL;QAChD,MAAMM,SAASF,UAAUnC,GAAGkB,KAAK,CAAC,aAAalB,GAAGa,GAAG,CAAC;QAEtD,IAAImB,QAAQ,GAAG;YACbH,kBAAkBS,IAAI,CAAC,KAAI,4BAA4B;QACzD;QAEAT,kBAAkBS,IAAI,CAAC,CAAC,gBAAgB,EAAEP,UAAU;QACpDF,kBAAkBS,IAAI,CAAC,CAAC,gBAAgB,EAAED,QAAQ;QAClDR,kBAAkBS,IAAI,CAAC,CAAC,gBAAgB,EAAErC,UAAUgC,aAAa/B,KAAK,GAAG;QACzE2B,kBAAkBS,IAAI,CAAC,CAAC,gBAAgB,EAAE9B,gBAAgByB,aAAaM,SAAS,GAAG;IACrF;IAEAxC,EAAE4B,IAAI,CAACE,kBAAkBW,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAElB,UAAUnB,MAAM,CAAC,CAAC,CAAC;AAC7E"}

package/dist/utils/typescript-validator.d.ts

@@ -0,0 +1,11 @@
+import type { PackageManager } from './package-manager.js';
+export type TypeScriptCheckResult = {
+    errors: string[];
+    success: boolean;
+};
+/**
+ * Run TypeScript type checking (tsc --noEmit)
+ * Skips silently if TypeScript not available
+ */
+export declare function runTypeScriptCheck(projectPath: string, packageManager: PackageManager): Promise<TypeScriptCheckResult>;
+//# sourceMappingURL=typescript-validator.d.ts.map

package/dist/utils/typescript-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-validator.d.ts","sourceRoot":"","sources":["../../src/utils/typescript-validator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,cAAc,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAmChC"}

package/dist/utils/typescript-validator.js

@@ -0,0 +1,58 @@
+import { spawn } from 'child_process';
+/**
+ * Run TypeScript type checking (tsc --noEmit)
+ * Skips silently if TypeScript not available
+ */ export async function runTypeScriptCheck(projectPath, packageManager) {
+    return new Promise((resolve)=>{
+        try {
+            const args = [
+                'exec',
+                'tsc',
+                '--noEmit'
+            ];
+            const child = spawn(packageManager, args, {
+                cwd: projectPath,
+                shell: true,
+                stdio: 'pipe'
+            });
+            let output = '';
+            child.stdout?.on('data', (data)=>{
+                output += data.toString();
+            });
+            child.on('close', (code)=>{
+                if (code === 0) {
+                    resolve({
+                        errors: [],
+                        success: true
+                    });
+                } else {
+                    const errors = parseTypeScriptErrors(output);
+                    resolve({
+                        errors,
+                        success: false
+                    });
+                }
+            });
+            child.on('error', ()=>{
+                // tsc not available - skip validation
+                resolve({
+                    errors: [],
+                    success: true
+                });
+            });
+        } catch  {
+            // Skip validation if error
+            resolve({
+                errors: [],
+                success: true
+            });
+        }
+    });
+}
+/**
+ * Parse TypeScript error output
+ */ function parseTypeScriptErrors(output) {
+    return output.split('\n').filter((line)=>line.includes('error TS')).map((line)=>line.trim());
+}
+
+//# sourceMappingURL=typescript-validator.js.map

package/dist/utils/typescript-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/typescript-validator.ts"],"sourcesContent":["import { spawn } from 'child_process'\n\nimport type { PackageManager } from './package-manager.js'\n\nexport type TypeScriptCheckResult = {\n  errors: string[]\n  success: boolean\n}\n\n/**\n * Run TypeScript type checking (tsc --noEmit)\n * Skips silently if TypeScript not available\n */\nexport async function runTypeScriptCheck(\n  projectPath: string,\n  packageManager: PackageManager,\n): Promise<TypeScriptCheckResult> {\n  return new Promise((resolve) => {\n    try {\n      const args = ['exec', 'tsc', '--noEmit']\n\n      const child = spawn(packageManager, args, {\n        cwd: projectPath,\n        shell: true,\n        stdio: 'pipe',\n      })\n\n      let output = ''\n\n      child.stdout?.on('data', (data) => {\n        output += data.toString()\n      })\n\n      child.on('close', (code) => {\n        if (code === 0) {\n          resolve({ errors: [], success: true })\n        } else {\n          const errors = parseTypeScriptErrors(output)\n          resolve({ errors, success: false })\n        }\n      })\n\n      child.on('error', () => {\n        // tsc not available - skip validation\n        resolve({ errors: [], success: true })\n      })\n    } catch {\n      // Skip validation if error\n      resolve({ errors: [], success: true })\n    }\n  })\n}\n\n/**\n * Parse TypeScript error output\n */\nfunction parseTypeScriptErrors(output: string): string[] {\n  return output\n    .split('\\n')\n    .filter((line) => line.includes('error TS'))\n    .map((line) => line.trim())\n}\n"],"names":["spawn","runTypeScriptCheck","projectPath","packageManager","Promise","resolve","args","child","cwd","shell","stdio","output","stdout","on","data","toString","code","errors","success","parseTypeScriptErrors","split","filter","line","includes","map","trim"],"mappings":"AAAA,SAASA,KAAK,QAAQ,gBAAe;AASrC;;;CAGC,GACD,OAAO,eAAeC,mBACpBC,WAAmB,EACnBC,cAA8B;IAE9B,OAAO,IAAIC,QAAQ,CAACC;QAClB,IAAI;YACF,MAAMC,OAAO;gBAAC;gBAAQ;gBAAO;aAAW;YAExC,MAAMC,QAAQP,MAAMG,gBAAgBG,MAAM;gBACxCE,KAAKN;gBACLO,OAAO;gBACPC,OAAO;YACT;YAEA,IAAIC,SAAS;YAEbJ,MAAMK,MAAM,EAAEC,GAAG,QAAQ,CAACC;gBACxBH,UAAUG,KAAKC,QAAQ;YACzB;YAEAR,MAAMM,EAAE,CAAC,SAAS,CAACG;gBACjB,IAAIA,SAAS,GAAG;oBACdX,QAAQ;wBAAEY,QAAQ,EAAE;wBAAEC,SAAS;oBAAK;gBACtC,OAAO;oBACL,MAAMD,SAASE,sBAAsBR;oBACrCN,QAAQ;wBAAEY;wBAAQC,SAAS;oBAAM;gBACnC;YACF;YAEAX,MAAMM,EAAE,CAAC,SAAS;gBAChB,sCAAsC;gBACtCR,QAAQ;oBAAEY,QAAQ,EAAE;oBAAEC,SAAS;gBAAK;YACtC;QACF,EAAE,OAAM;YACN,2BAA2B;YAC3Bb,QAAQ;gBAAEY,QAAQ,EAAE;gBAAEC,SAAS;YAAK;QACtC;IACF;AACF;AAEA;;CAEC,GACD,SAASC,sBAAsBR,MAAc;IAC3C,OAAOA,OACJS,KAAK,CAAC,MACNC,MAAM,CAAC,CAACC,OAASA,KAAKC,QAAQ,CAAC,aAC/BC,GAAG,CAAC,CAACF,OAASA,KAAKG,IAAI;AAC5B"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@payloadcms/figma",
+  "version": "0.0.1-alpha.0",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "payloadcms-figma": "bin/cli.js"
+  },
+  "files": [
+    "package.json",
+    "dist",
+    "bin"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@figma/rest-api-spec": "^0.34.0",
+    "@payloadcms/richtext-lexical": "3.54.0",
+    "@sindresorhus/slugify": "^3.0.0",
+    "arg": "^5.0.2",
+    "conf": "^13.0.1",
+    "esprima-next": "^6.0.2",
+    "figures": "^6.1.0",
+    "jose": "6.0.12",
+    "open": "^10.1.0",
+    "payload": "3.54.0",
+    "picocolors": "1.1.1",
+    "tar": "^7.4.3",
+    "terminal-link": "^5.0.0",
+    "ts-morph": "^21.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.12.0",
+    "tsx": "4.20.6",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "pnpm build:swc && pnpm build:types && pnpm copyfiles",
+    "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
+    "build:types": "tsc",
+    "clean": "rimraf -g \"{dist,*.tsbuildinfo,package}\"",
+    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png}\" dist/",
+    "debug:clear-tokens": "tsx scripts/clear-tokens.ts",
+    "debug:expire-token": "tsx scripts/expire-token.ts",
+    "debug:jwks": "tsx scripts/test-jwks-validation.ts",
+    "debug:refresh-token": "tsx scripts/refresh-token.ts",
+    "debug:tokens": "tsx scripts/debug-tokens.ts",
+    "debug:write-token": "tsx scripts/write-token.ts",
+    "lint": "eslint src",
+    "lint:fix": "eslint . --fix",
+    "start": "pnpm build && node ./bin/cli.js",
+    "test": "TEST_UNIT=true vitest run",
+    "test:int": "TEST_INT=true vitest run --config vitest.config.int.ts",
+    "test:int:watch": "TEST_INT=true vitest --config vitest.config.int.ts",
+    "test:watch": "TEST_UNIT=true vitest"
+  }
+}