jevway 0.1.2 → 0.3.0

package/dist/task/start-task.js

@@ -1,4 +1,5 @@
 import { connectChrome } from '../browser/chrome.js';
+import { dropStagedDownloads, useDownloads } from '../browser/downloads.js';
 import { Tab } from '../browser/tab.js';
 import { createAsk, profileOptions, resolveModel } from '../jev/model.js';
 import { replayMode } from '../jev/replay.js';
@@ -6,6 +7,8 @@ import { JourneySession } from '../journeys/journey-session.js';
 import { missingKeyMessage } from '../setup/env-file.js';
 import { hostsFromEnv, narrowHosts, outsideHosts } from './hosts.js';
 import { BrowserTask } from './run-task.js';
+import { retryingAsk } from '../jev/retry.js';
+import { desktopNotifier } from '../notify/desktop.js';
 /**
  * Connects a browser once and starts tasks on tabs inside it. Tasks and journeys need the chosen model's key:
  * `TYPESAFE_API_KEY` for Jev (default), `OPENROUTER_API_KEY` for Clef-omni. Without it the runner is still made, so an
@@ -29,7 +32,12 @@ export const createRunner = (source, choice = {}) => {
         return (client ??= createAsk(profile));
     };
     let chrome;
-    const browser = () => (chrome ??= connectChrome(source));
+    // Downloads are set up once per connection: staged in jevway's own browser, Chrome's own behaviour in the person's.
+    const browser = () => (chrome ??= connectChrome(source).then(async (handle) => {
+        await useDownloads(handle.cdp, source).catch(() => undefined);
+        return handle;
+    }));
+    let shown;
     return {
         /** Throws the missing-key message, so the CLI can report it as a usage error before any browser starts. */
         requireKey() {
@@ -39,30 +47,38 @@ export const createRunner = (source, choice = {}) => {
             const decider = ask();
             // The server's lists, narrowed by the call; a start URL outside them is never opened.
             const hosts = narrowHosts(hostsFromEnv(), { allowed: allowedHosts, blocked: blockedHosts });
-            const outside = url ? outsideHosts(url, hosts) : undefined;
-            if (outside)
-                throw new Error(`Not opened: ${outside}`);
+            if (url)
+                refuseOutside(url, hosts);
             const { cdp } = await browser();
             if (!url && !tab)
                 throw new Error('Pass `url` to open a new tab or `tab` to reuse an open one.');
             const page = url ? await Tab.open(cdp, url) : await Tab.find(cdp, tab);
+            const visible = await (shown ??= browserShown(source, cdp));
             const task = new BrowserTask(page, decider, {
                 ...profileOptions(profile),
                 ...definedOnly(options),
                 hosts,
                 screenshots: options.screenshots ?? screenshots,
+                waitForPersonSeconds: personWaitSeconds(options.waitForPersonSeconds),
+                person: { visible, notify: desktopNotifier() },
             });
             task.update({ confirmIrreversible, confirmTarget });
             return task;
         },
-        /** Reads a page with no model call and no input: an open tab by URL part, or a URL in a background tab closed again. */
-        async look({ url, tab }) {
-            const { cdp } = await browser();
+        /**
+         * Reads a page with no model call and no input: an open tab by URL part, or a URL in a background tab closed again.
+         * With `pdf`, the page printed as a PDF comes with it.
+         */
+        async look({ url, tab, pdf = false }) {
             if (!url && !tab)
                 throw new Error('Pass `url` to open a page or `tab` to read an open one.');
+            if (url)
+                refuseOutside(url, hostsFromEnv());
+            const { cdp } = await browser();
             const page = url ? await Tab.open(cdp, url) : await Tab.find(cdp, tab);
             try {
-                return await page.observe();
+                const state = await page.observe();
+                return pdf ? { ...state, pdf: await page.pdf() } : state;
             }
             finally {
                 if (url)
@@ -72,20 +88,63 @@ export const createRunner = (source, choice = {}) => {
         /** Mobile journey mapping; in the user's own Chrome it opens a separate window so screenshots keep rendering. */
         async startJourney(options) {
             const decider = ask();
+            // The server's host lists hold for journeys too: a start page outside them is never opened, and a step that
+            // lands outside them is refused before Jev is asked about the page.
+            const hosts = hostsFromEnv();
+            refuseOutside(options.startUrl, hosts);
             const { cdp } = await browser();
-            return JourneySession.start(cdp, decider, {
+            // A journey makes one model call per screen and has no loop-level retry, so a busy API gets two more tries.
+            return JourneySession.start(cdp, retryingAsk(decider, { delaysMs: JOURNEY_RETRY_MS }), {
                 newWindow: source === 'auto',
                 ...profileOptions(profile),
                 ...options,
+                hosts,
                 screenshots: options.screenshots ?? screenshots,
             });
         },
         async close() {
-            if (chrome)
-                await (await chrome).close();
+            if (chrome) {
+                const handle = await chrome;
+                await handle.close();
+                dropStagedDownloads(handle.cdp);
+            }
             chrome = undefined;
+            shown = undefined;
         },
     };
 };
+// Waits before each retry of a journey's model call after a busy or flaky API answer.
+const JOURNEY_RETRY_MS = [1000, 3000];
+// Waits for a person at a wall this long, in seconds, when the call names no wait and JEVWAY_PERSON_WAIT_SECONDS is unset.
+const PERSON_WAIT_SECONDS = 120;
+/**
+ * The call's wait for a person, else `JEVWAY_PERSON_WAIT_SECONDS` (whole seconds), else 120. A headless browser waits 0
+ * whatever this says (the task knows whether a person can see it).
+ *
+ * @example
+ * personWaitSeconds(undefined, { JEVWAY_PERSON_WAIT_SECONDS: '60' }) // 60
+ */
+export const personWaitSeconds = (call, env = process.env) => {
+    const raw = env.JEVWAY_PERSON_WAIT_SECONDS?.trim();
+    return call ?? (raw && /^\d+$/.test(raw) ? Number(raw) : PERSON_WAIT_SECONDS);
+};
+/** Whether a person can see this browser: never `launch-headless`, nor a headless Chrome behind a port or `auto`. */
+const browserShown = async (source, cdp) => {
+    if (source === 'launch-headless')
+        return false;
+    try {
+        const { userAgent } = await cdp.send('Browser.getVersion');
+        return !/HeadlessChrome/.test(String(userAgent));
+    }
+    catch {
+        return true;
+    }
+};
+/** Throws before a page outside the host rules is opened. */
+const refuseOutside = (url, hosts) => {
+    const outside = outsideHosts(url, hosts);
+    if (outside)
+        throw new Error(`Not opened: ${outside}`);
+};
 // Optional MCP/CLI arguments arrive as explicit undefined; they must not erase profile settings.
 const definedOnly = (options) => Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));

package/dist/task/totp.js

@@ -0,0 +1,124 @@
+import { createHmac } from 'node:crypto';
+const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+// RFC 4226 asks for at least 128 bits and recommends 160; real services hand out 80. Fewer is a mistake, such as a code passed as the secret.
+const MIN_SECRET_BITS = 80;
+const ALGORITHMS = { SHA1: 'sha1', SHA256: 'sha256', SHA512: 'sha512' };
+// A code typed with less than this left in its period could expire before the submit that follows it reaches the server.
+const FRESH_FOR_MS = 8_000;
+const decodeBase32 = (text) => {
+    const base32 = text.replace(/[\s-]/g, '').replace(/=+$/, '').toUpperCase();
+    if (!base32)
+        throw new Error('is empty: pass the authenticator secret (base32) or its otpauth://totp/ URI');
+    if (![...base32].every((char) => BASE32_ALPHABET.includes(char))) {
+        throw new Error('is not base32 (letters A–Z and digits 2–7) or an otpauth://totp/ URI');
+    }
+    const bits = base32.length * 5;
+    if (bits < MIN_SECRET_BITS) {
+        throw new Error(`is too short for an authenticator secret (${base32.length} characters, at least 16): pass the secret behind the QR code, not a code`);
+    }
+    const bytes = [];
+    let buffer = 0;
+    let held = 0;
+    for (const char of base32) {
+        buffer = (buffer << 5) | BASE32_ALPHABET.indexOf(char);
+        held += 5;
+        if (held >= 8) {
+            held -= 8;
+            bytes.push((buffer >>> held) & 0xff);
+        }
+    }
+    return { key: Buffer.from(bytes), base32 };
+};
+const wholeNumberIn = (raw, name, fallback, min, max) => {
+    if (raw === null)
+        return fallback;
+    const value = Number(raw);
+    if (!/^\d+$/.test(raw) || value < min || value > max)
+        throw new Error(`has ${name} "${raw}" in its URI; it must be ${min} to ${max}`);
+    return value;
+};
+const parseOtpauth = (text) => {
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        throw new Error('is not a valid otpauth://totp/ URI');
+    }
+    if (url.protocol !== 'otpauth:' || url.host.toLowerCase() !== 'totp')
+        throw new Error('must be base32 or an otpauth://totp/ URI (counter-based hotp is not supported)');
+    const secret = url.searchParams.get('secret');
+    if (!secret)
+        throw new Error('has no `secret` in its otpauth URI');
+    const algorithmName = url.searchParams.get('algorithm');
+    const algorithm = ALGORITHMS[(algorithmName ?? 'SHA1').toUpperCase()];
+    if (!algorithm)
+        throw new Error(`has algorithm "${algorithmName}" in its URI; it must be SHA1, SHA256 or SHA512`);
+    return {
+        ...decodeBase32(secret),
+        digits: wholeNumberIn(url.searchParams.get('digits'), 'digits', 6, 6, 8),
+        periodSeconds: wholeNumberIn(url.searchParams.get('period'), 'period', 30, 1, 300),
+        algorithm,
+    };
+};
+/**
+ * Reads an authenticator secret: base32 as apps print it (any case, spaced or hyphenated, padded or not; SHA1, 6 digits,
+ * 30 s), or an `otpauth://totp/` URI whose `digits`, `period` and `algorithm` are honoured. Throws a message that never
+ * repeats the secret.
+ *
+ * @example
+ * parseTotpSecret('JBSW Y3DP EHPK 3PXP') // { digits: 6, periodSeconds: 30, algorithm: 'sha1', … }
+ */
+export const parseTotpSecret = (text) => {
+    const given = text.trim();
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(given))
+        return { given, ...parseOtpauth(given) };
+    return { given, ...decodeBase32(given), digits: 6, periodSeconds: 30, algorithm: 'sha1' };
+};
+/**
+ * The caller's `totp` secrets by key, checked before any browser work; a key may not also be one of `values`. An input
+ * error names the key (`totp.<key>: …`) and never the secret.
+ *
+ * @example
+ * checkTotpSecrets({ github_otp: 'JBSWY3DPEHPK3PXP' }).get('github_otp')?.digits // 6
+ */
+export const checkTotpSecrets = (totp, values = {}) => new Map(Object.entries(totp ?? {}).map(([key, text]) => {
+    try {
+        if (key in values)
+            throw new Error('is also given in values; pass a key in one of them');
+        return [key, parseTotpSecret(text)];
+    }
+    catch (error) {
+        throw new Error(`totp.${key}: ${error.message}`);
+    }
+}));
+/** Each authenticator secret as the scrubber masks it, under its key: as given and as base32. */
+export const totpMasks = (authenticators) => [...authenticators].flatMap(([key, secret]) => [
+    [key, secret.given],
+    [key, secret.base32],
+]);
+/** The RFC 6238 code for the period that holds `atMs`. */
+export const totpCode = (secret, atMs) => {
+    const counter = Buffer.alloc(8);
+    counter.writeBigUInt64BE(BigInt(Math.floor(atMs / 1000 / secret.periodSeconds)));
+    const mac = createHmac(secret.algorithm, secret.key).update(counter).digest();
+    const offset = mac[mac.length - 1] & 0x0f;
+    const binary = mac.readUInt32BE(offset) & 0x7fffffff;
+    return String(binary % 10 ** secret.digits).padStart(secret.digits, '0');
+};
+/**
+ * The code to type now: the current one, or, with less than 8 s (a third of a short period) left, the next period's
+ * after `pause` waits for it. After the wait the code is for the new period even if the clock reads earlier.
+ *
+ * @example
+ * await typingCode(secret, { now: Date.now, pause: (ms) => limit.pause(ms) }) // '287082'
+ */
+export const typingCode = async (secret, { now, pause }) => {
+    const at = now();
+    const periodMs = secret.periodSeconds * 1000;
+    const left = periodMs - (at % periodMs);
+    if (left >= Math.min(FRESH_FOR_MS, periodMs / 3))
+        return totpCode(secret, at);
+    await pause(left);
+    return totpCode(secret, Math.max(now(), at + left));
+};

package/dist/task/upload-files.js

@@ -1,12 +1,25 @@
-import { accessSync, constants, statSync } from 'node:fs';
+import { accessSync, constants, createWriteStream, mkdirSync, rmSync, statSync } from 'node:fs';
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { request } from 'node:https';
+import { BlockList, isIP } from 'node:net';
 import { basename, isAbsolute } from 'node:path';
+import { finished } from 'node:stream/promises';
+import { safeFileName, uniqueFileName } from '../output/layout.js';
+import { outsideHosts } from './hosts.js';
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const MAX_REDIRECTS = 3;
+const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 60_000;
+/** True for a `files` value that is a URL to fetch rather than a local path. */
+const isUrl = (value) => SCHEME.test(value) && !/^[a-z]:[\\/]/i.test(value);
 /**
- * Checks the files a caller declares for upload, before any browser work. Each must be an absolute path to a readable
- * regular file. They are kept apart from `values`, so typed text can never become a path or a path typed text; the model
- * only ever picks one of these keys. Not restricted to a working directory: the server's own is unrelated to the user's.
+ * Checks the files a caller declares for upload, before any browser work. Each is an absolute path to a readable regular
+ * file, or an `https` URL fetched before the run (`fetchUploadUrls`). They are kept apart from `values`, so typed text
+ * can never become a path or a path typed text; the model only ever picks one of these keys. Not restricted to a working
+ * directory: the server's own is unrelated to the user's.
  *
  * @example
- * checkUploadFiles({ avatar: '/Users/ada/me.png' }); // { avatar: '/Users/ada/me.png' }
+ * checkUploadFiles({ avatar: '/Users/ada/me.png', cv: 'https://files.example/cv.pdf' }); // as given
  * checkUploadFiles({ avatar: 'me.png' }); // throws: files.avatar: "me.png" is not an absolute path
  */
 export const checkUploadFiles = (files) => {
@@ -14,6 +27,14 @@ export const checkUploadFiles = (files) => {
         const refuse = (why) => {
             throw new Error(`files.${key}: "${path}" ${why}`);
         };
+        if (isUrl(path)) {
+            const url = URL.canParse(path) ? new URL(path) : undefined;
+            if (url?.protocol !== 'https:' || !url.hostname)
+                refuse('is not an https URL');
+            if (url.username || url.password)
+                refuse('carries a user name or password; put the file on disk instead');
+            continue;
+        }
         if (!isAbsolute(path))
             refuse('is not an absolute path');
         let isFile = false;
@@ -41,3 +62,214 @@ export const checkUploadFiles = (files) => {
  * fileNames({ avatar: '/Users/ada/me.png' }); // { avatar: 'me.png' }
  */
 export const fileNames = (files) => Object.fromEntries(Object.entries(files).map(([key, path]) => [key, basename(path)]));
+// Every range a fetch for the caller must never reach: this machine, the local network, link-local (cloud metadata),
+// carrier-grade NAT, multicast and reserved space, and the IPv6 forms that lead back into them.
+const NOT_PUBLIC = new BlockList();
+for (const [network, prefix] of [
+    ['0.0.0.0', 8],
+    ['10.0.0.0', 8],
+    ['100.64.0.0', 10],
+    ['127.0.0.0', 8],
+    ['169.254.0.0', 16],
+    ['172.16.0.0', 12],
+    ['192.0.0.0', 24],
+    ['192.0.2.0', 24],
+    ['192.168.0.0', 16],
+    ['198.18.0.0', 15],
+    ['198.51.100.0', 24],
+    ['203.0.113.0', 24],
+    ['224.0.0.0', 3],
+]) {
+    NOT_PUBLIC.addSubnet(network, prefix, 'ipv4');
+}
+for (const [network, prefix] of [
+    ['::', 128],
+    ['::1', 128],
+    ['64:ff9b::', 96],
+    ['64:ff9b:1::', 48],
+    ['100::', 64],
+    ['2001:db8::', 32],
+    ['fc00::', 7],
+    ['fe80::', 10],
+    ['ff00::', 8],
+]) {
+    NOT_PUBLIC.addSubnet(network, prefix, 'ipv6');
+}
+// An IPv4-mapped IPv6 address (`::ffff:127.0.0.1`, `::ffff:7f00:1`) as the IPv4 address it reaches; undefined otherwise.
+const mappedIpv4 = (address) => {
+    const match = /^::ffff:(?:(\d+\.\d+\.\d+\.\d+)|([0-9a-f]{1,4}):([0-9a-f]{1,4}))$/i.exec(address);
+    if (!match)
+        return undefined;
+    if (match[1])
+        return match[1];
+    const high = parseInt(match[2], 16);
+    const low = parseInt(match[3], 16);
+    return [high >> 8, high & 255, low >> 8, low & 255].join('.');
+};
+/**
+ * Whether an address is on the public internet: never this machine, a private or link-local network, CGNAT, multicast,
+ * reserved space, or an IPv6 form (mapped, NAT64) of one.
+ *
+ * @example
+ * publicAddress('93.184.215.14') // true
+ * publicAddress('::ffff:127.0.0.1') // false
+ */
+export const publicAddress = (address) => {
+    const mapped = mappedIpv4(address);
+    if (mapped)
+        return publicAddress(mapped);
+    const family = isIP(address);
+    if (!family)
+        return false;
+    return !NOT_PUBLIC.check(address, family === 4 ? 'ipv4' : 'ipv6');
+};
+// A URL whose host is an address: the connection skips `lookup`, so it is checked here, by itself.
+const privateLiteral = (url) => {
+    const host = url.hostname.replace(/^\[|\]$/g, '');
+    return isIP(host) !== 0 && !publicAddress(host);
+};
+const resolveAll = (host) => dnsLookup(host, { all: true });
+/**
+ * A `lookup` for the HTTPS connection that resolves the host, refuses it when any address is not public, and hands the
+ * checked address to the connection, so the name can't resolve elsewhere between the check and the connect.
+ *
+ * @example
+ * request(url, { lookup: vettedLookup() }) // a host resolving to 10.0.0.5 fails: "… resolves to 10.0.0.5, a private or local address"
+ */
+export const vettedLookup = (resolve = resolveAll) => (hostname, options, callback) => {
+    resolve(hostname).then((addresses) => {
+        const blocked = addresses.find(({ address }) => !publicAddress(address));
+        if (blocked || !addresses.length) {
+            callback(new Error(`${hostname} resolves to ${blocked?.address ?? 'nothing'}, a private or local address`), '', 4);
+            return;
+        }
+        if (options.all)
+            callback(null, addresses);
+        else
+            callback(null, addresses[0].address, addresses[0].family);
+    }, (error) => callback(error, '', 4));
+};
+const httpsGet = (url, signal) => new Promise((resolve, reject) => {
+    const outgoing = request(url, { method: 'GET', lookup: vettedLookup(), timeout: FETCH_TIMEOUT_MS, signal, headers: { 'user-agent': 'jevway' } }, (incoming) => resolve({ status: incoming.statusCode ?? 0, headers: incoming.headers, body: incoming, close: () => incoming.destroy() }));
+    outgoing.on('timeout', () => outgoing.destroy(new Error(`no answer within ${FETCH_TIMEOUT_MS / 1000} s`)));
+    outgoing.on('error', reject);
+    outgoing.end();
+});
+const header = (headers, name) => {
+    const value = headers[name];
+    return Array.isArray(value) ? value[0] : value;
+};
+// The file name a server gives: RFC 5987 `filename*` first, then plain `filename`.
+const dispositionName = (disposition) => {
+    if (!disposition)
+        return undefined;
+    const extended = /filename\*\s*=\s*([^']*)'[^']*'([^;]+)/i.exec(disposition);
+    if (extended) {
+        try {
+            return decodeURIComponent(extended[2].trim());
+        }
+        catch {
+            // fall through to the plain name
+        }
+    }
+    return /filename\s*=\s*(?:"([^"]*)"|([^;]+))/i.exec(disposition)?.slice(1).find(Boolean)?.trim();
+};
+const urlName = (url) => {
+    try {
+        return decodeURIComponent(url.pathname.split('/').pop() ?? '');
+    }
+    catch {
+        return url.pathname.split('/').pop() ?? '';
+    }
+};
+/**
+ * Fetches every `https` value of `files` into `dir` and returns the files with each URL swapped for its path; local paths
+ * pass through. Only `https`, at most 3 redirects, each hop inside `hosts` and connected only to public addresses, at
+ * most 50 MB. The name comes from Content-Disposition, else the URL path, made safe, else the key. `known` remembers
+ * what a session already fetched. Every error starts with the key and the URL.
+ *
+ * @example
+ * await fetchUploadUrls({ cv: 'https://files.example/cv.pdf' }, { dir: '<run>/uploads' }) // { cv: '<run>/uploads/cv.pdf' }
+ */
+export const fetchUploadUrls = async (files, { dir, hosts = { blocked: [] }, get = httpsGet, known = new Map(), maxBytes = MAX_UPLOAD_BYTES, signal, }) => {
+    const fetched = {};
+    for (const [key, value] of Object.entries(files)) {
+        if (!isUrl(value)) {
+            fetched[key] = value;
+            continue;
+        }
+        const path = known.get(value) ?? (await fetchOne({ key, value, dir, hosts, get, maxBytes, signal }));
+        known.set(value, path);
+        fetched[key] = path;
+    }
+    return fetched;
+};
+const fetchOne = async ({ key, value, dir, hosts, get, maxBytes, signal, }) => {
+    const refuse = (why) => {
+        throw new Error(`files.${key}: "${value}" ${why}`);
+    };
+    let url = new URL(value);
+    const outside = outsideHosts(url.href, hosts);
+    if (outside)
+        refuse(`is outside this run's hosts: ${outside}`);
+    if (privateLiteral(url))
+        refuse('points at a private or local address');
+    for (let redirects = 0;; redirects++) {
+        const response = await get(url, signal).catch((error) => refuse(`could not be fetched: ${error.message}`));
+        const location = header(response.headers, 'location');
+        if (response.status >= 300 && response.status < 400 && location) {
+            response.close();
+            if (redirects >= MAX_REDIRECTS)
+                refuse(`redirected more than ${MAX_REDIRECTS} times`);
+            const next = new URL(location, url);
+            if (next.protocol !== 'https:')
+                refuse(`redirected to ${next.href}, and only https URLs are fetched`);
+            if (outsideHosts(next.href, hosts))
+                refuse(`redirected to ${next.href}, which is outside this run's hosts`);
+            if (privateLiteral(next))
+                refuse(`redirected to ${next.href}, a private or local address`);
+            if (next.username || next.password)
+                refuse('redirected to a URL with a user name or password');
+            url = next;
+            continue;
+        }
+        if (response.status < 200 || response.status >= 300) {
+            response.close();
+            refuse(`answered ${response.status}`);
+        }
+        if (Number(header(response.headers, 'content-length') ?? 0) > maxBytes) {
+            response.close();
+            refuse(`is larger than the ${capWords(maxBytes)} cap`);
+        }
+        mkdirSync(dir, { recursive: true });
+        const path = uniqueFileName(dir, safeFileName(dispositionName(header(response.headers, 'content-disposition')) ?? urlName(url), key));
+        await save(response, path, maxBytes).catch((error) => {
+            rmSync(path, { force: true });
+            refuse(error.message === TOO_BIG ? `is larger than the ${capWords(maxBytes)} cap` : `could not be fetched: ${error.message}`);
+        });
+        return path;
+    }
+};
+const TOO_BIG = 'too big';
+const capWords = (bytes) => (bytes % (1024 * 1024) === 0 ? `${bytes / (1024 * 1024)} MB` : `${bytes}-byte`);
+// Streams the body to `path`, counting bytes: a body that passes the cap is cut off there.
+const save = async (response, path, maxBytes) => {
+    const out = createWriteStream(path);
+    let bytes = 0;
+    try {
+        for await (const chunk of response.body) {
+            bytes += chunk.length;
+            if (bytes > maxBytes)
+                throw new Error(TOO_BIG);
+            if (!out.write(chunk))
+                await new Promise((resolve) => out.once('drain', () => resolve()));
+        }
+    }
+    catch (error) {
+        response.close();
+        out.destroy();
+        throw error;
+    }
+    out.end();
+    await finished(out);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jevway",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Hand a browser goal to TypeSafe Jev; get a short verified summary back. MCP server + CLI.",
   "keywords": [
     "mcp",
@@ -25,13 +25,13 @@
     "url": "git+https://github.com/AbdallahAHO/jevway.git"
   },
   "bin": {
-    "jevway": "dist/cli.js",
+    "jevway": "dist/cli/main.js",
     "jevway-mcp": "dist/mcp.js"
   },
   "files": [
     "dist",
     "skill",
-    "INSTALL-FOR-AGENTS.md",
+    "SETUP.md",
     "LICENSE",
     "LICENSE.jev-ultrafast"
   ],
@@ -39,7 +39,7 @@
     "node": ">=24"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && cp src/browser/snapshot.js dist/browser/snapshot.js && chmod +x dist/cli.js dist/mcp.js",
+    "build": "tsc -p tsconfig.build.json && cp src/browser/snapshot.js dist/browser/snapshot.js && chmod +x dist/cli/main.js dist/mcp.js",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "prepublishOnly": "pnpm typecheck && pnpm test && rm -rf dist && pnpm build",
@@ -47,8 +47,9 @@
     "release:status": "node release/release.ts status",
     "release:check": "node release/release.ts check",
     "verify": "node --env-file-if-exists=.env verify/run.ts",
+    "verify:mcp": "node verify/mcp-consumer.ts",
     "mcp": "node --env-file-if-exists=.env src/mcp.ts",
-    "cli": "node --env-file-if-exists=.env src/cli.ts",
+    "cli": "node --env-file-if-exists=.env src/cli/main.ts",
     "verify:reader": "node verify/reader.ts",
     "verify:journeys": "node --env-file-if-exists=.env verify/journeys.ts",
     "verify:real": "node --env-file-if-exists=.env verify/real-world.ts",
@@ -61,7 +62,7 @@
     "verify:forgejo": "node --env-file-if-exists=.env verify/forgejo.ts",
     "verify:signup": "node --env-file-if-exists=.env verify/signup.ts",
     "verify:vikunja": "node --env-file-if-exists=.env verify/vikunja.ts",
-    "verify:agent": "node verify/agent.ts",
+    "verify:agent": "node verify/agent/agent.ts",
     "verify:replay": "node verify/replay.ts",
     "report:render": "node verify/jobs/rerender.ts",
     "apps:forgejo:up": "docker compose -p jevway-forgejo -f verify/apps/forgejo/compose.yml up -d --wait && node verify/apps/forgejo/seed.ts users",
@@ -70,12 +71,13 @@
     "apps:vikunja:down": "docker compose -p jevway-vikunja -f verify/apps/vikunja/compose.yml down -v"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/server": "^2.4.0",
     "@typesafe-ai/sdk": "^0.7.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@types/node": "^22.20.3",
+    "@modelcontextprotocol/client": "^2.4.0",
+    "@types/node": "^24.19.2",
     "typescript": "^7.0.2",
     "vitest": "^5.0.1"
   }