@sanity/runtime-cli 11.1.1 → 11.1.3

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity-run COMMAND
 running command...
 $ sanity-run (--version)
-@sanity/runtime-cli/11.1.1 linux-x64 node-v24.11.0
+@sanity/runtime-cli/11.1.3 linux-x64 node-v24.11.0
 $ sanity-run --help [COMMAND]
 USAGE
   $ sanity-run COMMAND
@@ -92,7 +92,7 @@ EXAMPLES
   $ sanity-run blueprints add function --name my-function --fn-type document-create --fn-type document-update --lang js
 ```
 
-_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/add.ts)_
+_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/add.ts)_
 
 ## `sanity-run blueprints config`
 
@@ -124,7 +124,7 @@ EXAMPLES
   $ sanity-run blueprints config --edit --project-id <projectId> --stack-id <stackId>
 ```
 
-_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/config.ts)_
+_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/config.ts)_
 
 ## `sanity-run blueprints deploy`
 
@@ -146,7 +146,7 @@ EXAMPLES
   $ sanity-run blueprints deploy --no-wait
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/deploy.ts)_
 
 ## `sanity-run blueprints destroy`
 
@@ -173,7 +173,7 @@ EXAMPLES
   $ sanity-run blueprints destroy --stack-id <stackId> --project-id <projectId> --force --no-wait
 ```
 
-_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/destroy.ts)_
+_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/destroy.ts)_
 
 ## `sanity-run blueprints doctor`
 
@@ -191,7 +191,7 @@ DESCRIPTION
   Diagnose potential issues with Blueprint configuration
 ```
 
-_See code: [src/commands/blueprints/doctor.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/doctor.ts)_
+_See code: [src/commands/blueprints/doctor.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/doctor.ts)_
 
 ## `sanity-run blueprints info`
 
@@ -213,7 +213,7 @@ EXAMPLES
   $ sanity-run blueprints info --stack-id <stackId>
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/info.ts)_
 
 ## `sanity-run blueprints init [DIR]`
 
@@ -252,7 +252,7 @@ EXAMPLES
   $ sanity-run blueprints init --blueprint-type <json|js|ts> --stack-name <stackName>
 ```
 
-_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/init.ts)_
+_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/init.ts)_
 
 ## `sanity-run blueprints logs`
 
@@ -274,7 +274,7 @@ EXAMPLES
   $ sanity-run blueprints logs --watch
 ```
 
-_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/logs.ts)_
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/logs.ts)_
 
 ## `sanity-run blueprints plan`
 
@@ -291,7 +291,7 @@ EXAMPLES
   $ sanity-run blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/plan.ts)_
 
 ## `sanity-run blueprints stacks`
 
@@ -316,7 +316,7 @@ EXAMPLES
   $ sanity-run blueprints stacks --organization-id <organizationId>
 ```
 
-_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/blueprints/stacks.ts)_
+_See code: [src/commands/blueprints/stacks.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/blueprints/stacks.ts)_
 
 ## `sanity-run functions add`
 
@@ -358,7 +358,7 @@ EXAMPLES
   $ sanity-run functions add --name my-function --type document-create --type document-update --lang js
 ```
 
-_See code: [src/commands/functions/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/add.ts)_
+_See code: [src/commands/functions/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/add.ts)_
 
 ## `sanity-run functions dev`
 
@@ -366,10 +366,11 @@ Start the Sanity Function emulator
 
 ```
 USAGE
-  $ sanity-run functions dev [-p <value>] [-t <value>]
+  $ sanity-run functions dev [-h <value>] [-p <value>] [-t <value>]
 
 FLAGS
-  -p, --port=<value>     Port to start emulator on
+  -h, --host=<value>     The local network interface at which to listen. [default: "localhost"]
+  -p, --port=<value>     TCP port to start emulator on. [default: 8080]
   -t, --timeout=<value>  Maximum execution time for all functions, in seconds. Takes precedence over function-specific
                          `timeout`
 
@@ -377,10 +378,10 @@ DESCRIPTION
   Start the Sanity Function emulator
 
 EXAMPLES
-  $ sanity-run functions dev --port 8974
+  $ sanity-run functions dev --host 127.0.0.1 --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/dev.ts)_
 
 ## `sanity-run functions env add NAME KEY VALUE`
 
@@ -402,7 +403,7 @@ EXAMPLES
   $ sanity-run functions env add MyFunction API_URL https://api.example.com/
 ```
 
-_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/env/add.ts)_
+_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/env/add.ts)_
 
 ## `sanity-run functions env list NAME`
 
@@ -422,7 +423,7 @@ EXAMPLES
   $ sanity-run functions env list MyFunction
 ```
 
-_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/env/list.ts)_
+_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/env/list.ts)_
 
 ## `sanity-run functions env remove NAME KEY`
 
@@ -443,7 +444,7 @@ EXAMPLES
   $ sanity-run functions env remove MyFunction API_URL
 ```
 
-_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/env/remove.ts)_
+_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/env/remove.ts)_
 
 ## `sanity-run functions logs NAME`
 
@@ -477,7 +478,7 @@ EXAMPLES
   $ sanity-run functions logs <name> --delete
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/logs.ts)_
 
 ## `sanity-run functions test NAME`
 
@@ -526,7 +527,7 @@ EXAMPLES
   $ sanity-run functions test <name> --event update --data-before '{ "title": "before" }' --data-after '{ "title": "after" }'
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.1/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v11.1.3/src/commands/functions/test.ts)_
 
 ## `sanity-run help [COMMAND]`
 

package/dist/actions/functions/dev.d.ts

@@ -1,2 +1,2 @@
 import type { InvokeExecutionOptions } from '../../utils/types.js';
-export declare function dev(port: number, executionOptions?: Partial<InvokeExecutionOptions>): Promise<void>;
+export declare function dev(host: string, port: number, executionOptions?: Partial<InvokeExecutionOptions>): Promise<void>;

package/dist/actions/functions/dev.js

@@ -1,4 +1,4 @@
 import { app } from '../../server/app.js';
-export async function dev(port, executionOptions) {
-    app(Number(port), executionOptions);
+export async function dev(host, port, executionOptions) {
+    app(host, Number(port), executionOptions);
 }

package/dist/commands/functions/dev.d.ts

@@ -3,6 +3,7 @@ export default class DevCommand extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        host: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         port: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/functions/dev.js

@@ -2,9 +2,18 @@ import { Command, Flags } from '@oclif/core';
 import { functionDevCore } from '../../cores/functions/dev.js';
 export default class DevCommand extends Command {
     static description = 'Start the Sanity Function emulator';
-    static examples = ['<%= config.bin %> <%= command.id %> --port 8974'];
+    static examples = ['<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974'];
     static flags = {
-        port: Flags.integer({ char: 'p', description: 'Port to start emulator on', required: false }),
+        host: Flags.string({
+            char: 'h',
+            description: 'The local network interface at which to listen. [default: "localhost"]',
+            required: false,
+        }),
+        port: Flags.integer({
+            char: 'p',
+            description: 'TCP port to start emulator on. [default: 8080]',
+            required: false,
+        }),
         timeout: Flags.integer({
             char: 't',
             description: 'Maximum execution time for all functions, in seconds. Takes precedence over function-specific `timeout`',

package/dist/cores/blueprints/init.d.ts

@@ -1,3 +1,4 @@
+import type { ScopeType } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintInitOptions extends CoreConfig {
     token: string;
@@ -15,3 +16,37 @@ export interface BlueprintInitOptions extends CoreConfig {
     };
 }
 export declare function blueprintInitCore(options: BlueprintInitOptions): Promise<CoreResult>;
+export declare function validateFlags(flags: {
+    stackId?: string;
+    stackName?: string;
+    organizationId?: string;
+    projectId?: string;
+}): CoreResult | null;
+interface ResolvedScope {
+    scopeType: ScopeType;
+    scopeId: string;
+    stackId: string | undefined;
+}
+export declare function resolveScopeAndStack(params: {
+    projectId: string | undefined;
+    organizationId: string | undefined;
+    stackId: string | undefined;
+    stackName: string | undefined;
+    token: string;
+    log: (message: string) => void;
+}): Promise<ResolvedScope>;
+export declare function determineBlueprintExtension(params: {
+    requestedType: string | undefined;
+    blueprintDir: string;
+}): Promise<string>;
+export declare function createBlueprintFiles(params: {
+    blueprintDir: string;
+    userProvidedDirName: string | undefined;
+    blueprintExtension: string;
+    scopeType: ScopeType;
+    scopeId: string;
+    stackId: string | undefined;
+    bin: string;
+    log: (message: string) => void;
+}): Promise<CoreResult>;
+export {};

package/dist/cores/blueprints/init.js

@@ -11,149 +11,60 @@ import { verifyExampleExists, writeExample } from '../../actions/sanity/examples
 import { getProject } from '../../actions/sanity/projects.js';
 import { BLUEPRINT_CONFIG_FILE, BLUEPRINT_DIR } from '../../config.js';
 import { check, warn } from '../../utils/display/presenters.js';
-import { promptForProject, promptForStackId } from '../../utils/display/prompt.js';
-const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
+import { promptForProject } from '../../utils/display/prompt.js';
+const SCOPE_PROJECT = 'project';
+const SCOPE_ORGANIZATION = 'organization';
 export async function blueprintInitCore(options) {
     const { bin = 'sanity', log, token, args, flags } = options;
     try {
-        const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 
-        // 'organization-id': flagOrganizationId,
-        'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
+        const { dir: flagDir, example: flagExample, 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
         const { dir: argDir } = args;
-        const providedDir = argDir || flagDir;
-        const blueprintDir = providedDir || '.';
+        const userProvidedDirName = argDir || flagDir;
+        const blueprintDir = userProvidedDirName || '.';
         const existingBlueprint = findBlueprintFile(blueprintDir);
         if (existingBlueprint) {
             return { success: false, error: 'Existing Blueprint found.' };
         }
+        const validationError = validateFlags({
+            stackId: flagStackId,
+            stackName: flagStackName,
+            organizationId: flagOrganizationId,
+            projectId: flagProjectId,
+        });
+        if (validationError)
+            return validationError;
         if (flagExample) {
-            // ! short circuit for examples
-            log(warn(`Example feature is experimental. Setting up "${flagExample}"...`));
-            // we need to...
-            // * 1. verify example exists in the recipes repo
-            const exampleExists = await verifyExampleExists({ type: 'blueprint', name: flagExample });
-            if (!exampleExists) {
-                return { success: false, error: `Blueprint example "${flagExample}" does not exist.` };
-            }
-            // * 2. get a projectId from the user
-            const projectId = flagProjectId || (await promptForProject({ token })).projectId;
-            // * 3. create empty stack with name from example name
-            const stack = await createEmptyStack({
-                token,
-                scopeType: 'project',
-                scopeId: projectId,
-                name: `example-${flagExample}`,
-                projectBased: false,
-            });
-            // * 4. download and write example to disk
-            // take into account optional providedDir
-            const exampleDir = join(blueprintDir, providedDir ? '' : flagExample);
-            if (existsSync(exampleDir)) {
-                return { success: false, error: `Example directory "${exampleDir}" already exists.` };
-            }
-            const addedExample = await writeExample({
-                exampleType: 'blueprint',
+            return handleExampleInitialization({
                 exampleName: flagExample,
-                dir: exampleDir,
-            });
-            if (!addedExample) {
-                return { success: false, error: `Unable to download example "${flagExample}"` };
-            }
-            const { files, dir: newDir, instructions } = addedExample;
-            for (const filePath of Object.keys(files)) {
-                log(check(`${chalk.bold('Created:')}    ${newDir}/${filePath}`));
-            }
-            const discoveredBlueprint = findBlueprintFile(exampleDir);
-            if (!discoveredBlueprint) {
-                return { success: false, error: 'Failed to find blueprint file.' };
-            }
-            const { blueprintFilePath } = discoveredBlueprint;
-            // * 5. write config file
-            writeConfigFile({ blueprintFilePath, projectId, stackId: stack.id });
-            log(check(`${chalk.bold('Configured:')} ${exampleDir}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
-            // * 6. print next step
-            log(`\n  Run "${chalk.bold.magenta(`cd ${exampleDir} && npm i`)}" and check out the README`);
-            if (instructions) {
-                log('');
-                log(instructions);
-            }
-            return { success: true };
-        }
-        let blueprintExtension = flagBlueprintType || (await promptForBlueprintType());
-        if (!blueprintExtension) {
-            return { success: false, error: 'Blueprint type is required.' };
-        }
-        if (blueprintExtension === 'js') {
-            const packageJsonPath = join(blueprintDir, 'package.json');
-            const packageExists = existsSync(packageJsonPath);
-            if (packageExists) {
-                // if package.json#type is not module, set blueprintExtension to mjs
-                try {
-                    const packageJson = readFileSync(packageJsonPath, 'utf8');
-                    const packageJsonObject = JSON.parse(packageJson);
-                    if (packageJsonObject.type !== 'module') {
-                        blueprintExtension = 'mjs';
-                    }
-                }
-                catch { } // not our concern
-            }
-        }
-        let projectId = flagProjectId;
-        let stackId = flagStackId;
-        if (!projectId) {
-            const pickedProject = await promptForProject({ token });
-            projectId = pickedProject.projectId;
-        }
-        log('');
-        if (flagStackName) {
-            // using --stack-name gets around "LAUNCH LIMIT: 1 Stack per Project"
-            const stack = await createEmptyStack({
+                projectId: flagProjectId,
+                blueprintDir,
+                userProvidedDirName,
                 token,
-                scopeType: 'project',
-                scopeId: projectId,
-                name: flagStackName,
-                projectBased: false,
+                log,
             });
-            stackId = stack.id;
-        }
-        if (!stackId) {
-            // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
-            if (LAUNCH_LIMIT_STACK_PER_PROJECT) {
-                await createProjectBasedStack({ token, scopeType: 'project', scopeId: projectId }, log);
-                // do not set stackId, to avoid saving it to the config file
-            }
-            else {
-                stackId = await promptForStackId({ projectId, token });
-            }
-        }
-        const blueprintFileName = `sanity.blueprint.${blueprintExtension}`;
-        const blueprintFilePath = join(blueprintDir, blueprintFileName);
-        writeBlueprintToDisk({ blueprintFilePath });
-        if (providedDir)
-            log(check(`${chalk.bold('New folder created:')}  ${providedDir}/`));
-        log(check(`${chalk.bold('Created Blueprint:')}   ${providedDir ?? '.'}/${blueprintFileName}`));
-        writeConfigFile({ blueprintFilePath, projectId, stackId });
-        log(check(`${chalk.bold('Added configuration:')} ${providedDir ?? '.'}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
-        writeGitignoreFile(blueprintFilePath);
-        log(check(`${chalk.bold('Added .gitignore:')}    ${providedDir ?? '.'}/.gitignore`));
-        if (blueprintExtension !== 'json') {
-            try {
-                // check for || create package.json and add @sanity/blueprints to dependencies
-                await writeOrUpdateNodeDependency(blueprintFilePath, '@sanity/blueprints');
-                log(check(`${chalk.bold('Added dependency:')}    @sanity/blueprints`));
-            }
-            catch {
-                log(warn('Unable to add @sanity/blueprints to your project.'));
-            }
         }
-        const nextStepParts = [];
-        if (providedDir)
-            nextStepParts.push(`cd ${providedDir}`);
-        if (blueprintExtension !== 'json')
-            nextStepParts.push('npm install');
-        nextStepParts.push(`${bin} blueprints --help`);
-        log(`\n  Run "${chalk.bold.magenta(nextStepParts.join(' && '))}" to get started`);
-        return { success: true };
+        const { scopeType, scopeId, stackId } = await resolveScopeAndStack({
+            projectId: flagProjectId,
+            organizationId: flagOrganizationId,
+            stackId: flagStackId,
+            stackName: flagStackName,
+            token,
+            log,
+        });
+        const blueprintExtension = await determineBlueprintExtension({
+            requestedType: flagBlueprintType,
+            blueprintDir,
+        });
+        return createBlueprintFiles({
+            blueprintDir,
+            userProvidedDirName,
+            blueprintExtension,
+            scopeType,
+            scopeId,
+            stackId,
+            bin,
+            log,
+        });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -161,6 +72,158 @@ export async function blueprintInitCore(options) {
         return { success: false, error: errorMessage };
     }
 }
+export function validateFlags(flags) {
+    const { stackId, stackName, organizationId, projectId } = flags;
+    if (stackId && stackName) {
+        return { success: false, error: 'Cannot specify both --stack-id and --stack-name' };
+    }
+    if (organizationId && projectId) {
+        return { success: false, error: 'Cannot specify both --organization-id and --project-id' };
+    }
+    return null;
+}
+async function handleExampleInitialization(options) {
+    const { exampleName, blueprintDir, userProvidedDirName, projectId, token, log } = options;
+    log(warn(`Example feature is experimental. Setting up "${exampleName}"...`));
+    const exampleExists = await verifyExampleExists({ type: 'blueprint', name: exampleName });
+    if (!exampleExists) {
+        return { success: false, error: `Blueprint example "${exampleName}" does not exist.` };
+    }
+    const resolvedProjectId = projectId || (await promptForProject({ token })).projectId;
+    const stack = await createEmptyStack({
+        token,
+        scopeType: SCOPE_PROJECT,
+        scopeId: resolvedProjectId,
+        name: `example-${exampleName}`,
+        projectBased: false,
+    });
+    const exampleDir = userProvidedDirName || join(blueprintDir, exampleName);
+    if (existsSync(exampleDir)) {
+        return { success: false, error: `Example directory "${exampleDir}" already exists.` };
+    }
+    const addedExample = await writeExample({
+        exampleType: 'blueprint',
+        exampleName,
+        dir: exampleDir,
+    });
+    if (!addedExample) {
+        return { success: false, error: `Unable to download example "${exampleName}"` };
+    }
+    const { files, dir: newDir, instructions } = addedExample;
+    for (const filePath of Object.keys(files)) {
+        log(check(`${chalk.bold('Created:')}    ${newDir}/${filePath}`));
+    }
+    const discoveredBlueprint = findBlueprintFile(exampleDir);
+    if (!discoveredBlueprint) {
+        return { success: false, error: 'Failed to find blueprint file.' };
+    }
+    const { blueprintFilePath } = discoveredBlueprint;
+    writeConfigFile({ blueprintFilePath, projectId: resolvedProjectId, stackId: stack.id });
+    log(check(`${chalk.bold('Configured:')} ${exampleDir}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
+    log(`\n  Run "${chalk.bold.magenta(`cd ${exampleDir} && npm i`)}" and check out the README`);
+    if (instructions) {
+        log('');
+        log(instructions);
+    }
+    return { success: true };
+}
+export async function resolveScopeAndStack(params) {
+    const { projectId, organizationId, stackId, stackName, token, log } = params;
+    let scopeType = SCOPE_PROJECT;
+    let scopeId;
+    if (projectId) {
+        scopeType = SCOPE_PROJECT;
+        scopeId = projectId;
+    }
+    else if (organizationId) {
+        scopeType = SCOPE_ORGANIZATION;
+        scopeId = organizationId;
+    }
+    let resolvedStackId = stackId;
+    if (!resolvedStackId && stackName && scopeType && scopeId) {
+        // essentially the only way to create an org-scoped stack
+        const stack = await createEmptyStack({
+            token,
+            scopeType,
+            scopeId,
+            name: stackName,
+            projectBased: false,
+        });
+        resolvedStackId = stack.id;
+    }
+    if (!scopeId) {
+        const pickedProject = await promptForProject({ token });
+        scopeType = SCOPE_PROJECT;
+        scopeId = pickedProject.projectId;
+    }
+    if (!resolvedStackId) {
+        await getOrCreateProjectBasedStack({ token, projectId: scopeId, log });
+    }
+    return {
+        scopeType,
+        scopeId,
+        stackId: resolvedStackId,
+    };
+}
+export async function determineBlueprintExtension(params) {
+    const { requestedType, blueprintDir } = params;
+    const extension = requestedType || (await promptForBlueprintType());
+    if (extension === 'js') {
+        const packageJsonPath = join(blueprintDir, 'package.json');
+        const packageExists = existsSync(packageJsonPath);
+        if (packageExists) {
+            try {
+                const packageJson = readFileSync(packageJsonPath, 'utf8');
+                const packageJsonObject = JSON.parse(packageJson);
+                if (packageJsonObject.type !== 'module') {
+                    return 'mjs';
+                }
+            }
+            catch { }
+        }
+    }
+    return extension;
+}
+export async function createBlueprintFiles(params) {
+    const { blueprintDir, userProvidedDirName, blueprintExtension, scopeType, scopeId, stackId, bin, log, } = params;
+    if (!blueprintExtension) {
+        return { success: false, error: 'Blueprint type is required.' };
+    }
+    const blueprintFileName = `sanity.blueprint.${blueprintExtension}`;
+    const blueprintFilePath = join(blueprintDir, blueprintFileName);
+    writeBlueprintToDisk({ blueprintFilePath });
+    if (userProvidedDirName) {
+        log(check(`${chalk.bold('New folder created:')}  ${userProvidedDirName}/`));
+    }
+    const displayPath = userProvidedDirName || '.';
+    log(check(`${chalk.bold('Created Blueprint:')}   ${displayPath}/${blueprintFileName}`));
+    writeConfigFile({
+        blueprintFilePath,
+        stackId,
+        ...(scopeType === SCOPE_ORGANIZATION ? { organizationId: scopeId } : { projectId: scopeId }),
+    });
+    log(check(`${chalk.bold('Added configuration:')} ${displayPath}/${BLUEPRINT_DIR}/${BLUEPRINT_CONFIG_FILE}`));
+    writeGitignoreFile(blueprintFilePath);
+    log(check(`${chalk.bold('Added .gitignore:')}    ${displayPath}/.gitignore`));
+    if (blueprintExtension !== 'json') {
+        const blueprintsPackage = '@sanity/blueprints';
+        try {
+            await writeOrUpdateNodeDependency(blueprintFilePath, blueprintsPackage);
+            log(check(`${chalk.bold('Added dependency:')}    ${blueprintsPackage}`));
+        }
+        catch {
+            log(warn(`Unable to add ${blueprintsPackage} to your project.`));
+        }
+    }
+    const nextStepParts = [];
+    if (userProvidedDirName)
+        nextStepParts.push(`cd ${userProvidedDirName}`);
+    if (blueprintExtension !== 'json')
+        nextStepParts.push('npm install');
+    nextStepParts.push(`${bin} blueprints --help`);
+    log(`\n  Run "${chalk.bold.magenta(nextStepParts.join(' && '))}" to get started`);
+    return { success: true };
+}
 async function promptForBlueprintType() {
     const { pickedBlueprintsType } = await inquirer.prompt([
         {
@@ -178,27 +241,24 @@ async function promptForBlueprintType() {
     return pickedBlueprintsType;
 }
 // LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
-async function createProjectBasedStack(auth, log) {
-    if (auth.scopeType !== 'project') {
-        throw new Error('Auth must be for a project');
-    }
-    const { scopeId: projectId, token } = auth;
-    // get project
+async function getOrCreateProjectBasedStack(params) {
+    const { projectId, token, log } = params;
     const { ok: projectOk, project } = await getProject({
-        token: auth.token,
-        scopeType: 'project',
+        token,
+        scopeType: SCOPE_PROJECT,
         scopeId: projectId,
     });
     if (!projectOk) {
         throw new Error('Failed to find Project while creating Stack');
     }
-    const projectDisplayName = project.displayName;
     // check if project has a stack
-    const inferredStackId = `ST-${projectId}`;
-    const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
+    const { stack: existingStack, ok: stackOk } = await getStack({
+        auth: { token, scopeType: SCOPE_PROJECT, scopeId: projectId },
+        stackId: `ST-${projectId}`,
+    });
     // if existing stack, return stack
     if (stackOk && existingStack) {
-        log(warn(`"${projectDisplayName}" has an existing deployment.`));
+        log(warn(`"${project.displayName}" has an existing deployment.`));
         log(warn(`Deploying an empty Blueprint ${chalk.bold.red('will override the existing deployment!')}`));
         log('');
         return existingStack;
@@ -206,9 +266,9 @@ async function createProjectBasedStack(auth, log) {
     // if not, create a stack
     const stack = await createEmptyStack({
         token,
-        scopeType: 'project',
+        scopeType: SCOPE_PROJECT,
         scopeId: projectId,
-        name: projectDisplayName,
+        name: project.displayName,
     });
     return stack;
 }

package/dist/cores/functions/dev.d.ts

@@ -1,6 +1,7 @@
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface FunctionDevOptions extends CoreConfig {
     flags: {
+        host?: string;
         port?: number;
         timeout?: number;
     };

package/dist/cores/functions/dev.js

@@ -1,14 +1,14 @@
 import { dev } from '../../actions/functions/dev.js';
 export async function functionDevCore(options) {
     const { log, flags } = options;
-    const { port = 8080, timeout } = flags;
+    const { host = 'localhost', port = 8080, timeout } = flags;
     // Construct execution options only if timeout is provided
     const executionOptions = timeout
         ? { timeout }
         : undefined;
     try {
-        await dev(Number(port), executionOptions);
-        log(`Server is running on http://localhost:${port}\n`);
+        await dev(host, Number(port), executionOptions);
+        log(`Server is running on http://${host}:${port}\n`);
         return {
             success: true,
             // hold the line...

package/dist/server/app.d.ts

@@ -1,5 +1,5 @@
 import { type InvokeExecutionOptions } from '../utils/types.js';
-declare const app: (port: number, executionOptions?: Partial<InvokeExecutionOptions>) => void;
+declare const app: (host: string, port: number, executionOptions?: Partial<InvokeExecutionOptions>) => void;
 declare function parseDocumentUrl(url: string): {
     projectId: string;
     dataset: string;

package/dist/server/app.js

@@ -7,8 +7,7 @@ import config from '../config.js';
 import { isRecord } from '../utils/is-record.js';
 import { isEventType, } from '../utils/types.js';
 import { handleInvokeRequest } from './handlers/invoke.js';
-const host = 'localhost';
-const app = (port, executionOptions) => {
+const app = (host, port, executionOptions) => {
     const requestListener = async (req, res) => {
         res.setHeader('Content-Type', 'application/json');
         switch (true) {

package/oclif.manifest.json

@@ -866,12 +866,21 @@
       "args": {},
       "description": "Start the Sanity Function emulator",
       "examples": [
-        "<%= config.bin %> <%= command.id %> --port 8974"
+        "<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974"
       ],
       "flags": {
+        "host": {
+          "char": "h",
+          "description": "The local network interface at which to listen. [default: \"localhost\"]",
+          "name": "host",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "port": {
           "char": "p",
-          "description": "Port to start emulator on",
+          "description": "TCP port to start emulator on. [default: 8080]",
           "name": "port",
           "required": false,
           "hasDynamicHelp": false,
@@ -1408,5 +1417,5 @@
       ]
     }
   },
-  "version": "11.1.1"
+  "version": "11.1.3"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "11.1.1",
+  "version": "11.1.3",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",