create-aws-project 1.3.0 → 1.5.0

package/README.md

@@ -2,7 +2,9 @@
 
 Create a new AWS project from scratch including CloudFront, API Gateway, Lambdas, Cognito or Auth0, DynamoDB. GitHub pipeline for testing and deploying.
 
-[![npm version](https://img.shields.io/npm/v/create-aws-starter-kit.svg)](https://www.npmjs.com/package/create-aws-starter-kit)
+[![npm version](https://img.shields.io/npm/v/create-aws-project.svg)](https://www.npmjs.com/package/create-aws-project)
+
+![AWS Architecture Diagram](./aws-architecture-diagram.svg)
 
 ## Quick Start
 
@@ -33,7 +35,7 @@ The generated project is a full-stack Nx monorepo with:
 ## CLI Options
 
 ```
-create-aws-starter-kit [command] [options]
+create-aws-project [command] [options]
 
 Commands:
   (default)           Create a new project (interactive wizard)
@@ -45,10 +47,10 @@ Options:
   --version, -v       Show version number
 
 Examples:
-  npx create-aws-starter-kit my-app
-  npx create-aws-starter-kit setup-aws-envs
-  npx create-aws-starter-kit initialize-github dev
-  npx create-aws-starter-kit --help
+  npx create-aws-project my-app
+  npx create-aws-project setup-aws-envs
+  npx create-aws-project initialize-github dev
+  npx create-aws-project --help
 ```
 
 ## Wizard Prompts
@@ -74,30 +76,6 @@ The interactive wizard will ask you about:
   - Note: Node 25+ has Jest compatibility issues - use 22.x or 24.x
 - **npm** - Included with Node.js
 
-## After Generation
-
-Once your project is created:
-
-```bash
-cd my-project
-npm install
-```
-
-Then start developing:
-
-```bash
-# Start web app
-npm run web
-
-# Start mobile app
-npm run mobile
-
-# Deploy API to AWS
-npm run cdk:deploy
-```
-
-See the generated project's README for detailed documentation.
-
 ## Post-Install Setup
 
 After creating your project, you'll set up AWS environments and GitHub deployment. This is a one-time setup.
@@ -109,7 +87,29 @@ Before you begin:
 - GitHub repository created for your project
 - GitHub Personal Access Token with "repo" scope ([create one here](https://github.com/settings/tokens/new))
 
-### Step 1: Set Up AWS Environments
+### Step 1: connect to your .git project
+
+* Initialize the repository
+```
+git init
+```
+
+* Add the remote repository using the git remote add <name> <url> command. A common practice is to name it origin.
+```bash
+git remote add origin <REMOTE_URL>
+```
+
+* Verify the connection by listing your remotes. The -v flag shows the URLs.
+```bash
+git remote -v
+```
+
+* Push your local commits to the remote repository for the first time.
+```bash
+git push -u origin main
+```
+
+### Step 2: Set Up AWS Environments
 
 From your project directory, run:
 
@@ -136,7 +136,7 @@ AWS environment setup complete!
 
 Account IDs are saved to `.aws-starter-config.json` for the next step.
 
-### Step 2: Configure GitHub Environments
+### Step 3: Configure GitHub Environments
 
 For each environment, run:
 
@@ -215,6 +215,30 @@ Your Personal Access Token may be invalid or missing permissions. Ensure:
 
 Create a new token at: https://github.com/settings/tokens/new
 
+## After Setup
+
+Once your project is set up:
+
+```bash
+cd my-project
+npm install
+```
+
+Then start developing:
+
+```bash
+# Start web app
+npm run web
+
+# Start mobile app
+npm run mobile
+
+# Deploy API to AWS
+npm run cdk:deploy
+```
+
+See the generated project's README for detailed documentation.
+
 ## License
 
 ISC

package/dist/__tests__/harness/fixtures/config-factories.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectConfig } from '../../../types.js';
+export declare const createWebCognitoConfig: () => ProjectConfig;
+export declare const createWebAuth0Config: () => ProjectConfig;
+export declare const createMobileCognitoConfig: () => ProjectConfig;
+export declare const createMobileAuth0Config: () => ProjectConfig;
+export declare const createApiCognitoConfig: () => ProjectConfig;
+export declare const createApiAuth0Config: () => ProjectConfig;
+export declare const createWebMobileCognitoConfig: () => ProjectConfig;
+export declare const createWebMobileAuth0Config: () => ProjectConfig;
+export declare const createWebApiCognitoConfig: () => ProjectConfig;
+export declare const createWebApiAuth0Config: () => ProjectConfig;
+export declare const createMobileApiCognitoConfig: () => ProjectConfig;
+export declare const createMobileApiAuth0Config: () => ProjectConfig;
+export declare const createFullStackCognitoConfig: () => ProjectConfig;
+export declare const createFullStackAuth0Config: () => ProjectConfig;

package/dist/__tests__/harness/fixtures/config-factories.js

@@ -0,0 +1,71 @@
+/**
+ * Create a base configuration with sensible defaults.
+ * All factories should call this to ensure consistent structure.
+ */
+function createBaseConfig(overrides = {}) {
+    const authProvider = overrides.authProvider ?? 'cognito';
+    return {
+        projectName: overrides.projectName ?? 'test-project',
+        platforms: overrides.platforms ?? ['web', 'api'],
+        awsRegion: overrides.awsRegion ?? 'us-east-1',
+        features: overrides.features ?? [],
+        brandColor: overrides.brandColor ?? 'blue',
+        auth: {
+            provider: authProvider,
+            features: authProvider === 'none' ? [] : (overrides.authFeatures ?? []),
+        },
+    };
+}
+// Single platform factories
+export const createWebCognitoConfig = () => createBaseConfig({ projectName: 'test-web-cognito', platforms: ['web'], authProvider: 'cognito' });
+export const createWebAuth0Config = () => createBaseConfig({ projectName: 'test-web-auth0', platforms: ['web'], authProvider: 'auth0' });
+export const createMobileCognitoConfig = () => createBaseConfig({
+    projectName: 'test-mobile-cognito',
+    platforms: ['mobile'],
+    authProvider: 'cognito',
+});
+export const createMobileAuth0Config = () => createBaseConfig({ projectName: 'test-mobile-auth0', platforms: ['mobile'], authProvider: 'auth0' });
+export const createApiCognitoConfig = () => createBaseConfig({ projectName: 'test-api-cognito', platforms: ['api'], authProvider: 'cognito' });
+export const createApiAuth0Config = () => createBaseConfig({ projectName: 'test-api-auth0', platforms: ['api'], authProvider: 'auth0' });
+// Double platform factories
+export const createWebMobileCognitoConfig = () => createBaseConfig({
+    projectName: 'test-web-mobile-cognito',
+    platforms: ['web', 'mobile'],
+    authProvider: 'cognito',
+});
+export const createWebMobileAuth0Config = () => createBaseConfig({
+    projectName: 'test-web-mobile-auth0',
+    platforms: ['web', 'mobile'],
+    authProvider: 'auth0',
+});
+export const createWebApiCognitoConfig = () => createBaseConfig({
+    projectName: 'test-web-api-cognito',
+    platforms: ['web', 'api'],
+    authProvider: 'cognito',
+});
+export const createWebApiAuth0Config = () => createBaseConfig({
+    projectName: 'test-web-api-auth0',
+    platforms: ['web', 'api'],
+    authProvider: 'auth0',
+});
+export const createMobileApiCognitoConfig = () => createBaseConfig({
+    projectName: 'test-mobile-api-cognito',
+    platforms: ['mobile', 'api'],
+    authProvider: 'cognito',
+});
+export const createMobileApiAuth0Config = () => createBaseConfig({
+    projectName: 'test-mobile-api-auth0',
+    platforms: ['mobile', 'api'],
+    authProvider: 'auth0',
+});
+// Triple platform factories
+export const createFullStackCognitoConfig = () => createBaseConfig({
+    projectName: 'test-full-cognito',
+    platforms: ['web', 'mobile', 'api'],
+    authProvider: 'cognito',
+});
+export const createFullStackAuth0Config = () => createBaseConfig({
+    projectName: 'test-full-auth0',
+    platforms: ['web', 'mobile', 'api'],
+    authProvider: 'auth0',
+});

package/dist/__tests__/harness/fixtures/fixtures.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/harness/fixtures/fixtures.spec.js

@@ -0,0 +1,89 @@
+import { describe, it, expect } from '@jest/globals';
+import { TEST_MATRIX, getConfigsByTier, getConfigByName } from './matrix.js';
+describe('Test Fixtures', () => {
+    describe('TEST_MATRIX', () => {
+        it('should define exactly 14 configurations', () => {
+            expect(TEST_MATRIX).toHaveLength(14);
+        });
+        it('should have unique names for all configurations', () => {
+            const names = TEST_MATRIX.map(c => c.name);
+            const uniqueNames = new Set(names);
+            expect(uniqueNames.size).toBe(names.length);
+        });
+        it('should have unique project names for all configurations', () => {
+            const projectNames = TEST_MATRIX.map(c => c.config.projectName);
+            const uniqueNames = new Set(projectNames);
+            expect(uniqueNames.size).toBe(projectNames.length);
+        });
+        it('should cover all 7 platform combinations', () => {
+            const platformSets = TEST_MATRIX.map(c => [...c.config.platforms].sort().join('+'));
+            const uniquePlatforms = new Set(platformSets);
+            expect(uniquePlatforms.size).toBe(7);
+        });
+        it('should cover both auth providers (cognito, auth0)', () => {
+            const authProviders = TEST_MATRIX.map(c => c.config.auth.provider);
+            const uniqueProviders = new Set(authProviders);
+            expect(uniqueProviders).toContain('cognito');
+            expect(uniqueProviders).toContain('auth0');
+        });
+        it('should not include auth provider none', () => {
+            const authProviders = TEST_MATRIX.map(c => c.config.auth.provider);
+            const uniqueProviders = new Set(authProviders);
+            expect(uniqueProviders).not.toContain('none');
+        });
+    });
+    describe('getConfigsByTier', () => {
+        it('should return 1 config for smoke tier', () => {
+            const configs = getConfigsByTier('smoke');
+            expect(configs).toHaveLength(1);
+        });
+        it('should return 5 configs for core tier (smoke + core)', () => {
+            const configs = getConfigsByTier('core');
+            expect(configs).toHaveLength(5);
+        });
+        it('should return all 14 configs for full tier', () => {
+            const configs = getConfigsByTier('full');
+            expect(configs).toHaveLength(14);
+        });
+        it('core tier should include at least one config per platform', () => {
+            const configs = getConfigsByTier('core');
+            const platforms = new Set();
+            for (const config of configs) {
+                for (const platform of config.config.platforms) {
+                    platforms.add(platform);
+                }
+            }
+            expect(platforms).toContain('web');
+            expect(platforms).toContain('mobile');
+            expect(platforms).toContain('api');
+        });
+        it('core tier should include at least one config per auth provider', () => {
+            const configs = getConfigsByTier('core');
+            const providers = new Set(configs.map(c => c.config.auth.provider));
+            expect(providers).toContain('cognito');
+            expect(providers).toContain('auth0');
+        });
+    });
+    describe('getConfigByName', () => {
+        it('should return config when name exists', () => {
+            const config = getConfigByName('web-api-cognito');
+            expect(config.name).toBe('web-api-cognito');
+        });
+        it('should throw when name does not exist', () => {
+            expect(() => getConfigByName('nonexistent')).toThrow('Configuration "nonexistent" not found in TEST_MATRIX');
+        });
+    });
+    describe('Config validity', () => {
+        it.each(TEST_MATRIX)('$name should have valid ProjectConfig structure', ({ config }) => {
+            // Required fields
+            expect(config.projectName).toBeDefined();
+            expect(config.platforms.length).toBeGreaterThan(0);
+            expect(config.awsRegion).toBeDefined();
+            expect(config.brandColor).toBeDefined();
+            expect(config.auth.provider).toBeDefined();
+            // Valid values
+            expect(['web', 'mobile', 'api']).toEqual(expect.arrayContaining(config.platforms));
+            expect(['cognito', 'auth0', 'none']).toContain(config.auth.provider);
+        });
+    });
+});

package/dist/__tests__/harness/fixtures/index.d.ts

@@ -0,0 +1,2 @@
+export { createWebCognitoConfig, createWebAuth0Config, createMobileCognitoConfig, createMobileAuth0Config, createApiCognitoConfig, createApiAuth0Config, createWebMobileCognitoConfig, createWebMobileAuth0Config, createWebApiCognitoConfig, createWebApiAuth0Config, createMobileApiCognitoConfig, createMobileApiAuth0Config, createFullStackCognitoConfig, createFullStackAuth0Config, } from './config-factories.js';
+export { TEST_MATRIX, getConfigsByTier, getConfigByName, type TestTier, type TestConfiguration, } from './matrix.js';

package/dist/__tests__/harness/fixtures/index.js

@@ -0,0 +1,2 @@
+export { createWebCognitoConfig, createWebAuth0Config, createMobileCognitoConfig, createMobileAuth0Config, createApiCognitoConfig, createApiAuth0Config, createWebMobileCognitoConfig, createWebMobileAuth0Config, createWebApiCognitoConfig, createWebApiAuth0Config, createMobileApiCognitoConfig, createMobileApiAuth0Config, createFullStackCognitoConfig, createFullStackAuth0Config, } from './config-factories.js';
+export { TEST_MATRIX, getConfigsByTier, getConfigByName, } from './matrix.js';

package/dist/__tests__/harness/fixtures/matrix.d.ts

@@ -0,0 +1,28 @@
+import type { ProjectConfig } from '../../../types.js';
+export type TestTier = 'smoke' | 'core' | 'full';
+export interface TestConfiguration {
+    name: string;
+    config: ProjectConfig;
+    tier: TestTier;
+}
+/**
+ * Complete test matrix: 14 configurations (7 platforms x 2 auth providers)
+ *
+ * Tier assignments:
+ * - smoke: 1 config (quick sanity check)
+ * - core: 4 configs (PR validation - covers all platforms and auth providers)
+ * - full: 9 configs (release validation - remaining combinations)
+ */
+export declare const TEST_MATRIX: TestConfiguration[];
+/**
+ * Get configurations by tier (cumulative)
+ * - 'smoke' returns smoke configs only (1)
+ * - 'core' returns smoke + core configs (5)
+ * - 'full' returns all configs (14)
+ */
+export declare function getConfigsByTier(tier: TestTier): TestConfiguration[];
+/**
+ * Get a single configuration by name.
+ * Throws if not found (fail-fast for typos).
+ */
+export declare function getConfigByName(name: string): TestConfiguration;

package/dist/__tests__/harness/fixtures/matrix.js

@@ -0,0 +1,58 @@
+import * as factories from './config-factories.js';
+/**
+ * Complete test matrix: 14 configurations (7 platforms x 2 auth providers)
+ *
+ * Tier assignments:
+ * - smoke: 1 config (quick sanity check)
+ * - core: 4 configs (PR validation - covers all platforms and auth providers)
+ * - full: 9 configs (release validation - remaining combinations)
+ */
+export const TEST_MATRIX = [
+    // === SMOKE TIER (1 config) ===
+    // Most common configuration - web+api with cognito
+    { name: 'web-api-cognito', tier: 'smoke', config: factories.createWebApiCognitoConfig() },
+    // === CORE TIER (4 configs) ===
+    // Ensures every platform and every auth provider is tested on PRs
+    { name: 'web-cognito', tier: 'core', config: factories.createWebCognitoConfig() },
+    { name: 'mobile-auth0', tier: 'core', config: factories.createMobileAuth0Config() },
+    { name: 'api-cognito', tier: 'core', config: factories.createApiCognitoConfig() },
+    { name: 'full-auth0', tier: 'core', config: factories.createFullStackAuth0Config() },
+    // === FULL TIER (9 remaining configs) ===
+    // All other combinations for release validation
+    { name: 'web-auth0', tier: 'full', config: factories.createWebAuth0Config() },
+    { name: 'mobile-cognito', tier: 'full', config: factories.createMobileCognitoConfig() },
+    { name: 'api-auth0', tier: 'full', config: factories.createApiAuth0Config() },
+    { name: 'web-mobile-cognito', tier: 'full', config: factories.createWebMobileCognitoConfig() },
+    { name: 'web-mobile-auth0', tier: 'full', config: factories.createWebMobileAuth0Config() },
+    { name: 'web-api-auth0', tier: 'full', config: factories.createWebApiAuth0Config() },
+    { name: 'mobile-api-cognito', tier: 'full', config: factories.createMobileApiCognitoConfig() },
+    { name: 'mobile-api-auth0', tier: 'full', config: factories.createMobileApiAuth0Config() },
+    { name: 'full-cognito', tier: 'full', config: factories.createFullStackCognitoConfig() },
+];
+/**
+ * Get configurations by tier (cumulative)
+ * - 'smoke' returns smoke configs only (1)
+ * - 'core' returns smoke + core configs (5)
+ * - 'full' returns all configs (14)
+ */
+export function getConfigsByTier(tier) {
+    switch (tier) {
+        case 'smoke':
+            return TEST_MATRIX.filter(c => c.tier === 'smoke');
+        case 'core':
+            return TEST_MATRIX.filter(c => c.tier === 'smoke' || c.tier === 'core');
+        case 'full':
+            return TEST_MATRIX;
+    }
+}
+/**
+ * Get a single configuration by name.
+ * Throws if not found (fail-fast for typos).
+ */
+export function getConfigByName(name) {
+    const config = TEST_MATRIX.find(c => c.name === name);
+    if (!config) {
+        throw new Error(`Configuration "${name}" not found in TEST_MATRIX`);
+    }
+    return config;
+}

package/dist/__tests__/harness/local-runner.d.ts

@@ -0,0 +1,2 @@
+import { type TestTier } from './fixtures/index.js';
+export declare function runValidationSuite(tier?: TestTier): Promise<void>;

package/dist/__tests__/harness/local-runner.js

@@ -0,0 +1,184 @@
+import ora from 'ora';
+import pc from 'picocolors';
+import { getConfigsByTier, getConfigByName, TEST_MATRIX } from './fixtures/index.js';
+import { validateGeneratedProject } from './validate-project.js';
+// CI detection: disable spinner animations in CI environments
+const isCI = process.env.CI === 'true' || !process.stdout.isTTY;
+export async function runValidationSuite(tier = 'core') {
+    const configs = getConfigsByTier(tier);
+    const results = [];
+    const spinner = isCI ? null : ora();
+    console.log(pc.bold(`\nRunning ${configs.length} validation tests (tier: ${tier})\n`));
+    for (let i = 0; i < configs.length; i++) {
+        const config = configs[i];
+        const progress = `Testing ${i + 1}/${configs.length}: ${config.name}`;
+        // Show progress indicator
+        if (spinner) {
+            spinner.start(progress);
+        }
+        else {
+            console.log(progress);
+        }
+        try {
+            const result = await validateGeneratedProject(config.config);
+            results.push(result);
+            if (result.success) {
+                if (spinner) {
+                    spinner.succeed(pc.green(progress));
+                }
+                else {
+                    console.log(pc.green(`✓ PASS: ${progress}`));
+                }
+            }
+            else {
+                const failMsg = `${progress} (failed at ${result.failedStep})`;
+                if (spinner) {
+                    spinner.fail(pc.red(failMsg));
+                }
+                else {
+                    console.error(pc.red(`✗ FAIL: ${failMsg}`));
+                }
+                // Display error output immediately after failure
+                const failedStep = result.steps.find(s => !s.success);
+                if (failedStep) {
+                    console.error(pc.red('\n--- Error Output ---'));
+                    console.error(failedStep.output);
+                    console.error(pc.red('--- End Error Output ---\n'));
+                }
+            }
+        }
+        catch (error) {
+            const exceptionMsg = `${progress} (exception)`;
+            if (spinner) {
+                spinner.fail(pc.red(exceptionMsg));
+            }
+            else {
+                console.error(pc.red(`✗ FAIL: ${exceptionMsg}`));
+            }
+            console.error(error);
+            // Push a failed result for the summary
+            results.push({
+                success: false,
+                steps: [],
+                totalDuration: 0,
+            });
+        }
+        finally {
+            // Ensure spinner is stopped even on exception
+            if (spinner && spinner.isSpinning) {
+                spinner.stop();
+            }
+        }
+    }
+    // Display summary table
+    displaySummary(results, configs);
+    // Exit with appropriate code for CI integration
+    const allPassed = results.every(r => r.success);
+    process.exit(allPassed ? 0 : 1);
+}
+async function runSingleConfig(configName) {
+    const spinner = isCI ? null : ora();
+    console.log(pc.bold(`\nRunning single configuration: ${configName}\n`));
+    const testConfig = getConfigByName(configName);
+    const progress = `Testing: ${testConfig.name}`;
+    // Show progress indicator
+    if (spinner) {
+        spinner.start(progress);
+    }
+    else {
+        console.log(progress);
+    }
+    try {
+        const result = await validateGeneratedProject(testConfig.config);
+        if (result.success) {
+            if (spinner) {
+                spinner.succeed(pc.green(progress));
+            }
+            else {
+                console.log(pc.green(`✓ PASS: ${progress}`));
+            }
+        }
+        else {
+            const failMsg = `${progress} (failed at ${result.failedStep})`;
+            if (spinner) {
+                spinner.fail(pc.red(failMsg));
+            }
+            else {
+                console.error(pc.red(`✗ FAIL: ${failMsg}`));
+            }
+            // Display error output immediately after failure
+            const failedStep = result.steps.find(s => !s.success);
+            if (failedStep) {
+                console.error(pc.red('\n--- Error Output ---'));
+                console.error(failedStep.output);
+                console.error(pc.red('--- End Error Output ---\n'));
+            }
+        }
+        // Display summary table
+        displaySummary([result], [testConfig]);
+        // Exit with appropriate code for CI integration
+        process.exit(result.success ? 0 : 1);
+    }
+    catch (error) {
+        const exceptionMsg = `${progress} (exception)`;
+        if (spinner) {
+            spinner.fail(pc.red(exceptionMsg));
+        }
+        else {
+            console.error(pc.red(`✗ FAIL: ${exceptionMsg}`));
+        }
+        console.error(error);
+        process.exit(1);
+    }
+    finally {
+        // Ensure spinner is stopped even on exception
+        if (spinner && spinner.isSpinning) {
+            spinner.stop();
+        }
+    }
+}
+function displaySummary(results, configs) {
+    const rows = results.map((result, i) => ({
+        config: configs[i].name,
+        status: result.success ? pc.green('✓ PASS') : pc.red('✗ FAIL'),
+        failedStep: result.failedStep ?? '-',
+        duration: `${(result.totalDuration / 1000).toFixed(1)}s`,
+    }));
+    console.log(pc.bold('\n=== Validation Summary ===\n'));
+    console.table(rows);
+    const passed = results.filter(r => r.success).length;
+    const total = results.length;
+    const passRate = total > 0 ? ((passed / total) * 100).toFixed(1) : '0.0';
+    console.log(pc.bold(`\nResults: ${passed}/${total} passed (${passRate}%)`));
+}
+// CLI entry point - parse tier or config name argument and run
+const arg = process.argv[2] ?? 'core';
+// Validate argument - check if it's a valid tier or config name
+const validTiers = ['smoke', 'core', 'full'];
+const validConfigNames = TEST_MATRIX.map(c => c.name);
+if (validTiers.includes(arg)) {
+    // It's a tier - run the validation suite
+    runValidationSuite(arg).catch((error) => {
+        console.error(pc.red('\nFatal error during validation:'));
+        console.error(error);
+        process.exit(1);
+    });
+}
+else if (validConfigNames.includes(arg)) {
+    // It's a specific config name - run single config
+    runSingleConfig(arg).catch((error) => {
+        console.error(pc.red('\nFatal error during validation:'));
+        console.error(error);
+        process.exit(1);
+    });
+}
+else {
+    // Invalid argument - show error with all valid options
+    console.error(pc.red(`\nError: Invalid argument "${arg}"`));
+    console.error(pc.bold('\nValid tiers:'));
+    console.error(`  ${validTiers.join(', ')}`);
+    console.error(pc.bold('\nValid configuration names:'));
+    console.error(`  ${validConfigNames.join(', ')}`);
+    console.error('');
+    process.exit(1);
+}

package/dist/__tests__/harness/run-command.d.ts

@@ -0,0 +1,7 @@
+export interface CommandResult {
+    success: boolean;
+    exitCode: number;
+    output: string;
+    timedOut: boolean;
+}
+export declare function runCommand(command: string, args: string[], cwd: string, timeout?: number): Promise<CommandResult>;

package/dist/__tests__/harness/run-command.js

@@ -0,0 +1,26 @@
+import { execa } from 'execa';
+export async function runCommand(command, args, cwd, timeout = 600000 // 10 minutes default
+) {
+    try {
+        const result = await execa(command, args, {
+            cwd,
+            all: true,
+            timeout,
+        });
+        return {
+            success: true,
+            exitCode: result.exitCode ?? 0,
+            output: result.all ?? '',
+            timedOut: false,
+        };
+    }
+    catch (error) {
+        const execaError = error;
+        return {
+            success: false,
+            exitCode: execaError.exitCode ?? 1,
+            output: execaError.all ?? execaError.message ?? '',
+            timedOut: execaError.timedOut ?? false,
+        };
+    }
+}

package/dist/__tests__/harness/run-command.spec.d.ts

@@ -0,0 +1 @@
+export {};