@agentrhq/webcmd 0.2.4 → 0.3.0

package/dist/src/hosted/runner.js

@@ -0,0 +1,404 @@
+import { writeFileSync } from 'node:fs';
+import yaml from 'js-yaml';
+import { BrowserSessionArgvError, rewriteBrowserArgv } from '../cli-argv-preprocess.js';
+import { ConfigError, EXIT_CODES, toEnvelope } from '../errors.js';
+import { render as renderOutput } from '../output.js';
+import { HostedClient } from './client.js';
+import { parseHostedInvocation } from './args.js';
+import { findHostedCommand, hostedListRows, isLocalOnlyHostedCommand, renderHostedCommandHelp, renderHostedSiteHelp, siteNames, commandNamesForSite, } from './manifest.js';
+import { isHostedConfig, loadWebcmdConfig } from './config.js';
+export async function runHostedCli(argv, opts = {}) {
+    const config = opts.config ?? loadWebcmdConfig();
+    if (!isHostedConfig(config))
+        return { handled: false, exitCode: EXIT_CODES.SUCCESS };
+    const stdout = opts.stdout ?? process.stdout;
+    const stderr = opts.stderr ?? process.stderr;
+    const client = new HostedClient({
+        apiBaseUrl: config.hosted.apiBaseUrl,
+        apiKey: config.hosted.apiKey,
+        fetchImpl: opts.fetchImpl,
+    });
+    try {
+        await dispatchHosted(argv, client, stdout);
+        return { handled: true, exitCode: EXIT_CODES.SUCCESS };
+    }
+    catch (err) {
+        stderr.write(yaml.dump(toEnvelope(err), { sortKeys: false, lineWidth: 120, noRefs: true }));
+        return {
+            handled: true,
+            exitCode: errorExitCode(err),
+        };
+    }
+}
+async function dispatchHosted(argv, client, stdout) {
+    const normalized = stripGlobalOptions(argv);
+    const args = normalized.argv;
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        stdout.write('Usage: webcmd <site> <command> [options]\n       webcmd list\n       webcmd setup\n');
+        return;
+    }
+    if (args[0] === 'daemon') {
+        throw new ConfigError('webcmd daemon is local-only. Hosted mode has no local daemon.', 'Run `webcmd setup` and choose local mode to manage the local daemon.');
+    }
+    if (args[0] === 'browser') {
+        await dispatchHostedBrowser(args, normalized.profile, client, stdout);
+        return;
+    }
+    const manifest = await client.getManifest();
+    if (isCompletionRequest(args)) {
+        stdout.write(hostedCompletions(manifest, args).join('\n') + '\n');
+        return;
+    }
+    if (args[0] === 'list') {
+        renderHostedList(manifest, args.slice(1));
+        return;
+    }
+    const site = args[0];
+    const commandName = args[1];
+    if (!commandName || commandName === '--help' || commandName === '-h') {
+        stdout.write(renderHostedSiteHelp(manifest, site));
+        return;
+    }
+    const command = findHostedCommand(manifest, site, commandName);
+    if (!command) {
+        throw new ConfigError(`Unknown hosted Webcmd command: ${site}/${commandName}`);
+    }
+    if (isLocalOnlyHostedCommand(command)) {
+        throw new ConfigError(`Command ${command.command} is local-only and is not available in hosted mode.`, 'Run `webcmd setup` and choose local mode to use local-only commands.');
+    }
+    const parsed = parseHostedInvocation(command, [...args.slice(2), ...normalized.trailingCommandOptions]);
+    if (parsed.help) {
+        stdout.write(renderHostedCommandHelp(command));
+        return;
+    }
+    const response = await client.execute({
+        command: command.command,
+        args: parsed.args,
+        format: parsed.format,
+        trace: parsed.trace,
+        profile: parsed.profile ?? normalized.profile,
+    });
+    const result = response.result ?? response.rows ?? response.data ?? null;
+    renderOutput(result, {
+        fmt: parsed.format,
+        fmtExplicit: true,
+        columns: response.columns ?? command.columns,
+        title: command.command,
+        source: 'webcmd cloud',
+    });
+}
+async function dispatchHostedBrowser(argv, profile, client, stdout) {
+    const invocation = parseHostedBrowserInvocation(argv, profile);
+    const response = await client.runBrowserAction(invocation.session, {
+        command: invocation.command,
+        action: invocation.action,
+        args: invocation.args,
+        ...(invocation.profile !== undefined ? { profile: invocation.profile } : {}),
+        ...(invocation.windowMode !== undefined ? { windowMode: invocation.windowMode } : {}),
+        trace: 'off',
+    });
+    renderHostedBrowserResponse(stdout, invocation, response);
+}
+function parseHostedBrowserInvocation(argv, profile) {
+    let rewritten;
+    try {
+        rewritten = rewriteBrowserArgv(argv);
+    }
+    catch (error) {
+        if (error instanceof BrowserSessionArgvError) {
+            throw new ConfigError(error.message, 'Use: webcmd browser <session> <command>');
+        }
+        throw error;
+    }
+    if (rewritten[0] !== 'browser') {
+        throw new ConfigError('Hosted browser invocation must start with browser.');
+    }
+    if (rewritten[1] !== '--session' || !rewritten[2]) {
+        throw new ConfigError('<session> is required for hosted browser commands.', 'Use: webcmd browser <session> <command>');
+    }
+    const session = rewritten[2];
+    let index = 3;
+    let windowMode;
+    while (index < rewritten.length) {
+        const token = rewritten[index];
+        if (token === '--window') {
+            windowMode = parseWindowMode(rewritten[index + 1]);
+            index += 2;
+            continue;
+        }
+        if (token?.startsWith('--window=')) {
+            windowMode = parseWindowMode(token.slice('--window='.length));
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    const leaf = rewritten[index];
+    if (!leaf || leaf === '--help' || leaf === '-h') {
+        throw new ConfigError('Hosted browser command is required.', 'Use: webcmd browser <session> open <url>, state, screenshot, tab list, or eval <js>.');
+    }
+    const rest = rewritten.slice(index + 1);
+    const parsed = parseBrowserLeaf(leaf, rest);
+    return {
+        session,
+        command: `browser/${parsed.commandName}`,
+        action: parsed.action,
+        args: parsed.args,
+        ...(parsed.localPath !== undefined ? { localPath: parsed.localPath } : {}),
+        ...(profile !== undefined ? { profile } : {}),
+        ...(windowMode !== undefined ? { windowMode } : {}),
+    };
+}
+function parseWindowMode(value) {
+    if (value === 'foreground' || value === 'background')
+        return value;
+    throw new ConfigError('--window must be one of: foreground, background.');
+}
+function parseBrowserLeaf(leaf, argv) {
+    const parsed = splitOptions(argv);
+    switch (leaf) {
+        case 'bind':
+            throw new ConfigError('Browser bind is not supported in hosted mode.', 'Use browser state or browser tabs to inspect the active hosted page.');
+        case 'unbind':
+        case 'close':
+            return { commandName: leaf, action: 'close-window', args: {} };
+        case 'open':
+            return { commandName: 'open', action: 'navigate', args: { url: requiredPositional(parsed.positionals, 0, 'url') } };
+        case 'back':
+            return { commandName: 'back', action: 'back', args: {} };
+        case 'state':
+            return { commandName: 'state', action: 'snapshot', args: { source: parsed.options.source ?? 'dom' } };
+        case 'frames':
+            return { commandName: 'frames', action: 'frames', args: {} };
+        case 'screenshot': {
+            const localPath = parsed.positionals[0];
+            return {
+                commandName: 'screenshot',
+                action: 'screenshot',
+                args: {
+                    fullPage: parsed.options.fullPage === true,
+                    ...(parsed.options.width !== undefined ? { width: parsed.options.width } : {}),
+                    ...(parsed.options.height !== undefined ? { height: parsed.options.height } : {}),
+                },
+                ...(localPath !== undefined ? { localPath } : {}),
+            };
+        }
+        case 'tab':
+            return parseBrowserTab(parsed.positionals);
+        case 'eval':
+            return {
+                commandName: 'eval',
+                action: 'exec',
+                args: {
+                    js: requiredPositional(parsed.positionals, 0, 'js'),
+                    ...(parsed.options.frame !== undefined ? { frame: parsed.options.frame } : {}),
+                },
+            };
+        case 'scroll':
+            return {
+                commandName: 'scroll',
+                action: 'scroll',
+                args: {
+                    direction: requiredPositional(parsed.positionals, 0, 'direction'),
+                    amount: parsed.options.amount ?? 500,
+                },
+            };
+        case 'keys':
+            return { commandName: 'keys', action: 'press-key', args: { key: requiredPositional(parsed.positionals, 0, 'key') } };
+        case 'wait':
+            return {
+                commandName: 'wait',
+                action: 'wait',
+                args: {
+                    type: requiredPositional(parsed.positionals, 0, 'type'),
+                    ...(parsed.positionals[1] !== undefined ? { value: parsed.positionals[1] } : {}),
+                    ...(parsed.options.timeout !== undefined ? { timeout: parsed.options.timeout } : {}),
+                },
+            };
+        case 'click':
+            return { commandName: 'click', action: 'click', args: { target: requiredPositional(parsed.positionals, 0, 'target') } };
+        case 'type':
+            return {
+                commandName: 'type',
+                action: 'type',
+                args: {
+                    target: requiredPositional(parsed.positionals, 0, 'target'),
+                    text: requiredPositional(parsed.positionals, 1, 'text'),
+                },
+            };
+        case 'fill':
+            return {
+                commandName: 'fill',
+                action: 'fill',
+                args: {
+                    target: requiredPositional(parsed.positionals, 0, 'target'),
+                    text: requiredPositional(parsed.positionals, 1, 'text'),
+                },
+            };
+        case 'upload':
+            return {
+                commandName: 'upload',
+                action: 'set-file-input',
+                args: {
+                    selector: parsed.positionals[0] ?? 'input[type="file"]',
+                    files: parsed.positionals.slice(1),
+                },
+            };
+        case 'console':
+            return { commandName: 'console', action: 'console', args: parsed.options };
+        case 'network':
+            return { commandName: 'network', action: 'network', args: parsed.options };
+        default:
+            throw new ConfigError(`Hosted browser command is not supported yet: ${leaf}`);
+    }
+}
+function parseBrowserTab(positionals) {
+    const op = positionals[0] ?? 'list';
+    if (op === 'list')
+        return { commandName: 'tab/list', action: 'tabs', args: { op: 'list' } };
+    if (op === 'new')
+        return { commandName: 'tab/new', action: 'tabs', args: { op: 'new', ...(positionals[1] ? { url: positionals[1] } : {}) } };
+    if (op === 'select')
+        return { commandName: 'tab/select', action: 'tabs', args: { op: 'select', target: requiredPositional(positionals, 1, 'targetId') } };
+    if (op === 'close')
+        return { commandName: 'tab/close', action: 'tabs', args: { op: 'close', target: requiredPositional(positionals, 1, 'targetId') } };
+    throw new ConfigError(`Hosted browser tab command is not supported yet: ${op}`);
+}
+function splitOptions(argv) {
+    const positionals = [];
+    const options = {};
+    let literal = false;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (literal) {
+            positionals.push(token);
+            continue;
+        }
+        if (token === '--') {
+            literal = true;
+            continue;
+        }
+        if (!token.startsWith('-') || token === '-') {
+            positionals.push(token);
+            continue;
+        }
+        if (token.startsWith('--') && token.includes('=')) {
+            const [rawKey, ...rawValue] = token.slice(2).split('=');
+            options[toCamelCase(rawKey)] = coerceOptionValue(rawValue.join('='));
+            continue;
+        }
+        const key = token.replace(/^-+/, '');
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('-')) {
+            options[toCamelCase(key)] = coerceOptionValue(next);
+            i += 1;
+        }
+        else {
+            options[toCamelCase(key)] = true;
+        }
+    }
+    return { positionals, options };
+}
+function requiredPositional(values, index, label) {
+    const value = values[index];
+    if (value === undefined || value === '') {
+        throw new ConfigError(`Missing required browser argument: ${label}`);
+    }
+    return value;
+}
+function toCamelCase(value) {
+    return value.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function coerceOptionValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^-?\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    return value;
+}
+function renderHostedBrowserResponse(stdout, invocation, response) {
+    const result = response.result;
+    if (invocation.action === 'snapshot' && result && typeof result === 'object') {
+        const record = result;
+        stdout.write(`URL: ${typeof record.url === 'string' ? record.url : ''}\n\n`);
+        stdout.write(`${typeof record.snapshot === 'string' ? record.snapshot : JSON.stringify(record.snapshot, null, 2)}\n`);
+        return;
+    }
+    if (invocation.action === 'screenshot' && result && typeof result === 'object') {
+        const base64 = result.base64;
+        if (typeof base64 === 'string' && invocation.localPath) {
+            writeFileSync(invocation.localPath, Buffer.from(base64, 'base64'));
+            stdout.write(`Screenshot saved to: ${invocation.localPath}\n`);
+            return;
+        }
+        if (typeof base64 === 'string') {
+            stdout.write(`${base64}\n`);
+            return;
+        }
+    }
+    if (typeof result === 'string') {
+        stdout.write(`${result}\n`);
+        return;
+    }
+    stdout.write(`${JSON.stringify(result ?? response, null, 2)}\n`);
+}
+function renderHostedList(manifest, argv) {
+    const fmt = readFormat(argv);
+    const structured = fmt === 'json' || fmt === 'yaml' || fmt === 'yml';
+    renderOutput(hostedListRows(manifest, structured), {
+        fmt,
+        fmtExplicit: true,
+        columns: ['command', 'site', 'name', 'aliases', 'description', 'access', 'strategy', 'browser', 'args',
+            ...(structured ? ['columns', 'domain'] : [])],
+        title: 'webcmd/list',
+        source: 'webcmd cloud',
+    });
+}
+function readFormat(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '-f' || argv[i] === '--format')
+            return argv[i + 1] ?? 'table';
+        if (argv[i]?.startsWith('--format='))
+            return argv[i].slice('--format='.length);
+    }
+    return 'table';
+}
+function stripGlobalOptions(argv) {
+    const out = [];
+    const trailingCommandOptions = [];
+    let profile;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--profile') {
+            profile = argv[++i];
+            continue;
+        }
+        if (token.startsWith('--profile=')) {
+            profile = token.slice('--profile='.length);
+            continue;
+        }
+        out.push(token);
+    }
+    return { argv: out, trailingCommandOptions, ...(profile ? { profile } : {}) };
+}
+function isCompletionRequest(argv) {
+    return argv.includes('--get-completions');
+}
+function hostedCompletions(manifest, argv) {
+    const index = argv.indexOf('--get-completions');
+    const words = index === -1 ? argv : argv.slice(index + 1).filter((word) => word !== '--cursor');
+    const meaningful = words.filter((word) => !/^\d+$/.test(word));
+    if (meaningful.length <= 1)
+        return ['list', 'setup', ...siteNames(manifest)];
+    return commandNamesForSite(manifest, meaningful[0]);
+}
+function errorExitCode(err) {
+    if (err instanceof ConfigError)
+        return err.exitCode;
+    if (err && typeof err === 'object' && 'exitCode' in err && typeof err.exitCode === 'number') {
+        return err.exitCode;
+    }
+    return EXIT_CODES.GENERIC_ERROR;
+}

package/dist/src/hosted/runner.test.d.ts

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

package/dist/src/hosted/runner.test.js

@@ -0,0 +1,189 @@
+import { Writable } from 'node:stream';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { makeHostedConfig } from './config.js';
+import { runHostedCli } from './runner.js';
+const manifest = {
+    userId: 'user_demo',
+    generatedAt: '2026-07-08T00:00:00.000Z',
+    commands: [
+        {
+            site: 'github',
+            name: 'whoami',
+            command: 'github/whoami',
+            description: 'Show GitHub identity',
+            access: 'read',
+            strategy: 'COOKIE',
+            browser: true,
+            args: [],
+            columns: ['username'],
+            domain: 'github.com',
+        },
+        {
+            site: 'docker',
+            name: 'ps',
+            command: 'docker/ps',
+            description: 'Local Docker containers',
+            access: 'read',
+            strategy: 'LOCAL',
+            browser: false,
+            args: [],
+            columns: ['id'],
+        },
+    ],
+};
+function sink() {
+    let data = '';
+    return {
+        stream: new Writable({
+            write(chunk, _encoding, callback) {
+                data += String(chunk);
+                callback();
+            },
+        }),
+        text: () => data,
+    };
+}
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('runHostedCli', () => {
+    it('renders hosted list without LOCAL commands', async () => {
+        const logs = [];
+        vi.spyOn(console, 'log').mockImplementation((message = '') => {
+            logs.push(String(message));
+        });
+        const result = await runHostedCli(['list', '-f', 'json'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            fetchImpl: async () => new Response(JSON.stringify({ ok: true, manifest }), { status: 200 }),
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(logs.join('\n')).toContain('github/whoami');
+        expect(logs.join('\n')).not.toContain('docker/ps');
+    });
+    it('dispatches hosted commands to /v1/execute', async () => {
+        const requests = [];
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const result = await runHostedCli(['github', 'whoami', '-f', 'json'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            fetchImpl: async (url, init) => {
+                requests.push({
+                    url: String(url),
+                    body: init?.body ? JSON.parse(String(init.body)) : undefined,
+                });
+                if (String(url).endsWith('/v1/manifest')) {
+                    return new Response(JSON.stringify({ ok: true, manifest }), { status: 200 });
+                }
+                return new Response(JSON.stringify({
+                    ok: true,
+                    result: [{ username: 'octocat' }],
+                    columns: ['username'],
+                }), { status: 200 });
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(requests.at(-1)).toEqual({
+            url: 'https://api.example.com/v1/execute',
+            body: {
+                command: 'github/whoami',
+                args: {},
+                format: 'json',
+                trace: 'off',
+            },
+        });
+    });
+    it('rejects daemon commands in hosted mode', async () => {
+        const stderr = sink();
+        const result = await runHostedCli(['daemon', 'status'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stderr: stderr.stream,
+        });
+        expect(result.exitCode).toBe(78);
+        expect(stderr.text()).toMatch(/hosted mode has no local daemon/i);
+    });
+    it('routes hosted browser positional commands through the cloud lifecycle', async () => {
+        const requests = [];
+        const stdout = sink();
+        const result = await runHostedCli(['--profile', 'default', 'browser', 'work', 'open', 'https://example.com', '--window', 'background'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: stdout.stream,
+            fetchImpl: async (url, init) => {
+                requests.push({
+                    url: String(url),
+                    body: init?.body ? JSON.parse(String(init.body)) : undefined,
+                });
+                if (String(url).endsWith('/runs')) {
+                    return new Response(JSON.stringify({
+                        ok: true,
+                        run: {
+                            executionId: 'exec_browser',
+                            session: 'work',
+                            profile: { id: 'profile_default', displayName: 'default' },
+                        },
+                    }), { status: 201 });
+                }
+                if (String(url).endsWith('/actions')) {
+                    return new Response(JSON.stringify({
+                        ok: true,
+                        result: { url: 'https://example.com' },
+                        columns: ['url'],
+                        trace: null,
+                    }), { status: 200 });
+                }
+                return new Response(JSON.stringify({
+                    ok: true,
+                    execution: { id: 'exec_browser', status: 'succeeded' },
+                }), { status: 200 });
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(stdout.text()).toContain('https://example.com');
+        expect(requests).toEqual([
+            {
+                url: 'https://api.example.com/v1/browser/work/runs',
+                body: {
+                    command: 'browser/open',
+                    args: { url: 'https://example.com' },
+                    profile: 'default',
+                    windowMode: 'background',
+                    trace: 'off',
+                },
+            },
+            {
+                url: 'https://api.example.com/v1/browser/work/runs/exec_browser/actions',
+                body: {
+                    action: 'navigate',
+                    args: { url: 'https://example.com' },
+                    profile: 'default',
+                },
+            },
+            {
+                url: 'https://api.example.com/v1/browser/work/runs/exec_browser/finish',
+                body: {
+                    status: 'succeeded',
+                    profile: 'default',
+                },
+            },
+        ]);
+    });
+    it('rejects the retired hosted browser --session flag', async () => {
+        const stderr = sink();
+        const result = await runHostedCli(['browser', '--session', 'work', 'state'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stderr: stderr.stream,
+        });
+        expect(result.exitCode).toBe(78);
+        expect(stderr.text()).toMatch(/session.*no longer a public option/i);
+    });
+    it('rejects browser bind before making a hosted request', async () => {
+        const stderr = sink();
+        const fetchImpl = vi.fn();
+        const result = await runHostedCli(['browser', 'work', 'bind'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stderr: stderr.stream,
+            fetchImpl,
+        });
+        expect(result).toEqual({ handled: true, exitCode: 78 });
+        expect(stderr.text()).toMatch(/browser bind is not supported in hosted mode/i);
+        expect(fetchImpl).not.toHaveBeenCalled();
+    });
+});

package/dist/src/hosted/setup.d.ts

@@ -0,0 +1,9 @@
+import { type ConfigIo } from './config.js';
+export interface SetupIo extends ConfigIo {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    fetchImpl?: typeof fetch;
+    question?: (prompt: string) => Promise<string>;
+    write?: (message: string) => void;
+}
+export declare function runHostedSetup(io?: SetupIo): Promise<number>;

package/dist/src/hosted/setup.js

@@ -0,0 +1,49 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as defaultInput, stdout as defaultOutput } from 'node:process';
+import { HostedClient } from './client.js';
+import { defaultHostedApiBaseUrl, makeHostedConfig, makeLocalConfig, saveWebcmdConfig, } from './config.js';
+export async function runHostedSetup(io = {}) {
+    const write = io.write ?? ((message) => (io.output ?? defaultOutput).write(message));
+    const ownedReadline = io.question ? undefined : createInterface({
+        input: io.input ?? defaultInput,
+        output: io.output ?? defaultOutput,
+    });
+    const ask = io.question ?? ((prompt) => ownedReadline.question(prompt));
+    try {
+        write('Webcmd setup\n');
+        const mode = await ask('Use hosted Webcmd Cloud or local Webcmd? [hosted/local] ');
+        if (mode.trim().toLowerCase().startsWith('l')) {
+            saveWebcmdConfig(makeLocalConfig(io.now?.() ?? new Date()), io);
+            write('Webcmd is now configured for local mode.\n');
+            return 0;
+        }
+        const apiBaseUrl = defaultHostedApiBaseUrl(io.env ?? process.env);
+        const apiKey = (await ask('Webcmd API key: ')).trim();
+        if (!apiKey) {
+            write('A Webcmd API key is required for hosted mode.\n');
+            return 2;
+        }
+        const config = makeHostedConfig({
+            apiBaseUrl,
+            apiKey,
+            now: io.now?.() ?? new Date(),
+        });
+        try {
+            await new HostedClient({
+                apiBaseUrl: config.hosted.apiBaseUrl,
+                apiKey: config.hosted.apiKey,
+                fetchImpl: io.fetchImpl,
+            }).getMe();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            write(`Warning: could not verify API key yet: ${message}\n`);
+        }
+        saveWebcmdConfig(config, io);
+        write('Webcmd is now configured for hosted mode.\n');
+        return 0;
+    }
+    finally {
+        ownedReadline?.close();
+    }
+}

package/dist/src/hosted/setup.test.d.ts

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