@revyl/verify 0.0.0-stage → 0.2.0

package/dist/api/types.d.ts

@@ -0,0 +1,222 @@
+export type Platform = 'ios' | 'android' | 'web' | 'mac' | 'linux';
+export type MobilePlatform = 'ios' | 'android';
+export type ComputerPlatform = 'mac' | 'linux';
+export interface WebViewportRequest {
+    width?: number;
+    height?: number;
+    device_scale_factor?: number;
+}
+export interface WebSignInRequest {
+    path: string;
+    secret_name: string;
+    persona?: string;
+}
+export interface StartDeviceRequest {
+    platform: MobilePlatform | 'web';
+    is_simulation?: boolean;
+    session_id?: string;
+    app_id?: string;
+    build_id?: string;
+    app_url?: string;
+    device_model?: string;
+    os_version?: string;
+    idle_timeout_seconds?: number;
+    web?: {
+        viewport?: WebViewportRequest;
+        sign_in?: WebSignInRequest;
+    };
+}
+export interface StartDeviceResponse {
+    status: string;
+    platform: string;
+    session_id?: string | null;
+    workflow_run_id?: string | null;
+    error?: string | null;
+    message?: string | null;
+    trace_id?: string | null;
+}
+export type SessionStatus = 'queued' | 'starting' | 'running' | 'verifying' | 'stopping' | 'validating' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+export interface DeviceSessionDetail {
+    id: string;
+    status: SessionStatus | string;
+    platform?: string | null;
+    workflow_run_id?: string | null;
+    viewer_kind?: string | null;
+    error_message?: string | null;
+    screen_width?: number | null;
+    screen_height?: number | null;
+}
+export interface WorkerConnection {
+    status: 'ready' | 'not_ready' | 'cancelled' | 'stopped' | 'failed';
+    workflow_run_id: string;
+    worker_ws_url?: string | null;
+    message?: string | null;
+}
+export interface WorkerHealth {
+    status?: string;
+    device_connected?: boolean;
+    platform?: string;
+    screen_width?: number;
+    screen_height?: number;
+}
+export interface DeviceSessionStopResponse {
+    success: boolean;
+    request_accepted: boolean;
+    session_id: string;
+    status: string;
+    message: string;
+}
+export interface AppResponse {
+    id: string;
+    name?: string | null;
+    platform?: string | null;
+    default_branch_id?: string | null;
+}
+export interface BuildResponse {
+    id?: string | null;
+    app_id?: string | null;
+    artifact_kind?: string | null;
+    version?: string | null;
+}
+export interface BuildPage {
+    items: BuildResponse[];
+}
+export interface WhoAmI {
+    user_id?: string | null;
+    org_id?: string | null;
+    org_name?: string | null;
+    email?: string | null;
+}
+export interface WorkerActionResult {
+    success: boolean;
+    action?: string;
+    error?: string | null;
+}
+export type LiveStepType = 'instruction' | 'validation';
+export interface LiveStepOutput {
+    status?: 'success' | 'warning' | 'failed' | null;
+    status_reason?: string | null;
+    /** The verdict of a validation step. Revyl reports a validation that ran as status 'success', whatever its verdict. */
+    validation_result?: boolean | null;
+    reasoning?: string | null;
+}
+export interface LiveStepResult {
+    success: boolean;
+    step_type: LiveStepType | string;
+    step_id: string;
+    workflow_run_id?: string | null;
+    session_id?: string | null;
+    step_output: LiveStepOutput;
+}
+/** HTTP 202 from execute_step: the step runs asynchronously; poll step_status/{step_id}. */
+export interface StepAccepted {
+    step_id: string;
+    status: 'accepted';
+}
+export interface StepStatus {
+    step_id: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Present once the status is terminal. */
+    result?: LiveStepResult | null;
+}
+export interface ComputerRunCreate {
+    computer_session_id: string;
+    os: 'macos' | 'linux';
+}
+export type ComputerState = 'starting' | 'active' | 'closing' | 'stopped' | 'failed' | 'owner_lost';
+/** The fields Verify reads from a ComputerReport. */
+export interface ComputerReport {
+    computer_session_id: string;
+    state: ComputerState;
+    release: 'pending' | 'confirmed' | 'unknown';
+    failure_reason?: string | null;
+    expires_at?: string | null;
+}
+export interface ComputerRecordingResponse {
+    url: string;
+    duration_seconds?: number | null;
+    started_at?: string | null;
+}
+export interface ComputerProcessHandle {
+    computer_session_id: string;
+    handle_id: string;
+}
+/** Binary fields are base64. */
+export type ComputerCommand = {
+    timeout_ms: number;
+} & ({
+    kind: 'exec';
+    argv: string[];
+    stdin?: string;
+} | {
+    kind: 'file_read';
+    path: string;
+} | {
+    kind: 'file_write';
+    path: string;
+    data: string;
+} | {
+    kind: 'file_stat';
+    path: string;
+} | {
+    kind: 'process_list';
+} | {
+    kind: 'process_terminate';
+    handle: ComputerProcessHandle;
+});
+export interface ComputerExecResult {
+    kind: 'exec';
+    exit_code: number;
+    stdout?: string;
+    stderr?: string;
+}
+export type ComputerResult = ComputerExecResult | {
+    kind: 'file_read';
+    data: string;
+} | {
+    kind: 'file_write';
+    byte_count: number;
+} | {
+    kind: 'file_stat';
+    file_kind: 'file' | 'directory';
+    size_bytes: number;
+} | {
+    kind: 'process_list';
+    processes: Array<{
+        handle: ComputerProcessHandle;
+        state: 'running' | 'exited';
+        exit_code?: number | null;
+    }>;
+} | {
+    kind: 'process_terminate';
+    termination: 'confirmed';
+};
+export type ComputerExecution = {
+    outcome: 'succeeded';
+    result: ComputerResult;
+} | {
+    outcome: 'failed';
+    error_code: 'not_found' | 'access_denied' | 'exec_nonzero';
+    result?: ComputerExecResult | null;
+} | {
+    outcome: 'timed_out';
+    error_code: 'timed_out';
+    termination: 'confirmed' | 'unknown';
+    observed_exit_code?: number | null;
+} | {
+    outcome: 'unknown';
+    error_code: string;
+    termination: 'confirmed' | 'unknown';
+};
+export interface ComputerCommandResponse {
+    computer_session_id: string;
+    operation_id: string;
+    execution: ComputerExecution;
+    evidence: 'recorded' | 'pending' | 'failed';
+}
+export interface ComputerScreenshot {
+    width: number;
+    height: number;
+    /** Standard base64. */
+    png: string;
+}

package/dist/api/types.js

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

package/dist/auth.d.ts

@@ -0,0 +1,17 @@
+export type CredentialSource = 'REVYL_API_KEY' | 'revyl-cli-login';
+export interface Credentials {
+    token: string;
+    source: CredentialSource;
+}
+export declare function revylCredentialsPath(home?: string): string;
+/**
+ * Resolves the token Verify sends to Revyl, in the same order as the Revyl CLI:
+ * REVYL_API_KEY first, unless a browser login in ~/.revyl/credentials.json was
+ * marked to take precedence, then that login's access token or API key.
+ */
+export declare function resolveCredentials(options?: {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    nowMs?: number;
+}): Promise<Credentials | undefined>;
+export declare function missingCredentialsMessage(): string;

package/dist/auth.js

@@ -0,0 +1,65 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { VerifyError } from './errors.js';
+const ACCESS_TOKEN_EXPIRY_MARGIN_MS = 60_000;
+export function revylCredentialsPath(home = homedir()) {
+    return join(home, '.revyl', 'credentials.json');
+}
+/**
+ * Resolves the token Verify sends to Revyl, in the same order as the Revyl CLI:
+ * REVYL_API_KEY first, unless a browser login in ~/.revyl/credentials.json was
+ * marked to take precedence, then that login's access token or API key.
+ */
+export async function resolveCredentials(options = {}) {
+    const env = options.env ?? process.env;
+    const stored = await readStoredCredentials(revylCredentialsPath(options.home));
+    const storedToken = stored ? usableStoredToken(stored, options.nowMs ?? Date.now()) : undefined;
+    const envKey = env.REVYL_API_KEY?.trim();
+    const envKeyUsable = envKey !== undefined && envKey !== '' && !envKey.startsWith('${');
+    if (envKeyUsable && !(stored?.local_auth_override && storedToken)) {
+        return { token: envKey, source: 'REVYL_API_KEY' };
+    }
+    if (storedToken) {
+        return { token: storedToken, source: 'revyl-cli-login' };
+    }
+    return undefined;
+}
+export function missingCredentialsMessage() {
+    return [
+        'No Revyl credentials found.',
+        'Set REVYL_API_KEY to an API key from https://app.revyl.ai (Settings → API keys),',
+        "or sign in once with the Revyl CLI: 'revyl auth login'.",
+    ].join(' ');
+}
+async function readStoredCredentials(path) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new VerifyError('AUTH_MISSING', `Could not read ${path}: ${error.message}`, { cause: error });
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            throw new Error('not an object');
+        return parsed;
+    }
+    catch (error) {
+        throw new VerifyError('AUTH_MISSING', `${path} is not valid JSON. Run 'revyl auth login' again or set REVYL_API_KEY.`, { cause: error });
+    }
+}
+function usableStoredToken(stored, nowMs) {
+    if (stored.access_token && !isExpired(stored.expires_at, nowMs))
+        return stored.access_token;
+    return stored.api_key || undefined;
+}
+function isExpired(expiresAt, nowMs) {
+    if (!expiresAt)
+        return false;
+    const expiresAtMs = Date.parse(expiresAt);
+    return Number.isNaN(expiresAtMs) || nowMs + ACCESS_TOKEN_EXPIRY_MARGIN_MS > expiresAtMs;
+}

package/dist/cleanup.d.ts

@@ -0,0 +1,13 @@
+interface OpenSession {
+    readonly target: string;
+    close(): Promise<void>;
+}
+/**
+ * Keeps Revyl sessions from outliving the script that opened them. While a session is open, Verify
+ * closes it before the process ends: on Ctrl+C or SIGTERM, on an uncaught error, and when the script
+ * finishes without calling close(). It only handles a signal or error event nobody else is listening
+ * to, so test runners and apps that manage their own shutdown keep control of it.
+ */
+export declare function trackSession(session: OpenSession): void;
+export declare function untrackSession(session: OpenSession): void;
+export {};

package/dist/cleanup.js

@@ -0,0 +1,72 @@
+import { inspect } from 'node:util';
+import { isVerifyError } from './errors.js';
+const CLOSE_ALL_TIMEOUT_MS = 15_000;
+const open = new Set();
+const installed = [];
+let exiting = false;
+/**
+ * Keeps Revyl sessions from outliving the script that opened them. While a session is open, Verify
+ * closes it before the process ends: on Ctrl+C or SIGTERM, on an uncaught error, and when the script
+ * finishes without calling close(). It only handles a signal or error event nobody else is listening
+ * to, so test runners and apps that manage their own shutdown keep control of it.
+ */
+export function trackSession(session) {
+    open.add(session);
+    if (installed.length === 0)
+        install();
+}
+export function untrackSession(session) {
+    open.delete(session);
+    if (open.size === 0 && !exiting)
+        uninstall();
+}
+function install() {
+    const listen = (event, listener, onlyIfUnhandled) => {
+        if (onlyIfUnhandled && process.listenerCount(event) > 0)
+            return;
+        process.on(event, listener);
+        installed.push([event, listener]);
+    };
+    listen('SIGINT', () => onSignal(130), true);
+    listen('SIGTERM', () => onSignal(143), true);
+    listen('uncaughtException', (error) => onFatal(error), true);
+    listen('unhandledRejection', (reason) => onFatal(reason), true);
+    listen('beforeExit', onBeforeExit, false);
+}
+function uninstall() {
+    for (const [event, listener] of installed.splice(0))
+        process.off(event, listener);
+}
+function onSignal(code) {
+    if (exiting)
+        process.exit(code);
+    process.stderr.write(`\n[verify] Closing ${describeOpen()} before exiting. Press Ctrl+C again to exit now.\n`);
+    void exitAfterClosing(code);
+}
+function onFatal(error) {
+    if (exiting)
+        return;
+    process.stderr.write(`${isVerifyError(error) ? `${error.code}: ${error.message}` : inspect(error)}\n`);
+    if (open.size > 0)
+        process.stderr.write(`[verify] Closing ${describeOpen()} before exiting.\n`);
+    void exitAfterClosing(1);
+}
+function onBeforeExit() {
+    if (open.size === 0 || exiting)
+        return;
+    process.stderr.write(`[verify] Closing ${describeOpen()} the script left open. Call session.close() when you are done with a session.\n`);
+    void closeAll();
+}
+async function exitAfterClosing(code) {
+    exiting = true;
+    await closeAll();
+    process.exit(code);
+}
+async function closeAll() {
+    const closing = Promise.allSettled([...open].map((session) => session.close()));
+    await Promise.race([closing, new Promise((resolve) => setTimeout(resolve, CLOSE_ALL_TIMEOUT_MS).unref())]);
+}
+function describeOpen() {
+    const names = [...open].map((session) => session.target);
+    return names.length === 1 ? `the ${names[0]} session` : `${names.length} sessions (${names.join(', ')})`;
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,14 @@
+import type { Platform } from '../api/types.js';
+export interface InitAnswers {
+    platform: Platform;
+    appId?: string;
+    url?: string;
+}
+export interface InitResult {
+    created: string[];
+    gitignoreUpdated: boolean;
+}
+export declare function validateInitAnswers(answers: InitAnswers): InitAnswers;
+export declare function initProject(cwd: string, answers: InitAnswers, options?: {
+    force?: boolean;
+}): Promise<InitResult>;

package/dist/cli/init.js

@@ -0,0 +1,115 @@
+import { existsSync } from 'node:fs';
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { VerifyError } from '../errors.js';
+import { PACKAGE_NAME } from '../version.js';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CONFIG_FILE = 'verify.config.ts';
+const EXAMPLE_SCRIPT = join('verify', 'example.ts');
+export function validateInitAnswers(answers) {
+    if (!['web', 'ios', 'android', 'mac'].includes(answers.platform)) {
+        throw new VerifyError('INVALID_ARGUMENT', "--platform must be 'web', 'ios', 'android', or 'mac'. Linux init is unavailable; use open({ platform: 'linux' }) or a Linux config target.");
+    }
+    if (answers.platform === 'mac' && answers.appId !== undefined) {
+        throw new VerifyError('INVALID_ARGUMENT', '--app-id does not apply to Mac computers.');
+    }
+    if (answers.appId !== undefined && !UUID.test(answers.appId)) {
+        throw new VerifyError('INVALID_ARGUMENT', '--app-id must be a Revyl app id (a UUID).');
+    }
+    if (answers.url !== undefined) {
+        if (answers.platform !== 'web')
+            throw new VerifyError('INVALID_ARGUMENT', '--url applies to web targets only.');
+        if (!/^https:\/\/[^/?#@\s]+(\/[^?#\s]*)?$/.test(answers.url)) {
+            throw new VerifyError('INVALID_ARGUMENT', '--url must be a public HTTPS URL without credentials, query, or fragment.');
+        }
+    }
+    return answers;
+}
+export async function initProject(cwd, answers, options = {}) {
+    validateInitAnswers(answers);
+    const files = [
+        [CONFIG_FILE, configTemplate(answers)],
+        [EXAMPLE_SCRIPT, scriptTemplate(answers.platform)],
+    ];
+    const existing = files.map(([path]) => path).filter((path) => existsSync(join(cwd, path)));
+    if (existing.length > 0 && !options.force) {
+        throw new VerifyError('INVALID_ARGUMENT', `${existing.join(' and ')} already exist. Re-run with --force to overwrite.`);
+    }
+    for (const [path, content] of files) {
+        await mkdir(join(cwd, path, '..'), { recursive: true });
+        await writeFile(join(cwd, path), content);
+    }
+    return { created: files.map(([path]) => relative(cwd, join(cwd, path))), gitignoreUpdated: await ignoreOutput(cwd) };
+}
+async function ignoreOutput(cwd) {
+    const path = join(cwd, '.gitignore');
+    const current = existsSync(path) ? await readFile(path, 'utf8') : '';
+    if (current.split(/\r?\n/).some((line) => ['.verify', '.verify/', '/.verify', '/.verify/'].includes(line.trim())))
+        return false;
+    await appendFile(path, `${current === '' || current.endsWith('\n') ? '' : '\n'}.verify/\n`);
+    return true;
+}
+function configTemplate({ platform, appId, url }) {
+    const app = appId ? `'${appId}'` : `process.env.REVYL_APP_ID ?? 'REPLACE_WITH_YOUR_REVYL_APP_ID'`;
+    const target = platform === 'mac'
+        ? `    mac: { platform: 'mac' },`
+        : platform === 'web'
+            ? `    web: {
+      platform: 'web',
+      app: {
+        // The Revyl web app to open: copy its id from the app's page in Revyl.
+        appId: ${app},
+        // A public HTTPS URL, such as a preview deployment. Remove it to open the app's newest Revyl build.
+        url: '${url ?? 'https://example.com'}',
+      },
+      viewport: { width: 1280, height: 800 },
+    },`
+            : `    ${platform}: {
+      platform: '${platform}',
+      app: {
+        // The Revyl app to install: each session installs its newest build. Use buildId to pin one build.
+        appId: ${app},
+      },
+    },`;
+    return `import { defineConfig } from '${PACKAGE_NAME}';
+
+export default defineConfig({
+  targets: {
+${target}
+  },
+});
+`;
+}
+function scriptTemplate(platform) {
+    if (platform === 'mac') {
+        return `// Mac computers are in early access; ask support@revyl.ai to enable your organization.
+import assert from 'node:assert/strict';
+import { open } from '@revyl/verify';
+
+const session = await open('mac');
+try {
+  const result = await session.exec(['uname', '-s']);
+  assert.equal(result.stdout.trim(), 'Darwin');
+  await session.writeFile('hello.txt', 'Hello from Verify!\\n');
+  assert.equal((await session.readFile('hello.txt')).toString('utf8'), 'Hello from Verify!\\n');
+  assert.equal((await session.stat('hello.txt')).kind, 'file');
+} finally {
+  await session.close();
+}
+`;
+    }
+    const steps = platform === 'web'
+        ? `await session.instruction('Follow the link on the page');
+await session.validation('A page about domains reserved for documentation is shown');`
+        : `await session.instruction('Wait for the app to finish opening and show its first screen');
+await session.validation('The app has opened and shows its first screen without an error');`;
+    return `import { open } from '${PACKAGE_NAME}';
+
+// Opens the "${platform}" target from verify.config.ts on Revyl and prints a link to watch it live.
+// A failed instruction or validation throws, so this script exits non-zero, and Verify closes the session on the way out.
+const session = await open('${platform}');
+${steps}
+await session.screenshot({ path: '.verify/example.png' });
+await session.close();
+`;
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function main(argv: string[]): Promise<number>;
+export declare function runCli(argv: string[]): Promise<number>;

package/dist/cli/main.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { parseArgs } from 'node:util';
+import { RevylClient } from '../api/client.js';
+import { missingCredentialsMessage, resolveCredentials } from '../auth.js';
+import { VerifyError, errorMessage, isVerifyError } from '../errors.js';
+import { PACKAGE_NAME, VERSION } from '../version.js';
+import { initProject, validateInitAnswers } from './init.js';
+const HELP = `verify ${VERSION}: open Revyl cloud browsers, devices, and computers from your code
+
+Usage
+  npx ${PACKAGE_NAME} init [--platform web|ios|android|mac] [--app-id <id>] [--url <https-url>] [--force]
+      Write verify.config.ts and an example script, verify/example.ts
+  npx ${PACKAGE_NAME} whoami
+      Check which Revyl account your credentials belong to
+
+Authentication
+  REVYL_API_KEY, or a login from the Revyl CLI ('revyl auth login').
+
+Docs: https://github.com/RevylAI/verify/tree/v${VERSION}/packages/verify/docs
+`;
+const USAGE_CODES = new Set(['INVALID_ARGUMENT', 'AUTH_MISSING', 'AUTH_REJECTED']);
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case undefined:
+        case '-h':
+        case '--help':
+        case 'help':
+            process.stdout.write(HELP);
+            return 0;
+        case '-v':
+        case '--version':
+            process.stdout.write(`${VERSION}\n`);
+            return 0;
+        case 'init':
+            return initCommand(rest);
+        case 'whoami':
+            return whoamiCommand();
+        default:
+            process.stderr.write(`Unknown command: ${command}\n\n${HELP}`);
+            return 2;
+    }
+}
+async function initCommand(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            platform: { type: 'string', short: 'p' },
+            'app-id': { type: 'string' },
+            url: { type: 'string' },
+            force: { type: 'boolean' },
+        },
+    });
+    let answers;
+    if (values.platform) {
+        answers = validateInitAnswers({
+            platform: values.platform,
+            ...(values['app-id'] ? { appId: values['app-id'] } : {}),
+            ...(values.url ? { url: values.url } : {}),
+        });
+    }
+    else if (process.stdin.isTTY) {
+        answers = await askInitQuestions(values['app-id'], values.url);
+    }
+    else {
+        throw new VerifyError('INVALID_ARGUMENT', 'Pass --platform web, ios, android, or mac when not running in a terminal.');
+    }
+    const result = await initProject(process.cwd(), answers, { force: values.force ?? false });
+    const steps = [
+        `npm install --save-dev ${PACKAGE_NAME}`,
+        "Authenticate: export REVYL_API_KEY=<key from Revyl settings>, or run 'revyl auth login'",
+        ...(answers.platform === 'mac' ? [`Mac computers are not yet available in Revyl production. Early access works only on Revyl staging for enabled organizations; use the optional REVYL_BACKEND_URL override with staging credentials. Ask support@revyl.ai for access. See https://github.com/RevylAI/verify/blob/v${VERSION}/packages/verify/docs/computers.md#availability-and-errors`] : []),
+        ...(answers.platform === 'mac' || answers.appId ? [] : ['Put your Revyl app id in verify.config.ts (or set REVYL_APP_ID)']),
+        'node verify/example.ts',
+    ];
+    process.stdout.write([
+        `Created ${result.created.join(' and ')}${result.gitignoreUpdated ? ', and added .verify/ to .gitignore' : ''}.`,
+        '',
+        'Next:',
+        ...steps.map((step, index) => `  ${index + 1}. ${step}`),
+        '',
+    ].join('\n'));
+    return 0;
+}
+async function askInitQuestions(appId, url) {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const platform = ((await readline.question('What do you want to open? [web/ios/android/mac] (web): ')).trim().toLowerCase() || 'web');
+        if (platform === 'mac')
+            return validateInitAnswers({ platform, ...(appId ? { appId } : {}), ...(url ? { url } : {}) });
+        const id = appId ?? ((await readline.question('Revyl app id (Enter to fill in later): ')).trim() || undefined);
+        const webUrl = platform === 'web' ? (url ?? ((await readline.question('HTTPS URL to open (Enter for https://example.com): ')).trim() || undefined)) : undefined;
+        return validateInitAnswers({ platform, ...(id ? { appId: id } : {}), ...(webUrl ? { url: webUrl } : {}) });
+    }
+    finally {
+        readline.close();
+    }
+}
+async function whoamiCommand() {
+    const credentials = await resolveCredentials();
+    if (!credentials)
+        throw new VerifyError('AUTH_MISSING', missingCredentialsMessage());
+    const who = await new RevylClient({ token: credentials.token }).whoAmI();
+    const name = who.email ?? who.user_id ?? 'an unnamed user';
+    const org = who.org_name ?? who.org_id;
+    process.stdout.write(`Signed in to Revyl as ${name}${org ? ` in ${org}` : ''} (credentials from ${credentials.source}).\n`);
+    return 0;
+}
+export async function runCli(argv) {
+    try {
+        return await main(argv);
+    }
+    catch (error) {
+        if (isVerifyError(error)) {
+            process.stderr.write(`${error.code}: ${error.message}\n`);
+            return USAGE_CODES.has(error.code) ? 2 : 1;
+        }
+        if (error instanceof TypeError && error.code?.startsWith('ERR_PARSE_ARGS')) {
+            process.stderr.write(`${error.message}\nRun 'verify --help' for usage.\n`);
+            return 2;
+        }
+        process.stderr.write(`${errorMessage(error)}\n`);
+        return 1;
+    }
+}
+process.exitCode = await runCli(process.argv.slice(2));