@revyl/verify 0.3.1 → 0.4.0

package/dist/api/client.js

@@ -91,7 +91,7 @@ export class RevylClient {
             timeoutMs: options.timeoutMs,
             signal: options.signal,
             retry: options.retry ?? false,
-            headers: { 'X-Revyl-Agent': 'Verify' },
+            headers: { 'X-Revyl-Agent': 'Verify', ...options.headers },
         });
     }
     async sendOnce(method, url, options) {
@@ -198,7 +198,7 @@ export function edgeBlockedError(response) {
 }
 const REFUSAL_REASONS = new Set([
     'web_runtime_unavailable', 'web_runtime_not_configured', 'computer_limit', 'runtime_unavailable', 'computer_runtime_unavailable',
-    'computer_at_capacity', 'computer_not_running', 'computer_cannot_host_platform', 'computer_not_found',
+    'computer_at_capacity', 'computer_platform_at_capacity', 'computer_not_running', 'computer_cannot_host_platform', 'computer_not_found',
     'web_build_required', 'web_build_not_supported', 'ios_build_required', 'ios_build_not_supported',
     'android_build_required', 'android_build_not_supported', 'web_session_conflict', 'ios_session_conflict',
     'android_session_conflict', 'not_available_on_platform', 'request_timeout', 'protocol_error',

package/dist/auth.js

@@ -28,8 +28,8 @@ export async function resolveCredentials(options = {}) {
 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'.",
+        "Sign in through your browser with 'npx @revyl/verify login' in a terminal,",
+        'or set REVYL_API_KEY to an API key from https://app.revyl.ai (Settings → API keys).',
     ].join(' ');
 }
 async function readStoredCredentials(path) {

package/dist/cli/init.d.ts

@@ -8,6 +8,7 @@ export interface InitResult {
     created: string[];
     gitignoreUpdated: boolean;
 }
+export declare function webAppIdMissingMessage(url: string | undefined): string;
 export declare function validateInitAnswers(answers: InitAnswers): InitAnswers;
 export declare function initProject(cwd: string, answers: InitAnswers, options?: {
     force?: boolean;

package/dist/cli/init.js

@@ -5,7 +5,15 @@ 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');
+const EXAMPLE_SCRIPT = join('verify', 'example.mts');
+const SETTINGS_BUNDLE_ID = { ios: 'com.apple.Preferences', android: 'com.android.settings' };
+export function webAppIdMissingMessage(url) {
+    return [
+        'A Web target needs the id of a Web app in Revyl, so init wrote no files.',
+        'Create one at https://app.revyl.ai: click Create app, keep Web selected, and enter your site\'s public HTTPS URL. Then copy the app id from the app\'s page.',
+        `Then run: npx ${PACKAGE_NAME} init --platform web --app-id <app-id> --url ${url ?? 'https://example.com'}`,
+    ].join('\n');
+}
 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.");
@@ -23,13 +31,16 @@ export function validateInitAnswers(answers) {
             throw new VerifyError('INVALID_ARGUMENT', '--url must be a public HTTPS URL without credentials, query, or fragment.');
         }
     }
+    if (answers.platform === 'web' && answers.appId === undefined) {
+        throw new VerifyError('INVALID_ARGUMENT', webAppIdMissingMessage(answers.url));
+    }
     return answers;
 }
 export async function initProject(cwd, answers, options = {}) {
     validateInitAnswers(answers);
     const files = [
         [CONFIG_FILE, configTemplate(answers)],
-        [EXAMPLE_SCRIPT, scriptTemplate(answers.platform)],
+        [EXAMPLE_SCRIPT, scriptTemplate(answers)],
     ];
     const existing = files.map(([path]) => path).filter((path) => existsSync(join(cwd, path)));
     if (existing.length > 0 && !options.force) {
@@ -50,25 +61,33 @@ async function ignoreOutput(cwd) {
     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},
+        // The Revyl Web app to open.
+        appId: '${appId}',
         // 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}: {
+            : appId
+                ? `    ${platform}: {
       platform: '${platform}',
       app: {
         // The Revyl app to install: each session installs its newest build. Use buildId to pin one build.
-        appId: ${app},
+        appId: '${appId}',
+      },
+    },`
+                : `    ${platform}: {
+      platform: '${platform}',
+      app: {
+        // The device's built-in Settings app, so the example runs before you upload anything.
+        // To test your own app, replace this line with appId: '<your Revyl app id>'.
+        bundleId: '${SETTINGS_BUNDLE_ID[platform]}',
       },
     },`;
     return `import { defineConfig } from '${PACKAGE_NAME}';
@@ -80,7 +99,7 @@ ${target}
 });
 `;
 }
-function scriptTemplate(platform) {
+function scriptTemplate({ platform, appId }) {
     if (platform === 'mac') {
         return `// Mac computers are in early access; ask support@revyl.ai to enable your organization.
 import assert from 'node:assert/strict';
@@ -101,7 +120,13 @@ try {
     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');
+        : !appId && platform === 'ios'
+            ? `await session.instruction('Open General, then About');
+await session.validation('The screen shows the operating system version');`
+            : !appId && platform === 'android'
+                ? `await session.instruction('Open the screen that shows information about this device, such as About or About phone, then scroll or navigate until the operating system version is visible');
+await session.validation('The screen shows the version of the operating system');`
+                : `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}';
 

package/dist/cli/install.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { VerifyError } from '../errors.js';
 import { PACKAGE_NAME } from '../version.js';
@@ -32,24 +32,29 @@ export async function installVerify(cwd) {
     const manager = detectPackageManager(cwd);
     if (!existsSync(join(cwd, 'package.json')))
         await writeFile(join(cwd, 'package.json'), '{\n  "private": true,\n  "type": "module"\n}\n', { flag: 'wx' });
+    const shell = process.platform === 'win32';
     const args = manager === 'npm'
         ? ['install', '--save-dev', '--ignore-scripts']
-        : manager === 'yarn'
-            ? ['add', '--dev', '--mode=skip-builds']
-            : ['add', '--dev', '--ignore-scripts'];
+        : manager === 'pnpm'
+            ? ['add', '-D', '--ignore-scripts']
+            : manager === 'yarn'
+                ? yarnAddArgs(cwd, shell)
+                : ['add', '--dev', '--ignore-scripts'];
     args.push(PACKAGE_NAME);
     process.stdout.write(`Installing ${PACKAGE_NAME} with ${manager}...\n`);
     await new Promise((resolve, reject) => {
-        const env = Object.fromEntries(['PATH', 'HOME', 'USERPROFILE', 'TMPDIR', 'TEMP', 'TMP'].flatMap((key) => {
-            const value = process.env[key];
-            return value === undefined ? [] : [[key, value]];
-        }));
-        const child = spawn(manager, args, { cwd, env, stdio: 'inherit', shell: process.platform === 'win32', timeout: 180_000, killSignal: 'SIGKILL' });
+        const child = spawn(manager, args, { cwd, stdio: 'inherit', shell, timeout: 180_000, killSignal: 'SIGKILL' });
         const fail = () => reject(new VerifyError('CONFIG_INVALID', `Could not install ${PACKAGE_NAME} with ${manager}. Install it manually, then retry init --no-install.`));
         child.once('error', fail);
         child.once('exit', (code) => code === 0 ? resolve() : fail());
     });
 }
+function yarnAddArgs(cwd, shell) {
+    const major = Number.parseInt(spawnSync('yarn', ['--version'], { cwd, shell, encoding: 'utf8', timeout: 60_000 }).stdout?.trim() ?? '', 10);
+    if (major === 1)
+        return ['add', '--dev', '--ignore-scripts'];
+    return major >= 3 ? ['add', '--dev', '--mode=skip-build'] : ['add', '--dev'];
+}
 function detectPackageManager(cwd) {
     const lockfiles = [['pnpm-lock.yaml', 'pnpm'], ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'], ['package-lock.json', 'npm'], ['npm-shrinkwrap.json', 'npm']];
     for (let directory = cwd;; directory = dirname(directory)) {

package/dist/cli/login.js

@@ -53,7 +53,7 @@ export async function signIn(options = {}) {
                 continue;
             }
             if (credential.state === 'denied')
-                throw new VerifyError('AUTH_REJECTED', 'The Revyl login request was denied. Run your script again to sign in, or use revyl auth login.');
+                throw new VerifyError('AUTH_REJECTED', 'The Revyl login request was denied. Run your script again to sign in, or run npx @revyl/verify login.');
             if (credential.state !== 'approved')
                 throw invalidResponse();
             const token = requiredString(credential, 'api_key_token');
@@ -80,11 +80,11 @@ export async function signIn(options = {}) {
             await writePrivateState('credentials.json', stored);
             return { token, source: 'revyl-cli-login' };
         }
-        throw new VerifyError('AUTH_MISSING', 'The Revyl login request expired. Run your script again to sign in, or use revyl auth login.');
+        throw new VerifyError('AUTH_MISSING', 'The Revyl login request expired. Run your script again to sign in, or run npx @revyl/verify login.');
     }
     catch (error) {
         if (signal.aborted)
-            throw new VerifyError('AUTH_MISSING', 'Revyl sign-in was cancelled or timed out. Run your script again to sign in, or use revyl auth login.');
+            throw new VerifyError('AUTH_MISSING', 'Revyl sign-in was cancelled or timed out. Run your script again to sign in, or run npx @revyl/verify login.');
         throw error;
     }
     finally {
@@ -98,12 +98,12 @@ async function post(backendUrl, path, body, signal) {
         response = await fetch(new URL(path, backendUrl), { method: 'POST', headers: { 'Content-Type': 'application/json', Accept: 'application/json' }, body: JSON.stringify(body), redirect: 'error', signal: AbortSignal.any([signal, AbortSignal.timeout(15_000)]) });
     }
     catch {
-        throw new VerifyError('AUTH_MISSING', 'Could not reach Revyl to sign in. Run your script again, use revyl auth login, or set REVYL_API_KEY.');
+        throw new VerifyError('AUTH_MISSING', 'Could not reach Revyl to sign in. Run your script again, run npx @revyl/verify login, or set REVYL_API_KEY.');
     }
     if (response.status === 404)
-        throw new VerifyError('AUTH_MISSING', 'The Revyl login request is unavailable or expired. Run your script again, or use revyl auth login.');
+        throw new VerifyError('AUTH_MISSING', 'The Revyl login request is unavailable or expired. Run your script again, or run npx @revyl/verify login.');
     if (!response.ok)
-        throw new VerifyError('AUTH_REJECTED', `Revyl sign-in failed (HTTP ${response.status}). Run your script again, use revyl auth login, or set REVYL_API_KEY.`);
+        throw new VerifyError('AUTH_REJECTED', `Revyl sign-in failed (HTTP ${response.status}). Run your script again, run npx @revyl/verify login, or set REVYL_API_KEY.`);
     let value;
     try {
         value = await response.json();
@@ -130,7 +130,7 @@ function optionalString(value, key) {
     return text || undefined;
 }
 function invalidResponse() {
-    return new VerifyError('AUTH_REJECTED', 'Revyl returned an invalid sign-in response. Run your script again, use revyl auth login, or set REVYL_API_KEY.');
+    return new VerifyError('AUTH_REJECTED', 'Revyl returned an invalid sign-in response. Run your script again, run npx @revyl/verify login, or set REVYL_API_KEY.');
 }
 function tokenExpiry(token) {
     try {

package/dist/cli/main.js

@@ -1,25 +1,48 @@
 #!/usr/bin/env node
+import { rm } from 'node:fs/promises';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { RevylClient } from '../api/client.js';
-import { missingCredentialsMessage, resolveCredentials } from '../auth.js';
+import { missingCredentialsMessage, resolveCredentials, revylCredentialsPath } from '../auth.js';
 import { VerifyError, errorMessage, isVerifyError } from '../errors.js';
 import { PACKAGE_NAME, VERSION } from '../version.js';
-import { initProject, validateInitAnswers } from './init.js';
+import { initProject, validateInitAnswers, webAppIdMissingMessage } from './init.js';
 import { installVerify, packageHasVerify } from './install.js';
 import { signIn } from './login.js';
+const INIT_USAGE = `npx ${PACKAGE_NAME} init [--platform ios|android|web|mac] [--app-id <id>] [--url <https-url>] [--force] [--yes] [--no-install]`;
+const DOCS = `https://github.com/RevylAI/verify/tree/v${VERSION}/packages/verify/docs`;
 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] [--yes] [--no-install]
-      Install Verify, write verify.config.ts and an example script, then check authentication
+  ${INIT_USAGE}
+      Install Verify, write verify.config.ts and an example script, and sign in
+  npx ${PACKAGE_NAME} login
+      Sign in to Revyl through your browser
+  npx ${PACKAGE_NAME} logout
+      Remove the saved Revyl login from this computer
   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').
+  In a terminal, init, login, and your first open() sign you in through your browser and save the
+  login to ~/.revyl/credentials.json, which the Revyl CLI shares. In CI, set REVYL_API_KEY instead.
 
-Docs: https://github.com/RevylAI/verify/tree/v${VERSION}/packages/verify/docs
+Docs: ${DOCS}
+`;
+const INIT_HELP = `Usage: ${INIT_USAGE}
+
+Writes verify.config.ts and verify/example.mts, installs Verify when the project lacks it, and signs
+you in through your browser when no credentials are saved.
+
+  --platform    ios, android, web, or mac. Without it, init asks. iOS and Android without --app-id
+                open the device's built-in Settings app, so the example runs before you upload anything.
+  --app-id      The Revyl app to open. Required for web; create a Web app at https://app.revyl.ai first.
+  --url         The public HTTPS URL a web target opens (default https://example.com).
+  --force       Overwrite existing files.
+  --yes         Install Verify without asking.
+  --no-install  Skip installing Verify.
+
+Docs: ${DOCS}/getting-started.md
 `;
 const USAGE_CODES = new Set(['INVALID_ARGUMENT', 'AUTH_MISSING', 'AUTH_REJECTED']);
 export async function main(argv) {
@@ -37,8 +60,18 @@ export async function main(argv) {
             return 0;
         case 'init':
             return initCommand(rest);
-        case 'whoami':
-            return whoamiCommand();
+        case 'login':
+        case 'logout':
+        case 'whoami': {
+            const { values } = parseArgs({ args: rest, options: { help: { type: 'boolean', short: 'h' } } });
+            if (values.help) {
+                process.stdout.write(HELP);
+                return 0;
+            }
+            if (command === 'login')
+                return signInAndCheck(Boolean(process.stdin.isTTY) && !process.env.CI);
+            return command === 'logout' ? logoutCommand() : whoamiCommand();
+        }
         default:
             process.stderr.write(`Unknown command: ${command}\n\n${HELP}`);
             return 2;
@@ -54,8 +87,13 @@ async function initCommand(args) {
             force: { type: 'boolean' },
             yes: { type: 'boolean' },
             'no-install': { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
         },
     });
+    if (values.help) {
+        process.stdout.write(INIT_HELP);
+        return 0;
+    }
     const interactive = Boolean(process.stdin.isTTY) && !process.env.CI;
     let answers;
     if (values.platform) {
@@ -86,44 +124,46 @@ async function initCommand(args) {
     answers ??= await askInitQuestions(values['app-id'], values.url);
     const result = await initProject(process.cwd(), answers, { force: values.force ?? false });
     process.stdout.write(`Created ${result.created.join(' and ')}${result.gitignoreUpdated ? ', and added .verify/ to .gitignore' : ''}.\n`);
+    await signInAndCheck(interactive);
+    const steps = answers.platform === 'mac'
+        ? ['Mac computers are early access. Ask support@revyl.ai about access.', 'Once your organization has Mac access, run: node verify/example.mts']
+        : answers.appId
+            ? ['Run: node verify/example.mts']
+            : ['Run: node verify/example.mts', 'To test your own app, put its Revyl app id in verify.config.ts in place of the Settings bundle id.'];
+    process.stdout.write([
+        'Next:',
+        ...steps.map((step, index) => `  ${index + 1}. ${step}`),
+        '',
+    ].join('\n'));
+    return 0;
+}
+async function signInAndCheck(interactive) {
     const credentials = await resolveCredentials();
     if (!credentials) {
-        if (interactive) {
-            await signIn();
-        }
-        else {
+        if (!interactive)
             throw new VerifyError('AUTH_MISSING', `${missingCredentialsMessage()} In non-interactive environments, set the REVYL_API_KEY secret.`);
-        }
+        await signIn();
     }
     try {
-        await whoamiCommand();
+        return await whoamiCommand();
     }
     catch (error) {
         if (!interactive || !isVerifyError(error) || error.code !== 'AUTH_REJECTED')
             throw error;
         await signIn({ force: true });
-        await whoamiCommand();
+        return whoamiCommand();
     }
-    const steps = [
-        'Configure the generated verify.config.ts if needed',
-        ...(answers.platform === 'mac' ? ['Mac computers are early access. Ask support@revyl.ai about access.'] : []),
-        ...(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([
-        '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');
+        const platform = ((await readline.question('What do you want to open? [ios/android/web/mac] (ios): ')).trim().toLowerCase() || 'ios');
         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 question = platform === 'web' ? 'Revyl Web app id (Enter if you have none yet): ' : 'Revyl app id (Enter to use the built-in Settings app): ';
+        const id = appId ?? ((await readline.question(question)).trim() || undefined);
+        if (platform === 'web' && !id)
+            throw new VerifyError('INVALID_ARGUMENT', webAppIdMissingMessage(url));
         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 } : {}) });
     }
@@ -141,7 +181,27 @@ async function whoamiCommand() {
     process.stdout.write(`Signed in to Revyl as ${name}${org ? ` in ${org}` : ''} (credentials from ${credentials.source}).\n`);
     return 0;
 }
+async function logoutCommand() {
+    try {
+        await rm(revylCredentialsPath());
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw new VerifyError('AUTH_MISSING', `Could not remove ~/.revyl/credentials.json: ${errorMessage(error)}`);
+        process.stdout.write('No saved Revyl login on this computer.\n');
+        return 0;
+    }
+    process.stdout.write('Signed out: removed ~/.revyl/credentials.json, which the Revyl CLI shares. The API key it held still works until you delete it in Revyl (Settings → API keys).\n');
+    if (process.env.REVYL_API_KEY?.trim())
+        process.stdout.write('REVYL_API_KEY is still set in this environment, so Verify keeps using it.\n');
+    return 0;
+}
 export async function runCli(argv) {
+    const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+    if (major < 22 || (major === 22 && minor < 18)) {
+        process.stderr.write(`Verify needs Node.js 22.18 or later; this is Node.js ${process.version}.\n`);
+        return 1;
+    }
     try {
         return await main(argv);
     }

package/dist/computer-session.d.ts

@@ -27,6 +27,15 @@ export declare class ComputerSession implements Session {
     open(target: HostedTargetConfig): Promise<OpenedSession>;
     report(): Promise<Record<string, unknown>>;
     navigate(): Promise<never>;
+    tap(): Promise<never>;
+    type(): Promise<never>;
+    swipe(): Promise<never>;
+    pressKey(): Promise<never>;
+    back(): Promise<never>;
+    openUrl(): Promise<never>;
+    launchApp(): Promise<never>;
+    locate(): Promise<never>;
+    screenSize(): Promise<never>;
     get expiresAt(): Date | undefined;
     recording(): Promise<ComputerRecording | null>;
     instruction(): Promise<never>;

package/dist/computer-session.js

@@ -123,6 +123,33 @@ export class ComputerSession {
     navigate() {
         return this.unavailable('navigate');
     }
+    tap() {
+        return this.unavailable('tap');
+    }
+    type() {
+        return this.unavailable('type');
+    }
+    swipe() {
+        return this.unavailable('swipe');
+    }
+    pressKey() {
+        return this.unavailable('pressKey');
+    }
+    back() {
+        return this.unavailable('back');
+    }
+    openUrl() {
+        return this.unavailable('openUrl');
+    }
+    launchApp() {
+        return this.unavailable('launchApp');
+    }
+    locate() {
+        return this.unavailable('locate');
+    }
+    screenSize() {
+        return this.unavailable('screenSize');
+    }
     get expiresAt() {
         return this.expiresAtMs === undefined ? undefined : new Date(this.expiresAtMs);
     }

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
-export type VerifyErrorCode = 'INVALID_ARGUMENT' | 'CONFIG_NOT_FOUND' | 'CONFIG_INVALID' | 'AUTH_MISSING' | 'COMPUTER_ID_MISSING' | 'AUTH_REJECTED' | 'EDGE_BLOCKED' | 'API_ERROR' | 'SESSION_START_FAILED' | 'SESSION_ENDED' | 'SESSION_BUSY' | 'COMPUTER_LIMIT' | 'NOT_AVAILABLE_ON_PLATFORM' | 'ACTION_FAILED' | 'ACTION_UNCERTAIN' | 'INSTRUCTION_FAILED' | 'VALIDATION_FAILED' | 'STEP_FAILED' | 'COMMAND_FAILED' | 'NOT_FOUND' | 'ACCESS_DENIED' | 'TIMEOUT';
-export type RefusalReason = 'web_runtime_unavailable' | 'web_runtime_not_configured' | 'computer_limit' | 'runtime_unavailable' | 'computer_runtime_unavailable' | 'computer_at_capacity' | 'computer_not_running' | 'computer_cannot_host_platform' | 'computer_not_found' | 'web_build_required' | 'web_build_not_supported' | 'ios_build_required' | 'ios_build_not_supported' | 'android_build_required' | 'android_build_not_supported' | 'web_session_conflict' | 'ios_session_conflict' | 'android_session_conflict' | 'not_available_on_platform' | 'request_timeout' | 'protocol_error';
+export type VerifyErrorCode = 'INVALID_ARGUMENT' | 'CONFIG_NOT_FOUND' | 'CONFIG_INVALID' | 'AUTH_MISSING' | 'COMPUTER_ID_MISSING' | 'AUTH_REJECTED' | 'EDGE_BLOCKED' | 'API_ERROR' | 'SESSION_START_FAILED' | 'SESSION_ENDED' | 'SESSION_BUSY' | 'COMPUTER_LIMIT' | 'NOT_AVAILABLE_ON_PLATFORM' | 'ACTION_FAILED' | 'ACTION_UNCERTAIN' | 'INSTRUCTION_FAILED' | 'VALIDATION_FAILED' | 'STEP_FAILED' | 'COMMAND_FAILED' | 'NOT_FOUND' | 'ACCESS_DENIED' | 'MODEL_ERROR' | 'MODEL_KEY_MISSING' | 'TIMEOUT';
+export type RefusalReason = 'web_runtime_unavailable' | 'web_runtime_not_configured' | 'computer_limit' | 'runtime_unavailable' | 'computer_runtime_unavailable' | 'computer_at_capacity' | 'computer_platform_at_capacity' | 'computer_not_running' | 'computer_cannot_host_platform' | 'computer_not_found' | 'web_build_required' | 'web_build_not_supported' | 'ios_build_required' | 'ios_build_not_supported' | 'android_build_required' | 'android_build_not_supported' | 'web_session_conflict' | 'ios_session_conflict' | 'android_session_conflict' | 'not_available_on_platform' | 'request_timeout' | 'protocol_error';
 export declare class VerifyError extends Error {
     readonly code: VerifyErrorCode;
     readonly reason?: RefusalReason;

package/dist/index.d.ts

@@ -6,3 +6,8 @@ export type { HostedTargetConfig, MobileAppConfig, MobileTargetConfig, ComputerT
 export type { Platform, ComputerPlatform, MobilePlatform } from './api/types.js';
 export { VerifyError, isVerifyError } from './errors.js';
 export type { RefusalReason, VerifyErrorCode } from './errors.js';
+export { localAgent } from './agent/loop.js';
+export type { Grounding, LocalAgent, LocalAgentOptions, Location, ModelRun, ModelTurn, Point, SwipeDirection, Target } from './agent/loop.js';
+export type { CustomModel, ModelOption } from './agent/providers.js';
+export { anthropic, openaiCompatible } from './agent/model.js';
+export type { AnthropicOptions, JsonSchema, ModelAdapter, ModelReply, ModelRequest, ModelTool, ModelToolCall, ModelUsage, OpenAICompatibleOptions } from './agent/model.js';

package/dist/index.js

@@ -1,3 +1,5 @@
 export { attach, currentComputer, open } from './open.js';
 export { defineConfig } from './config.js';
 export { VerifyError, isVerifyError } from './errors.js';
+export { localAgent } from './agent/loop.js';
+export { anthropic, openaiCompatible } from './agent/model.js';

package/dist/open.d.ts

@@ -1,6 +1,8 @@
 import { type TargetConfig } from './config.js';
 import { type OpenedSession } from './session.js';
 import { ComputerSession } from './computer-session.js';
+import type { LocalAgent } from './agent/loop.js';
+import { type ModelOption } from './agent/providers.js';
 export interface OpenOptions {
     /** The config file to read target names from. Defaults to the nearest verify.config.ts at or above the current folder. */
     config?: string;
@@ -8,6 +10,10 @@ export interface OpenOptions {
     log?: false | ((line: string) => void);
     backendUrl?: string;
     appUrl?: string;
+    /** Runs every instruction and validation on your model, such as 'anthropic/claude-sonnet-5-5', instead of Revyl's agent. Browsers and devices only. */
+    model?: ModelOption;
+    /** Runs every instruction and validation on a custom agent from localAgent(). Pass model or agent, not both. */
+    agent?: LocalAgent;
 }
 export interface AttachOptions extends Pick<OpenOptions, 'log' | 'backendUrl' | 'appUrl'> {
     stopOnClose?: boolean;

package/dist/open.js

@@ -5,6 +5,7 @@ import { DEFAULT_STEP_TIMEOUT_MS, loadConfig, validateTarget } from './config.js
 import { VerifyError } from './errors.js';
 import { DeviceSession } from './session.js';
 import { ComputerSession } from './computer-session.js';
+import { chooseAgent } from './agent/providers.js';
 const signIns = new Map();
 async function credentialsForUse(options) {
     const credentials = await resolveCredentials();
@@ -53,10 +54,14 @@ export async function open(target, options = {}) {
     else {
         resolved = validateTarget(target);
     }
+    const agent = chooseAgent(options, 'open()');
+    if (agent && (resolved.platform === 'mac' || resolved.platform === 'linux')) {
+        throw new VerifyError('NOT_AVAILABLE_ON_PLATFORM', 'Your own model runs steps on browsers and devices, not on computers.');
+    }
     const credentials = await credentialsForUse(options);
     const log = options.log === false ? undefined : (options.log ?? ((line) => void process.stderr.write(`[verify] ${line}\n`)));
     const client = new RevylClient({ token: credentials.token, backendUrl: options.backendUrl });
     if (resolved.platform === 'mac' || resolved.platform === 'linux')
         return ComputerSession.start(client, resolved, { stepTimeout, log, appUrl: options.appUrl });
-    return DeviceSession.start(client, resolved, { stepTimeout, log, appUrl: options.appUrl });
+    return DeviceSession.start(client, resolved, { stepTimeout, log, appUrl: options.appUrl, ...(agent ? { agent } : {}) });
 }