@sanity/runtime-cli 14.13.4 → 15.0.0

package/dist/index.js

@@ -1,21 +1 @@
 export { run } from '@oclif/core';
-// Blueprints command classes
-export { default as BlueprintsAddCommand } from './commands/blueprints/add.js';
-export { default as BlueprintsConfigCommand } from './commands/blueprints/config.js';
-export { default as BlueprintsDeployCommand } from './commands/blueprints/deploy.js';
-export { default as BlueprintsDestroyCommand } from './commands/blueprints/destroy.js';
-export { default as BlueprintsDoctorCommand } from './commands/blueprints/doctor.js';
-export { default as BlueprintsInfoCommand } from './commands/blueprints/info.js';
-export { default as BlueprintsInitCommand } from './commands/blueprints/init.js';
-export { default as BlueprintsLogsCommand } from './commands/blueprints/logs.js';
-export { default as BlueprintsPlanCommand } from './commands/blueprints/plan.js';
-export { default as BlueprintsPromoteCommand } from './commands/blueprints/promote.js';
-export { default as BlueprintsStacksCommand } from './commands/blueprints/stacks.js';
-// Functions command classes
-export { default as FunctionsAddCommand } from './commands/functions/add.js';
-export { default as FunctionsDevCommand } from './commands/functions/dev.js';
-export { default as FunctionsEnvAddCommand } from './commands/functions/env/add.js';
-export { default as FunctionsEnvListCommand } from './commands/functions/env/list.js';
-export { default as FunctionsEnvRemoveCommand } from './commands/functions/env/remove.js';
-export { default as FunctionsLogsCommand } from './commands/functions/logs.js';
-export { default as FunctionsTestCommand } from './commands/functions/test.js';

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,14 @@
+interface CopyTool {
+    cmd: string;
+    args: string[];
+}
+export declare class ClipboardUnavailableError extends Error {
+    code: string;
+    triedTools: string[];
+    constructor(message: string, triedTools?: string[]);
+}
+/** Candidate copy tools for the current OS, in fallback order. */
+export declare function pickCopyTools(): CopyTool[];
+/** @throws {ClipboardUnavailableError} when no usable clipboard tool is available. */
+export declare function write(text: string): Promise<void>;
+export {};

package/dist/utils/clipboard.js

@@ -0,0 +1,73 @@
+import { spawn } from 'node:child_process';
+import { env, platform } from 'node:process';
+export class ClipboardUnavailableError extends Error {
+    code = 'CLIPBOARD_UNAVAILABLE';
+    triedTools;
+    constructor(message, triedTools = []) {
+        super(message);
+        this.name = 'ClipboardUnavailableError';
+        this.triedTools = triedTools;
+    }
+}
+/** Candidate copy tools for the current OS, in fallback order. */
+export function pickCopyTools() {
+    if (platform === 'darwin')
+        return [{ cmd: 'pbcopy', args: [] }];
+    if (platform === 'win32')
+        return [{ cmd: 'clip', args: [] }];
+    const tools = [];
+    if (env.WAYLAND_DISPLAY)
+        tools.push({ cmd: 'wl-copy', args: [] });
+    if (env.DISPLAY) {
+        tools.push({ cmd: 'xclip', args: ['-selection', 'clipboard'] });
+        tools.push({ cmd: 'xsel', args: ['--clipboard', '--input'] });
+    }
+    if (env.WSL_DISTRO_NAME)
+        tools.push({ cmd: 'clip.exe', args: [] });
+    return tools;
+}
+function tryWrite(tool, text) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(tool.cmd, tool.args, { stdio: ['pipe', 'ignore', 'pipe'] });
+        }
+        catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        let stderr = '';
+        child.on('error', reject);
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${tool.cmd} exited with code ${code}: ${stderr.trim()}`));
+        });
+        child.stdin?.end(text, 'utf8');
+    });
+}
+/** @throws {ClipboardUnavailableError} when no usable clipboard tool is available. */
+export async function write(text) {
+    const tools = pickCopyTools();
+    if (tools.length === 0) {
+        throw new ClipboardUnavailableError(`No clipboard tool available for platform "${platform}".`, []);
+    }
+    const triedTools = tools.map((t) => t.cmd);
+    let lastErr;
+    for (const tool of tools) {
+        try {
+            await tryWrite(tool, text);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    const message = lastErr instanceof Error ? lastErr.message : String(lastErr);
+    throw new ClipboardUnavailableError(`Clipboard write failed. Tools tried: ${triedTools.join(', ')}. Last error: ${message}`, triedTools);
+}

package/dist/utils/display/errors.d.ts

@@ -1,4 +1,8 @@
-import type { BlueprintIssue } from '../../actions/blueprints/index.js';
 import type { BlueprintParserError } from '../types.js';
+export type BlueprintIssue = {
+    code: 'NO_STACK_ID' | 'NO_SCOPE_TYPE' | 'NO_SCOPE_ID' | 'NO_STACK' | 'PARSE_ERROR';
+    message: string;
+    errors?: BlueprintParserError[];
+};
 export declare function presentBlueprintIssues(issues: BlueprintIssue[]): string;
 export declare function presentBlueprintParserErrors(errors: BlueprintParserError[]): string;

package/dist/utils/display/prompt.d.ts

@@ -1,33 +1,73 @@
+import type { Project } from '../../actions/sanity/projects.js';
 import type { Logger } from '../logger.js';
+import type { ScopeType } from '../types.js';
+export declare const BACK: unique symbol;
+export type Back = typeof BACK;
 export declare function promptForBlueprintType(): Promise<string>;
 /**
- * Prompt the user for a Project after selecting an Organization.
- * @param token - The Sanity API token
- * @returns The selected project, with the projectId and displayName
- * @throws {Error} If the user does not have any projects or if the API call fails
+ * Fetches organizations and prompts the user to pick one (if multiple).
+ * Returns the selected organization along with its projects.
  */
-export declare function promptForProject({ token, knownOrganizationId, knownProjectId, logger, }: {
+export declare function promptForOrganization({ token, knownOrganizationId, logger, allowBack, }: {
     token: string;
     knownOrganizationId?: string;
-    knownProjectId?: string;
     logger: Logger;
+    allowBack?: boolean;
+}): Promise<{
+    organization: {
+        id: string;
+        name: string;
+    };
+    projects: Project[];
+    wasPrompted: boolean;
+} | Back>;
+/**
+ * Asks the user whether to scope a Blueprint to an organization or a project.
+ */
+export declare function promptForScope({ allowBack, hasProjects, }?: {
+    allowBack?: boolean;
+    hasProjects?: boolean;
+}): Promise<ScopeType | Back>;
+/**
+ * Prompts the user to pick a project from a pre-fetched list of projects.
+ * Use after promptForOrganization when the user chose project scope.
+ */
+export declare function promptForProjectInOrg({ projects, knownProjectId, logger, allowBack, }: {
+    projects: Project[];
+    knownProjectId?: string;
+    logger?: Logger;
+    allowBack?: boolean;
 }): Promise<{
     projectId: string;
     displayName: string;
-}>;
+} | Back>;
 /**
- * Prompt the user for a Stack ID after selecting a Project.
- * Can be used to create a new Stack or select an existing one.
- * @param projectId - The ID of the Project
- * @param token - The Sanity API token
- * @returns The selected Stack ID
- * @throws {Error} If the user does not have any Stacks or if the API call fails
+ * Prompt the user for a Stack after scope has been determined.
+ * Can create a new Stack or select an existing one.
  */
-export declare function promptForStack({ projectId, token, logger, }: {
-    projectId: string;
+export declare function promptForStack({ scopeType, scopeId, token, logger, allowBack, }: {
+    scopeType: ScopeType;
+    scopeId: string;
     token: string;
     logger: Logger;
+    allowBack?: boolean;
 }): Promise<{
     stackId: string;
     name: string;
+} | Back>;
+/**
+ * Full wizard: Organization -> Scope -> Project (if project-scoped) -> Stack.
+ * Supports back-navigation between steps.
+ */
+export declare function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, }: {
+    token: string;
+    knownOrganizationId?: string;
+    knownProjectId?: string;
+    logger: Logger;
+}): Promise<{
+    scopeType: ScopeType;
+    scopeId: string;
+    displayName: string;
+    stackId: string;
+    stackName: string;
 }>;

package/dist/utils/display/prompt.js

@@ -3,6 +3,60 @@ import { createEmptyStack, listStacks } from '../../actions/blueprints/stacks.js
 import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
 import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
+// --- Wizard infrastructure ---
+export const BACK = Symbol('back');
+/**
+ * Runs a sequence of prompt steps with back-navigation support.
+ * Each step can return BACK to go to the previous non-skipped step.
+ * When going back, stale results from the current step onward are cleared.
+ */
+async function runWizard(steps) {
+    const results = {};
+    let i = 0;
+    while (i < steps.length) {
+        const step = steps[i];
+        if (step.shouldSkip?.(results)) {
+            i++;
+            continue;
+        }
+        const answer = await step.prompt(results);
+        if (answer === BACK) {
+            if (i === 0) {
+                // Cannot go back from the first step; re-prompt it
+                continue;
+            }
+            // Walk back to the previous non-skipped step
+            do {
+                i--;
+            } while (i > 0 && steps[i].shouldSkip?.(results));
+            // Erase 2 lines: the "← Back" answer line and the previous step's
+            // answered prompt. Back is only offered on steps where the previous
+            // step rendered a prompt, so this is always correct.
+            process.stdout.write('\x1b[1A\x1b[2K\x1b[1A\x1b[2K');
+            // Clear stale results from this step forward
+            for (let j = i; j < steps.length; j++) {
+                delete results[steps[j].key];
+            }
+            continue;
+        }
+        results[step.key] = answer;
+        i++;
+    }
+    return results;
+}
+/**
+ * Appends a "Back" choice to a list of select choices.
+ * Skipped for the first step in a wizard (nowhere to go back to).
+ */
+function withBackChoice(choices, allowBack) {
+    if (!allowBack)
+        return choices;
+    return [
+        ...choices,
+        { name: styleText('dim', '\u2190 Back'), value: BACK, description: 'Return to previous step' },
+    ];
+}
+// --- Standalone prompts ---
 export async function promptForBlueprintType() {
     return await select({
         message: 'Choose a Blueprint file type:',
@@ -14,60 +68,117 @@ export async function promptForBlueprintType() {
         default: 'ts',
     });
 }
+// --- Composable prompt functions for scope selection ---
 /**
- * Prompt the user for a Project after selecting an Organization.
- * @param token - The Sanity API token
- * @returns The selected project, with the projectId and displayName
- * @throws {Error} If the user does not have any projects or if the API call fails
+ * Fetches organizations and prompts the user to pick one (if multiple).
+ * Returns the selected organization along with its projects.
  */
-export async function promptForProject({ token, knownOrganizationId, knownProjectId, logger, }) {
+export async function promptForOrganization({ token, knownOrganizationId, logger, allowBack = false, }) {
+    const spinner = logger.ora('Loading organizations...').start();
     const { ok, error, organizations } = await groupProjectsByOrganization({ token, logger });
+    spinner.stop();
     if (!ok) {
-        throw new Error(error ?? 'Unknown error listing projects');
+        throw new Error(error ?? 'Unknown error listing organizations');
     }
     if (organizations.length === 0) {
-        throw new Error('No Sanity projects found. Use `npx sanity init` to create one.');
+        throw new Error('No Sanity organizations found. Use `npx sanity init` to create a project.');
     }
-    let projects;
+    let picked;
+    let wasPrompted = false;
     if (organizations.length > 1) {
-        const orgChoices = organizations.map(({ organization, projects }) => ({
-            name: `"${organization.name}" ${niceId(organization.id)}`,
-            value: organization.id,
-            disabled: !projects || projects.length === 0 ? '(0 Projects)' : false,
-        }));
+        wasPrompted = true;
+        const orgChoices = organizations.map(({ organization, projects }) => {
+            const projectCount = projects?.length ?? 0;
+            return {
+                name: `"${organization.name}" ${niceId(organization.id)}`,
+                value: organization.id,
+                description: `${projectCount} ${projectCount === 1 ? 'project' : 'projects'}`,
+            };
+        });
         const pickedOrgId = await select({
-            message: 'Which Organization would you like to use?',
-            choices: orgChoices,
+            message: 'Which organization would you like to use?',
+            choices: withBackChoice(orgChoices, allowBack),
             default: knownOrganizationId,
         });
+        if (pickedOrgId === BACK)
+            return BACK;
         const pickedOrg = organizations.find((o) => o.organization.id === pickedOrgId);
-        projects = pickedOrg?.projects;
+        if (!pickedOrg) {
+            throw new Error('No organization found with the given ID');
+        }
+        picked = pickedOrg;
     }
     else {
-        projects = organizations[0].projects;
+        picked = organizations[0];
+        logger(`Using organization "${picked.organization.name}" ${niceId(picked.organization.id)}`);
+    }
+    return {
+        organization: picked.organization,
+        projects: picked.projects ?? [],
+        wasPrompted,
+    };
+}
+/**
+ * Asks the user whether to scope a Blueprint to an organization or a project.
+ */
+export async function promptForScope({ allowBack = false, hasProjects = true, } = {}) {
+    const choices = [
+        {
+            name: 'Organization',
+            value: 'organization',
+            description: 'Manage resources across all projects in the organization',
+        },
+        {
+            name: 'Project',
+            value: 'project',
+            description: 'Manage resources within a single project',
+            disabled: hasProjects ? false : '(no projects in this organization)',
+        },
+    ];
+    const answer = await select({
+        message: 'How would you like to scope your Blueprint?',
+        choices: withBackChoice(choices, allowBack),
+        default: 'organization',
+    });
+    return answer;
+}
+/**
+ * Prompts the user to pick a project from a pre-fetched list of projects.
+ * Use after promptForOrganization when the user chose project scope.
+ */
+export async function promptForProjectInOrg({ projects, knownProjectId, logger, allowBack = false, }) {
+    if (projects.length === 0) {
+        throw new Error('No projects found in this organization.');
     }
     const projectChoices = projects.map(({ displayName, id: projectId }) => ({
         name: `"${displayName}" ${niceId(projectId)}`,
         value: projectId,
     }));
     let pickedProjectId;
-    if (projectChoices.length === 1) {
+    if (projectChoices.length === 1 && !allowBack) {
+        // Single-project confirm only when not in wizard (wizard has Back for navigation)
         const onlyProject = projectChoices[0];
         const confirmed = await confirm({
-            message: `Found 1 project. Use ${onlyProject.name}?`,
+            message: `Found 1 project in this organization. Use ${onlyProject.name}?`,
             default: true,
         });
-        if (confirmed)
+        if (confirmed) {
             pickedProjectId = onlyProject.value;
-        else
+            logger?.(`Using project ${onlyProject.name}`);
+        }
+        else {
             throw new Error('No project selected');
+        }
     }
     else {
-        pickedProjectId = await select({
-            message: 'Choose a Sanity Project:',
-            choices: projectChoices,
+        const answer = await select({
+            message: 'Choose a Sanity project:',
+            choices: withBackChoice(projectChoices, allowBack),
             default: knownProjectId,
         });
+        if (answer === BACK)
+            return BACK;
+        pickedProjectId = answer;
     }
     const pickedProject = projects.find((p) => p.id === pickedProjectId);
     if (!pickedProject)
@@ -75,44 +186,69 @@ export async function promptForProject({ token, knownOrganizationId, knownProjec
     return { projectId: pickedProject.id, displayName: pickedProject.displayName };
 }
 /**
- * Prompt the user for a Stack ID after selecting a Project.
- * Can be used to create a new Stack or select an existing one.
- * @param projectId - The ID of the Project
- * @param token - The Sanity API token
- * @returns The selected Stack ID
- * @throws {Error} If the user does not have any Stacks or if the API call fails
+ * Prompt the user for a Stack after scope has been determined.
+ * Can create a new Stack or select an existing one.
  */
-export async function promptForStack({ projectId, token, logger, }) {
-    const { ok: stacksOk, error: stacksErr, stacks, } = await listStacks({ token, scopeType: 'project', scopeId: projectId }, logger);
+export async function promptForStack({ scopeType, scopeId, token, logger, allowBack = false, }) {
+    if (!scopeId) {
+        throw new Error(`Cannot list Stacks: no ${scopeType} ID provided. ` +
+            'Provide --project-id or --organization-id, or select a scope in the wizard.');
+    }
+    const spinner = logger.ora('Loading Stacks...').start();
+    const { ok: stacksOk, error: stacksErr, stacks, } = await listStacks({ token, scopeType, scopeId }, logger);
+    spinner.stop();
     if (!stacksOk) {
-        throw new Error(stacksErr || 'Failed to list Stacks');
+        const scopeLabel = scopeType === 'organization' ? 'organization' : 'project';
+        throw new Error(stacksErr || `Failed to list Stacks for ${scopeLabel} "${scopeId}".`);
     }
     const NEW_STACK_ID = 'new';
     let pickedStackId = NEW_STACK_ID;
+    if (stacks.length === 0) {
+        logger('No existing Stacks found. Creating a new one.');
+    }
     if (stacks.length > 0) {
-        const stackChoices = [];
-        stackChoices.push(new Separator(styleText('underline', 'Create a new Stack:')));
-        stackChoices.push({ name: styleText('bold', 'New Stack ✨'), value: NEW_STACK_ID });
-        stackChoices.push(new Separator(styleText('underline', 'Use an existing Stack:')));
-        stackChoices.push(...stacks.map((s) => ({
-            name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
-            value: s.id,
-        })));
-        pickedStackId = await select({
+        const stackChoices = [
+            new Separator(styleText('underline', 'Create a new Stack:')),
+            { name: styleText('bold', 'New Stack'), value: NEW_STACK_ID },
+            new Separator(styleText('underline', 'Use an existing Stack:')),
+            ...stacks.map((s) => ({
+                name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
+                value: s.id,
+            })),
+        ];
+        if (allowBack) {
+            stackChoices.push(new Separator(), {
+                name: styleText('dim', '\u2190 Back'),
+                value: BACK,
+                description: 'Return to previous step',
+            });
+        }
+        const answer = await select({
             message: 'Select a deployment Stack:',
             choices: stackChoices,
             default: NEW_STACK_ID,
         });
+        if (answer === BACK)
+            return BACK;
+        pickedStackId = answer;
+    }
+    else if (allowBack) {
+        const proceed = await select({
+            message: 'No existing Stacks. Create a new one?',
+            choices: withBackChoice([{ name: 'Yes, create a new Stack', value: 'yes' }], allowBack),
+        });
+        if (proceed === BACK)
+            return BACK;
     }
     if (pickedStackId === NEW_STACK_ID) {
         const stackName = await input({
             message: 'Enter a name for your new Stack:',
-            validate: (input) => input.length > 0 || 'Stack name is required',
+            validate: (val) => val.length > 0 || 'Stack name is required',
         });
         const stack = await createEmptyStack({
             token,
-            scopeType: 'project',
-            scopeId: projectId,
+            scopeType,
+            scopeId,
             name: stackName,
             logger,
         });
@@ -123,3 +259,93 @@ export async function promptForStack({ projectId, token, logger, }) {
         throw new Error('Stack not found');
     return { stackId: pickedStack.id, name: pickedStack.name };
 }
+/**
+ * Full wizard: Organization -> Scope -> Project (if project-scoped) -> Stack.
+ * Supports back-navigation between steps.
+ */
+export async function runScopeAndStackWizard({ token, knownOrganizationId, knownProjectId, logger, }) {
+    const steps = [
+        {
+            key: 'organization',
+            prompt: async () => {
+                return await promptForOrganization({
+                    token,
+                    knownOrganizationId,
+                    logger,
+                    // First step -- no back
+                });
+            },
+        },
+        {
+            key: 'scopeType',
+            prompt: async (results) => {
+                const orgResult = results.organization;
+                return await promptForScope({
+                    allowBack: orgResult.wasPrompted,
+                    hasProjects: orgResult.projects.length > 0,
+                });
+            },
+        },
+        {
+            key: 'project',
+            shouldSkip: (results) => results.scopeType === 'organization',
+            prompt: async (results) => {
+                const orgResult = results.organization;
+                if (!orgResult)
+                    throw new Error('Organization not resolved');
+                return await promptForProjectInOrg({
+                    projects: orgResult.projects,
+                    knownProjectId,
+                    logger,
+                    allowBack: true,
+                });
+            },
+        },
+        {
+            key: 'stack',
+            prompt: async (results) => {
+                const scopeType = results.scopeType;
+                if (!scopeType)
+                    throw new Error('Scope type not resolved');
+                let scopeId;
+                if (scopeType === 'organization') {
+                    const orgResult = results.organization;
+                    scopeId = orgResult.organization.id;
+                }
+                else {
+                    const project = results.project;
+                    scopeId = project.projectId;
+                }
+                return await promptForStack({
+                    scopeType,
+                    scopeId,
+                    token,
+                    logger,
+                    allowBack: true,
+                });
+            },
+        },
+    ];
+    const result = await runWizard(steps);
+    const orgResult = result.organization;
+    const scopeType = result.scopeType;
+    const stack = result.stack;
+    let scopeId;
+    let displayName;
+    if (scopeType === 'organization') {
+        scopeId = orgResult.organization.id;
+        displayName = orgResult.organization.name;
+    }
+    else {
+        const project = result.project;
+        scopeId = project.projectId;
+        displayName = project.displayName;
+    }
+    return {
+        scopeType,
+        scopeId,
+        displayName,
+        stackId: stack.stackId,
+        stackName: stack.name,
+    };
+}