feat(artifacts): complete generic artifact system with upload handlers, tests, and action integration (#798)

- Add ArtifactUploadHandler with support for github-artifacts, storage (rclone),
  and local copy upload targets, including large file chunking for GitHub Artifacts
- Add 44 unit tests covering OutputTypeRegistry, OutputService, and
  ArtifactUploadHandler (config parsing, upload coordination, file collection)
- Add 6 new action.yml inputs for artifact configuration
- Add artifactManifestPath action output
- Wire artifact collection and upload into index.ts post-build flow

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

src/index.ts

@@ -1,8 +1,12 @@
 import * as core from '@actions/core';
+import path from 'node:path';
 import { Action, BuildParameters, Cache, Orchestrator, Docker, ImageTag, Output } from './model';
 import { Cli } from './model/cli/cli';
 import MacBuilder from './model/mac-builder';
 import PlatformSetup from './model/platform-setup';
+import { OutputService } from './model/orchestrator/services/output/output-service';
+import { OutputTypeRegistry } from './model/orchestrator/services/output/output-type-registry';
+import { ArtifactUploadHandler } from './model/orchestrator/services/output/artifact-upload-handler';
 
 async function runMain() {
   try {
@@ -42,6 +46,64 @@ async function runMain() {
     await Output.setAndroidVersionCode(buildParameters.androidVersionCode);
     await Output.setEngineExitCode(exitCode);
 
+    // Artifact collection and upload (runs on both success and failure)
+    try {
+      // Register custom output types if provided
+      if (buildParameters.artifactCustomTypes) {
+        try {
+          const customTypes = JSON.parse(buildParameters.artifactCustomTypes);
+          if (Array.isArray(customTypes)) {
+            for (const ct of customTypes) {
+              OutputTypeRegistry.registerType({
+                name: ct.name,
+                defaultPath: ct.defaultPath || ct.pattern || `./${ct.name}/`,
+                description: ct.description || `Custom output type: ${ct.name}`,
+                builtIn: false,
+              });
+            }
+          }
+        } catch (parseError) {
+          core.warning(`Failed to parse artifactCustomTypes: ${(parseError as Error).message}`);
+        }
+      }
+
+      // Collect outputs and generate manifest
+      const manifestPath = path.join(buildParameters.projectPath, 'output-manifest.json');
+      const manifest = await OutputService.collectOutputs(
+        buildParameters.projectPath,
+        buildParameters.buildGuid,
+        buildParameters.artifactOutputTypes,
+        manifestPath,
+      );
+
+      core.setOutput('artifactManifestPath', manifestPath);
+
+      // Upload artifacts
+      const uploadConfig = ArtifactUploadHandler.parseConfig(
+        buildParameters.artifactUploadTarget,
+        buildParameters.artifactUploadPath || undefined,
+        buildParameters.artifactCompression,
+        buildParameters.artifactRetentionDays,
+      );
+
+      const uploadResult = await ArtifactUploadHandler.uploadArtifacts(
+        manifest,
+        uploadConfig,
+        buildParameters.projectPath,
+      );
+
+      if (!uploadResult.success) {
+        core.warning(
+          `Artifact upload completed with errors: ${uploadResult.entries
+            .filter((e) => !e.success)
+            .map((e) => `${e.type}: ${e.error}`)
+            .join('; ')}`,
+        );
+      }
+    } catch (artifactError) {
+      core.warning(`Artifact collection/upload failed: ${(artifactError as Error).message}`);
+    }
+
     if (exitCode !== 0) {
       core.setFailed(`Build failed with exit code ${exitCode}`);
     }

src/model/build-parameters.ts

@@ -106,6 +106,12 @@ class BuildParameters {
   public cacheUnityInstallationOnMac!: boolean;
   public unityHubVersionOnMac!: string;
   public dockerWorkspacePath!: string;
+  public artifactOutputTypes!: string;
+  public artifactUploadTarget!: string;
+  public artifactUploadPath!: string;
+  public artifactCompression!: string;
+  public artifactRetentionDays!: string;
+  public artifactCustomTypes!: string;
 
   public static shouldUseRetainedWorkspaceMode(buildParameters: BuildParameters) {
     return buildParameters.maxRetainedWorkspaces > 0 && Orchestrator.lockedWorkspace !== ``;
@@ -242,6 +248,12 @@ class BuildParameters {
       cacheUnityInstallationOnMac: Input.cacheUnityInstallationOnMac,
       unityHubVersionOnMac: Input.unityHubVersionOnMac,
       dockerWorkspacePath: Input.dockerWorkspacePath,
+      artifactOutputTypes: Input.artifactOutputTypes,
+      artifactUploadTarget: Input.artifactUploadTarget,
+      artifactUploadPath: Input.artifactUploadPath,
+      artifactCompression: Input.artifactCompression,
+      artifactRetentionDays: Input.artifactRetentionDays,
+      artifactCustomTypes: Input.artifactCustomTypes,
     };
   }
 

src/model/input.ts

@@ -278,6 +278,30 @@ class Input {
     return Input.getInput('containerRegistryImageVersion') ?? '3';
   }
 
+  static get artifactOutputTypes(): string {
+    return Input.getInput('artifactOutputTypes') ?? 'build,logs,test-results';
+  }
+
+  static get artifactUploadTarget(): string {
+    return Input.getInput('artifactUploadTarget') ?? 'github-artifacts';
+  }
+
+  static get artifactUploadPath(): string {
+    return Input.getInput('artifactUploadPath') ?? '';
+  }
+
+  static get artifactCompression(): string {
+    return Input.getInput('artifactCompression') ?? 'gzip';
+  }
+
+  static get artifactRetentionDays(): string {
+    return Input.getInput('artifactRetentionDays') ?? '30';
+  }
+
+  static get artifactCustomTypes(): string {
+    return Input.getInput('artifactCustomTypes') ?? '';
+  }
+
   static get skipActivation(): string {
     return Input.getInput('skipActivation')?.toLowerCase() ?? 'false';
   }

src/model/orchestrator/services/output/artifact-service.test.ts

@@ -0,0 +1,522 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { OutputTypeRegistry, OutputTypeDefinition } from './output-type-registry';
+import { OutputService } from './output-service';
+import { OutputManifest } from './output-manifest';
+import { ArtifactUploadHandler, ArtifactUploadConfig } from './artifact-upload-handler';
+
+// Mock node:fs
+jest.mock('node:fs');
+const mockedFs = fs as jest.Mocked<typeof fs>;
+
+// Mock @actions/core (used by OrchestratorLogger)
+jest.mock('@actions/core', () => ({
+  info: jest.fn(),
+  warning: jest.fn(),
+  error: jest.fn(),
+  setOutput: jest.fn(),
+  getInput: jest.fn(),
+  setFailed: jest.fn(),
+  setSecret: jest.fn(),
+}));
+
+// Mock @actions/exec (used by upload handler for rclone)
+jest.mock('@actions/exec', () => ({
+  exec: jest.fn().mockResolvedValue(0),
+}));
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  OutputTypeRegistry.resetCustomTypes();
+});
+
+// ---------------------------------------------------------------------------
+// OutputTypeRegistry Tests
+// ---------------------------------------------------------------------------
+describe('OutputTypeRegistry', () => {
+  describe('built-in types', () => {
+    it('should have 8 built-in types', () => {
+      const allTypes = OutputTypeRegistry.getAllTypes();
+      const builtInTypes = allTypes.filter((t) => t.builtIn);
+      expect(builtInTypes).toHaveLength(8);
+    });
+
+    it.each(['build', 'test-results', 'server-build', 'data-export', 'images', 'logs', 'metrics', 'coverage'])(
+      'should include built-in type "%s"',
+      (typeName) => {
+        const typeDef = OutputTypeRegistry.getType(typeName);
+        expect(typeDef).toBeDefined();
+        expect(typeDef!.name).toBe(typeName);
+        expect(typeDef!.builtIn).toBe(true);
+      },
+    );
+
+    it('should return undefined for unknown types', () => {
+      const typeDef = OutputTypeRegistry.getType('nonexistent');
+      expect(typeDef).toBeUndefined();
+    });
+
+    it('should include default paths for all built-in types', () => {
+      const allTypes = OutputTypeRegistry.getAllTypes();
+      for (const typeDef of allTypes) {
+        expect(typeDef.defaultPath).toBeTruthy();
+        expect(typeof typeDef.defaultPath).toBe('string');
+      }
+    });
+
+    it('should include descriptions for all built-in types', () => {
+      const allTypes = OutputTypeRegistry.getAllTypes();
+      for (const typeDef of allTypes) {
+        expect(typeDef.description).toBeTruthy();
+        expect(typeof typeDef.description).toBe('string');
+      }
+    });
+  });
+
+  describe('custom type registration', () => {
+    it('should register a custom type', () => {
+      const customType: OutputTypeDefinition = {
+        name: 'custom-reports',
+        defaultPath: './Reports/',
+        description: 'Custom generated reports',
+        builtIn: false,
+      };
+
+      OutputTypeRegistry.registerType(customType);
+      const retrieved = OutputTypeRegistry.getType('custom-reports');
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.name).toBe('custom-reports');
+      expect(retrieved!.builtIn).toBe(false);
+    });
+
+    it('should not override built-in types', () => {
+      const override: OutputTypeDefinition = {
+        name: 'build',
+        defaultPath: './Override/',
+        description: 'Should not override',
+        builtIn: false,
+      };
+
+      OutputTypeRegistry.registerType(override);
+      const buildType = OutputTypeRegistry.getType('build');
+      expect(buildType!.defaultPath).not.toBe('./Override/');
+      expect(buildType!.builtIn).toBe(true);
+    });
+
+    it('should include custom types in getAllTypes', () => {
+      OutputTypeRegistry.registerType({
+        name: 'custom-a',
+        defaultPath: './A/',
+        description: 'Custom A',
+        builtIn: false,
+      });
+
+      const allTypes = OutputTypeRegistry.getAllTypes();
+      expect(allTypes.length).toBe(9); // 8 built-in + 1 custom
+      expect(allTypes.some((t) => t.name === 'custom-a')).toBe(true);
+    });
+
+    it('should reset custom types', () => {
+      OutputTypeRegistry.registerType({
+        name: 'temp-type',
+        defaultPath: './Temp/',
+        description: 'Temporary type',
+        builtIn: false,
+      });
+
+      expect(OutputTypeRegistry.getType('temp-type')).toBeDefined();
+      OutputTypeRegistry.resetCustomTypes();
+      expect(OutputTypeRegistry.getType('temp-type')).toBeUndefined();
+    });
+
+    it('should force builtIn to false when registering custom types', () => {
+      OutputTypeRegistry.registerType({
+        name: 'sneaky',
+        defaultPath: './Sneaky/',
+        description: 'Tries to be built-in',
+        builtIn: true, // Intentionally setting to true
+      });
+
+      const retrieved = OutputTypeRegistry.getType('sneaky');
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.builtIn).toBe(false);
+    });
+  });
+
+  describe('parseOutputTypes', () => {
+    it('should parse a comma-separated string of valid types', () => {
+      const types = OutputTypeRegistry.parseOutputTypes('build,logs,coverage');
+      expect(types).toHaveLength(3);
+      expect(types.map((t) => t.name)).toEqual(['build', 'logs', 'coverage']);
+    });
+
+    it('should skip unknown types', () => {
+      const types = OutputTypeRegistry.parseOutputTypes('build,unknown,logs');
+      expect(types).toHaveLength(2);
+      expect(types.map((t) => t.name)).toEqual(['build', 'logs']);
+    });
+
+    it('should handle empty string', () => {
+      const types = OutputTypeRegistry.parseOutputTypes('');
+      expect(types).toHaveLength(0);
+    });
+
+    it('should handle whitespace in type names', () => {
+      const types = OutputTypeRegistry.parseOutputTypes(' build , logs , coverage ');
+      expect(types).toHaveLength(3);
+    });
+
+    it('should include custom types when parsing', () => {
+      OutputTypeRegistry.registerType({
+        name: 'my-reports',
+        defaultPath: './Reports/',
+        description: 'Custom reports',
+        builtIn: false,
+      });
+
+      const types = OutputTypeRegistry.parseOutputTypes('build,my-reports');
+      expect(types).toHaveLength(2);
+      expect(types[1].name).toBe('my-reports');
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// OutputService Tests
+// ---------------------------------------------------------------------------
+describe('OutputService', () => {
+  const projectPath = '/project';
+  const buildGuid = 'test-guid-1234';
+
+  beforeEach(() => {
+    // Reset all fs mocks
+    mockedFs.existsSync.mockReset();
+    mockedFs.statSync.mockReset();
+    mockedFs.readdirSync.mockReset();
+    mockedFs.writeFileSync.mockReset();
+    mockedFs.mkdirSync.mockReset();
+  });
+
+  describe('collectOutputs', () => {
+    it('should return an empty manifest when no output types are declared', async () => {
+      const manifest = await OutputService.collectOutputs(projectPath, buildGuid, '');
+      expect(manifest.buildGuid).toBe(buildGuid);
+      expect(manifest.outputs).toHaveLength(0);
+      expect(manifest.timestamp).toBeTruthy();
+    });
+
+    it('should skip outputs where the path does not exist', async () => {
+      mockedFs.existsSync.mockReturnValue(false);
+
+      const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'build,logs');
+      expect(manifest.outputs).toHaveLength(0);
+    });
+
+    it('should collect directory outputs with file listings', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => true, size: 0 } as any);
+      mockedFs.readdirSync.mockImplementation((_dirPath: any, options?: any) => {
+        if (options?.withFileTypes) {
+          return [
+            { name: 'file1.txt', isDirectory: () => false },
+            { name: 'file2.txt', isDirectory: () => false },
+          ] as any;
+        }
+
+        return ['file1.txt', 'file2.txt'] as any;
+      });
+
+      const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'logs');
+      expect(manifest.outputs).toHaveLength(1);
+      expect(manifest.outputs[0].type).toBe('logs');
+      expect(manifest.outputs[0].files).toEqual(['file1.txt', 'file2.txt']);
+    });
+
+    it('should collect file output with correct size', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 4096 } as any);
+
+      const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'coverage');
+      expect(manifest.outputs).toHaveLength(1);
+      expect(manifest.outputs[0].size).toBe(4096);
+    });
+
+    it('should write manifest to disk when manifestPath is provided', async () => {
+      // existsSync returns false for output paths (no outputs found) but mkdirSync/writeFileSync should still be called
+      // The service only writes manifest when at least one output type is declared and types are resolved
+      // So we need to provide a valid output type and have its path exist
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 100 } as any);
+      mockedFs.mkdirSync.mockReturnValue(undefined);
+      mockedFs.writeFileSync.mockImplementation(() => {});
+
+      const manifestPath = '/output/manifest.json';
+      await OutputService.collectOutputs(projectPath, buildGuid, 'logs', manifestPath);
+
+      expect(mockedFs.mkdirSync).toHaveBeenCalledWith(path.dirname(manifestPath), { recursive: true });
+      expect(mockedFs.writeFileSync).toHaveBeenCalledWith(manifestPath, expect.any(String), 'utf8');
+    });
+
+    it('should generate valid JSON in the manifest file', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 200 } as any);
+      mockedFs.mkdirSync.mockReturnValue(undefined);
+      mockedFs.writeFileSync.mockImplementation(() => {});
+
+      const manifestPath = '/output/manifest.json';
+      await OutputService.collectOutputs(projectPath, buildGuid, 'coverage', manifestPath);
+
+      const writtenContent = (mockedFs.writeFileSync as jest.Mock).mock.calls[0][1];
+      const parsed = JSON.parse(writtenContent);
+      expect(parsed.buildGuid).toBe(buildGuid);
+      expect(Array.isArray(parsed.outputs)).toBe(true);
+      expect(parsed.outputs.length).toBeGreaterThan(0);
+    });
+
+    it('should set a valid ISO 8601 timestamp', async () => {
+      const manifest = await OutputService.collectOutputs(projectPath, buildGuid, '');
+      const parsed = new Date(manifest.timestamp);
+      expect(parsed.toISOString()).toBe(manifest.timestamp);
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ArtifactUploadHandler Tests
+// ---------------------------------------------------------------------------
+describe('ArtifactUploadHandler', () => {
+  const projectPath = '/project';
+
+  beforeEach(() => {
+    mockedFs.existsSync.mockReset();
+    mockedFs.statSync.mockReset();
+    mockedFs.readdirSync.mockReset();
+    mockedFs.mkdirSync.mockReset();
+    mockedFs.copyFileSync.mockReset();
+  });
+
+  describe('parseConfig', () => {
+    it('should parse valid config values', () => {
+      const config = ArtifactUploadHandler.parseConfig('github-artifacts', '/dest', 'gzip', '14');
+      expect(config.target).toBe('github-artifacts');
+      expect(config.destination).toBe('/dest');
+      expect(config.compression).toBe('gzip');
+      expect(config.retentionDays).toBe(14);
+    });
+
+    it('should default invalid target to github-artifacts', () => {
+      const config = ArtifactUploadHandler.parseConfig('invalid', undefined, 'none', '30');
+      expect(config.target).toBe('github-artifacts');
+    });
+
+    it('should default invalid compression to gzip', () => {
+      const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'brotli', '30');
+      expect(config.compression).toBe('gzip');
+    });
+
+    it('should default invalid retention to 30 days', () => {
+      const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'gzip', 'abc');
+      expect(config.retentionDays).toBe(30);
+    });
+
+    it('should default negative retention to 30 days', () => {
+      const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'gzip', '-5');
+      expect(config.retentionDays).toBe(30);
+    });
+
+    it('should set destination to undefined when empty string', () => {
+      const config = ArtifactUploadHandler.parseConfig('storage', '', 'none', '7');
+      expect(config.destination).toBeUndefined();
+    });
+  });
+
+  describe('uploadArtifacts', () => {
+    it('should skip upload when target is none', async () => {
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [{ type: 'build', path: './Builds/' }],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'none',
+        compression: 'gzip',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(true);
+      expect(result.entries).toHaveLength(0);
+    });
+
+    it('should return success with no entries for empty manifest', async () => {
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'github-artifacts',
+        compression: 'gzip',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(true);
+      expect(result.entries).toHaveLength(0);
+      expect(result.totalBytes).toBe(0);
+    });
+
+    it('should fail entry when output path does not exist', async () => {
+      mockedFs.existsSync.mockReturnValue(false);
+
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [{ type: 'build', path: './Builds/Missing/' }],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'local',
+        destination: '/output',
+        compression: 'none',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(false);
+      expect(result.entries).toHaveLength(1);
+      expect(result.entries[0].success).toBe(false);
+      expect(result.entries[0].error).toContain('does not exist');
+    });
+
+    it('should copy files for local upload target', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 1024 } as any);
+      mockedFs.mkdirSync.mockReturnValue(undefined);
+      mockedFs.copyFileSync.mockReturnValue(undefined);
+
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [{ type: 'logs', path: './Logs/build.log', size: 1024 }],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'local',
+        destination: '/output',
+        compression: 'none',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(true);
+      expect(result.entries).toHaveLength(1);
+      expect(result.entries[0].success).toBe(true);
+      expect(result.totalBytes).toBe(1024);
+    });
+
+    it('should fail local upload when no destination is provided', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 512 } as any);
+
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [{ type: 'logs', path: './Logs/build.log', size: 512 }],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'local',
+        compression: 'none',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(false);
+      expect(result.entries[0].success).toBe(false);
+      expect(result.entries[0].error).toContain('destination path');
+    });
+
+    it('should report correct duration', async () => {
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'none',
+        compression: 'gzip',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('collectFiles', () => {
+    it('should return single file for a file path', () => {
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false } as any);
+
+      const files = ArtifactUploadHandler.collectFiles('/path/to/file.txt');
+      expect(files).toEqual(['/path/to/file.txt']);
+    });
+
+    it('should return all files recursively for a directory', () => {
+      mockedFs.statSync.mockImplementation((p: any) => {
+        const pathStr = typeof p === 'string' ? p : p.toString();
+        if (pathStr.endsWith('.txt') || pathStr.endsWith('.log')) {
+          return { isDirectory: () => false } as any;
+        }
+
+        return { isDirectory: () => true } as any;
+      });
+
+      mockedFs.readdirSync.mockImplementation((dirPath: any, _options?: any) => {
+        const dirStr = typeof dirPath === 'string' ? dirPath : dirPath.toString();
+        if (dirStr === '/root') {
+          return [
+            { name: 'file1.txt', isDirectory: () => false },
+            { name: 'sub', isDirectory: () => true },
+          ] as any;
+        }
+        if (dirStr.endsWith('sub')) {
+          return [{ name: 'file2.log', isDirectory: () => false }] as any;
+        }
+
+        return [] as any;
+      });
+
+      const files = ArtifactUploadHandler.collectFiles('/root');
+      expect(files).toHaveLength(2);
+      expect(files).toContain(path.join('/root', 'file1.txt'));
+      expect(files).toContain(path.join('/root', 'sub', 'file2.log'));
+    });
+  });
+
+  describe('storage upload validation', () => {
+    it('should fail storage upload when no destination is provided', async () => {
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 256 } as any);
+
+      const manifest: OutputManifest = {
+        buildGuid: 'test-guid',
+        timestamp: new Date().toISOString(),
+        outputs: [{ type: 'build', path: './Builds/', size: 256 }],
+      };
+
+      const config: ArtifactUploadConfig = {
+        target: 'storage',
+        compression: 'gzip',
+        retentionDays: 30,
+      };
+
+      const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
+      expect(result.success).toBe(false);
+      expect(result.entries[0].error).toContain('destination URI');
+    });
+  });
+});

src/model/orchestrator/services/output/artifact-upload-handler.ts

@@ -0,0 +1,414 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { exec } from '@actions/exec';
+import OrchestratorLogger from '../core/orchestrator-logger';
+import { OutputManifest, OutputEntry } from './output-manifest';
+
+/**
+ * Configuration for artifact upload.
+ */
+export interface ArtifactUploadConfig {
+  /** Upload target: 'github-artifacts', 'storage', 'local', 'none' */
+  target: 'github-artifacts' | 'storage' | 'local' | 'none';
+
+  /** Destination path — storage URI for 'storage', local path for 'local' */
+  destination?: string;
+
+  /** Compression method */
+  compression: 'none' | 'gzip' | 'lz4';
+
+  /** Retention period in days (GitHub Artifacts only) */
+  retentionDays: number;
+}
+
+/**
+ * Result of an artifact upload operation.
+ */
+export interface UploadResult {
+  /** Whether the upload succeeded overall */
+  success: boolean;
+
+  /** Per-entry upload results */
+  entries: UploadEntryResult[];
+
+  /** Total bytes uploaded */
+  totalBytes: number;
+
+  /** Duration in milliseconds */
+  durationMs: number;
+}
+
+export interface UploadEntryResult {
+  /** The output type name */
+  type: string;
+
+  /** The output path */
+  path: string;
+
+  /** Whether this entry uploaded successfully */
+  success: boolean;
+
+  /** Bytes uploaded for this entry */
+  bytes: number;
+
+  /** Error message if upload failed */
+  error?: string;
+}
+
+/**
+ * GitHub Artifacts size limit per artifact (10 GB).
+ * Files larger than this must be split.
+ */
+const GITHUB_ARTIFACT_SIZE_LIMIT = 10 * 1024 * 1024 * 1024;
+
+/**
+ * Handles uploading build artifacts to various targets.
+ */
+export class ArtifactUploadHandler {
+  /**
+   * Upload artifacts described by a manifest to the configured target.
+   */
+  static async uploadArtifacts(
+    manifest: OutputManifest,
+    config: ArtifactUploadConfig,
+    projectPath: string,
+  ): Promise<UploadResult> {
+    const startTime = Date.now();
+    const result: UploadResult = {
+      success: true,
+      entries: [],
+      totalBytes: 0,
+      durationMs: 0,
+    };
+
+    if (config.target === 'none') {
+      OrchestratorLogger.log('[ArtifactUpload] Upload target is "none", skipping upload');
+      result.durationMs = Date.now() - startTime;
+
+      return result;
+    }
+
+    if (manifest.outputs.length === 0) {
+      OrchestratorLogger.log('[ArtifactUpload] No outputs in manifest, nothing to upload');
+      result.durationMs = Date.now() - startTime;
+
+      return result;
+    }
+
+    OrchestratorLogger.log(`[ArtifactUpload] Uploading ${manifest.outputs.length} output(s) to ${config.target}`);
+
+    for (const entry of manifest.outputs) {
+      const entryResult = await ArtifactUploadHandler.uploadEntry(entry, config, projectPath);
+      result.entries.push(entryResult);
+      result.totalBytes += entryResult.bytes;
+
+      if (!entryResult.success) {
+        result.success = false;
+      }
+    }
+
+    result.durationMs = Date.now() - startTime;
+
+    OrchestratorLogger.log(
+      `[ArtifactUpload] Upload complete: ${result.entries.filter((e) => e.success).length}/${
+        result.entries.length
+      } succeeded, ${result.totalBytes} bytes, ${result.durationMs}ms`,
+    );
+
+    return result;
+  }
+
+  /**
+   * Upload a single output entry.
+   */
+  private static async uploadEntry(
+    entry: OutputEntry,
+    config: ArtifactUploadConfig,
+    projectPath: string,
+  ): Promise<UploadEntryResult> {
+    const entryResult: UploadEntryResult = {
+      type: entry.type,
+      path: entry.path,
+      success: false,
+      bytes: entry.size || 0,
+    };
+
+    const resolvedPath = path.resolve(
+      projectPath,
+      entry.path.replace('{platform}', process.env.BUILD_TARGET || 'Unknown'),
+    );
+
+    if (!fs.existsSync(resolvedPath)) {
+      entryResult.error = `Output path does not exist: ${resolvedPath}`;
+      OrchestratorLogger.logWarning(`[ArtifactUpload] ${entryResult.error}`);
+
+      return entryResult;
+    }
+
+    try {
+      switch (config.target) {
+        case 'github-artifacts':
+          await ArtifactUploadHandler.uploadToGitHubArtifacts(entry, resolvedPath, config);
+          break;
+        case 'storage':
+          await ArtifactUploadHandler.uploadToStorage(entry, resolvedPath, config);
+          break;
+        case 'local':
+          await ArtifactUploadHandler.uploadToLocal(entry, resolvedPath, config);
+          break;
+      }
+      entryResult.success = true;
+      OrchestratorLogger.log(
+        `[ArtifactUpload] Uploaded '${entry.type}' (${entryResult.bytes} bytes) to ${config.target}`,
+      );
+    } catch (error: any) {
+      entryResult.error = error.message || String(error);
+      OrchestratorLogger.logWarning(`[ArtifactUpload] Failed to upload '${entry.type}': ${entryResult.error}`);
+    }
+
+    return entryResult;
+  }
+
+  /**
+   * Upload to GitHub Artifacts via @actions/artifact.
+   * Handles large file splitting if artifacts exceed the size limit.
+   */
+  private static async uploadToGitHubArtifacts(
+    entry: OutputEntry,
+    resolvedPath: string,
+    config: ArtifactUploadConfig,
+  ): Promise<void> {
+    // Dynamically require @actions/artifact — it may not be available in all environments.
+    // Using a variable to prevent TypeScript from resolving the module at compile time.
+    let artifact: any;
+    try {
+      const artifactModule = '@actions/artifact';
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      artifact = require(artifactModule);
+    } catch {
+      throw new Error('@actions/artifact package is not available. Install it to use github-artifacts upload target.');
+    }
+
+    const artifactClient = artifact.DefaultArtifactClient
+      ? new artifact.DefaultArtifactClient()
+      : artifact.default
+      ? new artifact.default()
+      : artifact;
+
+    const files = ArtifactUploadHandler.collectFiles(resolvedPath);
+
+    if (files.length === 0) {
+      OrchestratorLogger.logWarning(`[ArtifactUpload] No files found at ${resolvedPath} for '${entry.type}'`);
+
+      return;
+    }
+
+    const totalSize = entry.size || 0;
+    const artifactName = `unity-output-${entry.type}`;
+
+    if (totalSize > GITHUB_ARTIFACT_SIZE_LIMIT) {
+      OrchestratorLogger.log(
+        `[ArtifactUpload] Output '${entry.type}' exceeds GitHub Artifacts size limit (${totalSize} > ${GITHUB_ARTIFACT_SIZE_LIMIT}), splitting into chunks`,
+      );
+      await ArtifactUploadHandler.uploadChunked(artifactClient, artifactName, files, resolvedPath, config);
+    } else {
+      const rootDirectory = fs.statSync(resolvedPath).isDirectory() ? resolvedPath : path.dirname(resolvedPath);
+
+      if (typeof artifactClient.uploadArtifact === 'function') {
+        await artifactClient.uploadArtifact(artifactName, files, rootDirectory, {
+          retentionDays: config.retentionDays,
+          compressionLevel: config.compression === 'none' ? 0 : 6,
+        });
+      } else {
+        throw new Error(
+          '@actions/artifact client does not have uploadArtifact method. Ensure the package version is compatible.',
+        );
+      }
+    }
+  }
+
+  /**
+   * Upload large artifacts in chunks to stay within GitHub size limits.
+   */
+  private static async uploadChunked(
+    artifactClient: any,
+    baseName: string,
+    files: string[],
+    rootDirectory: string,
+    config: ArtifactUploadConfig,
+  ): Promise<void> {
+    const chunkSize = GITHUB_ARTIFACT_SIZE_LIMIT;
+    let currentChunkFiles: string[] = [];
+    let currentChunkSize = 0;
+    let chunkIndex = 0;
+
+    for (const filePath of files) {
+      const fileSize = fs.statSync(filePath).size;
+
+      if (currentChunkSize + fileSize > chunkSize && currentChunkFiles.length > 0) {
+        await ArtifactUploadHandler.uploadSingleChunk(
+          artifactClient,
+          `${baseName}-part${chunkIndex}`,
+          currentChunkFiles,
+          rootDirectory,
+          config,
+        );
+        chunkIndex++;
+        currentChunkFiles = [];
+        currentChunkSize = 0;
+      }
+
+      currentChunkFiles.push(filePath);
+      currentChunkSize += fileSize;
+    }
+
+    if (currentChunkFiles.length > 0) {
+      await ArtifactUploadHandler.uploadSingleChunk(
+        artifactClient,
+        chunkIndex > 0 ? `${baseName}-part${chunkIndex}` : baseName,
+        currentChunkFiles,
+        rootDirectory,
+        config,
+      );
+    }
+  }
+
+  private static async uploadSingleChunk(
+    artifactClient: any,
+    name: string,
+    files: string[],
+    rootDirectory: string,
+    config: ArtifactUploadConfig,
+  ): Promise<void> {
+    OrchestratorLogger.log(`[ArtifactUpload] Uploading chunk '${name}' with ${files.length} file(s)`);
+
+    if (typeof artifactClient.uploadArtifact === 'function') {
+      await artifactClient.uploadArtifact(name, files, rootDirectory, {
+        retentionDays: config.retentionDays,
+        compressionLevel: config.compression === 'none' ? 0 : 6,
+      });
+    }
+  }
+
+  /**
+   * Upload to remote storage via rclone.
+   */
+  private static async uploadToStorage(
+    entry: OutputEntry,
+    resolvedPath: string,
+    config: ArtifactUploadConfig,
+  ): Promise<void> {
+    if (!config.destination) {
+      throw new Error('Storage upload requires a destination URI in artifactUploadPath');
+    }
+
+    const destination = `${config.destination}/${entry.type}`;
+
+    OrchestratorLogger.log(`[ArtifactUpload] Uploading '${entry.type}' to storage: ${destination}`);
+
+    const args = ['copy', resolvedPath, destination, '--progress'];
+
+    if (config.compression !== 'none') {
+      // rclone doesn't have built-in compression flags for copy;
+      // compression is typically handled by the remote configuration.
+      // Log as informational.
+      OrchestratorLogger.log(
+        `[ArtifactUpload] Note: compression '${config.compression}' is configured at the remote level for rclone`,
+      );
+    }
+
+    await exec('rclone', args);
+  }
+
+  /**
+   * Upload to a local path (copy).
+   */
+  private static async uploadToLocal(
+    entry: OutputEntry,
+    resolvedPath: string,
+    config: ArtifactUploadConfig,
+  ): Promise<void> {
+    if (!config.destination) {
+      throw new Error('Local upload requires a destination path in artifactUploadPath');
+    }
+
+    const destination = path.join(config.destination, entry.type);
+    fs.mkdirSync(destination, { recursive: true });
+
+    OrchestratorLogger.log(`[ArtifactUpload] Copying '${entry.type}' to local path: ${destination}`);
+
+    ArtifactUploadHandler.copyRecursive(resolvedPath, destination);
+  }
+
+  /**
+   * Recursively copy files from source to destination.
+   */
+  private static copyRecursive(source: string, destination: string): void {
+    const stat = fs.statSync(source);
+
+    if (stat.isDirectory()) {
+      fs.mkdirSync(destination, { recursive: true });
+      const entries = fs.readdirSync(source);
+      for (const entry of entries) {
+        ArtifactUploadHandler.copyRecursive(path.join(source, entry), path.join(destination, entry));
+      }
+    } else {
+      fs.copyFileSync(source, destination);
+    }
+  }
+
+  /**
+   * Collect all files at a given path (recursively if directory).
+   */
+  static collectFiles(targetPath: string): string[] {
+    const stat = fs.statSync(targetPath);
+
+    if (!stat.isDirectory()) {
+      return [targetPath];
+    }
+
+    const files: string[] = [];
+    const entries = fs.readdirSync(targetPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(targetPath, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...ArtifactUploadHandler.collectFiles(fullPath));
+      } else {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Parse an ArtifactUploadConfig from action inputs.
+   */
+  static parseConfig(
+    target: string,
+    destination: string | undefined,
+    compression: string,
+    retentionDays: string,
+  ): ArtifactUploadConfig {
+    const validTargets = ['github-artifacts', 'storage', 'local', 'none'] as const;
+    const resolvedTarget = validTargets.includes(target as any)
+      ? (target as ArtifactUploadConfig['target'])
+      : 'github-artifacts';
+
+    const validCompressions = ['none', 'gzip', 'lz4'] as const;
+    const resolvedCompression = validCompressions.includes(compression as any)
+      ? (compression as ArtifactUploadConfig['compression'])
+      : 'gzip';
+
+    const parsedRetention = Number.parseInt(retentionDays, 10);
+    const resolvedRetention = Number.isNaN(parsedRetention) || parsedRetention <= 0 ? 30 : parsedRetention;
+
+    return {
+      target: resolvedTarget,
+      destination: destination || undefined,
+      compression: resolvedCompression,
+      retentionDays: resolvedRetention,
+    };
+  }
+}