@deeeed/metamask-harness 0.70.1 → 0.72.0

package/adapters/terminal/lib/readiness.mjs

@@ -0,0 +1,274 @@
+// Read-only readiness of a Web Terminal slot for recipe runs: checkout shape,
+// dependencies, the slot dev server, forced testnet, wallet fixture, browser,
+// MetaMask extension copy and the per-slot CDP port. Never launches anything
+// except the optional short-lived browser start probe.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { canonicalPath, fixtureEntry, loadWalletFixture, readBrowserState, terminalRuntimeDir, viemAccountFromEntry } from '../../../library/actions/terminal/platform/runtime.mjs';
+import { ownsProcess, pidAlive, portFree } from './processes.mjs';
+
+function check(id, ok, detail, { required = true, status } = {}) {
+  return { id, status: status ?? (ok ? 'pass' : 'fail'), required, detail };
+}
+
+export function isTerminalCheckout(target) {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(target, 'package.json'), 'utf8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return Boolean(deps.next) && existsSync(path.join(target, 'src/features/perpetuals'));
+  } catch {
+    return false;
+  }
+}
+
+async function httpStatus(url, timeoutMs = 20000) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), redirect: 'manual' });
+    return response.status;
+  } catch (error) {
+    return error?.name === 'TimeoutError' ? 'timeout' : 'unreachable';
+  }
+}
+
+// Diagnostic only. Whether the slot's dev server looks configured for testnet:
+// the farm starts `next dev` (temp/farmslot/next-dev.pid) with
+// NEXT_PUBLIC_HYPERLIQUID_FORCE_TESTNET=true. Process inspection cannot prove
+// what the browser talks to (macOS reports a process's initial environment,
+// and lsof cannot see other users' sockets), so this only warns; the browser
+// is held to testnet by the network and wallet layers (mainnet-guard.mjs, the
+// wallet host). Each listener on the app port must descend from the pid-file
+// process and run from the checkout (its cwd); every process on the way from
+// a listener up to the pid-file process is read exactly (argv and environment
+// entries from sysctl KERN_PROCARGS2) and must carry the testnet variable. An
+// unreadable process makes the result unknown.
+export const DEV_SERVER_PID_FILE = 'temp/farmslot/next-dev.pid';
+const FORCE_VARIABLE = 'NEXT_PUBLIC_HYPERLIQUID_FORCE_TESTNET';
+
+function run(command, args) {
+  try {
+    return execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  } catch (error) {
+    return typeof error?.stdout === 'string' ? error.stdout : '';
+  }
+}
+
+const PROCARGS_HELPER = `
+import ctypes, ctypes.util, json, struct, sys
+libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
+pid = int(sys.argv[1])
+argmax = ctypes.c_int(0)
+size = ctypes.c_size_t(ctypes.sizeof(argmax))
+if libc.sysctl((ctypes.c_int * 2)(1, 8), 2, ctypes.byref(argmax), ctypes.byref(size), None, 0) != 0:
+    print("null"); sys.exit(0)
+buf = ctypes.create_string_buffer(argmax.value)
+size = ctypes.c_size_t(argmax.value)
+if libc.sysctl((ctypes.c_int * 3)(1, 49, pid), 3, buf, ctypes.byref(size), None, 0) != 0:
+    print("null"); sys.exit(0)
+raw = buf.raw[:size.value]
+argc = struct.unpack("i", raw[:4])[0]
+rest = raw[4:]
+rest = rest[rest.index(b"\\0"):].lstrip(b"\\0")
+parts = rest.split(b"\\0")
+env = []
+for part in parts[argc:]:
+    if not part: break
+    env.append(part.decode("utf-8", "replace"))
+print(json.dumps({"argv": [p.decode("utf-8", "replace") for p in parts[:argc]], "env": env}))
+`;
+
+export const systemProbe = Object.freeze({
+  listeners: (port) => run('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t']).split('\n').map(Number).filter((pid) => pid > 0),
+  parents: () => new Map(run('ps', ['-A', '-o', 'pid=,ppid=']).split('\n')
+    .map((line) => line.trim().split(/\s+/u).map(Number))
+    .filter(([pid, ppid]) => pid > 0 && ppid >= 0)),
+  cwd: (pid) => (run('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn']).split('\n').find((line) => line.startsWith('n')) ?? '').slice(1) || null,
+  // { argv: string[], env: string[] } with exact element boundaries, or null.
+  procArgs: (pid) => {
+    const python = usablePython();
+    if (!python) return null;
+    try {
+      return JSON.parse(execFileSync(python, ['-c', PROCARGS_HELPER, String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 }).trim());
+    } catch {
+      return null;
+    }
+  },
+});
+
+// macOS's /usr/bin/python3 is a stub until the Command Line Tools are
+// installed, and running it opens an install dialog that takes keyboard
+// focus. Use it only when xcode-select reports a developer directory; any
+// other python3 on PATH is a real install.
+export function pythonFor({ found, platform = process.platform, developerDir }) {
+  if (!found) return null;
+  if (platform === 'darwin' && found === '/usr/bin/python3' && !developerDir()) return null;
+  return found;
+}
+
+let pythonChoice;
+function usablePython() {
+  if (pythonChoice === undefined) {
+    pythonChoice = pythonFor({ found: run('/usr/bin/which', ['python3']).trim(), developerDir: () => run('/usr/bin/xcode-select', ['-p']).trim() });
+  }
+  return pythonChoice;
+}
+
+export function environmentValue(env, name) {
+  const entry = env.find((item) => item.startsWith(`${name}=`));
+  return entry === undefined ? undefined : entry.slice(name.length + 1);
+}
+
+// `next dev` / `next start`: the argument after the next binary.
+export function nextServerMode(argv) {
+  for (let index = 0; index < argv.length - 1; index += 1) {
+    const element = argv[index];
+    if (element === 'next' || element.endsWith('/next') || element.endsWith('/next/dist/bin/next')) {
+      if (argv[index + 1] === 'dev' || argv[index + 1] === 'start') return argv[index + 1];
+    }
+  }
+  return null;
+}
+
+function chainTo(listener, root, parents) {
+  const chain = [];
+  let current = listener;
+  for (let hops = 0; current && hops < 64; hops += 1) {
+    chain.push(current);
+    if (current === root) return chain;
+    current = parents.get(current);
+  }
+  return null;
+}
+
+export function devServerTestnetDiagnostic(target, { appPort, probe = systemProbe } = {}) {
+  const checkout = canonicalPath(target);
+  const unknown = (detail) => ({ known: false, forced: false, detail });
+  const pidFile = path.join(checkout, DEV_SERVER_PID_FILE);
+  if (!existsSync(pidFile)) return unknown(`no ${DEV_SERVER_PID_FILE}`);
+  const root = Number(readFileSync(pidFile, 'utf8').trim());
+  if (!pidAlive(root)) return unknown(`next dev pid ${root} is not running`);
+  if (!appPort) return unknown('no app port to check');
+  const listeners = probe.listeners(appPort);
+  if (listeners.length === 0) return unknown(`nothing (visible to this user) listens on app port ${appPort}`);
+  const parents = probe.parents();
+  let mode = null;
+  for (const listener of listeners) {
+    const chain = chainTo(listener, root, parents);
+    if (!chain) return { known: true, forced: false, detail: `app port ${appPort} is served by pid ${listener}, outside next dev pid ${root}` };
+    const cwd = probe.cwd(listener);
+    if (!cwd || canonicalPath(cwd) !== checkout) {
+      return { known: true, forced: false, detail: `pid ${listener} on app port ${appPort} runs from ${cwd ?? 'an unknown directory'}, not ${checkout}` };
+    }
+    for (const pid of chain) {
+      const args = probe.procArgs(pid);
+      if (!args) return unknown(`cannot read the arguments and environment of pid ${pid}`);
+      // A process that rewrote its title (next-server) overwrote the memory
+      // its arguments and environment are read from.
+      if (args.env.length === 0) return unknown(`pid ${pid} (${args.argv[0] ?? '?'}) rewrote its process title; its environment is not readable`);
+      const processMode = nextServerMode(args.argv);
+      if (processMode === 'start') return { known: true, forced: false, detail: `pid ${pid} runs next start; its environment cannot prove what the build inlined` };
+      if (processMode === 'dev') mode = 'dev';
+      const value = environmentValue(args.env, FORCE_VARIABLE);
+      if (value !== 'true') {
+        return { known: true, forced: false, detail: `pid ${pid} (between app port ${appPort} and next dev pid ${root}) has ${FORCE_VARIABLE}=${value ?? '<unset>'}` };
+      }
+    }
+  }
+  if (mode !== 'dev') return { known: true, forced: false, detail: `no process serving app port ${appPort} runs next dev` };
+  return { known: true, forced: true, detail: `every process from app port ${appPort}'s listeners (cwd ${checkout}) up to next dev pid ${root} has ${FORCE_VARIABLE}=true` };
+}
+
+export const MAINNET_CONFIRMATION = 'REAL_FUNDS';
+
+// The launch only checks the requested network: mainnet needs the real-funds
+// confirmation. Testnet is enforced inside the browser (mainnet-guard.mjs).
+export function assertLaunchNetwork(_target, { network, mainnetConfirmation } = {}) {
+  const requested = network == null || network === '' ? 'testnet' : String(network);
+  if (requested !== 'testnet' && requested !== 'mainnet') {
+    throw new Error(`network must be testnet or mainnet, got ${JSON.stringify(network)}.`);
+  }
+  if (requested === 'mainnet' && mainnetConfirmation !== MAINNET_CONFIRMATION) {
+    throw new Error(`network=mainnet needs mainnet_confirmation=${MAINNET_CONFIRMATION}; refusing to launch the terminal browser.`);
+  }
+  return requested;
+}
+
+export async function terminalReadiness({
+  target,
+  appPort,
+  cdpPort,
+  signer = 'extension',
+  account = 'dev1',
+  env = process.env,
+  probeBrowser = undefined,
+}) {
+  const checks = [];
+  const shape = isTerminalCheckout(target);
+  checks.push(check('checkout', shape, shape ? 'Next.js checkout with src/features/perpetuals' : `${target} is not a Web Terminal checkout`));
+  const deps = ['next', '@nktkas/hyperliquid', '@metamask/perps-controller'].filter((name) => !existsSync(path.join(target, 'node_modules', name, 'package.json')));
+  checks.push(check('dependencies', deps.length === 0, deps.length === 0 ? 'next, @nktkas/hyperliquid and @metamask/perps-controller installed' : `missing: ${deps.join(', ')} (run npm ci on Node 22)`));
+
+  if (appPort) {
+    const status = await httpStatus(`http://127.0.0.1:${appPort}/order/BTC`);
+    checks.push(check('app-dev-server', status === 200, `GET http://localhost:${appPort}/order/BTC -> ${status}`));
+  } else {
+    checks.push(check('app-dev-server', false, 'no dev-server port; pass --watcher-port <port> or set TERMINAL_APP_PORT'));
+  }
+  // Advisory: the browser enforces testnet itself (mainnet-guard.mjs).
+  const testnet = devServerTestnetDiagnostic(target, { appPort });
+  checks.push(check('testnet-forced', testnet.known && testnet.forced, testnet.detail, {
+    required: false,
+    status: testnet.known && testnet.forced ? 'pass' : 'warn',
+  }));
+
+  try {
+    const { file, fixture } = await loadWalletFixture(target, env);
+    const address = viemAccountFromEntry(fixtureEntry(fixture, account)).address;
+    checks.push(check('wallet-fixture', true, `${path.basename(file)}: account ${account} -> ${address}`));
+  } catch (error) {
+    checks.push(check('wallet-fixture', false, error.message.split('\n')[0]));
+  }
+
+  if (probeBrowser) {
+    try {
+      const browser = await probeBrowser(env);
+      checks.push(check('browser', true, `${browser.version ?? browser.bin} (${browser.source})`));
+    } catch (error) {
+      checks.push(check('browser', false, error.message.split('\n')[0]));
+    }
+  }
+
+  const extensionDir = path.resolve(env.TERMINAL_EXTENSION_DIR || path.join(target, 'temp/metamask-extension/chrome'));
+  const manifestPath = path.join(extensionDir, 'manifest.json');
+  const extensionRequired = signer === 'extension';
+  if (existsSync(manifestPath)) {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    checks.push(check('metamask-extension', true, `MetaMask ${manifest.version} at ${extensionDir}`, { required: extensionRequired }));
+  } else {
+    checks.push(check('metamask-extension', false, `no extension dist at ${extensionDir}`, { required: extensionRequired }));
+  }
+  const checkout = env.TERMINAL_EXTENSION_CHECKOUT;
+  const checkoutOk = Boolean(checkout) && existsSync(path.join(checkout, 'node_modules/@metamask/browser-passworder'));
+  checks.push(check('extension-fixture-tooling', checkoutOk, checkoutOk
+    ? `extension checkout ${checkout} has fixture-state dependencies`
+    : 'TERMINAL_EXTENSION_CHECKOUT unset or not installed (needed to import the wallet into the extension)', { required: extensionRequired }));
+
+  const state = await readBrowserState(target);
+  const runtime = terminalRuntimeDir(target);
+  const live = Boolean(state && ownsProcess('browser', state.browserPid, runtime) && ownsProcess('wallet-host', state.hostPid, runtime));
+  if (cdpPort) {
+    const free = await portFree(cdpPort);
+    const owned = live && state.cdpPort === cdpPort;
+    checks.push(check('cdp-port', free || owned, free ? `CDP port ${cdpPort} is free` : owned ? `CDP port ${cdpPort} held by this slot's browser` : `CDP port ${cdpPort} is held by another process`));
+  } else {
+    checks.push(check('cdp-port', false, 'no CDP port; pass --cdp-port <port>'));
+  }
+  checks.push(check('browser-live', live, live
+    ? `browser pid ${state.browserPid} (${state.signer}, ${state.account?.name}) and wallet host pid ${state.hostPid}`
+    : 'no slot browser running (metamask.app.launch starts it)', { required: false }));
+
+  const failed = checks.filter((item) => item.required && item.status === 'fail').map((item) => item.id);
+  return { status: failed.length === 0 ? 'pass' : 'fail', checks, failed, browser: live ? state : null };
+}

package/adapters/terminal/lib/strict-wallet.mjs

@@ -0,0 +1,138 @@
+// EIP-1193 test wallet that enforces MetaMask's typed-data rule: reject
+// eth_signTypedData_v4 whose domain chainId differs from the active chain.
+// Signs with a viem account held by the wallet host; never exposes key
+// material. Ported from the TAT-4032 migration e2e strict wallet.
+
+export const DEFAULT_KNOWN_CHAINS = Object.freeze([1, 10, 137, 8453, 42161, 421614, 59144, 59141, 11155111]);
+
+const READ_RPC = {
+  1: 'https://ethereum-rpc.publicnode.com',
+  42161: 'https://arbitrum-one-rpc.publicnode.com',
+  421614: 'https://arbitrum-sepolia-rpc.publicnode.com',
+  59144: 'https://linea-rpc.publicnode.com',
+};
+
+// Only these reads go to the public RPC. Anything else the wallet does not
+// answer itself (eth_sendRawTransaction, account or filter methods, unknown
+// wallet_* calls) is refused before any network request.
+export const READ_ONLY_RPC_METHODS = Object.freeze([
+  'eth_blockNumber',
+  'eth_call',
+  'eth_estimateGas',
+  'eth_feeHistory',
+  'eth_gasPrice',
+  'eth_getBalance',
+  'eth_getBlockByHash',
+  'eth_getBlockByNumber',
+  'eth_getCode',
+  'eth_getLogs',
+  'eth_getStorageAt',
+  'eth_getTransactionByHash',
+  'eth_getTransactionCount',
+  'eth_getTransactionReceipt',
+  'eth_maxPriorityFeePerGas',
+  'web3_clientVersion',
+]);
+const READ_ONLY = new Set(READ_ONLY_RPC_METHODS);
+
+function rpcError(message, code) {
+  return Object.assign(new Error(message), { code });
+}
+
+function toBigIntDeep(types, primaryType, message) {
+  const out = {};
+  for (const field of types[primaryType] ?? []) {
+    const value = message[field.name];
+    if (value === undefined) continue;
+    if (/^u?int\d*$/u.test(field.type)) out[field.name] = BigInt(value);
+    else if (types[field.type]) out[field.name] = toBigIntDeep(types, field.type, value);
+    else out[field.name] = value;
+  }
+  return out;
+}
+
+export function createStrictWallet({
+  account,
+  chainId = 42161,
+  knownChains = DEFAULT_KNOWN_CHAINS,
+  refuseSwitch = false,
+  fetchImpl = globalThis.fetch,
+}) {
+  let activeChain = chainId;
+  const known = new Set(knownChains);
+  let rpcId = 1;
+
+  async function request({ method, params = [] }) {
+    switch (method) {
+      case 'eth_chainId':
+        return `0x${activeChain.toString(16)}`;
+      case 'net_version':
+        return String(activeChain);
+      case 'eth_accounts':
+      case 'eth_requestAccounts':
+        return [account.address];
+      case 'wallet_requestPermissions':
+      case 'wallet_getPermissions':
+        return [{ parentCapability: 'eth_accounts', caveats: [{ type: 'restrictReturnedAccounts', value: [account.address.toLowerCase()] }] }];
+      case 'wallet_revokePermissions':
+        return null;
+      case 'metamask_getProviderState':
+        return { accounts: [account.address.toLowerCase()], chainId: `0x${activeChain.toString(16)}`, isUnlocked: true, networkVersion: String(activeChain) };
+      case 'wallet_switchEthereumChain': {
+        const id = Number.parseInt(params[0].chainId, 16);
+        if (refuseSwitch) throw rpcError('User rejected the request.', 4001);
+        if (!known.has(id)) throw rpcError(`Unrecognized chain ID ${params[0].chainId}`, 4902);
+        activeChain = id;
+        return null;
+      }
+      case 'wallet_addEthereumChain':
+        known.add(Number.parseInt(params[0].chainId, 16));
+        return null;
+      case 'eth_signTypedData_v4': {
+        const [from, raw] = params;
+        const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        const domainChain = Number(BigInt(data.domain.chainId));
+        if (String(from).toLowerCase() !== account.address.toLowerCase()) throw rpcError('Unknown account', 4100);
+        if (domainChain !== activeChain) {
+          throw rpcError(`Provided chainId "${domainChain}" must match the active chainId "${activeChain}"`, -32602);
+        }
+        const types = { ...data.types };
+        delete types.EIP712Domain;
+        return account.signTypedData({
+          domain: { ...data.domain, chainId: domainChain },
+          types,
+          primaryType: data.primaryType,
+          message: toBigIntDeep(types, data.primaryType, data.message),
+        });
+      }
+      case 'personal_sign': {
+        const [message, from] = params;
+        if (String(from).toLowerCase() !== account.address.toLowerCase()) throw rpcError('Unknown account', 4100);
+        return account.signMessage({ message: { raw: message } });
+      }
+      case 'eth_sendTransaction':
+      case 'eth_sign':
+        throw rpcError(`${method} is not supported by the strict test wallet`, 4200);
+      default: {
+        if (!READ_ONLY.has(method)) throw rpcError(`${method} is not supported by the strict test wallet`, 4200);
+        const url = READ_RPC[activeChain];
+        if (!url) throw rpcError(`No read RPC for chain ${activeChain}`, 4200);
+        const response = await fetchImpl(url, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ jsonrpc: '2.0', id: rpcId++, method, params }),
+        });
+        const body = await response.json();
+        if (body.error) throw rpcError(body.error.message, body.error.code);
+        return body.result;
+      }
+    }
+  }
+
+  return {
+    request,
+    get chainId() {
+      return activeChain;
+    },
+  };
+}

package/adapters/terminal/stop.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// stop.mjs — stop the terminal slot browser, wallet host and console collector, verify the CDP port
+// is free. Idempotent: nothing running is success.
+//
+// Inputs: --target <checkout> [--cdp-port <port>] [--json]
+// Outputs: JSON summary on stdout. Exit 0 stopped/nothing to stop; 1 port still owned.
+// Never touches: the Next.js dev server (Farmslot owns it), browser profiles.
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { stopConsoleCollector, stopTerminalBrowser } from './lib/processes.mjs';
+
+const usage = 'Usage: stop.mjs --target <checkout> [--cdp-port <port>] [--json]';
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help') || argv.includes('-h')) {
+    process.stdout.write(`${usage}\n`);
+    process.exit(0);
+  }
+  const value = (flag) => {
+    const index = argv.indexOf(flag);
+    return index >= 0 ? argv[index + 1] : undefined;
+  };
+  const target = value('--target') ?? process.cwd();
+  const rawPort = value('--cdp-port') ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+  try {
+    const log = (message) => process.stderr.write(`[terminal/stop] ${message}\n`);
+    const result = await stopTerminalBrowser(target, { cdpPort: rawPort ? Number(rawPort) : undefined, log });
+    const collector = await stopConsoleCollector(target, { log });
+    process.stdout.write(`${JSON.stringify({ status: 'pass', ...result, consoleCollector: collector })}\n`);
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ status: 'fail', error: error.message })}\n`);
+    process.exit(1);
+  }
+}

package/adapters/terminal/verify.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// verify.mjs — `mm-harness verify --adapter terminal`: read-only readiness of a
+// Web Terminal slot (checkout, deps, dev server, forced testnet, fixture,
+// browser start probe, MetaMask extension copy, CDP port).
+//
+// Inputs: --target <checkout> [--cdp-port <port>] [--watcher-port <app port>]
+//   [--signer extension|injected] [--account <name>] [--json]
+// Outputs: readiness JSON (or a human summary) on stdout. Exit 0 ready; 1 not ready.
+// Never launches the slot browser or the dev server.
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveBrowser } from './launch.mjs';
+import { terminalReadiness } from './lib/readiness.mjs';
+
+const usage = 'Usage: verify.mjs --target <checkout> [--cdp-port <port>] [--watcher-port <app port>] [--signer extension|injected] [--account <name>] [--json]';
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help') || argv.includes('-h')) {
+    process.stdout.write(`${usage}\n`);
+    process.exit(0);
+  }
+  const value = (flag) => {
+    const index = argv.indexOf(flag);
+    return index >= 0 ? argv[index + 1] : undefined;
+  };
+  const num = (raw) => (raw && /^\d+$/u.test(raw) ? Number(raw) : undefined);
+  const report = await terminalReadiness({
+    target: path.resolve(value('--target') ?? process.cwd()),
+    appPort: num(value('--watcher-port') ?? process.env.TERMINAL_APP_PORT ?? process.env.WATCHER_PORT),
+    cdpPort: num(value('--cdp-port') ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT),
+    signer: value('--signer') ?? process.env.TERMINAL_SIGNER ?? 'extension',
+    account: value('--account') ?? process.env.TERMINAL_ACCOUNT ?? 'dev1',
+    probeBrowser: resolveBrowser,
+  });
+  if (argv.includes('--json')) {
+    process.stdout.write(`${JSON.stringify({ schemaVersion: 1, command: 'verify', adapter: 'terminal', ...report }, null, 2)}\n`);
+  } else {
+    for (const check of report.checks) {
+      const mark = check.status === 'pass' ? '✓' : check.status === 'warn' || !check.required ? '·' : '✗';
+      process.stdout.write(`${mark} ${check.id}: ${check.detail}\n`);
+    }
+    process.stdout.write(report.status === 'pass' ? 'terminal slot ready\n' : `not ready: ${report.failed.join(', ')}\n`);
+  }
+  process.exit(report.status === 'pass' ? 0 : 1);
+}