@sanity/cli-test 0.0.2-alpha.3 → 0.0.2-alpha.4

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export * from './test/createTestClient.js';
+export * from './test/createTestToken.js';
 export * from './test/mockApi.js';
+export * from './test/mockSanityCommand.js';
 export * from './test/testCommand.js';
 export * from './test/testHook.js';

package/dist/index.js

@@ -1,4 +1,7 @@
+export * from './test/createTestClient.js';
+export * from './test/createTestToken.js';
 export * from './test/mockApi.js';
+export * from './test/mockSanityCommand.js';
 export * from './test/testCommand.js';
 export * from './test/testHook.js';
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './test/mockApi.js'\nexport * from './test/testCommand.js'\nexport * from './test/testHook.js'\n"],"names":[],"mappings":"AAAA,cAAc,oBAAmB;AACjC,cAAc,wBAAuB;AACrC,cAAc,qBAAoB"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './test/createTestClient.js'\nexport * from './test/createTestToken.js'\nexport * from './test/mockApi.js'\nexport * from './test/mockSanityCommand.js'\nexport * from './test/testCommand.js'\nexport * from './test/testHook.js'\n"],"names":[],"mappings":"AAAA,cAAc,6BAA4B;AAC1C,cAAc,4BAA2B;AACzC,cAAc,oBAAmB;AACjC,cAAc,8BAA6B;AAC3C,cAAc,wBAAuB;AACrC,cAAc,qBAAoB"}

package/dist/test/createTestClient.d.ts

@@ -0,0 +1,44 @@
+import { type ClientConfig } from '@sanity/client';
+export interface CreateTestClientOptions extends ClientConfig {
+    /**
+     * API version for the client
+     */
+    apiVersion: string;
+    /**
+     * Authentication token
+     */
+    token: string;
+}
+/**
+ * Creates a real Sanity client instance for testing that makes actual HTTP requests.
+ * Use with mockApi() to intercept and mock the HTTP calls.
+ *
+ * @example
+ * ```typescript
+ * // Mock getGlobalCliClient to return a test client
+ * vi.mock('@sanity/cli-core', async (importOriginal) => {
+ *   const actual = await importOriginal<typeof import('@sanity/cli-core')>()
+ *   const {createTestClient} = await import('@sanity/cli-test')
+ *
+ *   return {
+ *     ...actual,
+ *     getGlobalCliClient: vi.fn().mockImplementation((opts) => {
+ *       return Promise.resolve(createTestClient({
+ *         apiVersion: opts.apiVersion,
+ *       }))
+ *     }),
+ *   }
+ * })
+ *
+ * // Then use mockApi to intercept requests
+ * mockApi({
+ *   apiVersion: 'v2025-02-19',
+ *   method: 'get',
+ *   uri: '/media-libraries',
+ * }).reply(200, {data: [...]})
+ * ```
+ */
+export declare function createTestClient(options: CreateTestClientOptions): {
+    client: import("@sanity/client").SanityClient;
+    request: import("vitest").Mock<(options: import("@sanity/client").RawRequestOptions) => Promise<any>>;
+};

package/dist/test/createTestClient.js

@@ -0,0 +1,51 @@
+import { createClient } from '@sanity/client';
+import { vi } from 'vitest';
+/**
+ * Creates a real Sanity client instance for testing that makes actual HTTP requests.
+ * Use with mockApi() to intercept and mock the HTTP calls.
+ *
+ * @example
+ * ```typescript
+ * // Mock getGlobalCliClient to return a test client
+ * vi.mock('@sanity/cli-core', async (importOriginal) => {
+ *   const actual = await importOriginal<typeof import('@sanity/cli-core')>()
+ *   const {createTestClient} = await import('@sanity/cli-test')
+ *
+ *   return {
+ *     ...actual,
+ *     getGlobalCliClient: vi.fn().mockImplementation((opts) => {
+ *       return Promise.resolve(createTestClient({
+ *         apiVersion: opts.apiVersion,
+ *       }))
+ *     }),
+ *   }
+ * })
+ *
+ * // Then use mockApi to intercept requests
+ * mockApi({
+ *   apiVersion: 'v2025-02-19',
+ *   method: 'get',
+ *   uri: '/media-libraries',
+ * }).reply(200, {data: [...]})
+ * ```
+ */ export function createTestClient(options) {
+    const { apiVersion, projectId, token, ...rest } = options;
+    const client = createClient({
+        apiVersion,
+        projectId,
+        requestTagPrefix: 'sanity.cli',
+        token,
+        useCdn: false,
+        useProjectHostname: projectId ? true : false,
+        ...rest
+    });
+    /**
+   * Mock the request method of the client to return the actual response from the client
+   */ const request = vi.fn((...args)=>client.request(...args));
+    return {
+        client,
+        request
+    };
+}
+
+//# sourceMappingURL=createTestClient.js.map

package/dist/test/createTestClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/createTestClient.ts"],"sourcesContent":["import {type ClientConfig, createClient} from '@sanity/client'\nimport {vi} from 'vitest'\n\nexport interface CreateTestClientOptions extends ClientConfig {\n  /**\n   * API version for the client\n   */\n  apiVersion: string\n\n  /**\n   * Authentication token\n   */\n  token: string\n}\n\n/**\n * Creates a real Sanity client instance for testing that makes actual HTTP requests.\n * Use with mockApi() to intercept and mock the HTTP calls.\n *\n * @example\n * ```typescript\n * // Mock getGlobalCliClient to return a test client\n * vi.mock('@sanity/cli-core', async (importOriginal) => {\n *   const actual = await importOriginal<typeof import('@sanity/cli-core')>()\n *   const {createTestClient} = await import('@sanity/cli-test')\n *\n *   return {\n *     ...actual,\n *     getGlobalCliClient: vi.fn().mockImplementation((opts) => {\n *       return Promise.resolve(createTestClient({\n *         apiVersion: opts.apiVersion,\n *       }))\n *     }),\n *   }\n * })\n *\n * // Then use mockApi to intercept requests\n * mockApi({\n *   apiVersion: 'v2025-02-19',\n *   method: 'get',\n *   uri: '/media-libraries',\n * }).reply(200, {data: [...]})\n * ```\n */\nexport function createTestClient(options: CreateTestClientOptions) {\n  const {apiVersion, projectId, token, ...rest} = options\n\n  const client = createClient({\n    apiVersion,\n    projectId,\n    requestTagPrefix: 'sanity.cli',\n    token,\n    useCdn: false,\n    useProjectHostname: projectId ? true : false,\n    ...rest,\n  })\n\n  /**\n   * Mock the request method of the client to return the actual response from the client\n   */\n  const request = vi.fn((...args: Parameters<typeof client.request>) => client.request(...args))\n\n  return {\n    client,\n    request,\n  }\n}\n"],"names":["createClient","vi","createTestClient","options","apiVersion","projectId","token","rest","client","requestTagPrefix","useCdn","useProjectHostname","request","fn","args"],"mappings":"AAAA,SAA2BA,YAAY,QAAO,iBAAgB;AAC9D,SAAQC,EAAE,QAAO,SAAQ;AAczB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,SAASC,iBAAiBC,OAAgC;IAC/D,MAAM,EAACC,UAAU,EAAEC,SAAS,EAAEC,KAAK,EAAE,GAAGC,MAAK,GAAGJ;IAEhD,MAAMK,SAASR,aAAa;QAC1BI;QACAC;QACAI,kBAAkB;QAClBH;QACAI,QAAQ;QACRC,oBAAoBN,YAAY,OAAO;QACvC,GAAGE,IAAI;IACT;IAEA;;GAEC,GACD,MAAMK,UAAUX,GAAGY,EAAE,CAAC,CAAC,GAAGC,OAA4CN,OAAOI,OAAO,IAAIE;IAExF,OAAO;QACLN;QACAI;IACF;AACF"}

package/dist/test/createTestToken.d.ts

@@ -0,0 +1 @@
+export declare function createTestToken(token: string): void;

package/dist/test/createTestToken.js

@@ -0,0 +1,6 @@
+import { vi } from 'vitest';
+export function createTestToken(token) {
+    vi.stubEnv('SANITY_AUTH_TOKEN', token);
+}
+
+//# sourceMappingURL=createTestToken.js.map

package/dist/test/createTestToken.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/createTestToken.ts"],"sourcesContent":["import {vi} from 'vitest'\n\nexport function createTestToken(token: string) {\n  vi.stubEnv('SANITY_AUTH_TOKEN', token)\n}\n"],"names":["vi","createTestToken","token","stubEnv"],"mappings":"AAAA,SAAQA,EAAE,QAAO,SAAQ;AAEzB,OAAO,SAASC,gBAAgBC,KAAa;IAC3CF,GAAGG,OAAO,CAAC,qBAAqBD;AAClC"}

package/dist/test/mockSanityCommand.d.ts

@@ -0,0 +1,45 @@
+import { type Command } from '@oclif/core';
+import { type CliConfig, type ProjectRootResult, SanityCommand } from '@sanity/cli-core';
+export interface MockSanityCommandOptions {
+    /**
+     * Mock CLI config (required if command uses getCliConfig or getProjectId)
+     */
+    cliConfig?: CliConfig;
+    /**
+     * Mock whether the terminal is interactive (used by isUnattended)
+     */
+    isInteractive?: boolean;
+    /**
+     * Mock project root result (required if command uses getProjectRoot)
+     */
+    projectRoot?: ProjectRootResult;
+    /**
+     * Mock authentication token (passed to API clients, bypasses getCliToken)
+     */
+    token?: string;
+}
+/**
+ * Creates a testable subclass of a command with mocked SanityCommand dependencies.
+ *
+ * @example
+ * ```ts
+ * // Basic config mocking
+ * const TestAdd = mockSanityCommand(Add, {
+ *   cliConfig: { api: { projectId: 'test-project' } }
+ * })
+ *
+ * // With mock API client
+ * const mockClient = {
+ *   getDocument: vi.fn().mockResolvedValue({ _id: 'doc1', title: 'Test' }),
+ *   fetch: vi.fn().mockResolvedValue([]),
+ * }
+ * const TestGet = mockSanityCommand(GetDocumentCommand, {
+ *   cliConfig: { api: { projectId: 'test-project', dataset: 'production' } },
+ *   projectApiClient: mockClient,
+ * })
+ *
+ * const {stdout} = await testCommand(TestGet, ['doc1'])
+ * expect(mockClient.getDocument).toHaveBeenCalledWith('doc1')
+ * ```
+ */
+export declare function mockSanityCommand<T extends typeof SanityCommand<typeof Command>>(CommandClass: T, options?: MockSanityCommandOptions): T;

package/dist/test/mockSanityCommand.js

@@ -0,0 +1,52 @@
+/**
+ * Creates a testable subclass of a command with mocked SanityCommand dependencies.
+ *
+ * @example
+ * ```ts
+ * // Basic config mocking
+ * const TestAdd = mockSanityCommand(Add, {
+ *   cliConfig: { api: { projectId: 'test-project' } }
+ * })
+ *
+ * // With mock API client
+ * const mockClient = {
+ *   getDocument: vi.fn().mockResolvedValue({ _id: 'doc1', title: 'Test' }),
+ *   fetch: vi.fn().mockResolvedValue([]),
+ * }
+ * const TestGet = mockSanityCommand(GetDocumentCommand, {
+ *   cliConfig: { api: { projectId: 'test-project', dataset: 'production' } },
+ *   projectApiClient: mockClient,
+ * })
+ *
+ * const {stdout} = await testCommand(TestGet, ['doc1'])
+ * expect(mockClient.getDocument).toHaveBeenCalledWith('doc1')
+ * ```
+ */ export function mockSanityCommand(CommandClass, options = {}) {
+    // Create a subclass that overrides methods when mocks are provided
+    // Note: we use @ts-expect-error because TypeScript can't properly infer
+    // the relationship between the generic CommandClass and SanityCommand
+    // @ts-expect-error - TypeScript struggles with abstract class subclassing
+    class MockedCommand extends CommandClass {
+        getCliConfig() {
+            if (options.cliConfig) {
+                return Promise.resolve(options.cliConfig);
+            }
+            return super.getCliConfig();
+        }
+        getProjectRoot() {
+            if (options.projectRoot) {
+                return Promise.resolve(options.projectRoot);
+            }
+            return super.getProjectRoot();
+        }
+        resolveIsInteractive() {
+            if (options.isInteractive !== undefined) {
+                return options.isInteractive;
+            }
+            return super.resolveIsInteractive();
+        }
+    }
+    return MockedCommand;
+}
+
+//# sourceMappingURL=mockSanityCommand.js.map

package/dist/test/mockSanityCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/mockSanityCommand.ts"],"sourcesContent":["import {type Command} from '@oclif/core'\nimport {type CliConfig, type ProjectRootResult, SanityCommand} from '@sanity/cli-core'\n\nexport interface MockSanityCommandOptions {\n  /**\n   * Mock CLI config (required if command uses getCliConfig or getProjectId)\n   */\n  cliConfig?: CliConfig\n  /**\n   * Mock whether the terminal is interactive (used by isUnattended)\n   */\n  isInteractive?: boolean\n  /**\n   * Mock project root result (required if command uses getProjectRoot)\n   */\n  projectRoot?: ProjectRootResult\n  /**\n   * Mock authentication token (passed to API clients, bypasses getCliToken)\n   */\n  token?: string\n}\n\n/**\n * Creates a testable subclass of a command with mocked SanityCommand dependencies.\n *\n * @example\n * ```ts\n * // Basic config mocking\n * const TestAdd = mockSanityCommand(Add, {\n *   cliConfig: { api: { projectId: 'test-project' } }\n * })\n *\n * // With mock API client\n * const mockClient = {\n *   getDocument: vi.fn().mockResolvedValue({ _id: 'doc1', title: 'Test' }),\n *   fetch: vi.fn().mockResolvedValue([]),\n * }\n * const TestGet = mockSanityCommand(GetDocumentCommand, {\n *   cliConfig: { api: { projectId: 'test-project', dataset: 'production' } },\n *   projectApiClient: mockClient,\n * })\n *\n * const {stdout} = await testCommand(TestGet, ['doc1'])\n * expect(mockClient.getDocument).toHaveBeenCalledWith('doc1')\n * ```\n */\nexport function mockSanityCommand<T extends typeof SanityCommand<typeof Command>>(\n  CommandClass: T,\n  options: MockSanityCommandOptions = {},\n): T {\n  // Create a subclass that overrides methods when mocks are provided\n  // Note: we use @ts-expect-error because TypeScript can't properly infer\n  // the relationship between the generic CommandClass and SanityCommand\n  // @ts-expect-error - TypeScript struggles with abstract class subclassing\n  class MockedCommand extends CommandClass {\n    protected getCliConfig(): Promise<CliConfig> {\n      if (options.cliConfig) {\n        return Promise.resolve(options.cliConfig)\n      }\n      return super.getCliConfig()\n    }\n\n    protected getProjectRoot(): Promise<ProjectRootResult> {\n      if (options.projectRoot) {\n        return Promise.resolve(options.projectRoot)\n      }\n      return super.getProjectRoot()\n    }\n\n    protected resolveIsInteractive(): boolean {\n      if (options.isInteractive !== undefined) {\n        return options.isInteractive\n      }\n      return super.resolveIsInteractive()\n    }\n  }\n\n  return MockedCommand as T\n}\n"],"names":["mockSanityCommand","CommandClass","options","MockedCommand","getCliConfig","cliConfig","Promise","resolve","getProjectRoot","projectRoot","resolveIsInteractive","isInteractive","undefined"],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASA,kBACdC,YAAe,EACfC,UAAoC,CAAC,CAAC;IAEtC,mEAAmE;IACnE,wEAAwE;IACxE,sEAAsE;IACtE,0EAA0E;IAC1E,MAAMC,sBAAsBF;QAChBG,eAAmC;YAC3C,IAAIF,QAAQG,SAAS,EAAE;gBACrB,OAAOC,QAAQC,OAAO,CAACL,QAAQG,SAAS;YAC1C;YACA,OAAO,KAAK,CAACD;QACf;QAEUI,iBAA6C;YACrD,IAAIN,QAAQO,WAAW,EAAE;gBACvB,OAAOH,QAAQC,OAAO,CAACL,QAAQO,WAAW;YAC5C;YACA,OAAO,KAAK,CAACD;QACf;QAEUE,uBAAgC;YACxC,IAAIR,QAAQS,aAAa,KAAKC,WAAW;gBACvC,OAAOV,QAAQS,aAAa;YAC9B;YACA,OAAO,KAAK,CAACD;QACf;IACF;IAEA,OAAOP;AACT"}

package/dist/test/testCommand.d.ts

@@ -1,6 +1,21 @@
 import { Command, Config } from '@oclif/core';
 import { type CaptureOptions, type CaptureResult } from './captureOutput.js';
-export declare function testCommand(command: (new (argv: string[], config: Config) => Command) & typeof Command, args?: string[], options?: {
+import { type MockSanityCommandOptions } from './mockSanityCommand.js';
+type CommandClass = (new (argv: string[], config: Config) => Command) & typeof Command;
+export interface TestCommandOptions {
+    /**
+     * Options for capturing output
+     */
     capture?: CaptureOptions;
+    /**
+     * Partial oclif config overrides
+     */
     config?: Partial<Config>;
-}): Promise<CaptureResult<unknown>>;
+    /**
+     * Mock options for SanityCommand dependencies (config, project root, API clients).
+     * When provided, the command is automatically wrapped with mockSanityCommand.
+     */
+    mocks?: MockSanityCommandOptions;
+}
+export declare function testCommand(command: CommandClass, args?: string[], options?: TestCommandOptions): Promise<CaptureResult<unknown>>;
+export {};

package/dist/test/testCommand.js

@@ -1,9 +1,11 @@
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { captureOutput } from './captureOutput.js';
+import { mockSanityCommand } from './mockSanityCommand.js';
 export async function testCommand(command, args, options) {
-    const commandInstancePromise = ()=>command.run(args || [], {
-            root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli'),
+    // If mocks provided, wrap the command with mockSanityCommand
+    const CommandToRun = options?.mocks ? mockSanityCommand(command, options.mocks) : command;
+    const commandInstancePromise = ()=>CommandToRun.run(args || [], {
+            root: fileURLToPath(import.meta.url),
             ...options?.config
         });
     return captureOutput(commandInstancePromise, options?.capture);

package/dist/test/testCommand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/test/testCommand.ts"],"sourcesContent":["import path from 'node:path'\nimport {fileURLToPath} from 'node:url'\n\nimport {Command, Config} from '@oclif/core'\n\nimport {type CaptureOptions, captureOutput, type CaptureResult} from './captureOutput.js'\n\nexport async function testCommand(\n  command: (new (argv: string[], config: Config) => Command) & typeof Command,\n  args?: string[],\n  options?: {capture?: CaptureOptions; config?: Partial<Config>},\n): Promise<CaptureResult<unknown>> {\n  const commandInstancePromise = () =>\n    command.run(args || [], {\n      root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli'),\n      ...options?.config,\n    })\n\n  return captureOutput(commandInstancePromise, options?.capture)\n}\n"],"names":["path","fileURLToPath","captureOutput","testCommand","command","args","options","commandInstancePromise","run","root","resolve","url","config","capture"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAC5B,SAAQC,aAAa,QAAO,WAAU;AAItC,SAA6BC,aAAa,QAA2B,qBAAoB;AAEzF,OAAO,eAAeC,YACpBC,OAA2E,EAC3EC,IAAe,EACfC,OAA8D;IAE9D,MAAMC,yBAAyB,IAC7BH,QAAQI,GAAG,CAACH,QAAQ,EAAE,EAAE;YACtBI,MAAMT,KAAKU,OAAO,CAACT,cAAc,YAAYU,GAAG,GAAG;YACnD,GAAGL,SAASM,MAAM;QACpB;IAEF,OAAOV,cAAcK,wBAAwBD,SAASO;AACxD"}
+{"version":3,"sources":["../../src/test/testCommand.ts"],"sourcesContent":["import {fileURLToPath} from 'node:url'\n\nimport {Command, Config} from '@oclif/core'\n\nimport {type CaptureOptions, captureOutput, type CaptureResult} from './captureOutput.js'\nimport {mockSanityCommand, type MockSanityCommandOptions} from './mockSanityCommand.js'\n\ntype CommandClass = (new (argv: string[], config: Config) => Command) & typeof Command\n\nexport interface TestCommandOptions {\n  /**\n   * Options for capturing output\n   */\n  capture?: CaptureOptions\n  /**\n   * Partial oclif config overrides\n   */\n  config?: Partial<Config>\n  /**\n   * Mock options for SanityCommand dependencies (config, project root, API clients).\n   * When provided, the command is automatically wrapped with mockSanityCommand.\n   */\n  mocks?: MockSanityCommandOptions\n}\n\nexport async function testCommand(\n  command: CommandClass,\n  args?: string[],\n  options?: TestCommandOptions,\n): Promise<CaptureResult<unknown>> {\n  // If mocks provided, wrap the command with mockSanityCommand\n  const CommandToRun = options?.mocks\n    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (mockSanityCommand(command as any, options.mocks) as CommandClass)\n    : command\n\n  const commandInstancePromise = () =>\n    CommandToRun.run(args || [], {\n      root: fileURLToPath(import.meta.url),\n      ...options?.config,\n    })\n\n  return captureOutput(commandInstancePromise, options?.capture)\n}\n"],"names":["fileURLToPath","captureOutput","mockSanityCommand","testCommand","command","args","options","CommandToRun","mocks","commandInstancePromise","run","root","url","config","capture"],"mappings":"AAAA,SAAQA,aAAa,QAAO,WAAU;AAItC,SAA6BC,aAAa,QAA2B,qBAAoB;AACzF,SAAQC,iBAAiB,QAAsC,yBAAwB;AAoBvF,OAAO,eAAeC,YACpBC,OAAqB,EACrBC,IAAe,EACfC,OAA4B;IAE5B,6DAA6D;IAC7D,MAAMC,eAAeD,SAASE,QAEzBN,kBAAkBE,SAAgBE,QAAQE,KAAK,IAChDJ;IAEJ,MAAMK,yBAAyB,IAC7BF,aAAaG,GAAG,CAACL,QAAQ,EAAE,EAAE;YAC3BM,MAAMX,cAAc,YAAYY,GAAG;YACnC,GAAGN,SAASO,MAAM;QACpB;IAEF,OAAOZ,cAAcQ,wBAAwBH,SAASQ;AACxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli-test",
-  "version": "0.0.2-alpha.3",
+  "version": "0.0.2-alpha.4",
   "description": "Sanity CLI test helpers and utilities",
   "keywords": [
     "sanity",
@@ -13,7 +13,11 @@
   ],
   "homepage": "https://github.com/sanity-io/cli",
   "bugs": "https://github.com/sanity-io/cli/issues",
-  "repository": "sanity-io/cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanity-io/cli.git",
+    "directory": "packages/@sanity/cli-test"
+  },
   "license": "MIT",
   "author": "Sanity.io <hello@sanity.io>",
   "type": "module",
@@ -32,21 +36,28 @@
   ],
   "dependencies": {
     "@oclif/core": "^4.8.0",
-    "ansis": "^3.17.0",
-    "nock": "^14.0.5"
+    "ansis": "^4.2.0",
+    "nock": "^14.0.10"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.0",
-    "@swc/cli": "^0.7.8",
-    "@swc/core": "^1.14.0",
+    "@oclif/core": "^4.8.0",
+    "@sanity/client": "^7.3.0",
+    "@swc/cli": "^0.7.9",
+    "@swc/core": "^1.15.8",
     "@types/debug": "^4.1.12",
-    "@types/node": "^20.19.24",
+    "@types/node": "^20.19.27",
     "eslint": "^9.39.2",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4",
     "@repo/tsconfig": "3.70.0",
+    "@sanity/cli-core": "0.1.0-alpha.5",
     "@sanity/eslint-config-cli": "0.0.0-alpha.1"
   },
+  "peerDependencies": {
+    "@oclif/core": "^4.0.0",
+    "@sanity/cli-core": "0.1.0-alpha.5"
+  },
   "engines": {
     "node": ">=20.19.1 <22 || >=22.12"
   },