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

package/dist/commands/prompt-to-create-project/resolve-text-input.js

@@ -0,0 +1,23 @@
+import * as p from '@clack/prompts';
+export async function resolveTextInput({ fieldName, initialValue, message, nonInteractive, value }) {
+    if (value !== undefined) {
+        const trimmedValue = value.trim();
+        if (!trimmedValue) {
+            throw new Error(`${fieldName} is required`);
+        }
+        return trimmedValue;
+    }
+    if (nonInteractive) {
+        return initialValue;
+    }
+    const promptedValue = await p.text({
+        initialValue,
+        message,
+        validate: (candidate)=>candidate?.trim() ? undefined : `${fieldName} is required`
+    });
+    if (p.isCancel(promptedValue)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return promptedValue.trim();
+}

package/dist/commands/prompt-to-create-project/resolve-workspace-plan-key.d.ts

@@ -0,0 +1,12 @@
+interface ProjectWorkspace {
+    isDefault: boolean;
+    name: string;
+    planKey: string;
+}
+interface ResolveWorkspacePlanKeyArgs {
+    nonInteractive?: boolean;
+    value?: string;
+    workspaces: ProjectWorkspace[];
+}
+export declare function resolveWorkspacePlanKey({ nonInteractive, value, workspaces, }: ResolveWorkspacePlanKeyArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/resolve-workspace-plan-key.js

@@ -0,0 +1,36 @@
+import * as p from '@clack/prompts';
+export async function resolveWorkspacePlanKey({ nonInteractive, value, workspaces }) {
+    if (value !== undefined) {
+        const planKey = value.trim();
+        const workspace = workspaces.find((candidate)=>candidate.planKey === planKey);
+        if (!workspace) {
+            throw new Error(`Workspace plan key "${planKey}" is not eligible. Available: ${formatWorkspaces(workspaces)}`);
+        }
+        return workspace.planKey;
+    }
+    if (workspaces.length === 1) {
+        return workspaces[0].planKey;
+    }
+    if (nonInteractive) {
+        const defaultWorkspace = workspaces.find((workspace)=>workspace.isDefault);
+        if (defaultWorkspace) {
+            return defaultWorkspace.planKey;
+        }
+        throw new Error(`Multiple eligible Figma workspaces. Pass --workspace <plan-key>. Available: ${formatWorkspaces(workspaces)}`);
+    }
+    const selectedWorkspacePlanKey = await p.select({
+        message: 'Select a Figma workspace:',
+        options: workspaces.map((workspace)=>({
+                label: workspace.name,
+                value: workspace.planKey
+            }))
+    });
+    if (p.isCancel(selectedWorkspacePlanKey)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return selectedWorkspacePlanKey;
+}
+function formatWorkspaces(workspaces) {
+    return workspaces.map((workspace)=>`${workspace.name} (${workspace.planKey})`).join(', ');
+}

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

@@ -0,0 +1 @@
+export declare function validateSubdomain(value: string | undefined): "Subdomain is required" | "Use 1–60 lowercase letters, numbers, or hyphens" | undefined;

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

@@ -0,0 +1,9 @@
+export function validateSubdomain(value) {
+    if (!value?.trim()) {
+        return 'Subdomain is required';
+    }
+    if (!/^[a-z0-9](?:[a-z0-9-]{0,58}[a-z0-9])?$/.test(value.trim())) {
+        return 'Use 1–60 lowercase letters, numbers, or hyphens';
+    }
+    return undefined;
+}

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

@@ -0,0 +1,24 @@
+import type { ProjectResourceType } from '../api/project-resource-type.js';
+import type { AuthCredential } from '../auth/credentials.js';
+interface ProjectCreationInputs {
+    description?: string;
+    name?: string;
+    region?: string;
+    subdomain?: string;
+    workspacePlanKey?: string;
+}
+interface PromptToCreateProjectArgs {
+    credential: AuthCredential;
+    inputs?: ProjectCreationInputs;
+    nonInteractive?: boolean;
+    projectPath: string;
+    resourceType: ProjectResourceType;
+}
+interface PromptToCreateProjectResponse {
+    domainName: string;
+    id: string;
+    name: string;
+}
+/** Prompt for required project fields and create a blank Figma CMS project. */
+export declare function promptToCreateProject({ credential, inputs, nonInteractive, projectPath, resourceType, }: PromptToCreateProjectArgs): Promise<PromptToCreateProjectResponse>;
+export {};

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

@@ -0,0 +1,69 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { createProject } from '../api/create-project.js';
+import { listProjectWorkspaces } from '../api/list-project-workspaces.js';
+import { formatProjectSubdomain } from './prompt-to-create-project/format-project-subdomain.js';
+import { getDefaultProjectName } from './prompt-to-create-project/get-default-project-name.js';
+import { resolveProjectRegion } from './prompt-to-create-project/resolve-project-region.js';
+import { resolveProjectSubdomain } from './prompt-to-create-project/resolve-project-subdomain.js';
+import { resolveTextInput } from './prompt-to-create-project/resolve-text-input.js';
+import { resolveWorkspacePlanKey } from './prompt-to-create-project/resolve-workspace-plan-key.js';
+/** Prompt for required project fields and create a blank Figma CMS project. */ export async function promptToCreateProject({ credential, inputs, nonInteractive, projectPath, resourceType }) {
+    const workspaces = await listProjectWorkspaces(credential);
+    if (workspaces.length === 0) {
+        if (nonInteractive) {
+            throw new Error('No eligible Figma workspaces found.');
+        }
+        p.log.error(pc.red('No eligible Figma workspaces found.'));
+        process.exit(1);
+    }
+    const defaultProjectName = await getDefaultProjectName(projectPath);
+    const projectName = await resolveTextInput({
+        fieldName: 'Project name',
+        initialValue: defaultProjectName,
+        message: 'Project name:',
+        nonInteractive,
+        value: inputs?.name
+    });
+    const projectDescription = await resolveTextInput({
+        fieldName: 'Description',
+        initialValue: `${projectName} project`,
+        message: 'Project description:',
+        nonInteractive,
+        value: inputs?.description
+    });
+    const projectSubdomain = await resolveProjectSubdomain({
+        credential,
+        initialValue: formatProjectSubdomain(projectName),
+        nonInteractive,
+        value: inputs?.subdomain
+    });
+    const parentPlanKey = await resolveWorkspacePlanKey({
+        nonInteractive,
+        value: inputs?.workspacePlanKey,
+        workspaces
+    });
+    const region = await resolveProjectRegion({
+        nonInteractive,
+        resourceType,
+        value: inputs?.region
+    });
+    const spinner = p.spinner();
+    spinner.start('Creating Figma project...');
+    try {
+        const project = await createProject({
+            name: projectName,
+            credential,
+            description: projectDescription,
+            parentPlanKey,
+            region,
+            resourceType,
+            subdomain: projectSubdomain
+        });
+        spinner.stop(pc.green(`✓ Project created: ${project.domainName}`));
+        return project;
+    } catch (error) {
+        spinner.stop(pc.red('✗ Failed to create project'));
+        throw error;
+    }
+}

package/dist/commands/setup-agent.d.ts

@@ -0,0 +1,12 @@
+export interface SetupAgentOptions {
+    global?: boolean;
+    project?: boolean;
+    yes?: boolean;
+}
+/** Install or update the bundled deploy skill through the standard skills CLI. */
+export declare function setupAgentCommand(options: SetupAgentOptions, dependencies?: {
+    homeDir?: string;
+    isTTY?: boolean;
+    projectDir?: string;
+    skillDir?: string;
+}): Promise<void>;

package/dist/commands/setup-agent.js

@@ -0,0 +1,123 @@
+import * as p from '@clack/prompts';
+import spawn from 'cross-spawn';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+const SKILL_NAME = 'deploy-to-figma';
+const require = createRequire(import.meta.url);
+const SKILLS_CLI_PATH = require.resolve('skills/bin/cli.mjs');
+/** Install or update the bundled deploy skill through the standard skills CLI. */ export async function setupAgentCommand(options, dependencies = {}) {
+    if (options.global && options.project) {
+        throw new Error('Use either --global or --project, not both.');
+    }
+    const isTTY = dependencies.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const scope = await resolveScope(options, isTTY);
+    const projectDir = dependencies.projectDir ?? process.cwd();
+    const homeDir = dependencies.homeDir ?? os.homedir();
+    const skillDir = dependencies.skillDir ?? resolveBundledSkillDir();
+    const installedDir = path.join(scope === 'global' ? homeDir : projectDir, '.agents', 'skills', SKILL_NAME);
+    const [bundledHash, installedHash] = await Promise.all([
+        hashDirectory(skillDir),
+        hashDirectory(installedDir)
+    ]);
+    if (!bundledHash) {
+        throw new Error(`Bundled ${SKILL_NAME} skill was not found at ${skillDir}.`);
+    }
+    if (bundledHash === installedHash) {
+        p.log.success(`✓ ${SKILL_NAME} skill is already up to date (${scope})`);
+        return;
+    }
+    p.log.step(`${installedHash ? 'Updating' : 'Installing'} ${SKILL_NAME} skill (${scope})...`);
+    const args = [
+        'add',
+        skillDir,
+        '--skill',
+        SKILL_NAME,
+        '--copy',
+        ...scope === 'global' ? [
+            '--global'
+        ] : [],
+        ...options.yes || !isTTY ? [
+            '--yes'
+        ] : []
+    ];
+    const exitCode = await run(process.execPath, [
+        SKILLS_CLI_PATH,
+        ...args
+    ], projectDir);
+    if (exitCode !== 0) {
+        throw new Error(`Skill installation failed with exit code ${exitCode}.`);
+    }
+    p.log.success(`✓ ${SKILL_NAME} skill ${installedHash ? 'updated' : 'installed'} (${scope})`);
+}
+async function resolveScope(options, isTTY) {
+    if (options.global) {
+        return 'global';
+    }
+    if (options.project) {
+        return 'project';
+    }
+    if (!isTTY) {
+        throw new Error('Non-interactive setup requires either --global or --project.');
+    }
+    const selected = await p.select({
+        initialValue: 'global',
+        message: 'Where should the Figma deploy skill be installed?',
+        options: [
+            {
+                label: 'Globally (recommended)',
+                value: 'global'
+            },
+            {
+                label: 'Current project only',
+                value: 'project'
+            }
+        ]
+    });
+    if (p.isCancel(selected)) {
+        throw new Error('Skill installation cancelled.');
+    }
+    return selected;
+}
+function resolveBundledSkillDir() {
+    return path.resolve(import.meta.dirname, '..', 'skills', SKILL_NAME);
+}
+async function hashDirectory(directory) {
+    if (!await pathExists(directory)) {
+        return null;
+    }
+    const hash = crypto.createHash('sha256');
+    async function visit(currentDir, relativeDir = '') {
+        const entries = await fs.readdir(currentDir, {
+            withFileTypes: true
+        });
+        entries.sort((left, right)=>left.name.localeCompare(right.name));
+        for (const entry of entries){
+            const relativePath = path.join(relativeDir, entry.name);
+            const absolutePath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await visit(absolutePath, relativePath);
+            } else if (entry.isFile()) {
+                hash.update(relativePath);
+                hash.update(await fs.readFile(absolutePath));
+            }
+        }
+    }
+    await visit(directory);
+    return hash.digest('hex');
+}
+function run(command, args, cwd) {
+    return new Promise((resolve, reject)=>{
+        const child = spawn(command, args, {
+            cwd,
+            stdio: 'inherit'
+        });
+        child.once('error', reject);
+        child.once('close', (code)=>resolve(code ?? 1));
+    });
+}
+async function pathExists(filePath) {
+    return fs.access(filePath).then(()=>true).catch(()=>false);
+}

package/dist/commands/write-project-configuration.d.ts

@@ -0,0 +1,12 @@
+import type { BootstrapInfo } from '../api/control-plane.js';
+import type { TokenStore } from '../auth/token-store.js';
+interface WriteProjectConfigurationArgs {
+    bootstrapInfo: BootstrapInfo | null;
+    environmentName: string;
+    projectDir: string;
+    projectId: string;
+    shouldWriteEnvironmentVariables?: boolean;
+    tokenStore: TokenStore;
+}
+export declare function writeProjectConfiguration({ bootstrapInfo, environmentName, projectDir, projectId, shouldWriteEnvironmentVariables, tokenStore, }: WriteProjectConfigurationArgs): Promise<void>;
+export {};

package/dist/commands/write-project-configuration.js

@@ -0,0 +1,16 @@
+import { getInfraEnvironment } from '../constants.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import { addOrUpdateEnvVar } from '../utils/env-management.js';
+export async function writeProjectConfiguration({ bootstrapInfo, environmentName, projectDir, projectId, shouldWriteEnvironmentVariables = true, tokenStore }) {
+    if (shouldWriteEnvironmentVariables) {
+        await addOrUpdateEnvVar(projectDir, 'FIGMA_PROJECT_ID', projectId);
+        await addOrUpdateEnvVar(projectDir, 'FIGMA_ENVIRONMENT_NAME', environmentName);
+        const infraEnvironment = getInfraEnvironment();
+        if (infraEnvironment !== 'production') {
+            await addOrUpdateEnvVar(projectDir, 'FIGMA_INFRA_ENV', infraEnvironment);
+        }
+    }
+    if (bootstrapInfo) {
+        cacheAllEnvironments(tokenStore, projectId, bootstrapInfo);
+    }
+}

package/dist/db-content-api/index.d.ts

@@ -29,7 +29,7 @@ export type ContentAPIAdapter = {
     client: ReturnType<typeof createClient<paths>>;
     clientVersionHeaders: Record<string, string>;
     contentSystemId: string;
-    documentSchema: DocumentSchemaWire;
+    documentSchema: () => DocumentSchemaWire;
     environmentName?: string;
     idType: 'uuid';
     notifyLocalJobQueue: boolean;