@sanity/runtime-cli 17.4.0-blueprinit.g0ac8878 → 17.5.0

package/skills/functions-env-remove.md

@@ -0,0 +1,22 @@
+# `npx @sanity/cli functions env remove`
+
+Delete one environment variable from a deployed Function. The command does not ask for confirmation and does not redeploy the Stack.
+
+Run from the Blueprint directory or a subdirectory; the manifest is required even though the command only touches remote state.
+
+## Required checks
+
+1. Obtain authorization to remove the key.
+2. Resolve the exact Function and Stack.
+3. Run `functions env list` and confirm that the key is present.
+4. Check whether the Function still requires the variable.
+
+## Remove
+
+```sh
+npx @sanity/cli functions env remove process-order LEGACY_API_URL --json
+```
+
+Override the locally configured Stack with `--stack NAME_OR_ID`.
+
+The JSON result contains the Function name and removed key, not the old value. If the value may be needed again, arrange a user-approved backup before removal; this command cannot retrieve it.

package/skills/functions-logs.md

@@ -0,0 +1,39 @@
+# `npx @sanity/cli functions logs`
+
+Fetch, stream, or delete logs for one deployed Function. Always provide the Function name; omitting it only prints valid names and command help.
+
+Run from the Blueprint directory or a subdirectory; the manifest supplies the valid Function names.
+
+## Fetch logs
+
+Prefer a bounded, structured query for agent work:
+
+```sh
+npx @sanity/cli functions logs process-order --limit 100 --json
+```
+
+`--limit` defaults to 50. Entries without both a level and a message are dropped, so a returned count can be lower than the limit even when more logs exist.
+
+When entries are found, the JSON result contains a `logs` array of `{time, requestId, level, message}`. Human-readable output drops `requestId` and prints local timestamps unless `--utc` is passed. Pass `--stack NAME_OR_ID` to override the locally configured Stack.
+
+Logs may contain payload data or application secrets. Summarize only what is needed and do not reproduce credentials or personal data.
+
+## Stream logs
+
+`--watch` (alias `--follow`, `-w`) keeps running until interrupted and emits human-readable output:
+
+```sh
+npx @sanity/cli functions logs process-order --watch
+```
+
+`--watch` cannot be combined with `--json`. Streamed timestamps are always UTC, so `--utc` is ignored. Use watch mode only when continuous monitoring is requested, and stop it when monitoring is complete.
+
+## Delete logs
+
+Deleting removes all logs for the Function. Obtain explicit authorization and confirm the Function and Stack first:
+
+```sh
+npx @sanity/cli functions logs process-order --delete
+```
+
+The command prompts (defaulting to no) unless `--force` is supplied, and `--force` requires `--delete`. Use `--force` only for an authorized non-interactive deletion. `--delete` is rejected alongside `--limit` or `--json`.

package/skills/functions-test.md

@@ -0,0 +1,31 @@
+# `npx @sanity/cli functions test`
+
+Invoke a local Function with a test payload. Local execution can still make network requests or mutate external systems, so inspect the handler and payload before running it.
+
+## Run a bounded test
+
+Always provide the Function name. Prefer a JSON file for nontrivial payloads:
+
+```sh
+npx @sanity/cli functions test process-order --file payload.json --json
+```
+
+Use `--data '{"orderId":"order-123"}'` for a small inline JSON object. `--data`, `--file`, and `--document-id` are alternative input modes, and each must resolve to a JSON object. File paths are joined to the current working directory, so pass relative paths.
+
+Payloads reach document and media-library Functions only. Scheduled and sync-tag-invalidation Functions are invoked with a fixed scheduled event, and any payload flag is accepted and then ignored.
+
+For document and media-library Functions, the event defaults to `create` and also accepts `update` and `delete`. For an update event, provide one complete before/after pair:
+
+```sh
+npx @sanity/cli functions test process-order --event update --file-before before.json --file-after after.json --json
+```
+
+The Blueprint's `event.filter` and `event.projection` are applied to the payload before the handler runs, and a payload the filter excludes is skipped rather than executed. `--timeout SECONDS` overrides the Function's configured `timeout` for this run (default 10 seconds).
+
+## Remote data and credentials
+
+`--document-id` fetches a document (`--project-id`, `--dataset`) or a media-library asset (`--media-library-id`) with the CLI's stored token before local execution. `--api` sets the API version used for that fetch.
+
+`--with-user-token` injects the authenticated CLI token into the Function context. Use it only for trusted local code when authenticated API behavior is part of the test. Never include the token in payloads or output.
+
+The JSON result contains logs and any Function response. Review logs for sensitive data before sharing them.

package/dist/actions/blueprinit/manifest.d.ts

@@ -1,15 +0,0 @@
-export declare const STARTER_DOCUMENT_TYPE = "post";
-export declare const STARTER_FUNCTION_NAME = "set-slug";
-export interface BlueprintManifestOptions {
-    projectName: string;
-    displayName: string;
-    projectId: string;
-    datasetName: string;
-    studioName: string;
-    studioSrc: string;
-    studioOrigin: string;
-    withFunction: boolean;
-}
-export declare function renderBlueprint(options: BlueprintManifestOptions): string;
-export declare function hostedStudioOrigin(studioName: string, sanityEnv?: string): string;
-export declare function slugify(value: string): string;

package/dist/actions/blueprinit/manifest.js

@@ -1,76 +0,0 @@
-const quote = (value) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
-export const STARTER_DOCUMENT_TYPE = 'post';
-export const STARTER_FUNCTION_NAME = 'set-slug';
-export function renderBlueprint(options) {
-    const { projectName, displayName, projectId, datasetName, studioName, studioSrc, studioOrigin, withFunction, } = options;
-    const definers = [
-        'type BlueprintResource',
-        'defineBlueprint',
-        'defineCorsOrigin',
-        'defineDataset',
-        'defineProject',
-    ];
-    if (withFunction)
-        definers.splice(4, 0, 'defineDocumentFunction');
-    const functionResource = withFunction
-        ? `    defineDocumentFunction({
-      name: ${quote(STARTER_FUNCTION_NAME)},
-      project: ${quote(projectId)},
-      event: {
-        on: ['create', 'update'],
-        filter: "_type == '${STARTER_DOCUMENT_TYPE}' && !defined(slug.current)",
-        projection: '{_id, title, slug}',
-      },
-    }),
-`
-        : '';
-    // Project references stay literal until the deploy API can resolve resource references here.
-    return `import {${definers.join(', ')}} from '@sanity/blueprints'
-
-export default defineBlueprint({
-  resources: [
-    defineProject({
-      name: ${quote(projectName)},
-      displayName: ${quote(displayName)},
-      lifecycle: {
-        deletionPolicy: 'retain',
-        ownershipAction: {type: 'attach', id: ${quote(projectId)}},
-      },
-    }),
-    defineDataset({
-      name: ${quote(datasetName)},
-      project: ${quote(projectId)},
-      lifecycle: {
-        deletionPolicy: 'retain',
-        ownershipAction: {type: 'attach', id: ${quote(datasetName)}, projectId: ${quote(projectId)}},
-      },
-    }),
-    defineCorsOrigin({
-      name: ${quote(`${studioName}-cors`)},
-      origin: ${quote(studioOrigin)},
-      allowCredentials: true,
-      project: ${quote(projectId)},
-    }),
-    {
-      name: ${quote(studioName)},
-      type: 'sanity.studio',
-      src: ${quote(studioSrc)},
-      slug: ${quote(studioName)},
-      title: ${quote(displayName)},
-      autoUpdates: {enabled: false},
-      project: ${quote(projectId)},
-    } as BlueprintResource,
-${functionResource}  ],
-})
-`;
-}
-export function hostedStudioOrigin(studioName, sanityEnv) {
-    const hostname = sanityEnv?.toLowerCase() === 'staging' ? 'studio.sanity.work' : 'sanity.studio';
-    return `https://${studioName}.${hostname}`;
-}
-export function slugify(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}

package/dist/actions/blueprinit/studio.d.ts

@@ -1,6 +0,0 @@
-export interface DetectedStudio {
-    configFile: string;
-    projectId?: string;
-    dataset?: string;
-}
-export declare function detectStudio(dir: string): DetectedStudio | undefined;

package/dist/actions/blueprinit/studio.js

@@ -1,43 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-const STUDIO_CONFIG_PATTERN = /^sanity\.config\.[cm]?[jt]sx?$/;
-const STUDIO_CLI_PATTERN = /^sanity\.cli\.[cm]?[jt]sx?$/;
-export function detectStudio(dir) {
-    let entries;
-    try {
-        entries = readdirSync(dir, { withFileTypes: true })
-            .filter((entry) => entry.isFile())
-            .map((entry) => entry.name);
-    }
-    catch {
-        return undefined;
-    }
-    const configFile = entries.find((name) => STUDIO_CONFIG_PATTERN.test(name));
-    if (!configFile)
-        return undefined;
-    const detected = { configFile };
-    const cliFile = entries.find((name) => STUDIO_CLI_PATTERN.test(name));
-    for (const file of [configFile, cliFile]) {
-        if (!file)
-            continue;
-        const source = readSource(join(dir, file));
-        if (!source)
-            continue;
-        detected.projectId ??= extractLiteral(source, 'projectId');
-        detected.dataset ??= extractLiteral(source, 'dataset');
-        if (detected.projectId && detected.dataset)
-            break;
-    }
-    return detected;
-}
-function readSource(filePath) {
-    try {
-        return readFileSync(filePath, 'utf8');
-    }
-    catch {
-        return undefined;
-    }
-}
-function extractLiteral(source, key) {
-    return source.match(new RegExp(`\\b${key}\\s*:\\s*(['"\`])([^'"\`\\\\]+)\\1`))?.[2];
-}

package/dist/actions/blueprinit/templates.d.ts

@@ -1,34 +0,0 @@
-export declare function renderStudioConfig(options: {
-    displayName: string;
-    projectId: string;
-    datasetName: string;
-}): string;
-export declare const STUDIO_SCHEMA_TYPES = "import {post} from './post'\n\nexport const schemaTypes = [post]\n";
-export declare const STUDIO_POST_TYPE = "import {defineField, defineType} from 'sanity'\n\nexport const post = defineType({\n  name: 'post',\n  title: 'Post',\n  type: 'document',\n  fields: [\n    defineField({name: 'title', type: 'string', validation: (rule) => rule.required()}),\n    // The set-slug function fills this when it is empty.\n    defineField({name: 'slug', type: 'slug', options: {source: 'title'}}),\n    defineField({name: 'publishedAt', title: 'Published at', type: 'datetime'}),\n    defineField({name: 'body', type: 'text'}),\n  ],\n})\n";
-export declare const FUNCTION_SET_SLUG = "import {createClient} from '@sanity/client'\nimport {documentEventHandler} from '@sanity/functions'\n\nconst slugify = (title: string) =>\n  title\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-+|-+$/g, '')\n    .slice(0, 96)\n\nexport const handler = documentEventHandler(async ({context, event}) => {\n  const {_id, title, slug} = event.data\n  if (!title || slug?.current) return\n\n  const client = createClient({apiVersion: '2025-05-01', ...context.clientOptions})\n  const current = slugify(title)\n  await client.patch(_id).set({slug: {_type: 'slug', current}}).commit()\n\n  console.log(`Set slug for ${_id}: ${current}`)\n})\n";
-export declare const studioPackageJson: (name: string) => {
-    name: string;
-    version: string;
-    private: boolean;
-    scripts: {
-        dev: string;
-        build: string;
-        deploy: string;
-    };
-    dependencies: {
-        react: string;
-        'react-dom': string;
-        sanity: string;
-        'styled-components': string;
-    };
-};
-export declare const functionPackageJson: (name: string) => {
-    name: string;
-    version: string;
-    private: boolean;
-    type: string;
-    dependencies: {
-        '@sanity/client': string;
-        '@sanity/functions': string;
-    };
-};

package/dist/actions/blueprinit/templates.js

@@ -1,83 +0,0 @@
-import { STARTER_DOCUMENT_TYPE, STARTER_FUNCTION_NAME } from './manifest.js';
-const quote = (value) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
-export function renderStudioConfig(options) {
-    return `import {defineConfig} from 'sanity'
-import {structureTool} from 'sanity/structure'
-import {schemaTypes} from './schemaTypes'
-
-export default defineConfig({
-  name: 'default',
-  title: ${quote(options.displayName)},
-  projectId: ${quote(options.projectId)},
-  dataset: ${quote(options.datasetName)},
-  plugins: [structureTool()],
-  schema: {types: schemaTypes},
-})
-`;
-}
-export const STUDIO_SCHEMA_TYPES = `import {post} from './post'
-
-export const schemaTypes = [post]
-`;
-export const STUDIO_POST_TYPE = `import {defineField, defineType} from 'sanity'
-
-export const post = defineType({
-  name: '${STARTER_DOCUMENT_TYPE}',
-  title: 'Post',
-  type: 'document',
-  fields: [
-    defineField({name: 'title', type: 'string', validation: (rule) => rule.required()}),
-    // The ${STARTER_FUNCTION_NAME} function fills this when it is empty.
-    defineField({name: 'slug', type: 'slug', options: {source: 'title'}}),
-    defineField({name: 'publishedAt', title: 'Published at', type: 'datetime'}),
-    defineField({name: 'body', type: 'text'}),
-  ],
-})
-`;
-export const FUNCTION_SET_SLUG = `import {createClient} from '@sanity/client'
-import {documentEventHandler} from '@sanity/functions'
-
-const slugify = (title: string) =>
-  title
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 96)
-
-export const handler = documentEventHandler(async ({context, event}) => {
-  const {_id, title, slug} = event.data
-  if (!title || slug?.current) return
-
-  const client = createClient({apiVersion: '2025-05-01', ...context.clientOptions})
-  const current = slugify(title)
-  await client.patch(_id).set({slug: {_type: 'slug', current}}).commit()
-
-  console.log(\`Set slug for \${_id}: \${current}\`)
-})
-`;
-export const studioPackageJson = (name) => ({
-    name,
-    version: '0.1.0',
-    private: true,
-    scripts: {
-        dev: 'sanity dev',
-        build: 'sanity build',
-        deploy: 'sanity deploy',
-    },
-    dependencies: {
-        react: '^19',
-        'react-dom': '^19',
-        sanity: '^4',
-        'styled-components': '^6',
-    },
-});
-export const functionPackageJson = (name) => ({
-    name,
-    version: '0.1.0',
-    private: true,
-    type: 'module',
-    dependencies: {
-        '@sanity/client': '^7',
-        '@sanity/functions': '^1',
-    },
-});

package/dist/actions/blueprinit/workspace.d.ts

@@ -1,16 +0,0 @@
-export interface WorkspaceOptions {
-    dir: string;
-    projectId: string;
-    displayName: string;
-    datasetName: string;
-    stackName: string;
-    studioName: string;
-    studioOrigin: string;
-    blueprintsVersion: string;
-}
-export interface WorkspaceResult {
-    blueprintFilePath: string;
-    files: string[];
-}
-export declare function scaffoldWorkspace(options: WorkspaceOptions): WorkspaceResult;
-export declare function adoptWorkspace(options: WorkspaceOptions): WorkspaceResult;

package/dist/actions/blueprinit/workspace.js

@@ -1,143 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, posix } from 'node:path';
-import { renderBlueprint, STARTER_FUNCTION_NAME } from './manifest.js';
-import { FUNCTION_SET_SLUG, functionPackageJson, renderStudioConfig, STUDIO_POST_TYPE, STUDIO_SCHEMA_TYPES, studioPackageJson, } from './templates.js';
-const GITIGNORE_ENTRY = '# Sanity Blueprints\n.sanity/';
-const DEFAULT_GITIGNORE = `node_modules
-.env
-
-${GITIGNORE_ENTRY}
-`;
-export function scaffoldWorkspace(options) {
-    const { dir, studioName } = options;
-    assertTargetsAvailable(dir, [
-        posix.join('studios', studioName),
-        posix.join('functions', STARTER_FUNCTION_NAME),
-    ]);
-    const packageJson = preparePackageJson(options, ['studios/*', 'functions/*']);
-    const files = [];
-    const write = createWriter(dir, files);
-    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({
-        ...manifestOptions(options),
-        studioSrc: `./studios/${studioName}`,
-        withFunction: true,
-    }));
-    write(posix.join('studios', studioName, 'package.json'), formatJson(studioPackageJson(studioName)));
-    write(posix.join('studios', studioName, 'sanity.config.ts'), renderStudioConfig(options));
-    write(posix.join('studios', studioName, 'schemaTypes', 'index.ts'), STUDIO_SCHEMA_TYPES);
-    write(posix.join('studios', studioName, 'schemaTypes', 'post.ts'), STUDIO_POST_TYPE);
-    write(posix.join('studios', studioName, 'static', '.gitkeep'), '');
-    write(posix.join('functions', STARTER_FUNCTION_NAME, 'package.json'), formatJson(functionPackageJson(STARTER_FUNCTION_NAME)));
-    write(posix.join('functions', STARTER_FUNCTION_NAME, 'index.ts'), FUNCTION_SET_SLUG);
-    writePreparedRootFiles(dir, packageJson, files);
-    return { blueprintFilePath, files };
-}
-export function adoptWorkspace(options) {
-    const { dir } = options;
-    const packageJson = preparePackageJson(options, []);
-    const files = [];
-    const write = createWriter(dir, files);
-    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({ ...manifestOptions(options), studioSrc: '.', withFunction: false }));
-    writePreparedRootFiles(dir, packageJson, files);
-    return { blueprintFilePath, files };
-}
-function manifestOptions(options) {
-    return {
-        projectName: options.stackName,
-        displayName: options.displayName,
-        projectId: options.projectId,
-        datasetName: options.datasetName,
-        studioName: options.studioName,
-        studioOrigin: options.studioOrigin,
-    };
-}
-function assertTargetsAvailable(dir, paths) {
-    const conflicts = paths.filter((path) => existsSync(join(dir, path)));
-    if (conflicts.length > 0) {
-        throw new Error(`Refusing to overwrite existing paths: ${conflicts.join(', ')}`);
-    }
-}
-function createWriter(dir, files) {
-    return (relativePath, content) => {
-        const filePath = join(dir, relativePath);
-        mkdirSync(dirname(filePath), { recursive: true });
-        writeFileSync(filePath, content);
-        files.push(relativePath);
-        return filePath;
-    };
-}
-function writePreparedRootFiles(dir, packageJson, files) {
-    if (writeGitignore(dir))
-        files.push('.gitignore');
-    writeFileSync(join(dir, 'package.json'), formatJson(packageJson));
-    files.push('package.json');
-}
-function writeGitignore(dir) {
-    const filePath = join(dir, '.gitignore');
-    if (!existsSync(filePath)) {
-        writeFileSync(filePath, DEFAULT_GITIGNORE);
-        return true;
-    }
-    const existing = readFileSync(filePath, 'utf8');
-    if (existing.split(/\r?\n/).some((line) => line.trim() === '.sanity/'))
-        return false;
-    writeFileSync(filePath, `${existing.trimEnd()}\n\n${GITIGNORE_ENTRY}\n`);
-    return true;
-}
-function preparePackageJson(options, requiredWorkspaces) {
-    const filePath = join(options.dir, 'package.json');
-    const parsed = existsSync(filePath)
-        ? JSON.parse(readFileSync(filePath, 'utf8'))
-        : {
-            name: options.stackName,
-            version: '0.1.0',
-            private: true,
-            type: 'module',
-        };
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('The existing package.json must contain a JSON object.');
-    }
-    const packageJson = parsed;
-    addWorkspaces(packageJson, requiredWorkspaces);
-    addBlueprintsDependency(packageJson, options.blueprintsVersion);
-    return packageJson;
-}
-function addWorkspaces(packageJson, required) {
-    if (required.length === 0)
-        return;
-    if (!packageJson.workspaces) {
-        packageJson.workspaces = required;
-        return;
-    }
-    if (Array.isArray(packageJson.workspaces)) {
-        packageJson.workspaces = [...new Set([...packageJson.workspaces, ...required])];
-        return;
-    }
-    if (!packageJson.workspaces || typeof packageJson.workspaces !== 'object') {
-        throw new Error('Cannot add generated packages to the existing package.json workspaces.');
-    }
-    const workspaces = packageJson.workspaces;
-    if (Array.isArray(workspaces.packages)) {
-        workspaces.packages = [...new Set([...workspaces.packages, ...required])];
-        return;
-    }
-    throw new Error('Cannot add generated packages to the existing package.json workspaces.');
-}
-function addBlueprintsDependency(packageJson, blueprintsVersion) {
-    const dependencies = recordOrEmpty(packageJson.dependencies);
-    const devDependencies = recordOrEmpty(packageJson.devDependencies);
-    if (dependencies['@sanity/blueprints'] || devDependencies['@sanity/blueprints'])
-        return;
-    packageJson.devDependencies = {
-        ...devDependencies,
-        '@sanity/blueprints': blueprintsVersion,
-    };
-}
-function recordOrEmpty(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function formatJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}

package/dist/actions/sanity/datasets.d.ts

@@ -1,15 +0,0 @@
-import type { Logger } from '../../utils/logger.js';
-import type { ActionResponse } from '../../utils/types.js';
-export interface Dataset {
-    name: string;
-    aclMode: string;
-}
-interface ListDatasetsResponse extends ActionResponse {
-    datasets: Dataset[];
-}
-export declare function listDatasets({ token, projectId, logger, }: {
-    token: string;
-    projectId: string;
-    logger: Logger;
-}): Promise<ListDatasetsResponse>;
-export {};

package/dist/actions/sanity/datasets.js

@@ -1,26 +0,0 @@
-import { createTracedFetch } from '../../utils/traced-fetch.js';
-import { projectsApiPath } from './projects.js';
-export async function listDatasets({ token, projectId, logger, }) {
-    const fetchFn = createTracedFetch(logger);
-    const url = `${projectsApiPath}/${encodeURIComponent(projectId)}/datasets`;
-    const response = await fetchFn(url, {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-    });
-    const body = await response.json();
-    if (!response.ok) {
-        return {
-            ok: false,
-            error: body.error?.message ?? response.statusText,
-            datasets: [],
-        };
-    }
-    return {
-        ok: true,
-        error: null,
-        datasets: body,
-    };
-}

package/dist/commands/blueprinit.d.ts

@@ -1,17 +0,0 @@
-import { RuntimeCommand } from '../baseCommands.js';
-export default class BlueprinitCommand extends RuntimeCommand<typeof BlueprinitCommand> {
-    static hidden: boolean;
-    static summary: string;
-    static description: string;
-    static examples: string[];
-    static flags: {
-        llms: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'studio-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<Record<string, unknown> | undefined>;
-}

package/dist/commands/blueprinit.js

@@ -1,59 +0,0 @@
-import { Flags } from '@oclif/core';
-import { llmsFlagConfig } from '@sanity-labs/oclif-plugin-skills-flag';
-import { RuntimeCommand } from '../baseCommands.js';
-import { blueprinitCore } from '../cores/blueprinit.js';
-import { Logger } from '../utils/logger.js';
-export default class BlueprinitCommand extends RuntimeCommand {
-    static hidden = true;
-    static summary = 'Experimental blueprints-first project init';
-    static description = `Scaffolds a Blueprint, Studio, and starter function around an existing Sanity project.
-
-This hidden command is an experiment; its interface and generated files are not stable.`;
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --yes',
-        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes',
-    ];
-    static flags = {
-        llms: Flags.boolean(llmsFlagConfig),
-        yes: Flags.boolean({
-            char: 'y',
-            description: 'Skip confirmation prompts',
-            default: false,
-        }),
-        'organization-id': Flags.string({
-            description: 'Organization to use when the account has several',
-            aliases: ['organization', 'organizationId', 'org'],
-        }),
-        'project-id': Flags.string({
-            description: 'Project to use when the organization has several',
-            aliases: ['project', 'projectId'],
-        }),
-        dataset: Flags.string({
-            description: 'Dataset to attach',
-        }),
-        'stack-name': Flags.string({
-            description: 'Name for the new organization-scoped Stack',
-        }),
-        'studio-name': Flags.string({
-            description: 'Name and hosted slug for the Studio resource',
-        }),
-    };
-    async run() {
-        const result = await blueprinitCore({
-            bin: this.config.bin,
-            log: Logger(this.log.bind(this), this.flags),
-            flags: {
-                yes: this.flags.yes,
-                organizationId: this.flags['organization-id'],
-                projectId: this.flags['project-id'],
-                datasetName: this.flags.dataset,
-                stackName: this.flags['stack-name'],
-                studioName: this.flags['studio-name'],
-            },
-        });
-        if (!result.success)
-            this.coreError(result);
-        return result.json;
-    }
-}

package/dist/cores/blueprinit/adopt.d.ts

@@ -1,6 +0,0 @@
-import type { DetectedStudio } from '../../actions/blueprinit/studio.js';
-import type { CoreResult } from '../index.js';
-import type { BlueprinitFlowOptions } from './types.js';
-export declare function adoptFlow(options: BlueprinitFlowOptions & {
-    studio: DetectedStudio;
-}): Promise<CoreResult>;