feat(cli): add npm publish workflow and CLI tests

Add .github/workflows/publish-cli.yml for publishing the CLI to npm on
release or via manual workflow_dispatch with dry-run support.

Add comprehensive test coverage for the CLI:
- input-mapper.test.ts: 16 tests covering argument mapping, boolean
  conversion, yargs internal property filtering, and Cli.options population
- commands.test.ts: 26 tests verifying command exports, builder flags,
  default values, and camelCase aliases for all six commands
- cli-integration.test.ts: 8 integration tests spawning the CLI process
  to verify help output, version info, and error handling

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: frostebite

.github/workflows/publish-cli.yml

@@ -0,0 +1,57 @@
+name: Publish CLI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      dry-run:
+        description: 'Dry run (no actual publish)'
+        required: false
+        default: 'true'
+        type: boolean
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Build
+        run: yarn build
+
+      - name: Run tests
+        run: yarn test
+
+      - name: Verify CLI
+        run: |
+          node lib/cli.js version
+          node lib/cli.js --help
+
+      - name: Publish (dry run)
+        if: github.event_name == 'workflow_dispatch' && inputs.dry-run == 'true'
+        run: npm publish --dry-run
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Publish
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.dry-run == 'false')
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

src/cli/__tests__/cli-integration.test.ts

@@ -0,0 +1,100 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+
+/**
+ * Integration tests that spawn the CLI as a child process and verify
+ * exit codes and output. Uses node with --require ts-node/register to
+ * run the TypeScript entry point directly so no build step is required.
+ */
+
+const CLI_ENTRY = path.resolve(__dirname, '..', '..', 'cli.ts');
+
+function runCli(cliArguments: string[]): Promise<{ code: number | null; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      ['--require', 'ts-node/register/transpile-only', CLI_ENTRY, ...cliArguments],
+      { timeout: 30_000, cwd: path.resolve(__dirname, '..', '..', '..') },
+      (error, stdout, stderr) => {
+        resolve({
+          code: error ? error.code ?? 1 : 0,
+          stdout: stdout.toString(),
+          stderr: stderr.toString(),
+        });
+      },
+    );
+  });
+}
+
+// Integration tests spawn child processes which need more time than the default 5s
+jest.setTimeout(30_000);
+
+describe('CLI integration', () => {
+  it('exits 0 and shows all commands for --help', async () => {
+    const result = await runCli(['--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('game-ci');
+    expect(result.stdout).toContain('build');
+    expect(result.stdout).toContain('activate');
+    expect(result.stdout).toContain('orchestrate');
+    expect(result.stdout).toContain('cache');
+    expect(result.stdout).toContain('status');
+    expect(result.stdout).toContain('version');
+  });
+
+  it('exits 0 and shows version info for version command', async () => {
+    const result = await runCli(['version']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('unity-builder');
+  });
+
+  it('exits 0 and shows build flags for build --help', async () => {
+    const result = await runCli(['build', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--target-platform');
+    expect(result.stdout).toContain('--unity-version');
+    expect(result.stdout).toContain('--project-path');
+    expect(result.stdout).toContain('--build-name');
+    expect(result.stdout).toContain('--builds-path');
+    expect(result.stdout).toContain('--build-method');
+    expect(result.stdout).toContain('--custom-parameters');
+    expect(result.stdout).toContain('--provider-strategy');
+  });
+
+  it('exits non-zero for an unknown command', async () => {
+    const result = await runCli(['nonexistent']);
+
+    expect(result.code).not.toStrictEqual(0);
+  });
+
+  it('exits non-zero when no command is provided', async () => {
+    const result = await runCli([]);
+
+    expect(result.code).not.toStrictEqual(0);
+  });
+
+  it('exits 0 for orchestrate --help', async () => {
+    const result = await runCli(['orchestrate', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--target-platform');
+    expect(result.stdout).toContain('--provider-strategy');
+  });
+
+  it('exits 0 for activate --help', async () => {
+    const result = await runCli(['activate', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('activate');
+  });
+
+  it('exits 0 for cache --help', async () => {
+    const result = await runCli(['cache', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('cache');
+  });
+});

src/cli/__tests__/commands.test.ts

@@ -0,0 +1,224 @@
+import buildCommand from '../commands/build';
+import activateCommand from '../commands/activate';
+import orchestrateCommand from '../commands/orchestrate';
+import cacheCommand from '../commands/cache';
+import statusCommand from '../commands/status';
+import versionCommand from '../commands/version';
+
+function createFakeYargs(): { yargs: any; options: Record<string, any> } {
+  const options: Record<string, any> = {};
+  const yargs: any = {
+    option: jest.fn(),
+    positional: jest.fn(),
+    example: jest.fn(),
+    env: jest.fn(),
+  };
+
+  yargs.option.mockImplementation((name: string, config: any) => {
+    options[name] = config;
+
+    return yargs;
+  });
+  yargs.positional.mockImplementation((name: string, config: any) => {
+    options[name] = config;
+
+    return yargs;
+  });
+  yargs.example.mockReturnValue(yargs);
+  yargs.env.mockReturnValue(yargs);
+
+  return { yargs, options };
+}
+
+describe('CLI commands', () => {
+  describe('build command', () => {
+    it('exports the correct command name', () => {
+      expect(buildCommand.command).toStrictEqual('build');
+    });
+
+    it('has a description', () => {
+      expect(buildCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof buildCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof buildCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines all expected build flags via builder', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      // Core build flags
+      expect(options['target-platform']).toBeDefined();
+      expect(options['target-platform'].demandOption).toStrictEqual(true);
+      expect(options['unity-version']).toBeDefined();
+      expect(options['project-path']).toBeDefined();
+      expect(options['build-profile']).toBeDefined();
+      expect(options['build-name']).toBeDefined();
+      expect(options['builds-path']).toBeDefined();
+      expect(options['build-method']).toBeDefined();
+      expect(options['custom-parameters']).toBeDefined();
+      expect(options['versioning']).toBeDefined();
+      expect(options['version']).toBeDefined();
+      expect(options['custom-image']).toBeDefined();
+      expect(options['manual-exit']).toBeDefined();
+      expect(options['enable-gpu']).toBeDefined();
+
+      // Android flags
+      expect(options['android-version-code']).toBeDefined();
+      expect(options['android-export-type']).toBeDefined();
+      expect(options['android-keystore-name']).toBeDefined();
+      expect(options['android-keystore-base64']).toBeDefined();
+      expect(options['android-keystore-pass']).toBeDefined();
+      expect(options['android-keyalias-name']).toBeDefined();
+      expect(options['android-keyalias-pass']).toBeDefined();
+      expect(options['android-target-sdk-version']).toBeDefined();
+      expect(options['android-symbol-type']).toBeDefined();
+
+      // Docker flags
+      expect(options['docker-cpu-limit']).toBeDefined();
+      expect(options['docker-memory-limit']).toBeDefined();
+      expect(options['docker-workspace-path']).toBeDefined();
+      expect(options['run-as-host-user']).toBeDefined();
+      expect(options['chown-files-to']).toBeDefined();
+
+      // Provider flags
+      expect(options['provider-strategy']).toBeDefined();
+      expect(options['skip-activation']).toBeDefined();
+      expect(options['unity-licensing-server']).toBeDefined();
+    });
+
+    it('sets correct default values', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      expect(options['unity-version'].default).toStrictEqual('auto');
+      expect(options['project-path'].default).toStrictEqual('.');
+      expect(options['builds-path'].default).toStrictEqual('build');
+      expect(options['versioning'].default).toStrictEqual('Semantic');
+      expect(options['manual-exit'].default).toStrictEqual(false);
+      expect(options['enable-gpu'].default).toStrictEqual(false);
+      expect(options['android-export-type'].default).toStrictEqual('androidPackage');
+      expect(options['android-symbol-type'].default).toStrictEqual('none');
+      expect(options['provider-strategy'].default).toStrictEqual('local');
+    });
+
+    it('provides camelCase aliases for kebab-case options', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      expect(options['target-platform'].alias).toStrictEqual('targetPlatform');
+      expect(options['unity-version'].alias).toStrictEqual('unityVersion');
+      expect(options['project-path'].alias).toStrictEqual('projectPath');
+      expect(options['build-name'].alias).toStrictEqual('buildName');
+      expect(options['builds-path'].alias).toStrictEqual('buildsPath');
+      expect(options['build-method'].alias).toStrictEqual('buildMethod');
+    });
+  });
+
+  describe('activate command', () => {
+    it('exports the correct command name', () => {
+      expect(activateCommand.command).toStrictEqual('activate');
+    });
+
+    it('has a description', () => {
+      expect(activateCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof activateCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof activateCommand.handler).toStrictEqual('function');
+    });
+  });
+
+  describe('orchestrate command', () => {
+    it('exports the correct command name', () => {
+      expect(orchestrateCommand.command).toStrictEqual('orchestrate');
+    });
+
+    it('has a description', () => {
+      expect(orchestrateCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof orchestrateCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof orchestrateCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines key orchestrator flags', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (orchestrateCommand.builder as Function)(yargs);
+
+      expect(options['target-platform']).toBeDefined();
+      expect(options['target-platform'].demandOption).toStrictEqual(true);
+      expect(options['provider-strategy']).toBeDefined();
+      expect(options['provider-strategy'].default).toStrictEqual('aws');
+      expect(options['aws-stack-name']).toBeDefined();
+      expect(options['kube-config']).toBeDefined();
+      expect(options['kube-volume']).toBeDefined();
+      expect(options['cache-key']).toBeDefined();
+      expect(options['watch-to-end']).toBeDefined();
+      expect(options['clone-depth']).toBeDefined();
+    });
+  });
+
+  describe('cache command', () => {
+    it('exports the correct command name', () => {
+      expect(cacheCommand.command).toStrictEqual('cache <action>');
+    });
+
+    it('has a description', () => {
+      expect(cacheCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof cacheCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof cacheCommand.handler).toStrictEqual('function');
+    });
+  });
+
+  describe('status command', () => {
+    it('exports the correct command name', () => {
+      expect(statusCommand.command).toStrictEqual('status');
+    });
+
+    it('has a description', () => {
+      expect(statusCommand.describe).toBeTruthy();
+    });
+
+    it('has a handler function', () => {
+      expect(typeof statusCommand.handler).toStrictEqual('function');
+    });
+  });
+
+  describe('version command', () => {
+    it('exports the correct command name', () => {
+      expect(versionCommand.command).toStrictEqual('version');
+    });
+
+    it('has a description', () => {
+      expect(versionCommand.describe).toBeTruthy();
+    });
+
+    it('has a handler function', () => {
+      expect(typeof versionCommand.handler).toStrictEqual('function');
+    });
+  });
+});