@sanity/cli 5.1.1-next.6 → 6.0.0-alpha.3

package/dist/util/migration/prettyMutationFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/migration/prettyMutationFormatter.ts"],"sourcesContent":["import {isatty} from 'node:tty'\n\nimport {convertToTree, formatTree, maxKeyLength} from '@sanity/cli-core/tree'\nimport {chalk} from '@sanity/cli-core/ux'\nimport {type Migration, type Mutation, type NodePatch, type Transaction} from '@sanity/migrate'\nimport {type KeyedSegment} from '@sanity/types'\n\ntype ItemRef = number | string\ntype Impact = 'destructive' | 'incremental' | 'maybeDestructive'\ntype Variant = 'info' | Impact\n\nconst isTty = isatty(1)\n\ninterface FormatterOptions<Subject> {\n  migration: Migration\n  subject: Subject\n\n  indentSize?: number\n}\n\nexport function prettyFormat({\n  indentSize = 0,\n  migration,\n  subject,\n}: FormatterOptions<(Mutation | Transaction)[] | Mutation | Transaction>): string {\n  return (Array.isArray(subject) ? subject : [subject])\n    .map((subjectEntry) => {\n      if (subjectEntry.type === 'transaction') {\n        return [\n          [\n            badge('transaction', 'info'),\n            subjectEntry.id === undefined ? null : chalk.underline(subjectEntry.id),\n          ]\n            .filter(Boolean)\n            .join(' '),\n          indent(\n            prettyFormat({\n              indentSize: indentSize,\n              migration,\n              subject: subjectEntry.mutations,\n            }),\n          ),\n        ].join('\\n\\n')\n      }\n      return prettyFormatMutation({\n        indentSize,\n        migration,\n        subject: subjectEntry,\n      })\n    })\n    .join('\\n\\n')\n}\n\nfunction encodeItemRef(ref: KeyedSegment | number): ItemRef {\n  return typeof ref === 'number' ? ref : ref._key\n}\n\nfunction badgeStyle(variant: Variant): typeof chalk {\n  const styles: Record<Variant, typeof chalk> = {\n    destructive: chalk.bgRed.black.bold,\n    incremental: chalk.bgGreen.black.bold,\n    info: chalk.bgWhite.black,\n    maybeDestructive: chalk.bgYellow.black.bold,\n  }\n\n  return styles[variant]\n}\n\nfunction badge(label: string, variant: Variant): string {\n  if (!isTty) {\n    return `[${label}]`\n  }\n\n  return badgeStyle(variant)(` ${label} `)\n}\n\nconst mutationImpact: Record<Mutation['type'], Impact> = {\n  create: 'incremental',\n  createIfNotExists: 'incremental',\n  createOrReplace: 'maybeDestructive',\n  delete: 'destructive',\n  patch: 'maybeDestructive',\n}\n\nfunction documentId(mutation: Mutation): string | undefined {\n  if ('id' in mutation) {\n    return mutation.id\n  }\n\n  if ('document' in mutation) {\n    return mutation.document._id\n  }\n\n  return undefined\n}\n\nconst listFormatter = new Intl.ListFormat('en-US', {\n  type: 'disjunction',\n})\n\nfunction mutationHeader(mutation: Mutation, migration: Migration): string {\n  const mutationType = badge(mutation.type, mutationImpact[mutation.type])\n\n  const documentType =\n    'document' in mutation || migration.documentTypes\n      ? badge(\n          'document' in mutation\n            ? mutation.document._type\n            : listFormatter.format(migration.documentTypes ?? []),\n          'info',\n        )\n      : null\n\n  // TODO: Should we list documentType when a mutation can be yielded for any document type?\n  return [mutationType, documentType, chalk.underline(documentId(mutation))]\n    .filter(Boolean)\n    .join(' ')\n}\n\nfunction prettyFormatMutation({\n  indentSize = 0,\n  migration,\n  subject,\n}: FormatterOptions<Mutation>): string {\n  const lock =\n    'options' in subject ? chalk.cyan(`(if revision==${subject.options?.ifRevision})`) : ''\n  const header = [mutationHeader(subject, migration), lock].join(' ')\n  const padding = ' '.repeat(indentSize)\n\n  if (\n    subject.type === 'create' ||\n    subject.type === 'createIfNotExists' ||\n    subject.type === 'createOrReplace'\n  ) {\n    return [header, '\\n', indent(JSON.stringify(subject.document, null, 2), indentSize)].join('')\n  }\n\n  if (subject.type === 'patch') {\n    const tree = convertToTree<NodePatch>(subject.patches.flat())\n    const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30)\n\n    return [\n      header,\n      '\\n',\n      formatTree<NodePatch>({\n        getMessage: (patch) => formatPatchMutation(patch),\n        indent: padding,\n        node: tree.children,\n        paddingLength,\n      }),\n    ].join('')\n  }\n\n  return header\n}\n\nfunction formatPatchMutation(patch: NodePatch): string {\n  const {op} = patch\n  const formattedType = chalk.bold(op.type)\n  if (op.type === 'unset') {\n    return `${chalk.red(formattedType)}()`\n  }\n  if (op.type === 'diffMatchPatch') {\n    return `${chalk.yellow(formattedType)}(${op.value})`\n  }\n  if (op.type === 'inc' || op.type === 'dec') {\n    return `${chalk.yellow(formattedType)}(${op.amount})`\n  }\n  if (op.type === 'set') {\n    return `${chalk.yellow(formattedType)}(${JSON.stringify(op.value)})`\n  }\n  if (op.type === 'setIfMissing') {\n    return `${chalk.green(formattedType)}(${JSON.stringify(op.value)})`\n  }\n  if (op.type === 'insert') {\n    return `${chalk.green(formattedType)}(${op.position}, ${encodeItemRef(\n      op.referenceItem,\n    )}, ${JSON.stringify(op.items)})`\n  }\n  if (op.type === 'replace') {\n    return `${chalk.yellow(formattedType)}(${encodeItemRef(op.referenceItem)}, ${JSON.stringify(\n      op.items,\n    )})`\n  }\n  if (op.type === 'truncate') {\n    return `${chalk.red(formattedType)}(${op.startIndex}, ${op.endIndex})`\n  }\n  // @ts-expect-error all cases are covered\n  throw new Error(`Invalid operation type: ${op.type}`)\n}\n\nfunction indent(subject: string, size = 2): string {\n  const padding = ' '.repeat(size)\n\n  return subject\n    .split('\\n')\n    .map((line) => padding + line)\n    .join('\\n')\n}\n"],"names":["isatty","convertToTree","formatTree","maxKeyLength","chalk","isTty","prettyFormat","indentSize","migration","subject","Array","isArray","map","subjectEntry","type","badge","id","undefined","underline","filter","Boolean","join","indent","mutations","prettyFormatMutation","encodeItemRef","ref","_key","badgeStyle","variant","styles","destructive","bgRed","black","bold","incremental","bgGreen","info","bgWhite","maybeDestructive","bgYellow","label","mutationImpact","create","createIfNotExists","createOrReplace","delete","patch","documentId","mutation","document","_id","listFormatter","Intl","ListFormat","mutationHeader","mutationType","documentType","documentTypes","_type","format","lock","cyan","options","ifRevision","header","padding","repeat","JSON","stringify","tree","patches","flat","paddingLength","Math","max","children","getMessage","formatPatchMutation","node","op","formattedType","red","yellow","value","amount","green","position","referenceItem","items","startIndex","endIndex","Error","size","split","line"],"mappings":"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"}

package/dist/util/moduleFormatUtils.d.ts

@@ -0,0 +1,3 @@
+import { type ChunkModule, type ChunkStats } from '../actions/build/buildStaticFiles.js';
+export declare function formatModuleSizes(modules: ChunkModule[]): string;
+export declare function sortModulesBySize(chunks: ChunkStats[]): ChunkModule[];

package/dist/util/moduleFormatUtils.js

@@ -0,0 +1,18 @@
+import { formatSize } from './formatSize.js';
+export function formatModuleSizes(modules) {
+    const lines = [];
+    for (const mod of modules){
+        lines.push(` - ${formatModuleName(mod.name)} (${formatSize(mod.renderedLength)})`);
+    }
+    return lines.join('\n');
+}
+function formatModuleName(modName) {
+    const delimiter = '/node_modules/';
+    const nodeIndex = modName.lastIndexOf(delimiter);
+    return nodeIndex === -1 ? modName : modName.slice(nodeIndex + delimiter.length);
+}
+export function sortModulesBySize(chunks) {
+    return chunks.flatMap((chunk)=>chunk.modules).toSorted((modA, modB)=>modB.renderedLength - modA.renderedLength);
+}
+
+//# sourceMappingURL=moduleFormatUtils.js.map

package/dist/util/moduleFormatUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/moduleFormatUtils.ts"],"sourcesContent":["import {type ChunkModule, type ChunkStats} from '../actions/build/buildStaticFiles.js'\nimport {formatSize} from './formatSize.js'\n\nexport function formatModuleSizes(modules: ChunkModule[]): string {\n  const lines: string[] = []\n  for (const mod of modules) {\n    lines.push(` - ${formatModuleName(mod.name)} (${formatSize(mod.renderedLength)})`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction formatModuleName(modName: string): string {\n  const delimiter = '/node_modules/'\n  const nodeIndex = modName.lastIndexOf(delimiter)\n  return nodeIndex === -1 ? modName : modName.slice(nodeIndex + delimiter.length)\n}\n\nexport function sortModulesBySize(chunks: ChunkStats[]): ChunkModule[] {\n  return chunks\n    .flatMap((chunk) => chunk.modules)\n    .toSorted((modA, modB) => modB.renderedLength - modA.renderedLength)\n}\n"],"names":["formatSize","formatModuleSizes","modules","lines","mod","push","formatModuleName","name","renderedLength","join","modName","delimiter","nodeIndex","lastIndexOf","slice","length","sortModulesBySize","chunks","flatMap","chunk","toSorted","modA","modB"],"mappings":"AACA,SAAQA,UAAU,QAAO,kBAAiB;AAE1C,OAAO,SAASC,kBAAkBC,OAAsB;IACtD,MAAMC,QAAkB,EAAE;IAC1B,KAAK,MAAMC,OAAOF,QAAS;QACzBC,MAAME,IAAI,CAAC,CAAC,GAAG,EAAEC,iBAAiBF,IAAIG,IAAI,EAAE,EAAE,EAAEP,WAAWI,IAAII,cAAc,EAAE,CAAC,CAAC;IACnF;IAEA,OAAOL,MAAMM,IAAI,CAAC;AACpB;AAEA,SAASH,iBAAiBI,OAAe;IACvC,MAAMC,YAAY;IAClB,MAAMC,YAAYF,QAAQG,WAAW,CAACF;IACtC,OAAOC,cAAc,CAAC,IAAIF,UAAUA,QAAQI,KAAK,CAACF,YAAYD,UAAUI,MAAM;AAChF;AAEA,OAAO,SAASC,kBAAkBC,MAAoB;IACpD,OAAOA,OACJC,OAAO,CAAC,CAACC,QAAUA,MAAMjB,OAAO,EAChCkB,QAAQ,CAAC,CAACC,MAAMC,OAASA,KAAKd,cAAc,GAAGa,KAAKb,cAAc;AACvE"}

package/dist/util/packageManager/__tests__/installPackages.test.js

@@ -0,0 +1,388 @@
+import { spinner } from '@sanity/cli-core/ux';
+import { execa } from 'execa';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { installDeclaredPackages, installNewPackages } from '../installPackages.js';
+import { getPartialEnvWithNpmPath } from '../packageManagerChoice.js';
+// Mock external dependencies
+vi.mock('execa', ()=>({
+        execa: vi.fn()
+    }));
+vi.mock('../packageManagerChoice.js', ()=>({
+        getPartialEnvWithNpmPath: vi.fn()
+    }));
+vi.mock('@sanity/cli-core/ux', async ()=>{
+    const actual = await vi.importActual('@sanity/cli-core/ux');
+    return {
+        ...actual,
+        spinner: vi.fn(()=>({
+                fail: vi.fn().mockReturnThis(),
+                start: vi.fn().mockReturnThis(),
+                succeed: vi.fn().mockReturnThis()
+            }))
+    };
+});
+const mockExeca = vi.mocked(execa);
+const mockSpinner = vi.mocked(spinner);
+const mockGetPartialEnvWithNpmPath = vi.mocked(getPartialEnvWithNpmPath);
+const mockOutput = {
+    error: vi.fn(),
+    log: vi.fn(),
+    warn: vi.fn()
+};
+const mockSpinnerInstance = {
+    fail: vi.fn().mockReturnThis(),
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis()
+};
+beforeEach(()=>{
+    vi.clearAllMocks();
+    mockGetPartialEnvWithNpmPath.mockReturnValue({
+        PATH: '/mock/path'
+    });
+    mockSpinner.mockReturnValue(mockSpinnerInstance);
+});
+describe('installDeclaredPackages', ()=>{
+    const workDir = '/test/project';
+    const context = {
+        output: mockOutput,
+        workDir
+    };
+    test('installs with npm successfully', async ()=>{
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installDeclaredPackages(workDir, 'npm', context);
+        expect(execa).toHaveBeenCalledWith('npm', [
+            'install'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.start).toHaveBeenCalled();
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+        expect(mockSpinnerInstance.fail).not.toHaveBeenCalled();
+    });
+    test('installs with yarn successfully', async ()=>{
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installDeclaredPackages(workDir, 'yarn', context);
+        expect(execa).toHaveBeenCalledWith('yarn', [
+            'install'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('installs with pnpm successfully', async ()=>{
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installDeclaredPackages(workDir, 'pnpm', context);
+        expect(execa).toHaveBeenCalledWith('pnpm', [
+            'install'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('installs with bun successfully', async ()=>{
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installDeclaredPackages(workDir, 'bun', context);
+        expect(execa).toHaveBeenCalledWith('bun', [
+            'install'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('handles manual package manager', async ()=>{
+        await installDeclaredPackages(workDir, 'manual', context);
+        expect(execa).not.toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith("Manual installation selected — run 'npm install' or equivalent");
+    });
+    test('handles installation failure with exit code', async ()=>{
+        const mockResult = {
+            exitCode: 1,
+            failed: true,
+            stdout: 'Error: Package not found'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await expect(installDeclaredPackages(workDir, 'npm', context));
+        expect(mockSpinnerInstance.fail).toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith('Error: Package not found');
+        expect(mockOutput.error).toHaveBeenCalledWith('Dependency installation failed', {
+            exit: 1
+        });
+    });
+    test('handles installation failure with failed flag', async ()=>{
+        const mockResult = {
+            exitCode: 0,
+            failed: true,
+            stdout: 'Command failed'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await expect(installDeclaredPackages(workDir, 'npm', context));
+        expect(mockSpinnerInstance.fail).toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith('Command failed');
+        expect(mockOutput.error).toHaveBeenCalledWith('Dependency installation failed', {
+            exit: 1
+        });
+    });
+});
+describe('installNewPackages', ()=>{
+    const workDir = '/test/project';
+    const context = {
+        output: mockOutput,
+        workDir
+    };
+    test('installs single package with npm successfully', async ()=>{
+        const options = {
+            packageManager: 'npm',
+            packages: [
+                '@sanity/vision'
+            ]
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installNewPackages(options, context);
+        expect(execa).toHaveBeenCalledWith('npm', [
+            'install',
+            '--save',
+            '@sanity/vision'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.start).toHaveBeenCalled();
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('installs multiple packages with yarn successfully', async ()=>{
+        const options = {
+            packageManager: 'yarn',
+            packages: [
+                '@sanity/vision',
+                'react-icons'
+            ]
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installNewPackages(options, context);
+        expect(execa).toHaveBeenCalledWith('yarn', [
+            'add',
+            '@sanity/vision',
+            'react-icons'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('installs packages with pnpm successfully', async ()=>{
+        const options = {
+            packageManager: 'pnpm',
+            packages: [
+                'lodash'
+            ]
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installNewPackages(options, context);
+        expect(execa).toHaveBeenCalledWith('pnpm', [
+            'add',
+            '--save-prod',
+            'lodash'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('installs packages with bun successfully', async ()=>{
+        const options = {
+            packageManager: 'bun',
+            packages: [
+                'express'
+            ]
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Installation successful'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installNewPackages(options, context);
+        expect(execa).toHaveBeenCalledWith('bun', [
+            'add',
+            'express'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('handles manual package manager for new packages', async ()=>{
+        const options = {
+            packageManager: 'manual',
+            packages: [
+                'some-package'
+            ]
+        };
+        await installNewPackages(options, context);
+        expect(execa).not.toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith("Manual installation selected - run 'npm install --save some-package' or equivalent");
+    });
+    test('handles installation failure with error output', async ()=>{
+        const options = {
+            packageManager: 'npm',
+            packages: [
+                'nonexistent-package'
+            ]
+        };
+        const mockResult = {
+            exitCode: 1,
+            failed: true,
+            stdout: 'Error: Package not found'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await expect(installNewPackages(options, context));
+        expect(mockSpinnerInstance.fail).toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith('Error: Package not found');
+        expect(mockOutput.error).toHaveBeenCalledWith('Package installation failed', {
+            exit: 1
+        });
+    });
+    test('handles installation failure with failed flag', async ()=>{
+        const options = {
+            packageManager: 'pnpm',
+            packages: [
+                'failing-package'
+            ]
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: true,
+            stdout: 'Command execution failed'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await expect(installNewPackages(options, context));
+        expect(mockSpinnerInstance.fail).toHaveBeenCalled();
+        expect(mockOutput.log).toHaveBeenCalledWith('Command execution failed');
+        expect(mockOutput.error).toHaveBeenCalledWith('Package installation failed', {
+            exit: 1
+        });
+    });
+    test('handles empty packages array', async ()=>{
+        const options = {
+            packageManager: 'npm',
+            packages: []
+        };
+        const mockResult = {
+            exitCode: 0,
+            failed: false,
+            stdout: 'Nothing to install'
+        };
+        mockExeca.mockResolvedValueOnce(mockResult);
+        await installNewPackages(options, context);
+        expect(execa).toHaveBeenCalledWith('npm', [
+            'install',
+            '--save'
+        ], {
+            cwd: workDir,
+            encoding: 'utf8',
+            env: {
+                PATH: '/mock/path'
+            },
+            stdio: 'pipe'
+        });
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+});
+describe('error handling edge cases', ()=>{
+    const workDir = '/test/project';
+    const context = {
+        output: mockOutput,
+        workDir
+    };
+    test('handles undefined result in installDeclaredPackages', async ()=>{
+        mockExeca.mockResolvedValueOnce(undefined);
+        await installDeclaredPackages(workDir, 'npm', context);
+        // Should not throw if result is undefined and no error conditions
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+    test('handles undefined result in installNewPackages', async ()=>{
+        const options = {
+            packageManager: 'npm',
+            packages: [
+                'test'
+            ]
+        };
+        mockExeca.mockResolvedValueOnce(undefined);
+        await installNewPackages(options, context);
+        // Should not throw if result is undefined and no error conditions
+        expect(mockSpinnerInstance.succeed).toHaveBeenCalled();
+    });
+});
+
+//# sourceMappingURL=installPackages.test.js.map

package/dist/util/packageManager/__tests__/installPackages.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/__tests__/installPackages.test.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport {execa, type Result} from 'execa'\nimport {beforeEach, describe, expect, test, vi} from 'vitest'\n\nimport {installDeclaredPackages, installNewPackages} from '../installPackages.js'\nimport {getPartialEnvWithNpmPath} from '../packageManagerChoice.js'\n\n// Mock external dependencies\nvi.mock('execa', () => ({\n  execa: vi.fn(),\n}))\n\nvi.mock('../packageManagerChoice.js', () => ({\n  getPartialEnvWithNpmPath: vi.fn(),\n}))\n\nvi.mock('@sanity/cli-core/ux', async () => {\n  const actual = await vi.importActual<typeof import('@sanity/cli-core/ux')>('@sanity/cli-core/ux')\n  return {\n    ...actual,\n    spinner: vi.fn(() => ({\n      fail: vi.fn().mockReturnThis(),\n      start: vi.fn().mockReturnThis(),\n      succeed: vi.fn().mockReturnThis(),\n    })),\n  }\n})\n\nconst mockExeca = vi.mocked(execa)\nconst mockSpinner = vi.mocked(spinner)\nconst mockGetPartialEnvWithNpmPath = vi.mocked(getPartialEnvWithNpmPath)\n\nconst mockOutput: Output = {\n  error: vi.fn() as never,\n  log: vi.fn(),\n  warn: vi.fn(),\n}\n\nconst mockSpinnerInstance = {\n  fail: vi.fn().mockReturnThis(),\n  start: vi.fn().mockReturnThis(),\n  succeed: vi.fn().mockReturnThis(),\n}\n\nbeforeEach(() => {\n  vi.clearAllMocks()\n  mockGetPartialEnvWithNpmPath.mockReturnValue({PATH: '/mock/path'})\n  mockSpinner.mockReturnValue(mockSpinnerInstance as never)\n})\n\ndescribe('installDeclaredPackages', () => {\n  const workDir = '/test/project'\n  const context = {output: mockOutput, workDir}\n\n  test('installs with npm successfully', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installDeclaredPackages(workDir, 'npm', context)\n\n    expect(execa).toHaveBeenCalledWith('npm', ['install'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.start).toHaveBeenCalled()\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n    expect(mockSpinnerInstance.fail).not.toHaveBeenCalled()\n  })\n\n  test('installs with yarn successfully', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installDeclaredPackages(workDir, 'yarn', context)\n\n    expect(execa).toHaveBeenCalledWith('yarn', ['install'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('installs with pnpm successfully', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installDeclaredPackages(workDir, 'pnpm', context)\n\n    expect(execa).toHaveBeenCalledWith('pnpm', ['install'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('installs with bun successfully', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installDeclaredPackages(workDir, 'bun', context)\n\n    expect(execa).toHaveBeenCalledWith('bun', ['install'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('handles manual package manager', async () => {\n    await installDeclaredPackages(workDir, 'manual', context)\n\n    expect(execa).not.toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith(\n      \"Manual installation selected — run 'npm install' or equivalent\",\n    )\n  })\n\n  test('handles installation failure with exit code', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 1,\n      failed: true,\n      stdout: 'Error: Package not found',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await expect(installDeclaredPackages(workDir, 'npm', context))\n\n    expect(mockSpinnerInstance.fail).toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith('Error: Package not found')\n    expect(mockOutput.error).toHaveBeenCalledWith('Dependency installation failed', {exit: 1})\n  })\n\n  test('handles installation failure with failed flag', async () => {\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: true,\n      stdout: 'Command failed',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await expect(installDeclaredPackages(workDir, 'npm', context))\n\n    expect(mockSpinnerInstance.fail).toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith('Command failed')\n    expect(mockOutput.error).toHaveBeenCalledWith('Dependency installation failed', {exit: 1})\n  })\n})\n\ndescribe('installNewPackages', () => {\n  const workDir = '/test/project'\n  const context = {output: mockOutput, workDir}\n\n  test('installs single package with npm successfully', async () => {\n    const options = {packageManager: 'npm' as const, packages: ['@sanity/vision']}\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installNewPackages(options, context)\n\n    expect(execa).toHaveBeenCalledWith('npm', ['install', '--save', '@sanity/vision'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.start).toHaveBeenCalled()\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('installs multiple packages with yarn successfully', async () => {\n    const options = {\n      packageManager: 'yarn' as const,\n      packages: ['@sanity/vision', 'react-icons'],\n    }\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installNewPackages(options, context)\n\n    expect(execa).toHaveBeenCalledWith('yarn', ['add', '@sanity/vision', 'react-icons'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('installs packages with pnpm successfully', async () => {\n    const options = {packageManager: 'pnpm' as const, packages: ['lodash']}\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installNewPackages(options, context)\n\n    expect(execa).toHaveBeenCalledWith('pnpm', ['add', '--save-prod', 'lodash'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('installs packages with bun successfully', async () => {\n    const options = {packageManager: 'bun' as const, packages: ['express']}\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Installation successful',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installNewPackages(options, context)\n\n    expect(execa).toHaveBeenCalledWith('bun', ['add', 'express'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('handles manual package manager for new packages', async () => {\n    const options = {packageManager: 'manual' as const, packages: ['some-package']}\n\n    await installNewPackages(options, context)\n\n    expect(execa).not.toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith(\n      \"Manual installation selected - run 'npm install --save some-package' or equivalent\",\n    )\n  })\n\n  test('handles installation failure with error output', async () => {\n    const options = {packageManager: 'npm' as const, packages: ['nonexistent-package']}\n    const mockResult: Partial<Result> = {\n      exitCode: 1,\n      failed: true,\n      stdout: 'Error: Package not found',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await expect(installNewPackages(options, context))\n\n    expect(mockSpinnerInstance.fail).toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith('Error: Package not found')\n    expect(mockOutput.error).toHaveBeenCalledWith('Package installation failed', {exit: 1})\n  })\n\n  test('handles installation failure with failed flag', async () => {\n    const options = {packageManager: 'pnpm' as const, packages: ['failing-package']}\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: true,\n      stdout: 'Command execution failed',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await expect(installNewPackages(options, context))\n\n    expect(mockSpinnerInstance.fail).toHaveBeenCalled()\n    expect(mockOutput.log).toHaveBeenCalledWith('Command execution failed')\n    expect(mockOutput.error).toHaveBeenCalledWith('Package installation failed', {exit: 1})\n  })\n\n  test('handles empty packages array', async () => {\n    const options = {packageManager: 'npm' as const, packages: []}\n    const mockResult: Partial<Result> = {\n      exitCode: 0,\n      failed: false,\n      stdout: 'Nothing to install',\n    }\n    mockExeca.mockResolvedValueOnce(mockResult as Result)\n\n    await installNewPackages(options, context)\n\n    expect(execa).toHaveBeenCalledWith('npm', ['install', '--save'], {\n      cwd: workDir,\n      encoding: 'utf8',\n      env: {PATH: '/mock/path'},\n      stdio: 'pipe',\n    })\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n})\n\ndescribe('error handling edge cases', () => {\n  const workDir = '/test/project'\n  const context = {output: mockOutput, workDir}\n\n  test('handles undefined result in installDeclaredPackages', async () => {\n    mockExeca.mockResolvedValueOnce(undefined as unknown as Result)\n\n    await installDeclaredPackages(workDir, 'npm', context)\n\n    // Should not throw if result is undefined and no error conditions\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n\n  test('handles undefined result in installNewPackages', async () => {\n    const options = {packageManager: 'npm' as const, packages: ['test']}\n    mockExeca.mockResolvedValueOnce(undefined as unknown as Result)\n\n    await installNewPackages(options, context)\n\n    // Should not throw if result is undefined and no error conditions\n    expect(mockSpinnerInstance.succeed).toHaveBeenCalled()\n  })\n})\n"],"names":["spinner","execa","beforeEach","describe","expect","test","vi","installDeclaredPackages","installNewPackages","getPartialEnvWithNpmPath","mock","fn","actual","importActual","fail","mockReturnThis","start","succeed","mockExeca","mocked","mockSpinner","mockGetPartialEnvWithNpmPath","mockOutput","error","log","warn","mockSpinnerInstance","clearAllMocks","mockReturnValue","PATH","workDir","context","output","mockResult","exitCode","failed","stdout","mockResolvedValueOnce","toHaveBeenCalledWith","cwd","encoding","env","stdio","toHaveBeenCalled","not","exit","options","packageManager","packages","undefined"],"mappings":"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"}

package/dist/util/packageManager/installPackages.d.ts

@@ -0,0 +1,18 @@
+import { type Output } from '@sanity/cli-core';
+import { type PackageManager } from './packageManagerChoice.js';
+/**
+ * @internal
+ */
+interface InstallOptions {
+    packageManager: PackageManager;
+    packages: string[];
+}
+export declare function installDeclaredPackages(cwd: string, packageManager: PackageManager, context: {
+    output: Output;
+    workDir: string;
+}): Promise<void>;
+export declare function installNewPackages(options: InstallOptions, context: {
+    output: Output;
+    workDir: string;
+}): Promise<void>;
+export {};

package/dist/util/packageManager/installPackages.js

@@ -0,0 +1,87 @@
+import { spinner } from '@sanity/cli-core/ux';
+import { execa } from 'execa';
+import { getPartialEnvWithNpmPath } from './packageManagerChoice.js';
+const PACKAGE_MANAGER_COMMANDS = {
+    add: {
+        bun: (packages)=>[
+                'add',
+                ...packages
+            ],
+        npm: (packages)=>[
+                'install',
+                '--save',
+                ...packages
+            ],
+        pnpm: (packages)=>[
+                'add',
+                '--save-prod',
+                ...packages
+            ],
+        yarn: (packages)=>[
+                'add',
+                ...packages
+            ]
+    },
+    install: {
+        bun: [
+            'install'
+        ],
+        npm: [
+            'install'
+        ],
+        pnpm: [
+            'install'
+        ],
+        yarn: [
+            'install'
+        ]
+    }
+};
+async function executePackageManagerCommand(packageManager, args, execOptions, output, errorMessage) {
+    const progress = spinner(`Running ${packageManager} ${args.join(' ')}\n`).start();
+    const result = await execa(packageManager, args, execOptions);
+    if (result?.exitCode || result?.failed) {
+        progress.fail();
+        output.log(String(result.stdout));
+        output.error(errorMessage, {
+            exit: 1
+        });
+    } else {
+        progress.succeed();
+    }
+}
+export async function installDeclaredPackages(cwd, packageManager, context) {
+    const { output } = context;
+    const execOptions = {
+        cwd,
+        encoding: 'utf8',
+        env: getPartialEnvWithNpmPath(cwd),
+        stdio: 'pipe'
+    };
+    if (packageManager === 'manual') {
+        const npmCommand = PACKAGE_MANAGER_COMMANDS.install.npm;
+        output.log(`Manual installation selected — run 'npm ${npmCommand.join(' ')}' or equivalent`);
+    } else {
+        const args = PACKAGE_MANAGER_COMMANDS.install[packageManager];
+        await executePackageManagerCommand(packageManager, args, execOptions, output, 'Dependency installation failed');
+    }
+}
+export async function installNewPackages(options, context) {
+    const { packageManager, packages } = options;
+    const { output, workDir } = context;
+    const execOptions = {
+        cwd: workDir,
+        encoding: 'utf8',
+        env: getPartialEnvWithNpmPath(workDir),
+        stdio: 'pipe'
+    };
+    if (packageManager === 'manual') {
+        const npmCommand = PACKAGE_MANAGER_COMMANDS.add.npm(packages);
+        output.log(`Manual installation selected - run 'npm ${npmCommand.join(' ')}' or equivalent`);
+    } else {
+        const args = PACKAGE_MANAGER_COMMANDS.add[packageManager](packages);
+        await executePackageManagerCommand(packageManager, args, execOptions, output, 'Package installation failed');
+    }
+}
+
+//# sourceMappingURL=installPackages.js.map

package/dist/util/packageManager/installPackages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/packageManager/installPackages.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport {execa, type Options} from 'execa'\n\nimport {getPartialEnvWithNpmPath, type PackageManager} from './packageManagerChoice.js'\n\ntype PackageManagerLibs = Exclude<PackageManager, 'manual'>\n\n/**\n * @internal\n */\ninterface InstallOptions {\n  packageManager: PackageManager\n  packages: string[]\n}\n\ninterface PackageManagerCommands {\n  add: {[key in PackageManagerLibs]: (packages: string[]) => string[]}\n  install: {[key in PackageManagerLibs]: string[]}\n}\n\nconst PACKAGE_MANAGER_COMMANDS: PackageManagerCommands = {\n  add: {\n    bun: (packages) => ['add', ...packages],\n    npm: (packages) => ['install', '--save', ...packages],\n    pnpm: (packages) => ['add', '--save-prod', ...packages],\n    yarn: (packages) => ['add', ...packages],\n  },\n  install: {\n    bun: ['install'],\n    npm: ['install'],\n    pnpm: ['install'],\n    yarn: ['install'],\n  },\n}\n\nasync function executePackageManagerCommand(\n  packageManager: PackageManagerLibs,\n  args: string[],\n  execOptions: Options,\n  output: Output,\n  errorMessage: string,\n): Promise<void> {\n  const progress = spinner(`Running ${packageManager} ${args.join(' ')}\\n`).start()\n\n  const result = await execa(packageManager, args, execOptions)\n\n  if (result?.exitCode || result?.failed) {\n    progress.fail()\n    output.log(String(result.stdout))\n    output.error(errorMessage, {exit: 1})\n  } else {\n    progress.succeed()\n  }\n}\n\nexport async function installDeclaredPackages(\n  cwd: string,\n  packageManager: PackageManager,\n  context: {output: Output; workDir: string},\n): Promise<void> {\n  const {output} = context\n  const execOptions: Options = {\n    cwd,\n    encoding: 'utf8',\n    env: getPartialEnvWithNpmPath(cwd),\n    stdio: 'pipe',\n  }\n\n  if (packageManager === 'manual') {\n    const npmCommand = PACKAGE_MANAGER_COMMANDS.install.npm\n    output.log(`Manual installation selected — run 'npm ${npmCommand.join(' ')}' or equivalent`)\n  } else {\n    const args = PACKAGE_MANAGER_COMMANDS.install[packageManager]\n    await executePackageManagerCommand(\n      packageManager,\n      args,\n      execOptions,\n      output,\n      'Dependency installation failed',\n    )\n  }\n}\n\nexport async function installNewPackages(\n  options: InstallOptions,\n  context: {output: Output; workDir: string},\n): Promise<void> {\n  const {packageManager, packages} = options\n  const {output, workDir} = context\n  const execOptions: Options = {\n    cwd: workDir,\n    encoding: 'utf8',\n    env: getPartialEnvWithNpmPath(workDir),\n    stdio: 'pipe',\n  }\n\n  if (packageManager === 'manual') {\n    const npmCommand = PACKAGE_MANAGER_COMMANDS.add.npm(packages)\n    output.log(`Manual installation selected - run 'npm ${npmCommand.join(' ')}' or equivalent`)\n  } else {\n    const args = PACKAGE_MANAGER_COMMANDS.add[packageManager](packages)\n    await executePackageManagerCommand(\n      packageManager,\n      args,\n      execOptions,\n      output,\n      'Package installation failed',\n    )\n  }\n}\n"],"names":["spinner","execa","getPartialEnvWithNpmPath","PACKAGE_MANAGER_COMMANDS","add","bun","packages","npm","pnpm","yarn","install","executePackageManagerCommand","packageManager","args","execOptions","output","errorMessage","progress","join","start","result","exitCode","failed","fail","log","String","stdout","error","exit","succeed","installDeclaredPackages","cwd","context","encoding","env","stdio","npmCommand","installNewPackages","options","workDir"],"mappings":"AACA,SAAQA,OAAO,QAAO,sBAAqB;AAC3C,SAAQC,KAAK,QAAqB,QAAO;AAEzC,SAAQC,wBAAwB,QAA4B,4BAA2B;AAiBvF,MAAMC,2BAAmD;IACvDC,KAAK;QACHC,KAAK,CAACC,WAAa;gBAAC;mBAAUA;aAAS;QACvCC,KAAK,CAACD,WAAa;gBAAC;gBAAW;mBAAaA;aAAS;QACrDE,MAAM,CAACF,WAAa;gBAAC;gBAAO;mBAAkBA;aAAS;QACvDG,MAAM,CAACH,WAAa;gBAAC;mBAAUA;aAAS;IAC1C;IACAI,SAAS;QACPL,KAAK;YAAC;SAAU;QAChBE,KAAK;YAAC;SAAU;QAChBC,MAAM;YAAC;SAAU;QACjBC,MAAM;YAAC;SAAU;IACnB;AACF;AAEA,eAAeE,6BACbC,cAAkC,EAClCC,IAAc,EACdC,WAAoB,EACpBC,MAAc,EACdC,YAAoB;IAEpB,MAAMC,WAAWjB,QAAQ,CAAC,QAAQ,EAAEY,eAAe,CAAC,EAAEC,KAAKK,IAAI,CAAC,KAAK,EAAE,CAAC,EAAEC,KAAK;IAE/E,MAAMC,SAAS,MAAMnB,MAAMW,gBAAgBC,MAAMC;IAEjD,IAAIM,QAAQC,YAAYD,QAAQE,QAAQ;QACtCL,SAASM,IAAI;QACbR,OAAOS,GAAG,CAACC,OAAOL,OAAOM,MAAM;QAC/BX,OAAOY,KAAK,CAACX,cAAc;YAACY,MAAM;QAAC;IACrC,OAAO;QACLX,SAASY,OAAO;IAClB;AACF;AAEA,OAAO,eAAeC,wBACpBC,GAAW,EACXnB,cAA8B,EAC9BoB,OAA0C;IAE1C,MAAM,EAACjB,MAAM,EAAC,GAAGiB;IACjB,MAAMlB,cAAuB;QAC3BiB;QACAE,UAAU;QACVC,KAAKhC,yBAAyB6B;QAC9BI,OAAO;IACT;IAEA,IAAIvB,mBAAmB,UAAU;QAC/B,MAAMwB,aAAajC,yBAAyBO,OAAO,CAACH,GAAG;QACvDQ,OAAOS,GAAG,CAAC,CAAC,wCAAwC,EAAEY,WAAWlB,IAAI,CAAC,KAAK,eAAe,CAAC;IAC7F,OAAO;QACL,MAAML,OAAOV,yBAAyBO,OAAO,CAACE,eAAe;QAC7D,MAAMD,6BACJC,gBACAC,MACAC,aACAC,QACA;IAEJ;AACF;AAEA,OAAO,eAAesB,mBACpBC,OAAuB,EACvBN,OAA0C;IAE1C,MAAM,EAACpB,cAAc,EAAEN,QAAQ,EAAC,GAAGgC;IACnC,MAAM,EAACvB,MAAM,EAAEwB,OAAO,EAAC,GAAGP;IAC1B,MAAMlB,cAAuB;QAC3BiB,KAAKQ;QACLN,UAAU;QACVC,KAAKhC,yBAAyBqC;QAC9BJ,OAAO;IACT;IAEA,IAAIvB,mBAAmB,UAAU;QAC/B,MAAMwB,aAAajC,yBAAyBC,GAAG,CAACG,GAAG,CAACD;QACpDS,OAAOS,GAAG,CAAC,CAAC,wCAAwC,EAAEY,WAAWlB,IAAI,CAAC,KAAK,eAAe,CAAC;IAC7F,OAAO;QACL,MAAML,OAAOV,yBAAyBC,GAAG,CAACQ,eAAe,CAACN;QAC1D,MAAMK,6BACJC,gBACAC,MACAC,aACAC,QACA;IAEJ;AACF"}

package/dist/util/packageManager/packageManagerChoice.d.ts

@@ -0,0 +1,29 @@
+export type PackageManager = 'bun' | 'manual' | 'npm' | 'pnpm' | 'yarn';
+/**
+ * Attempts to resolve the most optimal package manager to use to install/upgrade
+ * packages/dependencies at a given path. It does so by looking for package manager
+ * specific lockfiles. If it finds a lockfile belonging to a certain package manager,
+ * it prioritizes this one. However, if that package manager is not installed, it will
+ * prompt the user for which one they want to use and hint at the most optimal one
+ * not being installed.
+ *
+ * Note that this function also takes local npm binary paths into account - for instance,
+ * `yarn` can be installed as a dependency of the project instead of globally, and it
+ * will use that is available.
+ *
+ * The user can also select 'manual' to skip the process and run their preferred package
+ * manager manually. Commands using this function must take this `manual` choice into
+ * account and act accordingly if chosen.
+ *
+ * @param workDir - The working directory where a lockfile is most likely to be present
+ * @param options - Pass `interactive: false` to fall back to npm if most optimal is
+ *                  not available, instead of prompting
+ * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice
+ */
+export declare function getPackageManagerChoice(workDir: string, options: {
+    interactive: boolean;
+}): Promise<{
+    chosen: PackageManager;
+    mostOptimal?: PackageManager;
+}>;
+export declare function getPartialEnvWithNpmPath(cwd: string): NodeJS.ProcessEnv;