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

package/dist/api/check-project-subdomain-availability.d.ts

@@ -0,0 +1,12 @@
+import type { AuthCredential } from '../auth/credentials.js';
+interface CheckProjectSubdomainAvailabilityArgs {
+    credential: AuthCredential;
+    subdomain: string;
+}
+interface ProjectSubdomainAvailability {
+    available: boolean;
+    domainName: string;
+    reason: string;
+}
+export declare function checkProjectSubdomainAvailability({ credential, subdomain, }: CheckProjectSubdomainAvailabilityArgs): Promise<ProjectSubdomainAvailability>;
+export {};

package/dist/api/check-project-subdomain-availability.js

@@ -0,0 +1,32 @@
+import { getAuthHeaders } from '../auth/credentials.js';
+import { getEnvConfig } from '../constants.js';
+import { controlPlaneFetch } from './control-plane-fetch.js';
+export async function checkProjectSubdomainAvailability({ credential, subdomain }) {
+    if (process.env.FIGMA_MOCK_CONTROL_PLANE === 'true') {
+        return {
+            available: true,
+            domainName: `${subdomain}.pung.site`,
+            reason: ''
+        };
+    }
+    const response = await controlPlaneFetch({
+        context: 'check project subdomain availability',
+        options: {
+            body: JSON.stringify({
+                subdomain
+            }),
+            headers: {
+                ...getAuthHeaders(credential),
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
+        },
+        url: `${getEnvConfig().apiBaseUrl}/v1/cms/check_domain_availability`
+    });
+    const availabilityResponse = await response.json();
+    return {
+        available: availabilityResponse.meta.available,
+        domainName: availabilityResponse.meta.domain_name,
+        reason: availabilityResponse.meta.reason
+    };
+}

package/dist/api/control-plane-error.d.ts

@@ -0,0 +1,6 @@
+/** Error thrown when Control Plane API calls fail. */
+export declare class ControlPlaneError extends Error {
+    statusCode?: number | undefined;
+    cause?: Error | undefined;
+    constructor(message: string, statusCode?: number | undefined, cause?: Error | undefined);
+}

package/dist/api/control-plane-error.js

@@ -0,0 +1,8 @@
+/** Error thrown when Control Plane API calls fail. */ export class ControlPlaneError extends Error {
+    statusCode;
+    cause;
+    constructor(message, statusCode, cause){
+        super(message), this.statusCode = statusCode, this.cause = cause;
+        this.name = 'ControlPlaneError';
+    }
+}

package/dist/api/control-plane-fetch.d.ts

@@ -0,0 +1,7 @@
+interface ControlPlaneFetchArgs {
+    context: string;
+    options: RequestInit;
+    url: string;
+}
+export declare function controlPlaneFetch({ context, options, url }: ControlPlaneFetchArgs): Promise<Response>;
+export {};

package/dist/api/control-plane-fetch.js

@@ -0,0 +1,37 @@
+import { ControlPlaneError } from './control-plane-error.js';
+import { parseControlPlaneApiError } from './error-response.js';
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY = 1000;
+export async function controlPlaneFetch({ context, options, url }) {
+    let lastError;
+    for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
+        try {
+            const response = await fetch(url, options);
+            if (response.ok) {
+                return response;
+            }
+            if (response.status < 500) {
+                throw new ControlPlaneError(await parseControlPlaneApiError({
+                    context,
+                    response
+                }), response.status);
+            }
+            lastError = new ControlPlaneError(await parseControlPlaneApiError({
+                context,
+                response
+            }), response.status);
+        } catch (error) {
+            if (error instanceof ControlPlaneError) {
+                throw error;
+            }
+            lastError = error instanceof Error ? error : new Error('Unknown error');
+        }
+        if (attempt < MAX_RETRIES - 1) {
+            await sleep(INITIAL_RETRY_DELAY * Math.pow(2, attempt));
+        }
+    }
+    throw new ControlPlaneError(`Network error while ${context}: ${lastError?.message || 'Unknown error'}`, undefined, lastError);
+}
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}

package/dist/api/control-plane.d.ts

@@ -5,14 +5,6 @@
  */
 import type { AuthCredential } from '../auth/credentials.js';
 import type { Tenant } from '../types/config.js';
-/**
- * Error thrown when Control Plane API calls fail
- */
-export declare class ControlPlaneError extends Error {
-    statusCode?: number | undefined;
-    cause?: Error | undefined;
-    constructor(message: string, statusCode?: number | undefined, cause?: Error | undefined);
-}
 /**
  * Options for creating a new tenant
  */
@@ -77,7 +69,7 @@ export interface PerformDeploymentResponse {
     deploymentId: string;
     /** Status message */
     message: string;
-    /** List of tenant domains */
+    /** SiteDomain hostnames returned through the compatibility tenant_domains key */
     tenantDomains: string[];
 }
 export interface PerformDeploymentApiResponse {

package/dist/api/control-plane.js

@@ -5,22 +5,12 @@
  */ import { getAuthHeaders } from '../auth/credentials.js';
 import { getEnvConfig } from '../constants.js';
 import * as log from '../utils/log.js';
-import { parseControlPlaneApiError } from './error-response.js';
+import { controlPlaneFetch } from './control-plane-fetch.js';
 /**
  * Get the Control Plane API base URL based on environment
  */ function getControlPlaneBaseUrl() {
     return getEnvConfig().apiBaseUrl;
 }
-/**
- * Error thrown when Control Plane API calls fail
- */ export class ControlPlaneError extends Error {
-    statusCode;
-    cause;
-    constructor(message, statusCode, cause){
-        super(message), this.statusCode = statusCode, this.cause = cause;
-        this.name = 'ControlPlaneError';
-    }
-}
 /**
  * List all tenant instances for the authenticated user
  * Maps to: GET /v1/tenant
@@ -234,7 +224,7 @@ import { parseControlPlaneApiError } from './error-response.js';
             deploymentId: options.deploymentId,
             message: 'Deployment initiated successfully',
             tenantDomains: [
-                'example.figmasource.site'
+                'example.figma.site'
             ]
         };
     }
@@ -316,39 +306,3 @@ import { parseControlPlaneApiError } from './error-response.js';
     const data = await response.json();
     return data.meta.cms_resource_id;
 }
-const MAX_RETRIES = 3;
-const INITIAL_RETRY_DELAY = 1000;
-function sleep(ms) {
-    return new Promise((resolve)=>setTimeout(resolve, ms));
-}
-async function controlPlaneFetch(params) {
-    const { context, options, url } = params;
-    let lastError;
-    for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
-        try {
-            const response = await fetch(url, options);
-            if (response.ok) {
-                return response;
-            }
-            if (response.status < 500) {
-                throw new ControlPlaneError(await parseControlPlaneApiError({
-                    context,
-                    response
-                }), response.status);
-            }
-            lastError = new ControlPlaneError(await parseControlPlaneApiError({
-                context,
-                response
-            }), response.status);
-        } catch (error) {
-            if (error instanceof ControlPlaneError) {
-                throw error;
-            }
-            lastError = error instanceof Error ? error : new Error('Unknown error');
-        }
-        if (attempt < MAX_RETRIES - 1) {
-            await sleep(INITIAL_RETRY_DELAY * Math.pow(2, attempt));
-        }
-    }
-    throw new ControlPlaneError(`Network error while ${context}: ${lastError?.message || 'Unknown error'}`, undefined, lastError);
-}

package/dist/api/create-project.d.ts

@@ -0,0 +1,18 @@
+import type { AuthCredential } from '../auth/credentials.js';
+import type { ProjectResourceType } from './project-resource-type.js';
+interface CreateProjectArgs {
+    credential: AuthCredential;
+    description: string;
+    name: string;
+    parentPlanKey: string;
+    region: string;
+    resourceType: ProjectResourceType;
+    subdomain: string;
+}
+interface CreateProjectResponse {
+    domainName: string;
+    id: string;
+    name: string;
+}
+export declare function createProject({ name, credential, description, parentPlanKey, region, resourceType, subdomain, }: CreateProjectArgs): Promise<CreateProjectResponse>;
+export {};

package/dist/api/create-project.js

@@ -0,0 +1,37 @@
+import { getAuthHeaders } from '../auth/credentials.js';
+import { getEnvConfig } from '../constants.js';
+import { controlPlaneFetch } from './control-plane-fetch.js';
+export async function createProject({ name, credential, description, parentPlanKey, region, resourceType, subdomain }) {
+    if (process.env.FIGMA_MOCK_CONTROL_PLANE === 'true') {
+        return {
+            id: `cms_${Math.random().toString(36).substring(2, 11)}`,
+            name,
+            domainName: `${subdomain}.figmasource.site`
+        };
+    }
+    const response = await controlPlaneFetch({
+        context: 'create project',
+        options: {
+            body: JSON.stringify({
+                name,
+                description,
+                parent_plan_key: parentPlanKey,
+                region,
+                resource_type: resourceType,
+                subdomain
+            }),
+            headers: {
+                ...getAuthHeaders(credential),
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
+        },
+        url: `${getEnvConfig().apiBaseUrl}/v1/cms`
+    });
+    const projectResponse = await response.json();
+    return {
+        id: projectResponse.meta.tenant.id,
+        name: projectResponse.meta.tenant.name,
+        domainName: projectResponse.meta.tenant.domain_name
+    };
+}

package/dist/api/list-project-workspaces.d.ts

@@ -0,0 +1,8 @@
+import type { AuthCredential } from '../auth/credentials.js';
+interface ProjectWorkspace {
+    isDefault: boolean;
+    name: string;
+    planKey: string;
+}
+export declare function listProjectWorkspaces(credential: AuthCredential): Promise<ProjectWorkspace[]>;
+export {};

package/dist/api/list-project-workspaces.js

@@ -0,0 +1,28 @@
+import { getAuthHeaders } from '../auth/credentials.js';
+import { getEnvConfig } from '../constants.js';
+import { controlPlaneFetch } from './control-plane-fetch.js';
+export async function listProjectWorkspaces(credential) {
+    if (process.env.FIGMA_MOCK_CONTROL_PLANE === 'true') {
+        return [
+            {
+                name: 'Mock workspace',
+                isDefault: true,
+                planKey: 'team::mock-workspace'
+            }
+        ];
+    }
+    const response = await controlPlaneFetch({
+        context: 'list project workspaces',
+        options: {
+            headers: getAuthHeaders(credential),
+            method: 'POST'
+        },
+        url: `${getEnvConfig().apiBaseUrl}/v1/cms/workspaces`
+    });
+    const workspaceResponse = await response.json();
+    return workspaceResponse.meta.workspaces.map((workspace)=>({
+            name: workspace.name,
+            isDefault: workspace.is_default,
+            planKey: workspace.plan_key
+        }));
+}

package/dist/api/project-resource-type.d.ts

@@ -0,0 +1 @@
+export type ProjectResourceType = 'payload' | 'vite';

package/dist/api/project-resource-type.js

@@ -0,0 +1 @@
+export { };

package/dist/auth/headless-oauth-flow.d.ts

@@ -0,0 +1,23 @@
+import type { TokenStore } from './token-store.js';
+export interface StartHeadlessOAuthFlowResult {
+    authorizationUrl: string;
+    expiresAt: number;
+    sessionId: string;
+}
+export declare class HeadlessOAuthFlowError extends Error {
+    constructor(message: string);
+}
+/** Start OAuth without a callback listener so another process can resume it. */
+export declare function startHeadlessOAuthFlow(tokenStore: TokenStore, options?: {
+    now?: number;
+}): StartHeadlessOAuthFlowResult;
+/** Complete a previously started headless OAuth flow and store its tokens. */
+export declare function completeHeadlessOAuthFlow({ callbackUrl, now, sessionId, tokenStore, }: {
+    callbackUrl: string;
+    now?: number;
+    sessionId: string;
+    tokenStore: TokenStore;
+}): Promise<{
+    tokens: import("./types.js").FigmaTokens;
+    userId: string | undefined;
+}>;

package/dist/auth/headless-oauth-flow.js

@@ -0,0 +1,69 @@
+import crypto from 'node:crypto';
+import { getOAuthConfig } from '../config/oauth.js';
+import { buildAuthorizationUrl } from './browser.js';
+import { parsePastedCode } from './paste-code.js';
+import { generatePKCEPair } from './pkce.js';
+import { exchangeCodeForTokens } from './refresh.js';
+const HEADLESS_OAUTH_SESSION_TTL_MS = 10 * 60 * 1000;
+export class HeadlessOAuthFlowError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'HeadlessOAuthFlowError';
+    }
+}
+/** Start OAuth without a callback listener so another process can resume it. */ export function startHeadlessOAuthFlow(tokenStore, options = {}) {
+    const oauthConfig = getOAuthConfig();
+    const { codeChallenge, codeChallengeMethod, codeVerifier } = generatePKCEPair();
+    const now = options.now ?? Date.now();
+    const session = {
+        id: crypto.randomBytes(32).toString('base64url'),
+        clientId: oauthConfig.clientId,
+        codeVerifier,
+        expiresAt: now + HEADLESS_OAUTH_SESSION_TTL_MS,
+        redirectUri: oauthConfig.redirectUri,
+        state: crypto.randomBytes(32).toString('base64url')
+    };
+    tokenStore.setHeadlessOAuthSession(session);
+    return {
+        authorizationUrl: buildAuthorizationUrl({
+            authorizationUrl: oauthConfig.authorizationUrl,
+            clientId: session.clientId,
+            codeChallenge,
+            codeChallengeMethod,
+            redirectUri: session.redirectUri,
+            scopes: oauthConfig.scopes,
+            state: session.state
+        }),
+        expiresAt: session.expiresAt,
+        sessionId: session.id
+    };
+}
+/** Complete a previously started headless OAuth flow and store its tokens. */ export async function completeHeadlessOAuthFlow({ callbackUrl, now = Date.now(), sessionId, tokenStore }) {
+    const session = tokenStore.getHeadlessOAuthSession();
+    if (!session) {
+        throw new HeadlessOAuthFlowError('No pending login found. Start login again with --headless.');
+    }
+    if (session.id !== sessionId) {
+        throw new HeadlessOAuthFlowError('Login session does not match. Start login again with --headless.');
+    }
+    if (now >= session.expiresAt) {
+        tokenStore.clearHeadlessOAuthSession();
+        throw new HeadlessOAuthFlowError('Login session expired. Start login again with --headless.');
+    }
+    try {
+        try {
+            new URL(callbackUrl);
+        } catch  {
+            throw new HeadlessOAuthFlowError('Paste the full redirected URL so the login state can be verified.');
+        }
+        const code = parsePastedCode(callbackUrl, session.state);
+        const tokens = await exchangeCodeForTokens(code, session.codeVerifier, session.redirectUri, session.clientId);
+        tokenStore.setTokens(tokens);
+        return {
+            tokens,
+            userId: tokens.userId
+        };
+    } finally{
+        tokenStore.clearHeadlessOAuthSession();
+    }
+}

package/dist/auth/oauth-flow.d.ts

@@ -16,6 +16,8 @@ export interface OAuthFlowOptions {
     clientId?: string;
     /** Callback server fallback ports to try after port */
     fallbackPorts?: number[];
+    /** Open the browser without asking for confirmation */
+    openBrowserWithoutPrompt?: boolean;
     /** First callback server port to try */
     port?: number;
     /** Redirect URI (defaults to config) */

package/dist/auth/oauth-flow.js

@@ -54,7 +54,7 @@ import { exchangeCodeForTokens, refreshAccessToken, TokenRefreshError } from './
         };
     }
     // REAL OAUTH IMPLEMENTATION
-    const { clientId = oauthConfig.clientId, fallbackPorts, port, redirectUri = oauthConfig.redirectUri, scopes = oauthConfig.scopes, timeoutMs = 120000 } = options;
+    const { clientId = oauthConfig.clientId, fallbackPorts, openBrowserWithoutPrompt = false, port, redirectUri = oauthConfig.redirectUri, scopes = oauthConfig.scopes, timeoutMs = 120000 } = options;
     // Generate PKCE pair for enhanced security
     const { codeChallenge, codeChallengeMethod, codeVerifier } = generatePKCEPair();
     // Generate random state for CSRF protection
@@ -85,13 +85,18 @@ import { exchangeCodeForTokens, refreshAccessToken, TokenRefreshError } from './
             scopes,
             state
         });
-        // Prompt user to open browser
-        const shouldOpenBrowser = await p.confirm({
-            initialValue: true,
-            message: 'Open browser to authenticate with Figma?'
-        });
-        if (p.isCancel(shouldOpenBrowser)) {
-            throw new OAuthFlowError('Authentication cancelled by user');
+        // Ask interactive callers before opening a browser. Automated callers have
+        // already accepted defaults with -y, so proceed directly to authorization.
+        let shouldOpenBrowser = openBrowserWithoutPrompt;
+        if (!openBrowserWithoutPrompt) {
+            const browserConfirmation = await p.confirm({
+                initialValue: true,
+                message: 'Open browser to authenticate with Figma?'
+            });
+            if (p.isCancel(browserConfirmation)) {
+                throw new OAuthFlowError('Authentication cancelled by user');
+            }
+            shouldOpenBrowser = browserConfirmation;
         }
         let browserOpened = false;
         if (shouldOpenBrowser) {

package/dist/auth/token-store.d.ts

@@ -1,5 +1,5 @@
 import type { Environment } from '../constants.js';
-import type { BootstrapData, FigmaTokens, ProjectStoreScope, ProjectToken, TokenStoreConfig } from './types.js';
+import type { BootstrapData, FigmaTokens, HeadlessOAuthSession, ProjectStoreScope, ProjectToken, TokenStoreConfig } from './types.js';
 /**
  * Get the singleton TokenStore instance for an environment.
  */
@@ -23,6 +23,9 @@ export declare class TokenStore {
     getOauthInfo(): FigmaTokens | null;
     setTokens(tokens: FigmaTokens): void;
     clearTokens(): void;
+    getHeadlessOAuthSession(): HeadlessOAuthSession | null;
+    setHeadlessOAuthSession(session: HeadlessOAuthSession): void;
+    clearHeadlessOAuthSession(): void;
     hasValidOauthToken(): boolean;
     isOauthExpired(): boolean;
     getCurrentOauthToken(): null | string;

package/dist/auth/token-store.js

@@ -186,11 +186,25 @@ const PROJECT_STORE_SCHEMA_VERSION = 1;
     clearTokens() {
         this.oauthConfig.delete('accessToken');
         this.oauthConfig.delete('expiresAt');
+        this.oauthConfig.delete('headlessOAuthSession');
         this.oauthConfig.delete('refreshToken');
         this.oauthConfig.delete('scopes');
         this.oauthConfig.delete('tokenType');
         this.oauthConfig.delete('userId');
     }
+    getHeadlessOAuthSession() {
+        return this.safeGet({
+            config: this.oauthConfig,
+            key: 'headlessOAuthSession'
+        }) ?? null;
+    }
+    setHeadlessOAuthSession(session) {
+        this.oauthConfig.set('_schemaVersion', OAUTH_STORE_SCHEMA_VERSION);
+        this.oauthConfig.set('headlessOAuthSession', session);
+    }
+    clearHeadlessOAuthSession() {
+        this.oauthConfig.delete('headlessOAuthSession');
+    }
     hasValidOauthToken() {
         const tokens = this.getOauthInfo();
         if (!tokens) {

package/dist/auth/types.d.ts

@@ -32,6 +32,18 @@ export interface FigmaTokens {
     /** Figma user ID string */
     userId?: string;
 }
+/**
+ * Temporary state for a resumable OAuth login. Stored encrypted on the machine
+ * that generated the PKCE verifier and removed after completion or expiry.
+ */
+export interface HeadlessOAuthSession {
+    clientId: string;
+    codeVerifier: string;
+    expiresAt: number;
+    id: string;
+    redirectUri: string;
+    state: string;
+}
 /**
  * Raw token response from Figma OAuth2 token endpoint
  * Response from POST https://api.figma.com/v1/oauth/token

package/dist/cli.d.ts

@@ -1,3 +1,42 @@
+export declare const cliArgSpec: {
+    readonly '--adapter': StringConstructor;
+    readonly '--all': BooleanConstructor;
+    readonly '--callback-url': StringConstructor;
+    readonly '--complete': StringConstructor;
+    readonly '--debug': BooleanConstructor;
+    readonly '--description': StringConstructor;
+    readonly '--dry-run': BooleanConstructor;
+    readonly '--env': StringConstructor;
+    readonly '--force': BooleanConstructor;
+    readonly '--global': BooleanConstructor;
+    readonly '--headless': BooleanConstructor;
+    readonly '--help': BooleanConstructor;
+    readonly '--id': StringConstructor;
+    readonly '--infra-env': StringConstructor;
+    readonly '--json': BooleanConstructor;
+    readonly '--name': StringConstructor;
+    readonly '--no-agent': BooleanConstructor;
+    readonly '--output': StringConstructor;
+    readonly '--payload-version': StringConstructor;
+    readonly '--project': BooleanConstructor;
+    readonly '--region': StringConstructor;
+    readonly '--skip-auth': BooleanConstructor;
+    readonly '--skip-build': BooleanConstructor;
+    readonly '--skip-size-check': BooleanConstructor;
+    readonly '--subdomain': StringConstructor;
+    readonly '--template': StringConstructor;
+    readonly '--version': BooleanConstructor;
+    readonly '--workspace': StringConstructor;
+    readonly '--yes': BooleanConstructor;
+    readonly '--environment': "--env";
+    readonly '-e': "--env";
+    readonly '-f': "--force";
+    readonly '-h': "--help";
+    readonly '-n': "--name";
+    readonly '-t': "--template";
+    readonly '-v': "--version";
+    readonly '-y': "--yes";
+};
 /**
  * Entrypoint for bin/cli.js
  */