@cloudbeat/atlas-cli 0.1.0

package/dist/commands/files.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFiles = registerFiles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+const ui_1 = require("../ui");
+/** Project comes from --project, ATLAS_PROJECT, or the saved default. */
+function projectName(flag) {
+    const name = (0, config_1.loadConfig)({ project: flag }).project;
+    if (!name) {
+        throw new ui_1.CliError('No project. Pass --project <name>, set ATLAS_PROJECT, or run `atlas config set project <name>`.', ui_1.EXIT.USAGE);
+    }
+    return name;
+}
+function humanSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function registerFiles(program) {
+    const files = program.command('files').description('Manage a project\'s test files');
+    files
+        .command('list')
+        .description('List files stored in the project')
+        .option('-p, --project <name>', 'project name')
+        .option('--json', 'machine-readable output')
+        .action(async (opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const project = await api.projectByName(projectName(opts.project));
+        const stored = await api.files(project.id);
+        if (opts.json) {
+            console.log(JSON.stringify(stored, null, 2));
+            return;
+        }
+        if (stored.length === 0) {
+            ui_1.log.warn(`No files in project "${project.name}".`);
+            return;
+        }
+        const table = new cli_table3_1.default({
+            head: [chalk_1.default.dim('FILENAME'), chalk_1.default.dim('TYPE'), chalk_1.default.dim('SIZE'), chalk_1.default.dim('UPLOADED')],
+            style: { head: [], border: [] },
+        });
+        for (const f of stored) {
+            table.push([
+                f.filename,
+                f.file_type,
+                humanSize(f.size_bytes),
+                new Date(f.uploaded_at).toLocaleString(),
+            ]);
+        }
+        console.log(table.toString());
+    });
+    files
+        .command('upload <files...>')
+        .description('Upload files into the project (replaces same-named files)')
+        .option('-p, --project <name>', 'project name')
+        .action(async (paths, opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const project = await api.projectByName(projectName(opts.project));
+        const missing = paths.filter(p => !fs_1.default.existsSync(p));
+        if (missing.length)
+            throw new ui_1.CliError(`File(s) not found: ${missing.join(', ')}`, ui_1.EXIT.USAGE);
+        await api.uploadFiles(project.id, paths);
+        for (const p of paths) {
+            ui_1.log.ok(`${path_1.default.basename(p)} → ${project.name} (${humanSize(fs_1.default.statSync(p).size)})`);
+        }
+    });
+    files
+        .command('download <filename>')
+        .description('Download one file from the project')
+        .option('-p, --project <name>', 'project name')
+        .option('-o, --out <path>', 'where to write it (default: the filename, in cwd)')
+        .action(async (filename, opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const project = await api.projectByName(projectName(opts.project));
+        const buf = await api.downloadFile(project.id, filename);
+        const dest = opts.out ?? filename;
+        fs_1.default.writeFileSync(dest, buf);
+        ui_1.log.ok(`${filename} → ${dest} (${humanSize(buf.length)})`);
+    });
+    files
+        .command('rm <filename>')
+        .description('Delete a file from the project')
+        .option('-p, --project <name>', 'project name')
+        .option('-y, --yes', 'skip the confirmation prompt')
+        .action(async (filename, opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const project = await api.projectByName(projectName(opts.project));
+        // Deleting stored files is destructive and not undoable from the CLI, so
+        // it is opt-in when there is no TTY to ask on (i.e. in CI).
+        if (!opts.yes) {
+            if (!process.stdin.isTTY) {
+                throw new ui_1.CliError('Refusing to delete without --yes when not interactive.', ui_1.EXIT.USAGE);
+            }
+            const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise(r => rl.question(`Delete "${filename}" from ${project.name}? [y/N] `, a => { rl.close(); r(a.trim()); }));
+            if (answer.toLowerCase() !== 'y') {
+                ui_1.log.info('Cancelled.');
+                return;
+            }
+        }
+        await api.deleteFile(project.id, filename);
+        ui_1.log.ok(`Deleted ${filename} from ${project.name}`);
+    });
+}
+//# sourceMappingURL=files.js.map

package/dist/commands/projects.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProjects = registerProjects;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const ui_1 = require("../ui");
+function registerProjects(program) {
+    program
+        .command('projects')
+        .description('List projects visible to this credential')
+        .option('--json', 'machine-readable output')
+        .action(async (opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const projects = await api.projects();
+        if (opts.json) {
+            console.log(JSON.stringify(projects, null, 2));
+            return;
+        }
+        if (projects.length === 0) {
+            ui_1.log.warn('No projects visible to this credential.');
+            return;
+        }
+        const table = new cli_table3_1.default({
+            head: [chalk_1.default.dim('NAME'), chalk_1.default.dim('ID'), chalk_1.default.dim('DEFAULT JMX')],
+            style: { head: [], border: [] },
+        });
+        for (const p of projects) {
+            table.push([p.name, String(p.id), p.jmx_filename ?? chalk_1.default.dim('—')]);
+        }
+        console.log(table.toString());
+    });
+}
+//# sourceMappingURL=projects.js.map

package/dist/commands/record.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRecord = registerRecord;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const module_1 = require("module");
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+const ui_1 = require("../ui");
+const RECORDER_PKG = '@cloudbeat/atlas-recorder';
+/**
+ * The recorder is launched, never bundled.
+ *
+ * It depends on Playwright and installs a Chromium build on postinstall — a few
+ * hundred MB. This CLI's main audience is CI, where a browser is never opened,
+ * so making it a hard dependency would tax every pipeline install for a feature
+ * they don't use. Resolve it at runtime instead and tell the user how to get it.
+ */
+function resolveRecorderBin() {
+    const require = (0, module_1.createRequire)(__filename);
+    for (const spec of [`${RECORDER_PKG}/package.json`, RECORDER_PKG]) {
+        try {
+            const pkgPath = spec.endsWith('package.json')
+                ? require.resolve(spec)
+                : path_1.default.join(path_1.default.dirname(require.resolve(spec)), '..', 'package.json');
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            const rel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.['atlas-rec'];
+            if (rel) {
+                const bin = path_1.default.resolve(path_1.default.dirname(pkgPath), rel);
+                if (fs_1.default.existsSync(bin))
+                    return bin;
+            }
+        }
+        catch {
+            /* not installed here — try the next resolution strategy */
+        }
+    }
+    return null;
+}
+function runRecorder(bin, args) {
+    return new Promise(resolve => {
+        const child = (0, child_process_1.spawn)(process.execPath, [bin, ...args], { stdio: 'inherit' });
+        child.on('exit', code => resolve(code ?? 0));
+    });
+}
+function registerRecord(program) {
+    program
+        .command('record [url]')
+        .description('Record a browser session into a JMeter test plan')
+        .option('-o, --out <file>', 'output .jmx (merged into if it already exists)', 'scenario.jmx')
+        .option('-n, --name <name>', 'scenario / thread-group name')
+        .option('--cookies <file>', 'preload cookies to skip SSO')
+        .option('--profile <dir>', 'browser profile directory for a persistent session')
+        .option('--upload', 'upload the recorded .jmx into the project when done')
+        .option('-p, --project <name>', 'project to upload into (with --upload)')
+        .action(async (url, opts) => {
+        // Fail on an unusable --upload before spending a recording session on it.
+        let project = null;
+        if (opts.upload) {
+            const name = (0, config_1.loadConfig)({ project: opts.project }).project;
+            if (!name) {
+                throw new ui_1.CliError('--upload needs a project: pass --project <name> or set ATLAS_PROJECT.', ui_1.EXIT.USAGE);
+            }
+            project = await api_1.AtlasApi.fromConfig().projectByName(name);
+        }
+        const bin = resolveRecorderBin();
+        if (!bin) {
+            ui_1.log.error(`The recorder is not installed.`);
+            ui_1.log.info('');
+            ui_1.log.info(`  npm install -g ${RECORDER_PKG}`);
+            ui_1.log.info('');
+            ui_1.log.dim('It is a separate package because it downloads a Chromium build,');
+            ui_1.log.dim('which CI installs of this CLI do not need.');
+            throw new ui_1.CliError('Recorder unavailable', ui_1.EXIT.USAGE);
+        }
+        const args = ['record'];
+        if (url)
+            args.push(url);
+        args.push('-o', opts.out);
+        if (opts.name)
+            args.push('-n', opts.name);
+        if (opts.cookies)
+            args.push('--cookies', opts.cookies);
+        if (opts.profile)
+            args.push('--profile', opts.profile);
+        const code = await runRecorder(bin, args);
+        if (code !== 0)
+            throw new ui_1.CliError(`Recorder exited with code ${code}`, ui_1.EXIT.ERROR);
+        if (!fs_1.default.existsSync(opts.out)) {
+            throw new ui_1.CliError(`Recorder finished but ${opts.out} was not written.`, ui_1.EXIT.ERROR);
+        }
+        ui_1.log.ok(`Recorded ${chalk_1.default.bold(opts.out)}`);
+        if (project) {
+            await api_1.AtlasApi.fromConfig().uploadFiles(project.id, [opts.out]);
+            ui_1.log.ok(`Uploaded ${path_1.default.basename(opts.out)} → ${project.name}`);
+            ui_1.log.dim(`run it with: atlas run --project ${project.name} --jmx ${path_1.default.basename(opts.out)}`);
+        }
+    });
+}
+//# sourceMappingURL=record.js.map

package/dist/commands/results.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSummary = printSummary;
+exports.registerResults = registerResults;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+const ui_1 = require("../ui");
+const gates_1 = require("../gates");
+const junit_1 = require("../junit");
+function errorColour(pct) {
+    if (pct === 0)
+        return chalk_1.default.green;
+    if (pct < 5)
+        return chalk_1.default.yellow;
+    return chalk_1.default.red;
+}
+/** Aggregation report, TOTAL first — same shape the dashboard shows. */
+function printSummary(rows) {
+    const table = new cli_table3_1.default({
+        head: ['LABEL', 'GROUP', '#', 'AVG', 'P90', 'P95', 'P99', 'MAX', 'REQ/S', 'ERR%'].map(h => chalk_1.default.dim(h)),
+        colAligns: ['left', 'left', 'right', 'right', 'right', 'right', 'right', 'right', 'right', 'right'],
+        style: { head: [], border: [] },
+    });
+    for (const r of rows) {
+        const isTotal = r.label === '_all';
+        const cell = (s) => (isTotal ? chalk_1.default.bold(s) : s);
+        table.push([
+            cell(isTotal ? 'TOTAL' : r.label),
+            cell(isTotal ? '' : r.threadGroup),
+            cell(String(r.requests)),
+            cell(String(r.avgMs)),
+            cell(String(r.p90Ms)),
+            cell(String(r.p95Ms)),
+            cell(String(r.p99Ms)),
+            cell(String(r.maxMs)),
+            cell(String(r.throughput)),
+            errorColour(r.errorPct)(cell(`${r.errorPct}%`)),
+        ]);
+    }
+    console.log(table.toString());
+}
+function registerResults(program) {
+    program
+        .command('results <testId>')
+        .description('Show the aggregation report for a run')
+        .option('--json', 'machine-readable output')
+        .option('--junit <path>', 'write JUnit XML (with --gate, one case per gate)')
+        .option('--gate <expr...>', 'evaluate thresholds against these results')
+        .action(async (testId, opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const { rows } = await api.summary(testId);
+        if (rows.length === 0) {
+            throw new ui_1.CliError(`No metrics found for "${testId}".`, ui_1.EXIT.ERROR);
+        }
+        const gates = (0, gates_1.parseGates)(opts.gate ?? []);
+        const results = gates.length ? (0, gates_1.evaluateGates)(gates, rows) : [];
+        const overall = rows.find(r => r.label === '_all');
+        if (opts.junit) {
+            const project = (0, config_1.loadConfig)().project ?? testId.split('-')[0];
+            (0, junit_1.writeJUnit)(opts.junit, (0, junit_1.buildJUnit)({ testId, project, durationSec: 0, gates: results, overall }));
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ testId, rows, gates: results }, null, 2));
+        }
+        else {
+            printSummary(rows);
+            for (const r of results) {
+                if (r.passed)
+                    ui_1.log.ok(chalk_1.default.dim('gate ') + (0, gates_1.formatGate)(r));
+                else
+                    ui_1.log.error(chalk_1.default.bold('gate ') + (0, gates_1.formatGate)(r));
+            }
+        }
+        const failed = results.filter(r => !r.passed);
+        if (failed.length) {
+            throw new ui_1.CliError(`${failed.length} of ${results.length} gate(s) failed.`, ui_1.EXIT.GATE_FAILED);
+        }
+    });
+    program
+        .command('status <testId>')
+        .description('Whether a run is still going, and its headline numbers')
+        .option('--json', 'machine-readable output')
+        .action(async (testId, opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const [status, summary] = await Promise.all([
+            api.testStatus(testId),
+            api.summary(testId).catch(() => ({ rows: [] })),
+        ]);
+        const overall = summary.rows.find(r => r.label === '_all');
+        if (opts.json) {
+            console.log(JSON.stringify({ testId, ...status, overall }, null, 2));
+            return;
+        }
+        ui_1.log.info(`${chalk_1.default.bold(testId)}  ${status.running ? chalk_1.default.green('● running') : chalk_1.default.dim('✓ completed')}`);
+        if (overall) {
+            ui_1.log.info(`requests ${overall.requests}  ·  avg ${overall.avgMs}ms  ·  p95 ${overall.p95Ms}ms  ·  ` +
+                `${errorColour(overall.errorPct)(`${overall.errorPct}% errors`)}`);
+        }
+        else {
+            ui_1.log.warn('No metrics reported yet.');
+        }
+    });
+    program
+        .command('stop <testId>')
+        .description('Stop a running test')
+        .action(async (testId) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const res = await api.stop(testId);
+        if (res.unreachable?.length || res.stillRunning?.length) {
+            // The API only marks a server stopped once it confirms the process is
+            // gone; anything else must be surfaced, not rounded up to success.
+            ui_1.log.warn(`Stopped on ${res.ok} server(s), but could not confirm all of them.`);
+            if (res.unreachable?.length)
+                ui_1.log.warn(`unreachable: ${res.unreachable.join(', ')}`);
+            if (res.stillRunning?.length)
+                ui_1.log.warn(`still running: ${res.stillRunning.join(', ')}`);
+            throw new ui_1.CliError('Run not fully stopped — retry when those servers are reachable.', ui_1.EXIT.ERROR);
+        }
+        ui_1.log.ok(`Stopped ${testId} on ${res.ok} server(s).`);
+    });
+}
+//# sourceMappingURL=results.js.map

package/dist/commands/run.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRun = registerRun;
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../api");
+const config_1 = require("../config");
+const ui_1 = require("../ui");
+const gates_1 = require("../gates");
+const junit_1 = require("../junit");
+const results_1 = require("./results");
+const TERMINAL = ['done', 'cancelled', 'error'];
+/** Pick which load generators to target: explicit names, a count, or a cluster. */
+async function resolveTarget(api, opts) {
+    if (opts.cluster) {
+        const clusters = await api.clusters();
+        const hit = clusters.find(c => c.name.toLowerCase() === opts.cluster.toLowerCase());
+        if (!hit) {
+            throw new ui_1.CliError(`No cluster named "${opts.cluster}". Available: ${clusters.map(c => c.name).join(', ') || '(none)'}`, ui_1.EXIT.USAGE);
+        }
+        const unitCount = parseInt(opts.units ?? '1', 10);
+        if (!Number.isFinite(unitCount) || unitCount < 1) {
+            throw new ui_1.CliError('--units must be a positive integer', ui_1.EXIT.USAGE);
+        }
+        return { poolId: hit.id, unitCount, describe: `${unitCount} unit(s) on cluster ${hit.name}` };
+    }
+    const fleet = await api.servers();
+    if (fleet.length === 0) {
+        throw new ui_1.CliError('No load generators available to this credential.', ui_1.EXIT.USAGE);
+    }
+    if (opts.server?.length) {
+        const wanted = opts.server.flatMap(s => s.split(','));
+        const ids = [];
+        for (const name of wanted.map(w => w.trim()).filter(Boolean)) {
+            const hit = fleet.find(s => s.name.toLowerCase() === name.toLowerCase());
+            if (!hit) {
+                throw new ui_1.CliError(`No server named "${name}". Available: ${fleet.map(s => s.name).join(', ')}`, ui_1.EXIT.USAGE);
+            }
+            ids.push(hit.id);
+        }
+        return { serverIds: ids, describe: `${ids.length} server(s)` };
+    }
+    const n = parseInt(opts.servers ?? '1', 10);
+    if (!Number.isFinite(n) || n < 1)
+        throw new ui_1.CliError('--servers must be a positive integer', ui_1.EXIT.USAGE);
+    if (n > fleet.length) {
+        throw new ui_1.CliError(`Asked for ${n} servers but only ${fleet.length} are available.`, ui_1.EXIT.USAGE);
+    }
+    // Off servers are fine: the scheduler powers on whatever it needs.
+    const chosen = fleet.slice(0, n);
+    return { serverIds: chosen.map(s => s.id), describe: chosen.map(s => s.name).join(', ') };
+}
+/** Poll the queue entry until it reaches a terminal state or the timeout hits. */
+async function waitForRun(api, queueId, timeoutMs, intervalMs, quiet) {
+    const deadline = Date.now() + timeoutMs;
+    let lastState = null;
+    for (;;) {
+        const entry = await api.queueEntry(queueId);
+        if (entry.state !== lastState) {
+            if (!quiet)
+                ui_1.log.step(`${entry.state}${entry.testId ? chalk_1.default.dim(`  ${entry.testId}`) : ''}`);
+            lastState = entry.state;
+        }
+        if (TERMINAL.includes(entry.state))
+            return entry;
+        if (Date.now() > deadline) {
+            throw new ui_1.CliError(`Timed out after ${(0, ui_1.formatDuration)(timeoutMs)} waiting for the run (last state: ${entry.state}). ` +
+                `The test may still be running — check \`atlas status ${entry.testId ?? ''}\`.`, ui_1.EXIT.ERROR);
+        }
+        await new Promise(r => setTimeout(r, intervalMs));
+    }
+}
+function registerRun(program) {
+    program
+        .command('run')
+        .description('Start a load test (optionally waiting for it and gating on results)')
+        .option('-p, --project <name>', 'project name')
+        .option('--jmx <filename>', 'JMX file to run (default: the project\'s)')
+        .option('-s, --servers <n>', 'number of load generators to use', '1')
+        .option('--server <name...>', 'target specific generators by name')
+        .option('--cluster <name>', 'run on an elastic cluster instead of fixed servers')
+        .option('--units <n>', 'containers to allocate when using --cluster', '1')
+        .option('--args <jmeterArgs>', 'extra JMeter arguments')
+        .option('--no-split', 'send whole data files to every generator instead of splitting')
+        .option('-w, --wait', 'wait for the run to finish')
+        .option('--timeout <duration>', 'how long to wait with --wait', '2h')
+        .option('--interval <duration>', 'poll interval with --wait', '10s')
+        .option('--gate <expr...>', 'pass/fail thresholds, e.g. error_rate<1,p95<2000 (implies --wait)')
+        .option('--junit <path>', 'write JUnit XML for the gates (implies --wait)')
+        .option('--json', 'machine-readable output')
+        .action(async (opts) => {
+        const api = api_1.AtlasApi.fromConfig();
+        const name = (0, config_1.loadConfig)({ project: opts.project }).project;
+        if (!name) {
+            throw new ui_1.CliError('No project. Pass --project <name> or set ATLAS_PROJECT.', ui_1.EXIT.USAGE);
+        }
+        const gates = (0, gates_1.parseGates)(opts.gate ?? []);
+        // Gates and JUnit are meaningless without results, so they imply --wait
+        // rather than silently producing nothing.
+        const wait = opts.wait || gates.length > 0 || !!opts.junit;
+        const project = await api.projectByName(name);
+        const target = await resolveTarget(api, opts);
+        const submitted = await api.run(project.id, {
+            serverIds: target.serverIds,
+            poolId: target.poolId,
+            unitCount: target.unitCount,
+            jmx: opts.jmx,
+            jmeterArgs: opts.args,
+            splitCsvs: opts.split,
+        });
+        if (!opts.json) {
+            ui_1.log.ok(submitted.status === 'queued'
+                ? `Queued (position ${submitted.position ?? '?'}) — servers are busy with another run.`
+                : `Started on ${target.describe}`);
+            if (submitted.testId)
+                ui_1.log.dim(`test id: ${submitted.testId}`);
+        }
+        if (!wait) {
+            if (opts.json)
+                console.log(JSON.stringify(submitted, null, 2));
+            else if (submitted.testId) {
+                ui_1.log.dim(`dashboard: ${api.baseUrl}/${project.name}/${submitted.testId}`);
+            }
+            return;
+        }
+        const startedAt = Date.now();
+        const entry = await waitForRun(api, submitted.queueId, (0, ui_1.parseDuration)(opts.timeout), (0, ui_1.parseDuration)(opts.interval), !!opts.json);
+        const durationSec = Math.round((Date.now() - startedAt) / 1000);
+        if (entry.state === 'error') {
+            throw new ui_1.CliError(`Run failed (test id: ${entry.testId ?? 'none'})`, ui_1.EXIT.ERROR);
+        }
+        if (entry.state === 'cancelled') {
+            throw new ui_1.CliError('Run was cancelled.', ui_1.EXIT.ERROR);
+        }
+        if (!entry.testId) {
+            throw new ui_1.CliError('Run finished without a test id — no results to report.', ui_1.EXIT.ERROR);
+        }
+        const { rows } = await api.summary(entry.testId);
+        const overall = rows.find(r => r.label === '_all');
+        let results = [];
+        if (gates.length)
+            results = (0, gates_1.evaluateGates)(gates, rows);
+        if (opts.junit) {
+            (0, junit_1.writeJUnit)(opts.junit, (0, junit_1.buildJUnit)({ testId: entry.testId, project: project.name, durationSec, gates: results, overall }));
+            if (!opts.json)
+                ui_1.log.dim(`JUnit written to ${opts.junit}`);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                testId: entry.testId, state: entry.state, durationSec, overall, gates: results,
+            }, null, 2));
+        }
+        else {
+            console.log();
+            (0, results_1.printSummary)(rows);
+            console.log();
+            for (const r of results) {
+                if (r.passed)
+                    ui_1.log.ok(chalk_1.default.dim('gate ') + (0, gates_1.formatGate)(r));
+                else
+                    ui_1.log.error(chalk_1.default.bold('gate ') + (0, gates_1.formatGate)(r));
+            }
+            ui_1.log.dim(`dashboard: ${api.baseUrl}/${project.name}/${entry.testId}`);
+        }
+        const failed = results.filter(r => !r.passed);
+        if (failed.length) {
+            throw new ui_1.CliError(`${failed.length} of ${results.length} gate(s) failed.`, ui_1.EXIT.GATE_FAILED);
+        }
+    });
+}
+//# sourceMappingURL=run.js.map

package/dist/config.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_URL = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.clearCredentials = clearCredentials;
+exports.configPath = configPath;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.atlas');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+exports.DEFAULT_URL = 'https://atlas.cloudbeat.io';
+function readFile() {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Effective config: flags beat environment, environment beats the config file.
+ * CI sets ATLAS_URL/ATLAS_TOKEN and never runs `atlas login`.
+ */
+function loadConfig(flags = {}) {
+    const file = readFile();
+    return {
+        url: flags.url || process.env.ATLAS_URL || file.url || exports.DEFAULT_URL,
+        token: flags.token || process.env.ATLAS_TOKEN || file.token,
+        project: flags.project || process.env.ATLAS_PROJECT || file.project,
+    };
+}
+/** Persist a partial update. The file holds a credential, so it is 0600. */
+function saveConfig(update) {
+    fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const merged = { ...readFile(), ...update };
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + '\n', { mode: 0o600 });
+    // Re-assert the mode: writeFileSync's mode applies only when creating.
+    fs_1.default.chmodSync(CONFIG_FILE, 0o600);
+}
+function clearCredentials() {
+    const cfg = readFile();
+    delete cfg.token;
+    fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+}
+function configPath() {
+    return CONFIG_FILE;
+}
+//# sourceMappingURL=config.js.map