Merge pull request #2852 from hey-api/fix/cli-typescript

fix(cli): move cli script to typescript

.changeset/short-phones-count.md

···
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix(cli): move cli script to typescript

.github/copilot-instructions.md

···
 # Server starts on http://localhost:5173/
 
 # Run CLI tool directly
-node packages/openapi-ts/bin/index.cjs --help
+node packages/openapi-ts/dist/run.js --help
 # or after building
 npx @hey-api/openapi-ts --help
 ```
···
 
    ```bash
    # Test CLI help
-   node packages/openapi-ts/bin/index.cjs --help
+   node packages/openapi-ts/dist/run.js --help
 
    # Test CLI version
-   node packages/openapi-ts/bin/index.cjs --version
+   node packages/openapi-ts/dist/run.js --version
 
    # Test basic code generation with a simple OpenAPI spec
    # Create a minimal test spec and generate client code
-   node packages/openapi-ts/bin/index.cjs -i path/to/spec.json -o ./test-output --plugins "@hey-api/client-fetch" "@hey-api/typescript"
+   node packages/openapi-ts/dist/run.js -i path/to/spec.json -o ./test-output --plugins "@hey-api/client-fetch" "@hey-api/typescript"
    ```
 
 2. **Example Application Test**:

.github/workflows/ci.yml

···
       - name: Build packages
         run: pnpm build --filter="@hey-api/**"
 
-      - name: Build examples
-        if: matrix.node-version == '24.10.0' && matrix.os == 'ubuntu-latest'
-        run: pnpm build --filter="@example/**"
-
       - name: Check examples generated code
         if: matrix.node-version == '24.10.0' && matrix.os == 'ubuntu-latest'
         run: pnpm examples:check
+
+      - name: Build examples
+        if: matrix.node-version == '24.10.0' && matrix.os == 'ubuntu-latest'
+        run: pnpm build --filter="@example/**"
 
       - name: Run linter
         run: pnpm lint

.gitignore

···
 .turbo
 
 # test files
+.gen/
 test/generated
 
 # debug files

.vscode/launch.json

···
       "request": "launch",
       "name": "openapi-ts",
       "skipFiles": ["<node_internals>/**"],
+      "cwd": "${workspaceFolder}/dev",
       "runtimeExecutable": "node",
-      "runtimeArgs": [],
-      "program": "${workspaceFolder}/packages/openapi-ts/bin/index.cjs",
-      "args": [
-        "-f",
-        "${workspaceFolder}/packages/openapi-ts-tests/main/test/openapi-ts.config.ts"
-      ]
+      "runtimeArgs": ["-r", "ts-node/register/transpile-only"],
+      "program": "${workspaceFolder}/packages/openapi-ts/src/cli.ts"
     }
   ]
 }

package.json

···
     "@config/vite-base": "workspace:*",
     "@eslint/js": "9.32.0",
     "@hey-api/custom-client": "workspace:*",
+    "@hey-api/openapi-ts": "workspace:*",
     "@types/node": "22.10.5",
     "@typescript-eslint/eslint-plugin": "8.29.1",
     "@vitest/coverage-v8": "3.1.1",
···
     "prettier": "3.4.2",
     "rollup": "4.31.0",
     "rollup-plugin-dts": "6.1.1",
+    "ts-node": "10.9.2",
     "tsdown": "0.15.8",
     "turbo": "2.5.8",
     "typescript": "5.9.3",

packages/openapi-ts-tests/main/.gitignore

···
 .env
 
 # test files
+.gen/
 test/generated
 generated/

packages/openapi-ts-tests/main/test/bin.test.ts

···
-import path from 'node:path';
-
-import { sync } from 'cross-spawn';
-import { describe, expect, it } from 'vitest';
-
-import { getSpecsPath } from '../../utils';
-
-describe('bin', () => {
-  it('supports required parameters', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      '@hey-api/client-fetch',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('generates angular client', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/angular',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('generates axios client', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/axios',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('generates fetch client', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/fetch',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('generates node client', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/node',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('generates xhr client', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/xhr',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('supports all parameters', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      'legacy/fetch',
-      '--useOptions',
-      '--exportCore',
-      'true',
-      '--plugins',
-      '@hey-api/schemas',
-      '@hey-api/sdk',
-      '@hey-api/typescript',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.error).toBeFalsy();
-    expect(result.status).toBe(0);
-  });
-
-  it('throws error without input', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.stderr.toString()).toContain('missing input');
-  });
-
-  it('throws error without output', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.stderr.toString()).toContain('missing output');
-  });
-
-  it('throws error with wrong parameters', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--unknown',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.stderr.toString()).toContain(
-      `error: unknown option '--unknown'`,
-    );
-  });
-
-  it('displays help', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--help',
-      '--dry-run',
-      'true',
-    ]);
-    expect(result.stdout.toString()).toContain(`Usage: openapi-ts [options]`);
-    expect(result.stdout.toString()).toContain(`-i, --input <value>`);
-    expect(result.stdout.toString()).toContain(`-o, --output <value>`);
-    expect(result.stderr.toString()).toBe('');
-  });
-});
-
-describe('cli', () => {
-  it('handles false booleans', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--debug',
-      '--plugins',
-      '--useOptions',
-      'false',
-      '--dry-run',
-      'true',
-    ]);
-    const stderr = result.stderr.toString();
-    expect(stderr).toMatch(/level: 'debug'/);
-    expect(stderr).toMatch(/dryRun: true/);
-    expect(stderr).not.toMatch(/@hey-api\/schemas/);
-    expect(stderr).not.toMatch(/@hey-api\/sdk/);
-    expect(stderr).not.toMatch(/@hey-api\/typescript/);
-    expect(stderr).toMatch(/useOptions: false/);
-  });
-
-  it('handles true booleans', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      '@hey-api/client-fetch',
-      '--debug',
-      '--plugins',
-      '@hey-api/schemas',
-      '@hey-api/sdk',
-      '@hey-api/typescript',
-      '--useOptions',
-      'true',
-      '--dry-run',
-      'true',
-    ]);
-    const stderr = result.stderr.toString();
-    expect(stderr).toMatch(/level: 'debug'/);
-    expect(stderr).toMatch(/dryRun: true/);
-    expect(stderr).toMatch(/@hey-api\/schemas/);
-    expect(stderr).toMatch(/@hey-api\/sdk/);
-    expect(stderr).toMatch(/@hey-api\/typescript/);
-    expect(stderr).toMatch(/useOptions: true/);
-  });
-
-  it('handles optional booleans', () => {
-    const result = sync('node', [
-      path.resolve(
-        __dirname,
-        '..',
-        '..',
-        '..',
-        'openapi-ts',
-        'bin',
-        'index.cjs',
-      ),
-      '--input',
-      path.resolve(getSpecsPath(), 'v3.json'),
-      '--output',
-      path.resolve(__dirname, 'generated', 'bin'),
-      '--client',
-      '@hey-api/client-fetch',
-      '--debug',
-      '--plugins',
-      '@hey-api/schemas',
-      '@hey-api/sdk',
-      '@hey-api/typescript',
-      '--useOptions',
-      '--dry-run',
-      'true',
-    ]);
-    const stderr = result.stderr.toString();
-    expect(stderr).toMatch(/level: 'debug'/);
-    expect(stderr).toMatch(/dryRun: true/);
-    expect(stderr).toMatch(/@hey-api\/schemas/);
-    expect(stderr).toMatch(/@hey-api\/sdk/);
-    expect(stderr).toMatch(/@hey-api\/typescript/);
-    expect(stderr).toMatch(/useOptions: true/);
-  });
-});

packages/openapi-ts-tests/main/test/cli.test.ts

···
+import path from 'node:path';
+
+import { sync } from 'cross-spawn';
+import { describe, expect, it } from 'vitest';
+
+import { getSpecsPath } from '../../utils';
+
+const specs = getSpecsPath();
+
+describe('bin', () => {
+  it('openapi-ts works', () => {
+    const result = sync('openapi-ts', [
+      '--input',
+      path.resolve(specs, 'v3.json'),
+      '--output',
+      path.resolve(__dirname, '.gen'),
+      '--dry-run',
+      'true',
+    ]);
+    expect(result.error).toBeFalsy();
+    expect(result.status).toBe(0);
+  });
+});

packages/openapi-ts-tests/main/test/openapi-ts.config.ts dev/openapi-ts.config.ts

···
 // @ts-ignore
 import { defineConfig, utils } from '@hey-api/openapi-ts';
 
-import { getSpecsPath } from '../../utils';
 // @ts-ignore
-import { myClientPlugin } from './custom/client/plugin';
+import { myClientPlugin } from '../packages/openapi-ts-tests/main/test/custom/client/plugin';
+import { getSpecsPath } from '../packages/openapi-ts-tests/utils';
 
 // @ts-ignore
 // eslint-disable-next-line arrow-body-style
···
         //   importFileExtension: '.ts',
         //   // indexFile: false,
         //   // lint: 'eslint',
-        //   path: path.resolve(__dirname, 'generated', 'sample'),
+        //   path: path.resolve(__dirname, '.gen'),
         //   tsConfigPath: path.resolve(
         //     __dirname,
         //     'tsconfig',
         //     'tsconfig.nodenext.json',
         //   ),
         // },
-        path.resolve(__dirname, 'generated', 'sample'),
+        '.gen',
       ],
       parser: {
         filters: {
···
     //     // level: 'debug',
     //     path: './logs',
     //   },
-    //   output: path.resolve(__dirname, 'generated', 'sample'),
+    //   output: '.gen',
     // },
   ];
 });

packages/openapi-ts/bin/index.cjs

···
-#!/usr/bin/env node
-
-'use strict';
-
-const path = require('path');
-
-const { program } = require('commander');
-const pkg = require('../package.json');
-
-const params = program
-  .name(Object.keys(pkg.bin)[0])
-  .usage('[options]')
-  .version(pkg.version)
-  .option(
-    '-c, --client <value>',
-    'HTTP client to generate [@hey-api/client-axios, @hey-api/client-fetch, @hey-api/client-next, @hey-api/client-nuxt, legacy/angular, legacy/axios, legacy/fetch, legacy/node, legacy/xhr]',
-  )
-  .option('-d, --debug', 'Set log level to debug')
-  .option('--dry-run [value]', 'Skip writing files to disk?')
-  .option(
-    '-e, --experimental-parser [value]',
-    'Opt-in to the experimental parser?',
-  )
-  .option('-f, --file [value]', 'Path to the config file')
-  .option(
-    '-i, --input <value>',
-    'OpenAPI specification (path, url, or string content)',
-  )
-  .option('-l, --logs [value]', 'Logs folder')
-  .option('-o, --output <value>', 'Output folder')
-  .option('-p, --plugins [value...]', "List of plugins you'd like to use")
-  .option(
-    '--base [value]',
-    'DEPRECATED. Manually set base in OpenAPI config instead of inferring from server value',
-  )
-  .option('-s, --silent', 'Set log level to silent')
-  .option(
-    '--no-log-file',
-    'Disable writing a log file. Works like --silent but without suppressing console output',
-  )
-  .option(
-    '-w, --watch [value]',
-    'Regenerate the client when the input file changes?',
-  )
-  .option('--exportCore [value]', 'DEPRECATED. Write core files to disk')
-  .option('--name <value>', 'DEPRECATED. Custom client class name')
-  .option('--request <value>', 'DEPRECATED. Path to custom request file')
-  .option(
-    '--useOptions [value]',
-    'DEPRECATED. Use options instead of arguments?',
-  )
-  .parse(process.argv)
-  .opts();
-
-const stringToBoolean = (value) => {
-  if (value === 'true') {
-    return true;
-  }
-  if (value === 'false') {
-    return false;
-  }
-  return value;
-};
-
-const processParams = (obj, booleanKeys) => {
-  for (const key of booleanKeys) {
-    const value = obj[key];
-    if (typeof value === 'string') {
-      const parsedValue = stringToBoolean(value);
-      delete obj[key];
-      obj[key] = parsedValue;
-    }
-  }
-  if (obj.file) {
-    obj.configFile = obj.file;
-  }
-  return obj;
-};
-
-async function start() {
-  let userConfig;
-
-  try {
-    const { createClient } = require(
-      path.resolve(__dirname, '../dist/index.cjs'),
-    );
-
-    userConfig = processParams(params, [
-      'dryRun',
-      'logFile',
-      'experimentalParser',
-      'exportCore',
-      'useOptions',
-    ]);
-
-    if (params.plugins === true) {
-      userConfig.plugins = [];
-    } else if (params.plugins) {
-      userConfig.plugins = params.plugins;
-    } else if (userConfig.client) {
-      userConfig.plugins = ['@hey-api/typescript', '@hey-api/sdk'];
-    }
-
-    if (userConfig.client) {
-      userConfig.plugins.push(userConfig.client);
-      delete userConfig.client;
-    }
-
-    userConfig.logs = userConfig.logs
-      ? {
-          path: userConfig.logs,
-        }
-      : {};
-
-    if (userConfig.debug || stringToBoolean(process.env.DEBUG)) {
-      userConfig.logs.level = 'debug';
-    } else if (userConfig.silent) {
-      userConfig.logs.level = 'silent';
-    }
-
-    userConfig.logs.file = userConfig.logFile;
-    delete userConfig.logFile;
-
-    if (typeof params.watch === 'string') {
-      userConfig.watch = Number.parseInt(params.watch, 10);
-    }
-
-    if (!Object.keys(userConfig.logs).length) {
-      delete userConfig.logs;
-    }
-
-    const context = await createClient(userConfig);
-    if (
-      !context[0] ||
-      !context[0].config ||
-      !context[0].config.input ||
-      !context[0].config.input.some(
-        (input) => input.watch && input.watch.enabled,
-      )
-    ) {
-      process.exit(0);
-    }
-  } catch {
-    process.exit(1);
-  }
-}
-
-start();

packages/openapi-ts/bin/run.cmd

···
+@echo off
+node "%~dp0\run.js" %*
+

packages/openapi-ts/bin/run.js

···
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const target = path.join(__dirname, '..', 'dist', 'run.js');
+
+if (!fs.existsSync(target)) {
+  console.error('openapi-ts not built (expect dist/run.js)');
+  process.exit(1);
+}
+
+const res = spawnSync(process.execPath, [target, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+});
+process.exit(res.status ?? 0);

packages/openapi-ts/package.json

···
     "./package.json": "./package.json"
   },
   "bin": {
-    "openapi-ts": "bin/index.cjs"
+    "openapi-ts": "./bin/run.js"
   },
   "files": [
     "bin",

packages/openapi-ts/src/__tests__/cli.test.ts

···
+import type { Mock } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { runCli } from '~/cli';
+import { createClient } from '~/index';
+
+vi.mock('~/index', () => {
+  const result: Awaited<ReturnType<typeof createClient>> = [];
+  return {
+    createClient: vi.fn().mockResolvedValue(result),
+  };
+});
+const spyExit = vi
+  .spyOn(process, 'exit')
+  .mockImplementation(() => ({}) as never);
+
+const spy = createClient as Mock;
+
+describe('cli', () => {
+  beforeEach(() => {
+    spy.mockClear();
+    spyExit.mockClear();
+  });
+
+  it('with default options', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [String(process.argv[0]), String(process.argv[1])];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      logs: {
+        file: true,
+      },
+    });
+  });
+
+  it('with minimal options', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--input',
+        'foo.json',
+        '--output',
+        'bar',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      input: 'foo.json',
+      logs: {
+        file: true,
+      },
+      output: 'bar',
+    });
+  });
+
+  it('with no plugins', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--plugins',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      logs: {
+        file: true,
+      },
+      plugins: [],
+    });
+  });
+
+  it('with plugins', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--plugins',
+        'foo',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      logs: {
+        file: true,
+      },
+      plugins: ['foo'],
+    });
+  });
+
+  it('with default plugins', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--client',
+        'foo',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      logs: {
+        file: true,
+      },
+      plugins: ['@hey-api/typescript', '@hey-api/sdk', 'foo'],
+    });
+  });
+
+  describe('logs', () => {
+    it('debug', async () => {
+      const originalArgv = process.argv.slice();
+      try {
+        process.argv = [
+          String(process.argv[0]),
+          String(process.argv[1]),
+          '--debug',
+        ];
+        await runCli();
+      } finally {
+        process.argv = originalArgv;
+      }
+      expect(spy).toHaveBeenCalledWith({
+        logs: {
+          file: true,
+          level: 'debug',
+        },
+      });
+    });
+
+    it('silent', async () => {
+      const originalArgv = process.argv.slice();
+      try {
+        process.argv = [
+          String(process.argv[0]),
+          String(process.argv[1]),
+          '--silent',
+        ];
+        await runCli();
+      } finally {
+        process.argv = originalArgv;
+      }
+      expect(spy).toHaveBeenCalledWith({
+        logs: {
+          file: true,
+          level: 'silent',
+        },
+      });
+    });
+
+    it('no log file', async () => {
+      const originalArgv = process.argv.slice();
+      try {
+        process.argv = [
+          String(process.argv[0]),
+          String(process.argv[1]),
+          '--no-log-file',
+        ];
+        await runCli();
+      } finally {
+        process.argv = originalArgv;
+      }
+      expect(spy).toHaveBeenCalledWith({
+        logs: {
+          file: false,
+        },
+      });
+    });
+  });
+
+  it('with all options', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--client',
+        'foo',
+        '--dry-run',
+        'true',
+        '--experimental-parser',
+        'true',
+        '--file',
+        'bar',
+        '--input',
+        'baz',
+        '--logs',
+        'qux',
+        '--output',
+        'quux',
+        '--plugins',
+        '--watch',
+        '--useOptions',
+        '--exportCore',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      configFile: 'bar',
+      dryRun: true,
+      experimentalParser: true,
+      exportCore: true,
+      input: 'baz',
+      logs: {
+        file: true,
+        path: 'qux',
+      },
+      output: 'quux',
+      plugins: ['foo'],
+      useOptions: true,
+      watch: true,
+    });
+  });
+
+  it('with false booleans', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [
+        String(process.argv[0]),
+        String(process.argv[1]),
+        '--useOptions',
+        'false',
+      ];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spy).toHaveBeenCalledWith({
+      logs: {
+        file: true,
+      },
+      useOptions: false,
+    });
+  });
+
+  it('exits when not in watch mode', async () => {
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [String(process.argv[0]), String(process.argv[1])];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spyExit).toHaveBeenCalledWith(0);
+  });
+
+  it('does not exit in watch mode', async () => {
+    spy.mockResolvedValueOnce([
+      {
+        config: { input: [{ watch: { enabled: true } }] },
+      },
+    ]);
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [String(process.argv[0]), String(process.argv[1])];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spyExit).not.toHaveBeenCalled();
+  });
+
+  it('exits with error code on error', async () => {
+    spy.mockRejectedValueOnce('Some error');
+    const originalArgv = process.argv.slice();
+    try {
+      process.argv = [String(process.argv[0]), String(process.argv[1])];
+      await runCli();
+    } finally {
+      process.argv = originalArgv;
+    }
+    expect(spyExit).toHaveBeenCalledWith(1);
+  });
+});

packages/openapi-ts/src/cli.ts

···
+import type { OptionValues } from 'commander';
+import { Command } from 'commander';
+
+import { createClient } from '~/index';
+
+import pkg from '../package.json' assert { type: 'json' };
+
+const stringToBoolean = (
+  value: string | undefined,
+): boolean | string | undefined => {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return value;
+};
+
+const processParams = (
+  obj: OptionValues,
+  booleanKeys: ReadonlyArray<string>,
+): OptionValues => {
+  for (const key of booleanKeys) {
+    const value = obj[key];
+    if (typeof value === 'string') {
+      const parsedValue = stringToBoolean(value);
+      delete obj[key];
+      obj[key] = parsedValue;
+    }
+  }
+  return obj;
+};
+
+export const runCli = async (): Promise<void> => {
+  const params = new Command()
+    .name(Object.keys(pkg.bin)[0]!)
+    .usage('[options]')
+    .version(pkg.version)
+    .option(
+      '-c, --client <value>',
+      'HTTP client to generate [@hey-api/client-axios, @hey-api/client-fetch, @hey-api/client-next, @hey-api/client-nuxt, legacy/angular, legacy/axios, legacy/fetch, legacy/node, legacy/xhr]',
+    )
+    .option('-d, --debug', 'Set log level to debug')
+    .option('--dry-run [value]', 'Skip writing files to disk?')
+    .option(
+      '-e, --experimental-parser [value]',
+      'Opt-in to the experimental parser?',
+    )
+    .option('-f, --file [value]', 'Path to the config file')
+    .option(
+      '-i, --input <value>',
+      'OpenAPI specification (path, url, or string content)',
+    )
+    .option('-l, --logs [value]', 'Logs folder')
+    .option('-o, --output <value>', 'Output folder')
+    .option('-p, --plugins [value...]', "List of plugins you'd like to use")
+    .option(
+      '--base [value]',
+      'DEPRECATED. Manually set base in OpenAPI config instead of inferring from server value',
+    )
+    .option('-s, --silent', 'Set log level to silent')
+    .option(
+      '--no-log-file',
+      'Disable writing a log file. Works like --silent but without suppressing console output',
+    )
+    .option(
+      '-w, --watch [value]',
+      'Regenerate the client when the input file changes?',
+    )
+    .option('--exportCore [value]', 'DEPRECATED. Write core files to disk')
+    .option('--name <value>', 'DEPRECATED. Custom client class name')
+    .option('--request <value>', 'DEPRECATED. Path to custom request file')
+    .option(
+      '--useOptions [value]',
+      'DEPRECATED. Use options instead of arguments?',
+    )
+    .parse(process.argv)
+    .opts();
+
+  let userConfig: Record<string, unknown>;
+
+  try {
+    userConfig = processParams(params, [
+      'dryRun',
+      'experimentalParser',
+      'exportCore',
+      'logFile',
+      'useOptions',
+    ]);
+
+    if (userConfig.file) {
+      userConfig.configFile = userConfig.file;
+      delete userConfig.file;
+    }
+
+    if (params.plugins === true) {
+      userConfig.plugins = [];
+    } else if (params.plugins) {
+      userConfig.plugins = params.plugins;
+    } else if (userConfig.client) {
+      userConfig.plugins = ['@hey-api/typescript', '@hey-api/sdk'];
+    }
+
+    if (userConfig.client) {
+      (userConfig.plugins as Array<string>).push(userConfig.client as string);
+      delete userConfig.client;
+    }
+
+    userConfig.logs = userConfig.logs
+      ? {
+          path: userConfig.logs,
+        }
+      : {};
+
+    if (userConfig.debug || stringToBoolean(process.env.DEBUG)) {
+      (userConfig.logs as Record<string, unknown>).level = 'debug';
+      delete userConfig.debug;
+    } else if (userConfig.silent) {
+      (userConfig.logs as Record<string, unknown>).level = 'silent';
+      delete userConfig.silent;
+    }
+
+    (userConfig.logs as Record<string, unknown>).file = userConfig.logFile;
+    delete userConfig.logFile;
+
+    if (typeof params.watch === 'string') {
+      userConfig.watch = Number.parseInt(params.watch, 10);
+    }
+
+    if (!Object.keys(userConfig.logs as Record<string, unknown>).length) {
+      delete userConfig.logs;
+    }
+
+    const context = await createClient(
+      userConfig as unknown as Required<Parameters<typeof createClient>>[0],
+    );
+    if (
+      !context[0]?.config.input.some(
+        (input) => input.watch && input.watch.enabled,
+      )
+    ) {
+      process.exit(0);
+    }
+  } catch {
+    process.exit(1);
+  }
+};

packages/openapi-ts/src/generate.ts

···
+import { checkNodeVersion } from '~/config/engine';
+import type { Configs } from '~/config/init';
+import { initConfigs } from '~/config/init';
+import { getLogs } from '~/config/logs';
+import { createClient as pCreateClient } from '~/createClient';
+import {
+  ConfigValidationError,
+  JobError,
+  logCrashReport,
+  openGitHubIssueWithCrashReport,
+  printCrashReport,
+  shouldReportCrash,
+} from '~/error';
+import type { IR } from '~/ir/types';
+import type { Client } from '~/types/client';
+import type { UserConfig } from '~/types/config';
+import type { LazyOrAsync, MaybeArray } from '~/types/utils';
+import { printCliIntro } from '~/utils/cli';
+import { registerHandlebarTemplates } from '~/utils/handlebars';
+import { Logger } from '~/utils/logger';
+
+/**
+ * Generate a client from the provided configuration.
+ *
+ * @param userConfig User provided {@link UserConfig} configuration(s).
+ */
+export const createClient = async (
+  userConfig?: LazyOrAsync<MaybeArray<UserConfig>>,
+  logger = new Logger(),
+): Promise<ReadonlyArray<Client | IR.Context>> => {
+  const resolvedConfig =
+    typeof userConfig === 'function' ? await userConfig() : userConfig;
+  const userConfigs = resolvedConfig
+    ? resolvedConfig instanceof Array
+      ? resolvedConfig
+      : [resolvedConfig]
+    : [];
+
+  let rawLogs = userConfigs.find(
+    (config) => getLogs(config).level !== 'silent',
+  )?.logs;
+  if (typeof rawLogs === 'string') {
+    rawLogs = getLogs({ logs: rawLogs });
+  }
+
+  let configs: Configs | undefined;
+
+  try {
+    checkNodeVersion();
+
+    const eventCreateClient = logger.timeEvent('createClient');
+
+    const eventConfig = logger.timeEvent('config');
+    configs = await initConfigs({ logger, userConfigs });
+    const printIntro = configs.results.some(
+      (result) => result.config.logs.level !== 'silent',
+    );
+    if (printIntro) {
+      printCliIntro();
+    }
+    eventConfig.timeEnd();
+
+    const allConfigErrors = configs.results.flatMap((result) =>
+      result.errors.map((error) => ({ error, jobIndex: result.jobIndex })),
+    );
+    if (allConfigErrors.length) {
+      throw new ConfigValidationError(allConfigErrors);
+    }
+
+    const eventHandlebars = logger.timeEvent('handlebars');
+    const templates = registerHandlebarTemplates();
+    eventHandlebars.timeEnd();
+
+    const clients = await Promise.all(
+      configs.results.map(async (result) => {
+        try {
+          return await pCreateClient({
+            config: result.config,
+            dependencies: configs!.dependencies,
+            jobIndex: result.jobIndex,
+            logger,
+            templates,
+          });
+        } catch (error) {
+          throw new JobError('', {
+            error,
+            jobIndex: result.jobIndex,
+          });
+        }
+      }),
+    );
+    const result = clients.filter((client) => Boolean(client)) as ReadonlyArray<
+      Client | IR.Context
+    >;
+
+    eventCreateClient.timeEnd();
+
+    const printLogs = configs.results.some(
+      (result) => result.config.logs.level === 'debug',
+    );
+    logger.report(printLogs);
+
+    return result;
+  } catch (error) {
+    const results = configs?.results ?? [];
+
+    const logs =
+      results.find((result) => result.config.logs.level !== 'silent')?.config
+        .logs ??
+      results[0]?.config.logs ??
+      rawLogs;
+    const dryRun =
+      results.some((result) => result.config.dryRun) ??
+      userConfigs.some((config) => config.dryRun) ??
+      false;
+    const logPath =
+      logs?.file && !dryRun
+        ? logCrashReport(error, logs.path ?? '')
+        : undefined;
+    if (!logs || logs.level !== 'silent') {
+      printCrashReport({ error, logPath });
+      const isInteractive =
+        results.some((result) => result.config.interactive) ??
+        userConfigs.some((config) => config.interactive) ??
+        false;
+      if (await shouldReportCrash({ error, isInteractive })) {
+        await openGitHubIssueWithCrashReport(error);
+      }
+    }
+
+    throw error;
+  }
+};

packages/openapi-ts/src/generate/legacy/output.ts

···
   if (
     !isLegacyClient(config) &&
     'bundle' in clientPlugin.config &&
-    clientPlugin.config.bundle
+    clientPlugin.config.bundle &&
+    !config.dryRun
   ) {
     const meta: ProjectRenderMeta = {
       importFileExtension: config.output.importFileExtension,

packages/openapi-ts/src/generate/output.ts

···
   };
 
   const client = getClientPlugin(context.config);
-  if ('bundle' in client.config && client.config.bundle) {
+  if (
+    'bundle' in client.config &&
+    client.config.bundle &&
+    !context.config.dryRun
+  ) {
     // not proud of this one
     // @ts-expect-error
     context.config._FRAGILE_CLIENT_BUNDLE_RENAMED = generateClientBundle({

packages/openapi-ts/src/index.ts

···
 // @ts-expect-error
 import colorSupport from 'color-support';
 
-import { checkNodeVersion } from '~/config/engine';
-import type { Configs } from '~/config/init';
-import { initConfigs } from '~/config/init';
-import { getLogs } from '~/config/logs';
-import { createClient as pCreateClient } from '~/createClient';
-import {
-  ConfigValidationError,
-  JobError,
-  logCrashReport,
-  openGitHubIssueWithCrashReport,
-  printCrashReport,
-  shouldReportCrash,
-} from '~/error';
-import type { IR } from '~/ir/types';
-import type { Client } from '~/types/client';
 import type { UserConfig } from '~/types/config';
 import type { LazyOrAsync, MaybeArray } from '~/types/utils';
-import { printCliIntro } from '~/utils/cli';
-import { registerHandlebarTemplates } from '~/utils/handlebars';
-import { Logger } from '~/utils/logger';
 
 colors.enabled = colorSupport().hasBasic;
 
-/**
- * Generate a client from the provided configuration.
- *
- * @param userConfig User provided {@link UserConfig} configuration(s).
- */
-export const createClient = async (
-  userConfig?: LazyOrAsync<MaybeArray<UserConfig>>,
-  logger = new Logger(),
-): Promise<ReadonlyArray<Client | IR.Context>> => {
-  const resolvedConfig =
-    typeof userConfig === 'function' ? await userConfig() : userConfig;
-  const userConfigs = resolvedConfig
-    ? resolvedConfig instanceof Array
-      ? resolvedConfig
-      : [resolvedConfig]
-    : [];
-
-  let rawLogs = userConfigs.find(
-    (config) => getLogs(config).level !== 'silent',
-  )?.logs;
-  if (typeof rawLogs === 'string') {
-    rawLogs = getLogs({ logs: rawLogs });
-  }
-
-  let configs: Configs | undefined;
-
-  try {
-    checkNodeVersion();
-
-    const eventCreateClient = logger.timeEvent('createClient');
-
-    const eventConfig = logger.timeEvent('config');
-    configs = await initConfigs({ logger, userConfigs });
-    const printIntro = configs.results.some(
-      (result) => result.config.logs.level !== 'silent',
-    );
-    if (printIntro) {
-      printCliIntro();
-    }
-    eventConfig.timeEnd();
-
-    const allConfigErrors = configs.results.flatMap((result) =>
-      result.errors.map((error) => ({ error, jobIndex: result.jobIndex })),
-    );
-    if (allConfigErrors.length) {
-      throw new ConfigValidationError(allConfigErrors);
-    }
-
-    const eventHandlebars = logger.timeEvent('handlebars');
-    const templates = registerHandlebarTemplates();
-    eventHandlebars.timeEnd();
-
-    const clients = await Promise.all(
-      configs.results.map(async (result) => {
-        try {
-          return await pCreateClient({
-            config: result.config,
-            dependencies: configs!.dependencies,
-            jobIndex: result.jobIndex,
-            logger,
-            templates,
-          });
-        } catch (error) {
-          throw new JobError('', {
-            error,
-            jobIndex: result.jobIndex,
-          });
-        }
-      }),
-    );
-    const result = clients.filter((client) => Boolean(client)) as ReadonlyArray<
-      Client | IR.Context
-    >;
-
-    eventCreateClient.timeEnd();
-
-    const printLogs = configs.results.some(
-      (result) => result.config.logs.level === 'debug',
-    );
-    logger.report(printLogs);
-
-    return result;
-  } catch (error) {
-    const results = configs?.results ?? [];
-
-    const logs =
-      results.find((result) => result.config.logs.level !== 'silent')?.config
-        .logs ??
-      results[0]?.config.logs ??
-      rawLogs;
-    const dryRun =
-      results.some((result) => result.config.dryRun) ??
-      userConfigs.some((config) => config.dryRun) ??
-      false;
-    const logPath =
-      logs?.file && !dryRun
-        ? logCrashReport(error, logs.path ?? '')
-        : undefined;
-    if (!logs || logs.level !== 'silent') {
-      printCrashReport({ error, logPath });
-      const isInteractive =
-        results.some((result) => result.config.interactive) ??
-        userConfigs.some((config) => config.interactive) ??
-        false;
-      if (await shouldReportCrash({ error, isInteractive })) {
-        await openGitHubIssueWithCrashReport(error);
-      }
-    }
-
-    throw error;
-  }
-};
+export { createClient } from './generate';
 
 /**
  * Type helper for openapi-ts.config.ts, returns {@link MaybeArray<UserConfig>} object(s)

packages/openapi-ts/src/ir/context.ts

···
 
 import type { IR } from './types';
 
-export class IRContext<Spec extends Record<string, any> = any> {
+export class Context<Spec extends Record<string, any> = any> {
   /**
    * Configuration for parsing and generating the output. This
    * is a mix of user-provided and default values.

packages/openapi-ts/src/ir/types.d.ts

···
   ServerObject,
 } from '~/openApi/3.1.x/types/spec';
 
-import type { IRContext } from './context';
+import type { Context as IRContext } from './context';
 import type { IRMediaType } from './mediaType';
 
 interface IRBodyObject {

packages/openapi-ts/src/openApi/index.ts

···
 import { satisfies } from '~/config/utils/package';
-import { IRContext } from '~/ir/context';
+import { Context } from '~/ir/context';
 import type { IR } from '~/ir/types';
 import { parseV2_0_X } from '~/openApi/2.0.x';
 import { parseV3_0_X } from '~/openApi/3.0.x';
···
   logger: Logger;
   spec: unknown;
 }): IR.Context | undefined => {
-  const context = new IRContext({
+  const context = new Context({
     config,
     dependencies,
     logger,

packages/openapi-ts/src/openApi/shared/utils/graph.ts

···
 
   eventBuildGraph.timeEnd();
 
-  // functions creating data for debug scripts located in `debug-helpers/`
+  // functions creating data for debug scripts located in `dev/`
   // const { maxChildren, maxDepth, totalNodes } = debugTools.graph.analyzeStructure(graph);
   // const nodesForViz = debugTools.graph.exportForVisualization(graph);
-  // fs.writeFileSync('debug-helpers/graph.json', JSON.stringify(nodesForViz, null, 2));
+  // fs.writeFileSync('dev/graph.json', JSON.stringify(nodesForViz, null, 2));
 
   return { graph };
 };

packages/openapi-ts/src/run.ts

···
+#!/usr/bin/env node
+
+import { runCli } from '~/cli';
+
+runCli();

packages/openapi-ts/tsdown.config.ts

···
   },
   clean: true,
   dts: true,
-  entry: ['src/index.ts', 'src/internal.ts'],
+  entry: ['./src/{index,internal,run}.ts'],
   format: ['cjs', 'esm'],
   minify: !options.watch,
   onSuccess: async () => {

pnpm-lock.yaml

···
       '@hey-api/custom-client':
         specifier: workspace:*
         version: link:packages/custom-client
+      '@hey-api/openapi-ts':
+        specifier: workspace:*
+        version: link:packages/openapi-ts
       '@types/node':
         specifier: 22.10.5
         version: 22.10.5
···
       rollup-plugin-dts:
         specifier: 6.1.1
         version: 6.1.1(rollup@4.31.0)(typescript@5.9.3)
+      ts-node:
+        specifier: 10.9.2
+        version: 10.9.2(@types/node@22.10.5)(typescript@5.9.3)
       tsdown:
         specifier: 0.15.8
         version: 0.15.8(@arethetypeswrong/core@0.18.2)(typescript@5.9.3)
···
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: 19.2.0
-        version: 19.2.0(3d70bfaaf57777265a4e229c41aeb4c6)
+        version: 19.2.0(a969acb6c0970aa981df1cb7672d7c2e)
       '@angular/cli':
         specifier: 19.2.0
         version: 19.2.0(@types/node@22.10.5)(chokidar@4.0.3)
···
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: 19.2.0
-        version: 19.2.0(a969acb6c0970aa981df1cb7672d7c2e)
+        version: 19.2.0(3d70bfaaf57777265a4e229c41aeb4c6)
       '@angular/cli':
         specifier: 19.2.0
         version: 19.2.0(@types/node@22.10.5)(chokidar@4.0.3)
···
       eslint: 9.17.0(jiti@2.6.1)
       eslint-import-resolver-node: 0.3.9
       eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1))
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.17.0(jiti@2.6.1))
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1))
       eslint-plugin-jsx-a11y: 6.10.2(eslint@9.17.0(jiti@2.6.1))
       eslint-plugin-react: 7.37.5(eslint@9.17.0(jiti@2.6.1))
       eslint-plugin-react-hooks: 5.2.0(eslint@9.17.0(jiti@2.6.1))
···
       tinyglobby: 0.2.14
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.17.0(jiti@2.6.1))
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1))
     transitivePeerDependencies:
       - supports-color
 
···
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.17.0(jiti@2.6.1)):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.6.1))(typescript@5.8.3))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1)))(eslint@9.17.0(jiti@2.6.1)):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9

pnpm-workspace.yaml

···
   - examples/**/*
   - packages/**/*
 
-onlyBuiltDependencies:
-  - esbuild
-  - lmdb
-  - msgpackr-extract
-  - sharp
-  - unrs-resolver
-
 patchedDependencies:
   vitepress: patches/vitepress.patch

scripts/examples-generate.sh

···
 ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
 echo "⏳ Generating client code for all examples..."
+
 # Find all examples with openapi-ts script and generate code in parallel
 # Concurrency control: adjust this number depending on CI machine resources
 CONCURRENCY=${CONCURRENCY:-4}
···
     echo "Generating: $example_name"
     set -e
     cd "$dir"
-    echo "-> Running pnpm openapi-ts"
-    pnpm openapi-ts
+    echo "-> Running openapi-ts"
+    pnpm run openapi-ts
 
     # Format generated files in this example only to keep the step fast
     if command -v pnpm >/dev/null 2>&1 && pnpm -w -s --version >/dev/null 2>&1; then
···
     echo "✅ $name succeeded"
   else
     name=$(cat "$tmpdir/$pid.name" 2>/dev/null || echo "$pid")
-    log=$(cat "$tmpdir/$pid.log" 2>/dev/null || echo "(no log)")
-    echo "❌ $name failed — see log: $tmpdir/$pid.log"
+    # Read the metadata file which contains the path to the real log
+    logpath=$(cat "$tmpdir/$pid.log" 2>/dev/null || echo "")
+    if [ -n "$logpath" ] && [ -f "$logpath" ]; then
+      echo "❌ $name failed — showing full log ($logpath):"
+      echo "---- full log start ----"
+      cat "$logpath" || true
+      echo "---- full log end ----"
+    else
+      echo "❌ $name failed — no log found (metadata: $tmpdir/$pid.log)"
+    fi
     failed=1
   fi
 done

scripts/publish-preview-packages.sh

···
-#!/bin/bash
+#!/usr/bin/env bash
 
 result=$(pnpx turbo run build --affected --dry-run=json)