feat: CLI plugin adapter for @game-ci/cli

package.json

@@ -3,6 +3,10 @@
   "version": "3.0.0",
   "description": "Build Unity projects for different platforms.",
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli-plugin": "./src/cli-plugin/index.ts"
+  },
   "repository": "git@github.com:game-ci/unity-builder.git",
   "author": "Webber <webber@takken.io>",
   "license": "MIT",

src/cli-plugin/build-parameters-adapter.ts

@@ -0,0 +1,131 @@
+import BuildParameters from '../model/build-parameters';
+import { customAlphabet } from 'nanoid';
+import OrchestratorConstants from '../model/orchestrator/options/orchestrator-constants';
+
+/**
+ * Maps CLI yargs options (flat key-value pairs) into a BuildParameters object.
+ *
+ * When the orchestrator is consumed as a CLI plugin, the CLI collects options via
+ * yargs and passes them as a plain object. This adapter bridges that format to the
+ * BuildParameters class that all providers expect.
+ */
+export function createBuildParametersFromCliOptions(options: Record<string, any>): BuildParameters {
+  const bp = new BuildParameters();
+
+  // Unity / build settings
+  bp.editorVersion = options.engineVersion || options.editorVersion || options.unityVersion || '';
+  bp.customImage = options.customImage || '';
+  bp.unitySerial = options.unitySerial || process.env.UNITY_SERIAL || '';
+  bp.unityLicensingServer = options.unityLicensingServer || '';
+  bp.skipActivation = options.skipActivation || 'false';
+  bp.runnerTempPath = options.runnerTempPath || process.env.RUNNER_TEMP || '';
+  bp.targetPlatform = options.targetPlatform || 'StandaloneLinux64';
+  bp.projectPath = options.projectPath || '.';
+  bp.buildProfile = options.buildProfile || '';
+  bp.buildName = options.buildName || options.targetPlatform || 'StandaloneLinux64';
+  bp.buildPath = options.buildPath || `build/${bp.targetPlatform}`;
+  bp.buildFile = options.buildFile || bp.buildName;
+  bp.buildMethod = options.buildMethod || '';
+  bp.buildVersion = options.buildVersion || '0.0.1';
+  bp.manualExit = options.manualExit === true || options.manualExit === 'true';
+  bp.enableGpu = options.enableGpu === true || options.enableGpu === 'true';
+
+  // Android
+  bp.androidVersionCode = options.androidVersionCode || '';
+  bp.androidKeystoreName = options.androidKeystoreName || '';
+  bp.androidKeystoreBase64 = options.androidKeystoreBase64 || '';
+  bp.androidKeystorePass = options.androidKeystorePass || '';
+  bp.androidKeyaliasName = options.androidKeyaliasName || '';
+  bp.androidKeyaliasPass = options.androidKeyaliasPass || '';
+  bp.androidTargetSdkVersion = options.androidTargetSdkVersion || '';
+  bp.androidSdkManagerParameters = options.androidSdkManagerParameters || '';
+  bp.androidExportType = options.androidExportType || 'androidPackage';
+  bp.androidSymbolType = options.androidSymbolType || 'none';
+
+  // Docker / container settings
+  bp.dockerCpuLimit = options.dockerCpuLimit || '';
+  bp.dockerMemoryLimit = options.dockerMemoryLimit || '';
+  bp.dockerIsolationMode = options.dockerIsolationMode || 'default';
+  bp.containerRegistryRepository = options.containerRegistryRepository || 'unityci/editor';
+  bp.containerRegistryImageVersion = options.containerRegistryImageVersion || '3';
+  bp.dockerWorkspacePath = options.dockerWorkspacePath || '/github/workspace';
+
+  // Provider / orchestrator settings
+  bp.providerStrategy = options.providerStrategy || 'local-docker';
+  bp.customParameters = options.customParameters || '';
+  bp.sshAgent = options.sshAgent || '';
+  bp.sshPublicKeysDirectoryPath = options.sshPublicKeysDirectoryPath || '';
+  bp.gitPrivateToken = options.gitPrivateToken || '';
+  bp.runAsHostUser = options.runAsHostUser || 'false';
+  bp.chownFilesTo = options.chownFilesTo || '';
+
+  // AWS
+  bp.awsStackName = options.awsStackName || 'game-ci';
+  bp.awsEndpoint = options.awsEndpoint;
+  bp.awsCloudFormationEndpoint = options.awsCloudFormationEndpoint || options.awsEndpoint;
+  bp.awsEcsEndpoint = options.awsEcsEndpoint || options.awsEndpoint;
+  bp.awsKinesisEndpoint = options.awsKinesisEndpoint || options.awsEndpoint;
+  bp.awsCloudWatchLogsEndpoint = options.awsCloudWatchLogsEndpoint || options.awsEndpoint;
+  bp.awsS3Endpoint = options.awsS3Endpoint || options.awsEndpoint;
+
+  // Storage
+  bp.storageProvider = options.storageProvider || 's3';
+  bp.rcloneRemote = options.rcloneRemote || '';
+
+  // Kubernetes
+  bp.kubeConfig = options.kubeConfig || '';
+  bp.kubeVolume = options.kubeVolume || '';
+  bp.kubeVolumeSize = options.kubeVolumeSize || '25Gi';
+  bp.kubeStorageClass = options.kubeStorageClass || '';
+
+  // Container resources
+  bp.containerMemory = options.containerMemory || '3072';
+  bp.containerCpu = options.containerCpu || '1024';
+  bp.containerNamespace = options.containerNamespace || 'default';
+
+  // Hooks
+  bp.commandHooks = options.commandHooks || '';
+  bp.postBuildContainerHooks = options.postBuildContainerHooks || '';
+  bp.preBuildContainerHooks = options.preBuildContainerHooks || '';
+  bp.customJob = options.customJob || '';
+
+  // Git / CI
+  bp.runNumber = options.runNumber || process.env.GITHUB_RUN_NUMBER || '0';
+  bp.branch = options.branch || process.env.GITHUB_REF?.replace('refs/', '').replace('heads/', '') || '';
+  bp.githubRepo = options.githubRepo || process.env.GITHUB_REPOSITORY || '';
+  bp.orchestratorRepoName = options.orchestratorRepoName || 'game-ci/unity-builder';
+  bp.cloneDepth = Number.parseInt(options.cloneDepth || '50', 10);
+  bp.gitSha = options.gitSha || process.env.GITHUB_SHA || '';
+  bp.orchestratorBranch = options.orchestratorBranch || 'main';
+  bp.orchestratorDebug = options.orchestratorDebug === true || options.orchestratorDebug === 'true';
+
+  // Build platform
+  bp.buildPlatform = options.buildPlatform || (bp.providerStrategy !== 'local' ? 'linux' : process.platform);
+  bp.isCliMode = true;
+
+  // Caching
+  bp.cacheKey = options.cacheKey || bp.branch;
+  bp.pullInputList = options.pullInputList ? options.pullInputList.split(',') : [];
+  bp.inputPullCommand = options.inputPullCommand || '';
+
+  // Advanced
+  bp.maxRetainedWorkspaces = Number.parseInt(options.maxRetainedWorkspaces || '0', 10);
+  bp.useLargePackages = options.useLargePackages === true || options.useLargePackages === 'true';
+  bp.useCompressionStrategy = options.useCompressionStrategy === true || options.useCompressionStrategy === 'true';
+  bp.garbageMaxAge = Number(options.garbageMaxAge) || 24;
+  bp.githubChecks = options.githubChecks === true || options.githubChecks === 'true';
+  bp.asyncWorkflow = options.asyncOrchestrator === true || options.asyncOrchestrator === 'true';
+  bp.githubCheckId = options.githubCheckId || '';
+  bp.finalHooks = options.finalHooks ? options.finalHooks.split(',') : [];
+  bp.skipLfs = options.skipLfs === true || options.skipLfs === 'true';
+  bp.skipCache = options.skipCache === true || options.skipCache === 'true';
+  bp.cacheUnityInstallationOnMac =
+    options.cacheUnityInstallationOnMac === true || options.cacheUnityInstallationOnMac === 'true';
+  bp.unityHubVersionOnMac = options.unityHubVersionOnMac || '';
+
+  // IDs
+  bp.logId = customAlphabet(OrchestratorConstants.alphabet, 9)();
+  bp.buildGuid = options.buildGuid || `${bp.runNumber}-${bp.targetPlatform}`;
+
+  return bp;
+}

src/cli-plugin/cli-plugin.test.ts

@@ -0,0 +1,94 @@
+import orchestratorPlugin from './index';
+import { createBuildParametersFromCliOptions } from './build-parameters-adapter';
+
+describe('CLI Plugin Adapter', () => {
+  describe('orchestratorPlugin', () => {
+    it('has required GameCIPlugin fields', () => {
+      expect(orchestratorPlugin.name).toBe('orchestrator');
+      expect(orchestratorPlugin.version).toBe('3.0.0');
+    });
+
+    it('registers options plugin with wildcard engine', () => {
+      expect(orchestratorPlugin.options).toHaveLength(1);
+      expect(orchestratorPlugin.options[0].engine).toBe('*');
+      expect(typeof orchestratorPlugin.options[0].configure).toBe('function');
+    });
+
+    it('exposes all built-in provider strategies', () => {
+      const providers = orchestratorPlugin.providers;
+      expect(providers).toHaveProperty('aws');
+      expect(providers).toHaveProperty('k8s');
+      expect(providers).toHaveProperty('local-docker');
+      expect(providers).toHaveProperty('local-system');
+      expect(providers).toHaveProperty('local');
+      expect(providers).toHaveProperty('test');
+    });
+
+    it('provider constructors are functions', () => {
+      for (const [, Ctor] of Object.entries(orchestratorPlugin.providers)) {
+        expect(typeof Ctor).toBe('function');
+      }
+    });
+  });
+
+  describe('configureOrchestratorOptions', () => {
+    it('registers options on a yargs-like object', () => {
+      const registered: Record<string, any> = {};
+      const mockYargs = {
+        option(name: string, config: any) {
+          registered[name] = config;
+
+          return mockYargs;
+        },
+      };
+
+      orchestratorPlugin.options[0].configure(mockYargs);
+
+      // Spot-check key options
+
+      expect(registered).toHaveProperty('containerCpu');
+      expect(registered).toHaveProperty('containerMemory');
+      expect(registered).toHaveProperty('awsStackName');
+      expect(registered).toHaveProperty('kubeConfig');
+      expect(registered).toHaveProperty('storageProvider');
+      expect(registered).toHaveProperty('commandHooks');
+      expect(registered).toHaveProperty('orchestratorDebug');
+      expect(registered).toHaveProperty('region');
+    });
+  });
+
+  describe('createBuildParametersFromCliOptions', () => {
+    it('maps yargs options to BuildParameters', () => {
+      const bp = createBuildParametersFromCliOptions({
+        providerStrategy: 'aws',
+        containerMemory: '4096',
+        containerCpu: '2048',
+        awsStackName: 'my-stack',
+        targetPlatform: 'StandaloneLinux64',
+        buildName: 'MyGame',
+        kubeConfig: 'base64config',
+      });
+
+      expect(bp.providerStrategy).toBe('aws');
+      expect(bp.containerMemory).toBe('4096');
+      expect(bp.containerCpu).toBe('2048');
+      expect(bp.awsStackName).toBe('my-stack');
+      expect(bp.targetPlatform).toBe('StandaloneLinux64');
+      expect(bp.buildName).toBe('MyGame');
+      expect(bp.kubeConfig).toBe('base64config');
+      expect(bp.isCliMode).toBe(true);
+    });
+
+    it('applies defaults for missing options', () => {
+      const bp = createBuildParametersFromCliOptions({});
+
+      expect(bp.providerStrategy).toBe('local-docker');
+      expect(bp.containerMemory).toBe('3072');
+      expect(bp.containerCpu).toBe('1024');
+      expect(bp.awsStackName).toBe('game-ci');
+      expect(bp.containerNamespace).toBe('default');
+      expect(bp.kubeVolumeSize).toBe('25Gi');
+      expect(bp.storageProvider).toBe('s3');
+    });
+  });
+});

src/cli-plugin/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @game-ci/orchestrator-plugin
+ *
+ * CLI plugin adapter for the unity-builder orchestrator.
+ * Exports a GameCIPlugin that the CLI consumes via PluginRegistry.
+ *
+ * Usage in CLI:
+ *   import orchestratorPlugin from '@game-ci/orchestrator-plugin';
+ *   await PluginRegistry.register(orchestratorPlugin);
+ *
+ * Or via plugin loader:
+ *   await PluginLoader.load('@game-ci/orchestrator-plugin');
+ */
+
+import AwsBuildPlatform from '../model/orchestrator/providers/aws';
+import Kubernetes from '../model/orchestrator/providers/k8s';
+import LocalDockerOrchestrator from '../model/orchestrator/providers/docker';
+import LocalOrchestrator from '../model/orchestrator/providers/local';
+import TestOrchestrator from '../model/orchestrator/providers/test';
+import { configureOrchestratorOptions } from './orchestrator-options-plugin';
+import { createProviderAdapter } from './provider-adapter';
+
+/**
+ * GameCIPlugin-compatible export.
+ *
+ * This object matches the GameCIPlugin interface defined in @game-ci/cli:
+ * - name, version: plugin metadata
+ * - options: registers orchestrator-specific CLI options (aws, k8s, hooks, etc.)
+ * - providers: maps strategy names to provider constructors
+ */
+const orchestratorPlugin = {
+  name: 'orchestrator',
+  version: '3.0.0',
+
+  /**
+   * Options plugins — register orchestrator-specific yargs options.
+   * engine: '*' means these options apply regardless of which engine is detected.
+   */
+  options: [
+    {
+      engine: '*',
+      configure: configureOrchestratorOptions,
+    },
+  ],
+
+  /**
+   * Provider constructors keyed by strategy name.
+   * Each is wrapped via createProviderAdapter so the CLI can instantiate them
+   * with yargs options (flat key-value) instead of BuildParameters directly.
+   */
+  providers: {
+    aws: createProviderAdapter(AwsBuildPlatform),
+    k8s: createProviderAdapter(Kubernetes),
+    'local-docker': createProviderAdapter(LocalDockerOrchestrator),
+    'local-system': createProviderAdapter(LocalOrchestrator),
+    local: createProviderAdapter(LocalOrchestrator),
+    test: createProviderAdapter(TestOrchestrator),
+  },
+};
+
+export default orchestratorPlugin;
+export { orchestratorPlugin };
+export { createBuildParametersFromCliOptions } from './build-parameters-adapter';
+export { configureOrchestratorOptions } from './orchestrator-options-plugin';
+export { createProviderAdapter } from './provider-adapter';