@payloadcms/figma 0.1.0-alpha.3 → 0.1.0-alpha.5

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
  */

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
@@ -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,23 +1,32 @@
 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-skill': BooleanConstructor;
+    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";

package/dist/cli.js

@@ -11,6 +11,7 @@ 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 { setupAgentCommand } from './commands/setup-agent.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { uploadSchemaCommand } from './commands/upload-schema.js';
 import { setInfraEnvironment } from './constants.js';
@@ -18,23 +19,32 @@ import { helpMessage } from './utils/messages.js';
 export const cliArgSpec = {
     '--adapter': String,
     '--all': Boolean,
+    '--callback-url': String,
+    '--complete': String,
     '--debug': Boolean,
+    '--description': String,
     '--dry-run': Boolean,
     '--env': String,
     '--force': Boolean,
+    '--global': Boolean,
+    '--headless': Boolean,
     '--help': Boolean,
     '--id': String,
     '--infra-env': String,
     '--json': Boolean,
     '--name': String,
-    '--no-skill': Boolean,
+    '--no-agent': Boolean,
     '--output': String,
     '--payload-version': String,
+    '--project': Boolean,
+    '--region': String,
     '--skip-auth': Boolean,
     '--skip-build': Boolean,
     '--skip-size-check': Boolean,
+    '--subdomain': String,
     '--template': String,
     '--version': Boolean,
+    '--workspace': String,
     '--yes': Boolean,
     // Aliases
     '--environment': '--env',
@@ -104,7 +114,16 @@ class Main {
                 helpMessage();
                 process.exit(0);
             }
-            // Debug command outputs plain text for copy-paste — skip styled intro
+            // JSON and debug commands output plain text — skip styled intro.
+            if (subcommand === 'login' && this.args['--json']) {
+                await loginCommand({
+                    callbackUrl: this.args['--callback-url'],
+                    completeSessionId: this.args['--complete'],
+                    headless: this.args['--headless'],
+                    json: true
+                });
+                process.exit(0);
+            }
             if (subcommand === 'debug') {
                 await debugCommand();
                 process.exit(0);
@@ -132,12 +151,17 @@ class Main {
                 case 'deploy':
                     await deployCommand({
                         id: this.args['--id'],
+                        name: this.args['--name'],
                         adapter: this.args['--adapter'],
                         debug: this.args['--debug'],
+                        description: this.args['--description'],
                         env: this.args['--env'],
                         output: this.args['--output'],
+                        region: this.args['--region'],
                         skipBuild: this.args['--skip-build'],
                         skipSizeCheck: this.args['--skip-size-check'],
+                        subdomain: this.args['--subdomain'],
+                        workspace: this.args['--workspace'],
                         yes: this.args['--yes']
                     });
                     break;
@@ -153,7 +177,7 @@ class Main {
                         debug: this.args['--debug'],
                         env: this.args['--env'],
                         force: this.args['--force'],
-                        noSkill: this.args['--no-skill'],
+                        noAgent: this.args['--no-agent'],
                         payloadVersion: this.args['--payload-version'],
                         skipAuth: this.args['--skip-auth'],
                         template: this.args['--template']
@@ -166,7 +190,11 @@ class Main {
                     });
                     break;
                 case 'login':
-                    await loginCommand();
+                    await loginCommand({
+                        callbackUrl: this.args['--callback-url'],
+                        completeSessionId: this.args['--complete'],
+                        headless: this.args['--headless']
+                    });
                     break;
                 case 'logout':
                     await logoutCommand({
@@ -174,6 +202,13 @@ class Main {
                         debug: this.args['--debug']
                     });
                     break;
+                case 'setup-agent':
+                    await setupAgentCommand({
+                        global: this.args['--global'],
+                        project: this.args['--project'],
+                        yes: this.args['--yes']
+                    });
+                    break;
                 case 'upgrade':
                     await upgradeCommand({
                         isDryRun: this.args['--dry-run']

package/dist/commands/bootstrap.js

@@ -1,6 +1,7 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { ControlPlaneError, getBootstrapInfo } from '../api/control-plane.js';
+import { getBootstrapInfo } from '../api/control-plane.js';
+import { ControlPlaneError } from '../api/control-plane-error.js';
 import { getValidCredential } from '../auth/oauth-flow.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getInfraEnvironment } from '../constants.js';