@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.61

package/dist/auth/token-store.js

@@ -1,6 +1,26 @@
 /* eslint-disable perfectionist/sort-classes */ import Conf from 'conf';
+import fsSync from 'node:fs';
 import { TOKEN_EXPIRY_BUFFER_SECONDS } from '../config/oauth.js';
+import { getInfraEnvironment } from '../constants.js';
+import * as log from '../utils/log.js';
 import { deriveEncryptionKey } from './crypto-utils.js';
+/**
+ * Environment-keyed instances for singleton pattern
+ */ const instances = {};
+/**
+ * Get the singleton TokenStore instance for an environment
+ * Use this for all production code to ensure a single shared instance per environment
+ *
+ * @param environment - The environment to get the token store for
+ * @returns The singleton TokenStore instance for that environment
+ */ export function getTokenStore(environment = getInfraEnvironment()) {
+    if (!instances[environment]) {
+        instances[environment] = new TokenStore({
+            environment
+        });
+    }
+    return instances[environment];
+}
 /**
  * Secure storage manager for Figma OAuth2 tokens
  *
@@ -11,23 +31,62 @@ import { deriveEncryptionKey } from './crypto-utils.js';
  *
  * Tokens are encrypted at rest with a machine-specific key and file permissions
  * are set to 0600 (owner read/write only)
+ *
+ * For production code, use getTokenStore() to get the singleton instance.
+ * The constructor is still exported for test isolation.
  */ export class TokenStore {
     config;
+    environment;
     constructor(options){
-        this.config = new Conf({
-            configName: options?.configName || 'payloadcms-figma',
-            projectName: 'payloadcms-figma',
-            // Enable encryption with machine-specific key for better security
+        if (process.env.AWS_EXECUTION_ENV) {
+            throw new Error('TokenStore cannot be used in AWS Lambda environments');
+        }
+        const environment = options?.environment ?? 'production';
+        const projectName = environment === 'production' ? 'payloadcms-figma' : `payloadcms-figma-${environment}`;
+        this.environment = environment;
+        const confOptions = {
+            clearInvalidConfig: false,
+            configName: options?.configName || projectName,
             encryptionKey: options?.encryptionKey || deriveEncryptionKey(),
-            // Clear schema to avoid validation issues
-            clearInvalidConfig: true
-        });
+            projectName
+        };
+        try {
+            this.config = new Conf(confOptions);
+        } catch (error) {
+            // Deserialization failed (e.g. encryption key changed).
+            // Log diagnostics, clear the corrupted file, then create a fresh store.
+            if (environment === 'staging') {
+                log.warning(`Token store corrupted, resetting. ` + `Error: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+            // Temporarily allow clearing so Conf can reinitialize
+            this.config = new Conf({
+                ...confOptions,
+                clearInvalidConfig: true
+            });
+            // Force a write so the corrupt file is replaced with an empty store.
+            // Without this, clearInvalidConfig only ignores bad reads in memory
+            // and the corrupt file persists, triggering this fallback every time.
+            this.config.clear();
+        }
+    }
+    safeGet(key) {
+        try {
+            return this.config.get(key);
+        } catch (error) {
+            if (this.environment === 'staging') {
+                const filePath = this.config.path;
+                const fileExists = fsSync.existsSync(filePath);
+                const fileSize = fileExists ? fsSync.statSync(filePath).size : 0;
+                log.warning(`Token store read failed (key: ${key}). ` + `File: ${filePath}, exists: ${fileExists}, size: ${fileSize}B. ` + `Error: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+            return undefined;
+        }
     }
     /**
    * Retrieve stored tokens
    * @returns FigmaTokens if stored, null otherwise
    */ getTokens() {
-        const tokens = this.config.get('tokens');
+        const tokens = this.safeGet('tokens');
         return tokens || null;
     }
     /**
@@ -35,6 +94,16 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * @param tokens - Figma OAuth2 tokens to store
    */ setTokens(tokens) {
         this.config.set('tokens', tokens);
+        // Verify the round-trip: read back what we just wrote
+        const readBack = this.safeGet('tokens');
+        if (!readBack || readBack.accessToken !== tokens.accessToken) {
+            if (this.environment === 'staging') {
+                const filePath = this.config.path;
+                const fileExists = fsSync.existsSync(filePath);
+                const fileSize = fileExists ? fsSync.statSync(filePath).size : 0;
+                log.warning(`Token verify-after-write FAILED. ` + `File: ${filePath}, exists: ${fileExists}, size: ${fileSize}B. ` + `Written accessToken starts: ${tokens.accessToken.substring(0, 10)}..., ` + `Read back: ${readBack ? readBack.accessToken.substring(0, 10) + '...' : 'null'}`);
+            }
+        }
     }
     /**
    * Clear all stored tokens (used for logout)
@@ -56,8 +125,7 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * Includes a buffer time to avoid using tokens that are about to expire
    * @returns true if token is expired or will expire within buffer time
    */ isExpired() {
-        // Access config directly to avoid circular dependency with getTokens()
-        const tokens = this.config.get('tokens');
+        const tokens = this.safeGet('tokens');
         if (!tokens) {
             return true;
         }
@@ -112,7 +180,7 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * @param tenantId - The tenant/CMS ID
    * @returns ProjectToken if stored and valid, null otherwise
    */ getProjectToken(tenantId) {
-        const projectTokens = this.config.get('projectTokens') || {};
+        const projectTokens = this.safeGet('projectTokens') || {};
         const projectToken = projectTokens[tenantId];
         if (!projectToken) {
             return null;
@@ -129,7 +197,7 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * @param tenantId - The tenant/CMS ID
    * @param projectToken - The project token to store
    */ setProjectToken(tenantId, projectToken) {
-        const projectTokens = this.config.get('projectTokens') || {};
+        const projectTokens = this.safeGet('projectTokens') || {};
         projectTokens[tenantId] = projectToken;
         this.config.set('projectTokens', projectTokens);
     }
@@ -137,7 +205,7 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * Clear a project token for a specific tenant
    * @param tenantId - The tenant/CMS ID
    */ clearProjectToken(tenantId) {
-        const projectTokens = this.config.get('projectTokens') || {};
+        const projectTokens = this.safeGet('projectTokens') || {};
         delete projectTokens[tenantId];
         this.config.set('projectTokens', projectTokens);
     }
@@ -180,9 +248,45 @@ import { deriveEncryptionKey } from './crypto-utils.js';
    * Get all tenant IDs that have stored project tokens
    * @returns Array of tenant IDs
    */ getAllProjectTokenTenantIds() {
-        const projectTokens = this.config.get('projectTokens') || {};
+        const projectTokens = this.safeGet('projectTokens') || {};
         return Object.keys(projectTokens);
     }
+    /**
+   * Build the composite key for bootstrap data storage
+   * @param projectId - The CMS resource/project ID
+   * @param environmentName - The environment name (e.g. 'production', 'staging')
+   * @returns Composite key string
+   */ bootstrapKey(projectId, environmentName) {
+        return `${projectId}:${environmentName}`;
+    }
+    /**
+   * Retrieve bootstrap data for a project + environment
+   * @param projectId - The CMS resource/project ID
+   * @param environmentName - The environment name
+   * @returns BootstrapData if stored, null otherwise
+   */ getBootstrapData(projectId, environmentName) {
+        const allData = this.safeGet('bootstrapData') || {};
+        return allData[this.bootstrapKey(projectId, environmentName)] || null;
+    }
+    /**
+   * Store bootstrap data for a project + environment
+   * @param projectId - The CMS resource/project ID
+   * @param environmentName - The environment name
+   * @param data - The bootstrap data to store
+   */ setBootstrapData(projectId, environmentName, data) {
+        const allData = this.safeGet('bootstrapData') || {};
+        allData[this.bootstrapKey(projectId, environmentName)] = data;
+        this.config.set('bootstrapData', allData);
+    }
+    /**
+   * Clear bootstrap data for a project + environment
+   * @param projectId - The CMS resource/project ID
+   * @param environmentName - The environment name
+   */ clearBootstrapData(projectId, environmentName) {
+        const allData = this.safeGet('bootstrapData') || {};
+        delete allData[this.bootstrapKey(projectId, environmentName)];
+        this.config.set('bootstrapData', allData);
+    }
 }
 
 //# sourceMappingURL=token-store.js.map

package/dist/auth/types.d.ts

@@ -1,5 +1,6 @@
 import type { ErrorResponsePayloadWithErrMessage, ErrorResponsePayloadWithErrorBoolean, User } from '@figma/rest-api-spec';
 import type { JWTPayload as JoseJWTPayload } from 'jose';
+import type { Environment } from '../constants.js';
 /**
  * Standard OAuth2 scopes for user-level permissions
  * @see https://www.figma.com/developers/api#oauth2
@@ -105,12 +106,14 @@ export interface OAuthTokenRefreshParams {
 /**
  * Configuration for token storage
  */
-export interface TokenStoreConfig {
-    /** Custom config name (defaults to 'payloadcms-figma') */
+export type TokenStoreConfig = {
+    /** Config file name (for testing) */
     configName?: string;
-    /** Enable encryption (defaults to true) */
+    /** Encryption key (for testing) */
     encryptionKey?: string;
-}
+    /** Environment for config file naming */
+    environment?: Environment;
+};
 /**
  * PKCE (Proof Key for Code Exchange) pair for OAuth2 public clients
  * @see https://datatracker.ietf.org/doc/html/rfc7636
@@ -158,6 +161,16 @@ export type FigmaErrorResponse = ErrorResponsePayloadWithErrMessage | ErrorRespo
  * Re-exported from @figma/rest-api-spec
  */
 export type FigmaUser = User;
+/**
+ * Bootstrap data cached in the local encrypted store
+ * Keyed by projectId:environmentName
+ */
+export type BootstrapData = {
+    contentSystemId: string;
+    oauthClientId: string;
+    oauthClientSecret: string;
+    tenantInstanceId: string;
+};
 /**
  * JWT payload structure from Figma project tokens
  * Extends jose's standard JWTPayload with Figma-specific claims

package/dist/cli.js

@@ -1,12 +1,17 @@
 import * as p from '@clack/prompts';
 import arg from 'arg';
 import pc from 'picocolors';
+import { buildLambdaZipCommand } from './commands/build-lambda-zip.js';
+import { debugCommand } from './commands/debug.js';
 import { deployCommand } from './commands/deploy.js';
+import { envCommand } from './commands/env.js';
 import { initCommand } from './commands/init.js';
 import { listTokensCommand } from './commands/list-tokens.js';
 import { loginCommand } from './commands/login.js';
 import { logoutCommand } from './commands/logout.js';
-import { feedbackOutro, helpMessage } from './utils/messages.js';
+import { upgradeCommand } from './commands/upgrade.js';
+import { setInfraEnvironment } from './constants.js';
+import { helpMessage } from './utils/messages.js';
 /**
  * Entrypoint for bin/cli.js
  */ export async function main() {
@@ -24,16 +29,30 @@ class Main {
     constructor(){
         // @ts-expect-error bad typings
         this.args = arg({
+            // Hidden flag — intentionally not displayed in help output yet.
+            // Auto-detection covers most cases; this is an escape hatch for testing.
+            // May expose in help text once multi-framework support is public.
+            '--adapter': String,
+            '--all': Boolean,
             '--debug': Boolean,
+            '--dry-run': Boolean,
+            '--env': String,
             '--force': Boolean,
             '--help': Boolean,
             '--id': String,
+            '--infra-env': String,
             '--name': String,
             '--skip-auth': Boolean,
+            '--skip-build': Boolean,
+            '--version': Boolean,
             '--yes': Boolean,
             // Aliases
+            '--environment': '--env',
+            '-e': '--env',
             '-f': '--force',
             '-h': '--help',
+            '-n': '--name',
+            '-v': '--version',
             '-y': '--yes'
         }, {
             permissive: true
@@ -42,6 +61,19 @@ class Main {
         if (this.args['--debug']) {
             process.env.DEBUG = 'true';
         }
+        // Handle --infra-env flag for infrastructure environment switching
+        if (this.args['--infra-env']) {
+            const infraEnvArg = this.args['--infra-env'].toLowerCase();
+            if (infraEnvArg === 'prod' || infraEnvArg === 'production') {
+                setInfraEnvironment('production');
+            } else if (infraEnvArg === 'staging') {
+                setInfraEnvironment('staging');
+            } else {
+                // eslint-disable-next-line no-console
+                console.error(`Invalid --infra-env value: ${this.args['--infra-env']}. Use 'production' or 'staging'.`);
+                process.exit(1);
+            }
+        }
     }
     async init() {
         try {
@@ -49,30 +81,60 @@ class Main {
                 helpMessage();
                 process.exit(0);
             }
+            if (this.args['--version']) {
+                const { getOwnVersion } = await import('./utils/version-check.js');
+                const version = await getOwnVersion();
+                // eslint-disable-next-line no-console
+                console.log(version);
+                process.exit(0);
+            }
             // Get the subcommand (first non-flag argument)
             const subcommand = this.args._[0];
+            if (!subcommand) {
+                helpMessage();
+                process.exit(0);
+            }
+            // Debug command outputs plain text for copy-paste — skip styled intro
+            if (subcommand === 'debug') {
+                await debugCommand();
+                process.exit(0);
+            }
             // eslint-disable-next-line no-console
             console.log('\n');
             p.intro(pc.bgCyan(pc.black(' @payloadcms/figma ')));
             // Route to appropriate command handler
             switch(subcommand){
+                case 'build-lambda-zip':
+                    await buildLambdaZipCommand();
+                    break;
                 case 'deploy':
                     await deployCommand({
+                        id: this.args['--id'],
+                        adapter: this.args['--adapter'],
                         debug: this.args['--debug'],
+                        env: this.args['--env'],
+                        skipBuild: this.args['--skip-build'],
                         yes: this.args['--yes']
                     });
                     break;
+                case 'env':
+                    await envCommand({
+                        name: this.args._[1]
+                    });
+                    break;
                 case 'init':
                     await initCommand({
                         id: this.args['--id'],
                         name: this.args['--name'],
                         debug: this.args['--debug'],
+                        env: this.args['--env'],
                         force: this.args['--force'],
                         skipAuth: this.args['--skip-auth']
                     });
                     break;
                 case 'list-tokens':
                     listTokensCommand({
+                        all: this.args['--all'],
                         debug: this.args['--debug']
                     });
                     break;
@@ -81,13 +143,14 @@ class Main {
                     break;
                 case 'logout':
                     await logoutCommand({
+                        all: this.args['--all'],
                         debug: this.args['--debug']
                     });
                     break;
-                case undefined:
-                    // No subcommand - show default message
-                    p.note("Let's create a new CMS!");
-                    p.outro(feedbackOutro());
+                case 'upgrade':
+                    await upgradeCommand({
+                        isDryRun: this.args['--dry-run']
+                    });
                     break;
                 default:
                     p.log.error(pc.red(`Unknown command: ${subcommand}`));

package/dist/commands/build-lambda-zip.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build Lambda deployment zip from current directory
+ */
+export declare function buildLambdaZipCommand(): Promise<void>;
+//# sourceMappingURL=build-lambda-zip.d.ts.map

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

@@ -0,0 +1,19 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { buildLambdaZip } from '../utils/build-lambda-zip.js';
+/**
+ * Build Lambda deployment zip from current directory
+ */ export async function buildLambdaZipCommand() {
+    const projectPath = process.cwd();
+    const s = p.spinner();
+    s.start('Creating lambda.zip');
+    try {
+        await buildLambdaZip(projectPath);
+        s.stop(pc.green('✓ Created lambda.zip'));
+    } catch (error) {
+        s.stop(pc.red('✗ Failed to create lambda.zip'));
+        throw error;
+    }
+}
+
+//# sourceMappingURL=build-lambda-zip.js.map

package/dist/commands/debug.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Handle the `@payloadcms/figma debug` command
+ *
+ * Outputs environment, auth, project, and package info for debugging.
+ * All data is local — no network calls are made.
+ */
+export declare function debugCommand(): Promise<void>;
+//# sourceMappingURL=debug.d.ts.map

package/dist/commands/debug.js

@@ -0,0 +1,176 @@
+import fsSync from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { getEncryptionKeyHash } from '../auth/crypto-utils.js';
+import { getTokenStore } from '../auth/token-store.js';
+import { getInfraEnvironment } from '../constants.js';
+import { getEnvVarSync } from '../utils/env-management.js';
+import { maskToken } from '../utils/token-display.js';
+import { getOwnVersion } from '../utils/version-check.js';
+/**
+ * Handle the `@payloadcms/figma debug` command
+ *
+ * Outputs environment, auth, project, and package info for debugging.
+ * All data is local — no network calls are made.
+ */ export async function debugCommand() {
+    const env = getInfraEnvironment();
+    const tokenStore = getTokenStore(env);
+    const cwd = process.cwd();
+    const lines = [
+        'Debug Info:',
+        ''
+    ];
+    appendSystemSection(lines, env);
+    appendAuthSection(lines, tokenStore, cwd);
+    appendTokenStoreDiagnostics(lines, tokenStore);
+    appendProjectSection(lines, tokenStore, cwd);
+    await appendPackagesSection(lines);
+    // eslint-disable-next-line no-console
+    console.log(lines.join('\n'));
+}
+function appendSystemSection(lines, env) {
+    lines.push(`Infra Environment:  ${env}`);
+    lines.push(`Node:               ${process.version}`);
+    lines.push(`OS:                 ${os.platform()} ${os.arch()}`);
+    lines.push('');
+}
+function appendAuthSection(lines, tokenStore, cwd) {
+    const tokens = tokenStore.getTokens();
+    lines.push('Auth:');
+    if (!tokens) {
+        lines.push('  Status:           Not authenticated');
+        lines.push('');
+        return;
+    }
+    const isValid = tokenStore.hasValidTokens();
+    lines.push(`  Status:           ${isValid ? 'Authenticated' : 'Token expired'}`);
+    const email = getEmailFromClaims(tokenStore, cwd);
+    if (email) {
+        lines.push(`  Email:            ${email}`);
+    } else if (tokens.userId) {
+        lines.push(`  User ID:          ${tokens.userId}`);
+    }
+    lines.push(`  Token Expires:    ${formatExpiryTime(tokens.expiresAt)}`);
+    lines.push('');
+}
+function appendTokenStoreDiagnostics(lines, tokenStore) {
+    lines.push('Token Store:');
+    const filePath = tokenStore.getStoragePath();
+    const fileExists = fsSync.existsSync(filePath);
+    const fileSize = fileExists ? fsSync.statSync(filePath).size : 0;
+    lines.push(`  File:             ${filePath}`);
+    lines.push(`  File Exists:      ${fileExists}`);
+    lines.push(`  File Size:        ${fileSize}B`);
+    const canRead = tokenStore.getTokens() !== null || tokenStore.getRefreshToken() !== null;
+    lines.push(`  Decryption:       ${fileExists ? canRead || fileSize === 0 ? 'OK' : 'FAILED' : 'N/A'}`);
+    lines.push(`  Key Hash:         ${getEncryptionKeyHash()}`);
+    lines.push('');
+}
+function appendProjectSection(lines, tokenStore, cwd) {
+    const projectId = getEnvVarSync(cwd, 'FIGMA_PROJECT_ID');
+    const environmentName = getEnvVarSync(cwd, 'FIGMA_ENVIRONMENT_NAME');
+    lines.push('Project:');
+    if (!projectId) {
+        lines.push("  Not initialized (run 'init' first)");
+        lines.push('');
+        return;
+    }
+    lines.push(`  Project ID:         ${projectId}`);
+    lines.push(`  Environment:        ${environmentName ?? '(not set)'}`);
+    // Show bootstrap data from local store
+    if (projectId && environmentName) {
+        const bootstrapData = tokenStore.getBootstrapData(projectId, environmentName);
+        if (bootstrapData) {
+            lines.push(`  Content System ID:  ${bootstrapData.contentSystemId}`);
+            lines.push(`  Tenant Instance ID: ${bootstrapData.tenantInstanceId}`);
+            lines.push(`  OAuth Client ID:    ${maskToken(bootstrapData.oauthClientId)}`);
+            const projectToken = tokenStore.getProjectToken(bootstrapData.contentSystemId);
+            if (projectToken) {
+                lines.push(`  Project Token:      ${formatExpiryTime(projectToken.expiresAt)}`);
+            }
+        } else {
+            lines.push('  Bootstrap Data:     (not cached)');
+        }
+    }
+    lines.push('');
+}
+async function appendPackagesSection(lines) {
+    lines.push('Packages:');
+    const cliVersion = await getOwnVersion();
+    lines.push(`  @payloadcms/figma:  ${cliVersion}`);
+    const payloadVersion = getPayloadVersion();
+    lines.push(`  payload:            ${payloadVersion}`);
+}
+/**
+ * Try resolving email from bootstrap data, then iterate all stored project tokens.
+ */ function getEmailFromClaims(tokenStore, cwd) {
+    const projectId = getEnvVarSync(cwd, 'FIGMA_PROJECT_ID');
+    const environmentName = getEnvVarSync(cwd, 'FIGMA_ENVIRONMENT_NAME');
+    if (projectId && environmentName) {
+        const bootstrapData = tokenStore.getBootstrapData(projectId, environmentName);
+        if (bootstrapData) {
+            const email = tokenStore.getProjectTokenClaims(bootstrapData.contentSystemId)?.email;
+            if (email) {
+                return email;
+            }
+        }
+    }
+    for (const id of tokenStore.getAllProjectTokenTenantIds()){
+        const email = tokenStore.getProjectTokenClaims(id)?.email;
+        if (email) {
+            return email;
+        }
+    }
+    return null;
+}
+function getPayloadVersion() {
+    try {
+        const require = createRequire(path.join(process.cwd(), 'noop.js'));
+        const resolved = require.resolve('payload');
+        const packageJsonPath = findPackageJson(path.dirname(resolved));
+        if (!packageJsonPath) {
+            return 'not found';
+        }
+        const content = fsSync.readFileSync(packageJsonPath, 'utf-8');
+        return JSON.parse(content).version;
+    } catch  {
+        return 'not found';
+    }
+}
+function findPackageJson(dir) {
+    const { root } = path.parse(dir);
+    while(dir !== root){
+        const candidate = path.join(dir, 'package.json');
+        if (fsSync.existsSync(candidate)) {
+            return candidate;
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Format expiry timestamp as ISO string with relative time
+ * e.g. "2026-02-11T10:30:00.000Z (in 23h 15m)" or "2026-02-10T08:00:00.000Z (expired 2h ago)"
+ */ function formatExpiryTime(expiresAt) {
+    const iso = new Date(expiresAt).toISOString();
+    const diff = expiresAt - Date.now();
+    if (diff < 0) {
+        return `${iso} (expired ${formatDuration(Math.abs(diff))} ago)`;
+    }
+    return `${iso} (in ${formatDuration(diff)})`;
+}
+function formatDuration(ms) {
+    const minutes = Math.floor(ms / 60000);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d ${hours % 24}h`;
+    }
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    return `${minutes}m`;
+}
+
+//# sourceMappingURL=debug.js.map

package/dist/commands/deploy.d.ts

@@ -1,9 +1,18 @@
+import type { AdapterName } from '../utils/deploy-adapter.js';
 /**
  * Options for deploy command
  */
 export interface DeployCommandOptions {
+    /** Framework adapter (nextjs, nitro, vite). Auto-detected if omitted. */
+    adapter?: AdapterName;
     /** Enable debug mode */
     debug?: boolean;
+    /** Figma environment name (e.g. 'production', 'staging') */
+    env?: string;
+    /** CMS Resource ID (overrides FIGMA_PROJECT_ID) */
+    id?: string;
+    /** Skip the build step (use existing build) */
+    skipBuild?: boolean;
     /** Skip confirmation prompts */
     yes?: boolean;
 }