@bitclaw/loadtest 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Chavez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @bitclaw/loadtest
+
+Load testing CLI for sqlite-saas apps. Supports both Bun-native and k6 test engines.
+
+## Quick Start
+
+```bash
+# From repo root
+bun run loadtest:bun --app runmist          # Quick Bun-native test
+bun run loadtest:k6 --app runmist           # Full k6 test
+
+# From package directory
+cd packages/loadtest
+bun src/cli.ts run --app runmist --mode quick
+bun src/cli.ts report --app runmist
+```
+
+## CLI Usage
+
+```bash
+loadtest run [options]     # Run load tests
+loadtest report [options]  # Generate report from results
+```
+
+### Run Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--app <name>` | required | App to test (matches `apps/{name}/`) |
+| `--mode <mode>` | `quick` | Test mode: `quick`, `full`, or `stress` |
+| `--engine <engine>` | `bun` | Engine: `bun` (native) or `k6` |
+| `--production` | `false` | Test against production URL |
+| `--public-only` | `false` | Skip authenticated endpoints |
+| `--json` | `false` | Output results as JSON |
+| `--tier <tier>` | — | Hetzner tier for threshold overrides |
+
+## Per-App Configuration
+
+Each app defines a `loadtest.config.ts` in its directory:
+
+```typescript
+// apps/runmist/loadtest.config.ts
+import type { AppLoadTestConfig } from '@bitclaw/loadtest'
+
+export default {
+  appName: 'runmist',
+  baseUrl: 'http://localhost:3001',
+  productionUrl: 'https://runmist.com',
+
+  auth: {
+    loginEndpoint: '/api/loadtest/auth',
+    emailEnvVar: 'LOADTEST_EMAIL',
+    passwordEnvVar: 'LOADTEST_PASSWORD',
+    sessionCookieName: 'runmist_session',
+  },
+
+  publicEndpoints: [
+    { path: '/', method: 'GET' },
+    { path: '/api/health', method: 'GET' },
+  ],
+
+  authenticatedEndpoints: [
+    { path: '/dashboard', method: 'GET' },
+    { path: '/servers', method: 'GET' },
+  ],
+
+  modes: {
+    quick: { concurrencyLevels: [1, 5], durationSec: 5, warmupRequests: 10 },
+    full: { concurrencyLevels: [1, 5, 10, 25], durationSec: 15, warmupRequests: 50 },
+    stress: { concurrencyLevels: [1, 10, 25, 50, 100], durationSec: 30, warmupRequests: 100 },
+  },
+
+  thresholds: {
+    p95MaxMs: 50,
+    minSuccessRate: 99.5,
+    minThroughput: 100,
+    tiers: {
+      cpx21: { p95MaxMs: 50, minSuccessRate: 99.5, minThroughput: 100 },
+      cpx31: { p95MaxMs: 30, minSuccessRate: 99.9, minThroughput: 200 },
+    },
+  },
+} satisfies AppLoadTestConfig
+```
+
+## Engines
+
+### Bun-Native (`--engine bun`)
+
+Uses Bun's built-in HTTP client for fast, zero-dependency load testing. Best for quick local validation.
+
+### k6 (`--engine k6`)
+
+Uses [k6](https://k6.io/) for production-grade load testing with detailed metrics. Requires k6 to be installed. k6 scripts are in `k6/` directory (e.g., `k6/runmist.js`).
+
+## Thresholds
+
+Tests can define pass/fail thresholds:
+
+- **p95MaxMs** — Maximum acceptable P95 latency
+- **minSuccessRate** — Minimum success rate (0-100%)
+- **minThroughput** — Minimum req/s at lowest concurrency
+
+Hetzner tier overrides let you set different thresholds per server type.
+
+## Testing
+
+```bash
+cd packages/loadtest
+bun test
+```
+
+6 test files covering config loading, runners, auth, and report formatting.

package/dist/__fixtures__/configs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reusable AppLoadTestConfig and ThresholdConfig test data.
+ */
+import type { AppLoadTestConfig, AuthConfig } from '../types';
+export declare const SAMPLE_AUTH_CONFIG: AuthConfig;
+export declare const SAMPLE_CONFIG_WITH_AUTH: AppLoadTestConfig;
+export declare const SAMPLE_CONFIG_PUBLIC_ONLY: AppLoadTestConfig;
+//# sourceMappingURL=configs.d.ts.map

package/dist/__fixtures__/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/__fixtures__/configs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAmB,MAAM,UAAU,CAAC;AAE/E,eAAO,MAAM,kBAAkB,EAAE,UAKhC,CAAC;AAYF,eAAO,MAAM,uBAAuB,EAAE,iBA4BrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,iBA2BvC,CAAC"}

package/dist/__fixtures__/configs.js

@@ -0,0 +1,75 @@
+/**
+ * Reusable AppLoadTestConfig and ThresholdConfig test data.
+ */
+export const SAMPLE_AUTH_CONFIG = {
+    loginEndpoint: '/api/loadtest/auth',
+    emailEnvVar: 'LOADTEST_EMAIL',
+    passwordEnvVar: 'LOADTEST_PASSWORD',
+    sessionCookieName: 'runmist_session'
+};
+const SAMPLE_THRESHOLDS = {
+    p95MaxMs: 500,
+    minSuccessRate: 95,
+    minThroughput: 50,
+    tiers: {
+        CPX11: { p95MaxMs: 800, minSuccessRate: 90, minThroughput: 30 },
+        CPX31: { p95MaxMs: 300, minSuccessRate: 98, minThroughput: 100 }
+    }
+};
+export const SAMPLE_CONFIG_WITH_AUTH = {
+    appName: 'runmist',
+    baseUrl: 'http://localhost:3001',
+    productionUrl: 'https://runmist.com',
+    auth: SAMPLE_AUTH_CONFIG,
+    publicEndpoints: [
+        { path: '/login', label: 'Login page' },
+        { path: '/', label: 'Landing page' }
+    ],
+    authenticatedEndpoints: [
+        { path: '/dashboard', label: 'Dashboard' },
+        { path: '/servers', label: 'Servers' },
+        { path: '/settings', label: 'Settings' }
+    ],
+    modes: {
+        quick: { concurrencyLevels: [1, 10], durationSec: 5, warmupRequests: 3 },
+        full: {
+            concurrencyLevels: [10, 50, 100],
+            durationSec: 10,
+            warmupRequests: 5
+        },
+        stress: {
+            concurrencyLevels: [50, 100, 200, 500],
+            durationSec: 15,
+            warmupRequests: 10
+        }
+    },
+    thresholds: SAMPLE_THRESHOLDS
+};
+export const SAMPLE_CONFIG_PUBLIC_ONLY = {
+    appName: 'weatherdestination',
+    baseUrl: 'http://localhost:3000',
+    publicEndpoints: [
+        { path: '/', label: 'Home' },
+        { path: '/blog', label: 'Blog' },
+        { path: '/docs', label: 'Docs' }
+    ],
+    authenticatedEndpoints: [],
+    modes: {
+        quick: { concurrencyLevels: [1, 10], durationSec: 5, warmupRequests: 3 },
+        full: {
+            concurrencyLevels: [10, 50, 100],
+            durationSec: 10,
+            warmupRequests: 5
+        },
+        stress: {
+            concurrencyLevels: [50, 100, 200, 500],
+            durationSec: 15,
+            warmupRequests: 10
+        }
+    },
+    thresholds: {
+        p95MaxMs: 500,
+        minSuccessRate: 99,
+        minThroughput: 100
+    }
+};

package/dist/__fixtures__/results.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reusable ScenarioResult and LoadTestResults test data.
+ */
+import type { LoadTestResults, ScenarioResult } from '../types';
+export declare const PASSING_SCENARIO: ScenarioResult;
+export declare const FAILING_P95_SCENARIO: ScenarioResult;
+export declare const FAILING_SUCCESS_RATE_SCENARIO: ScenarioResult;
+export declare const FAILING_THROUGHPUT_SCENARIO: ScenarioResult;
+export declare const MULTI_VIOLATION_SCENARIO: ScenarioResult;
+export declare const PASSING_RESULTS: LoadTestResults;
+export declare const FAILING_RESULTS: LoadTestResults;
+export declare const EMPTY_RESULTS: LoadTestResults;
+//# sourceMappingURL=results.d.ts.map

package/dist/__fixtures__/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../../src/__fixtures__/results.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEhE,eAAO,MAAM,gBAAgB,EAAE,cAmB9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,cAmBlC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,cAmB3C,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,cAmBzC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,cAmBtC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAK7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAK7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,eAK3B,CAAC"}

package/dist/__fixtures__/results.js

@@ -0,0 +1,121 @@
+/**
+ * Reusable ScenarioResult and LoadTestResults test data.
+ */
+export const PASSING_SCENARIO = {
+    endpoint: '/dashboard',
+    label: 'Dashboard',
+    method: 'GET',
+    concurrency: 10,
+    durationSec: 5,
+    totalRequests: 500,
+    successCount: 495,
+    failCount: 5,
+    successRate: 99,
+    throughput: 150,
+    p50: 80,
+    p95: 200,
+    p99: 350,
+    min: 20,
+    max: 450,
+    avg: 100,
+    statusCodes: { 200: 495, 500: 5 },
+    avgBodySize: 1024
+};
+export const FAILING_P95_SCENARIO = {
+    endpoint: '/slow',
+    label: 'Slow endpoint',
+    method: 'GET',
+    concurrency: 50,
+    durationSec: 5,
+    totalRequests: 300,
+    successCount: 297,
+    failCount: 3,
+    successRate: 99,
+    throughput: 150,
+    p50: 400,
+    p95: 900,
+    p99: 1200,
+    min: 100,
+    max: 1500,
+    avg: 450,
+    statusCodes: { 200: 297, 504: 3 },
+    avgBodySize: 2048
+};
+export const FAILING_SUCCESS_RATE_SCENARIO = {
+    endpoint: '/flaky',
+    label: 'Flaky endpoint',
+    method: 'GET',
+    concurrency: 10,
+    durationSec: 5,
+    totalRequests: 200,
+    successCount: 170,
+    failCount: 30,
+    successRate: 85,
+    throughput: 150,
+    p50: 100,
+    p95: 300,
+    p99: 400,
+    min: 30,
+    max: 500,
+    avg: 120,
+    statusCodes: { 200: 170, 500: 30 },
+    avgBodySize: 512
+};
+export const FAILING_THROUGHPUT_SCENARIO = {
+    endpoint: '/bottleneck',
+    label: 'Bottleneck',
+    method: 'GET',
+    concurrency: 10,
+    durationSec: 5,
+    totalRequests: 100,
+    successCount: 98,
+    failCount: 2,
+    successRate: 98,
+    throughput: 20,
+    p50: 100,
+    p95: 300,
+    p99: 400,
+    min: 30,
+    max: 500,
+    avg: 120,
+    statusCodes: { 200: 98, 503: 2 },
+    avgBodySize: 768
+};
+export const MULTI_VIOLATION_SCENARIO = {
+    endpoint: '/broken',
+    label: 'Broken endpoint',
+    method: 'GET',
+    concurrency: 100,
+    durationSec: 5,
+    totalRequests: 100,
+    successCount: 60,
+    failCount: 40,
+    successRate: 60,
+    throughput: 20,
+    p50: 500,
+    p95: 1500,
+    p99: 2000,
+    min: 200,
+    max: 3000,
+    avg: 700,
+    statusCodes: { 200: 60, 500: 30, 503: 10 },
+    avgBodySize: 256
+};
+export const PASSING_RESULTS = {
+    baseUrl: 'http://localhost:3001',
+    startedAt: '2025-01-01T00:00:00.000Z',
+    completedAt: '2025-01-01T00:01:00.000Z',
+    scenarios: [PASSING_SCENARIO]
+};
+export const FAILING_RESULTS = {
+    baseUrl: 'http://localhost:3001',
+    startedAt: '2025-01-01T00:00:00.000Z',
+    completedAt: '2025-01-01T00:01:00.000Z',
+    scenarios: [FAILING_P95_SCENARIO, FAILING_SUCCESS_RATE_SCENARIO]
+};
+export const EMPTY_RESULTS = {
+    baseUrl: 'http://localhost:3001',
+    startedAt: '2025-01-01T00:00:00.000Z',
+    completedAt: '2025-01-01T00:01:00.000Z',
+    scenarios: []
+};

package/dist/auth/session.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Load test authentication — obtains session cookies from the
+ * dedicated /api/loadtest/auth endpoint.
+ */
+import type { AuthConfig, SessionState } from '../types';
+/**
+ * Authenticate against the dedicated loadtest auth endpoint.
+ * Returns the raw Set-Cookie header value for injection into requests.
+ */
+export declare function authenticateSession(baseUrl: string, auth: AuthConfig): Promise<SessionState>;
+/**
+ * Pre-create a pool of authenticated sessions for high-concurrency tests.
+ * Distributes load across multiple sessions so a single token isn't hammered.
+ *
+ * @param count Number of sessions to create (default: 1 per 20 concurrent workers)
+ */
+export declare function createSessionPool(baseUrl: string, auth: AuthConfig, count: number): Promise<SessionState[]>;
+//# sourceMappingURL=session.d.ts.map

package/dist/auth/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/auth/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEzD;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC,CAmDvB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,YAAY,EAAE,CAAC,CASzB"}

package/dist/auth/session.js

@@ -0,0 +1,58 @@
+/**
+ * Load test authentication — obtains session cookies from the
+ * dedicated /api/loadtest/auth endpoint.
+ */
+/**
+ * Authenticate against the dedicated loadtest auth endpoint.
+ * Returns the raw Set-Cookie header value for injection into requests.
+ */
+export async function authenticateSession(baseUrl, auth) {
+    // Use direct credentials if provided, otherwise read from env vars
+    const email = auth.credentials?.email ?? process.env[auth.emailEnvVar];
+    const password = auth.credentials?.password ?? process.env[auth.passwordEnvVar];
+    if (!email || !password) {
+        throw new Error(`Missing credentials. Set ${auth.emailEnvVar} and ${auth.passwordEnvVar} env vars.\n` +
+            `Example: ${auth.emailEnvVar}=admin@runmist.local ${auth.passwordEnvVar}=runmist123 bun run loadtest ...`);
+    }
+    const url = `${baseUrl}${auth.loginEndpoint}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+        redirect: 'manual'
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`Auth failed (${response.status}): ${body}\n` +
+            `Endpoint: ${url}\n` +
+            `Make sure LOADTEST_AUTH_ENABLED=true is set in the app's env.`);
+    }
+    // Extract session cookie from Set-Cookie header
+    const setCookie = response.headers.getSetCookie?.() ?? [];
+    const sessionCookie = setCookie.find(c => c.startsWith(`${auth.sessionCookieName}=`));
+    if (!sessionCookie) {
+        throw new Error(`No ${auth.sessionCookieName} cookie in response.\n` +
+            `Set-Cookie headers: ${setCookie.join('; ')}`);
+    }
+    // Extract just the cookie name=value pair (strip attributes like Path, HttpOnly, etc.)
+    const cookieValue = sessionCookie.split(';')[0];
+    return {
+        cookies: cookieValue,
+        authenticated: true
+    };
+}
+/**
+ * Pre-create a pool of authenticated sessions for high-concurrency tests.
+ * Distributes load across multiple sessions so a single token isn't hammered.
+ *
+ * @param count Number of sessions to create (default: 1 per 20 concurrent workers)
+ */
+export async function createSessionPool(baseUrl, auth, count) {
+    const poolSize = Math.max(1, count);
+    const sessions = [];
+    for (let i = 0; i < poolSize; i++) {
+        const session = await authenticateSession(baseUrl, auth);
+        sessions.push(session);
+    }
+    return sessions;
+}

package/dist/cli/commands/report.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CLI `report` command — display or re-format previous results.
+ */
+import type { Command } from 'commander';
+export declare function registerReportCommand(program: Command): void;
+//# sourceMappingURL=report.d.ts.map

package/dist/cli/commands/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/report.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0C5D"}

package/dist/cli/commands/report.js

@@ -0,0 +1,46 @@
+/**
+ * CLI `report` command — display or re-format previous results.
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..', '..', '..', '..', '..');
+export function registerReportCommand(program) {
+    program
+        .command('report')
+        .description('Display results from a previous k6 JSON export')
+        .option('--file <path>', 'Path to JSON results file')
+        .option('--last', 'Show the most recent results file')
+        .action(async (opts) => {
+        try {
+            let filePath;
+            if (opts.file) {
+                filePath = resolve(opts.file);
+            }
+            else if (opts.last) {
+                // Find the most recent loadtest-*.json file
+                const files = readdirSync(REPO_ROOT)
+                    .filter(f => f.startsWith('loadtest-') && f.endsWith('.json'))
+                    .sort()
+                    .reverse();
+                if (files.length === 0) {
+                    console.error('No loadtest result files found. Run a test with --json first.');
+                    process.exit(1);
+                }
+                filePath = resolve(REPO_ROOT, files[0]);
+            }
+            else {
+                console.error('Specify --file <path> or --last');
+                process.exit(1);
+                return;
+            }
+            const raw = readFileSync(filePath, 'utf-8');
+            JSON.parse(raw);
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/run.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CLI `run` command — executes load tests against an app.
+ */
+import type { Command } from 'commander';
+export declare function registerRunCommand(program: Command): void;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWzC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsGzD"}

package/dist/cli/commands/run.js

@@ -0,0 +1,97 @@
+/**
+ * CLI `run` command — executes load tests against an app.
+ */
+import { listConfiguredApps, loadConfig } from '../../config/loader';
+import { checkThresholds, formatJson, formatReport } from '../../reports/formatter';
+import { runAppLoadTest } from '../../runner/bun-runner';
+import { runK6Test } from '../../runner/k6-runner';
+export function registerRunCommand(program) {
+    program
+        .command('run')
+        .description('Run load tests against an app')
+        .option('--app <name>', 'App to test (e.g., runmist, weatherdestination)')
+        .option('--mode <mode>', 'Test mode: quick, full, stress', 'quick')
+        .option('--engine <engine>', 'Test engine: bun, k6', 'bun')
+        .option('--production', 'Test against production URL', false)
+        .option('--public-only', 'Only test public endpoints', false)
+        .option('--json', 'Output results as JSON', false)
+        .option('--tier <tier>', 'Hetzner tier for threshold comparison (CPX11/21/31/41)')
+        .option('--url <url>', 'Override base URL')
+        .option('--list', 'List available apps with load test configs')
+        .action(async (opts) => {
+        try {
+            // Handle --list
+            if (opts.list) {
+                const apps = await listConfiguredApps();
+                if (apps.length === 0) {
+                    process.stdout.write('No apps with load test configs found.\n');
+                }
+                else {
+                    process.stdout.write('Apps with load test configs:\n');
+                    for (const app of apps) {
+                        process.stdout.write(`  ${app}\n`);
+                    }
+                }
+                return;
+            }
+            if (!opts.app) {
+                console.error('--app is required. Use --list to see available apps.');
+                process.exit(1);
+            }
+            const mode = opts.mode;
+            const engine = opts.engine;
+            // Validate mode
+            if (!['quick', 'full', 'stress'].includes(mode)) {
+                console.error(`Invalid mode "${mode}". Use: quick, full, stress`);
+                process.exit(1);
+            }
+            // Validate engine
+            if (!['bun', 'k6'].includes(engine)) {
+                console.error(`Invalid engine "${engine}". Use: bun, k6`);
+                process.exit(1);
+            }
+            // Load config
+            const config = await loadConfig(opts.app);
+            // Determine base URL
+            const baseUrl = opts.url ??
+                (opts.production && config.productionUrl
+                    ? config.productionUrl
+                    : config.baseUrl);
+            // Run with selected engine
+            if (engine === 'k6') {
+                await runK6Test(opts.app, {
+                    baseUrl,
+                    email: process.env.LOADTEST_EMAIL,
+                    password: process.env.LOADTEST_PASSWORD,
+                    jsonOutput: opts.json
+                        ? `loadtest-${opts.app}-${Date.now()}.json`
+                        : undefined
+                });
+            }
+            else {
+                const results = await runAppLoadTest(config, mode, {
+                    publicOnly: opts.publicOnly,
+                    baseUrl
+                });
+                if (opts.json) {
+                    process.stdout.write(`${formatJson(results, config, opts.tier)}\n`);
+                }
+                else {
+                    process.stdout.write(`${formatReport(results, config, opts.tier)}\n`);
+                }
+                // Check thresholds and set exit code
+                const thresholds = opts.tier
+                    ? (config.thresholds.tiers?.[opts.tier] ?? config.thresholds)
+                    : config.thresholds;
+                const check = checkThresholds(results, thresholds);
+                if (!check.passed) {
+                    process.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerReportCommand } from './cli/commands/report';
+import { registerRunCommand } from './cli/commands/run';
+const program = new Command();
+program
+    .name('loadtest')
+    .description('Load testing CLI for sqlite-saas apps')
+    .version('0.1.0');
+registerRunCommand(program);
+registerReportCommand(program);
+program.parse();