@thegitai/cli 1.0.0-preview.37 → 1.0.0-preview.39

package/README.md

@@ -43,8 +43,28 @@ CLI login tokens use a rolling 48-hour inactivity timeout. If one expires during
 any server request, the CLI removes the expired credential and signs you in
 again on the next run.
 
+## Chrome browser control
+
+The TheGitAI Chrome extension is separately installed. After installing it,
+start `ai` normally and ask about your current tab or a website task. It uses
+your existing Chrome profile, website sessions, and terminal login. Connection
+is automatic; no setup/start command, second sign-in, or manual tab attachment
+is required. Tabs used by the agent join a TheGitAI tab group in an existing
+window. The conversation stays in your terminal.
+
+Default mode asks before using a website and can remember that site for the
+session. Auto-Accept allows browser actions; Plan mode reads pages without
+clicking, typing, or navigating. Use Stop/Resume in the extension popup to
+pause browser control, or Disable to disconnect it. Chrome's protected pages,
+including browser settings and extension management, cannot be controlled.
+
+The extension is currently a development download and is not yet listed in the
+Chrome Web Store. Its version and distribution are independent of this npm
+package. Ubuntu with Chrome is the initial validation target.
+
 ## Structured questions
 
+
 The agent can pause its current turn to ask up to four related questions in one
 form. Use **↑ / ↓**, the displayed option number, or **Enter** to choose, and
 **← / →** to move between questions. **Something else / add details** is the

package/dist/bin/ai.js

@@ -6,9 +6,10 @@ import { isSignInCancelled } from '../src/api/browser-login.js';
 import { runSignIn } from '../src/signin.js';
 import { STARTUP_RETRY_BUDGET, authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
 import { formatCliHelpText } from '../src/help-text.js';
-import { createSession } from '../src/session.js';
+import { createSession, disposeSession } from '../src/session.js';
 import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../src/session-store.js';
 import { runClientInteractive } from '../src/ui/repl.js';
+import { startBrowserDiscoveryInBackground } from '../src/browser/session-bridge.js';
 import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
 import { formatSessionExitNotice } from '../src/session-exit.js';
 import { formatUsageText } from '../src/usage.js';
@@ -237,26 +238,32 @@ export async function main() {
     if (sourceSnapshot) {
         applySessionSnapshot(session, sourceSnapshot);
     }
+    startBrowserDiscoveryInBackground({ cwd: rootDir, env: session.env });
     const initialPrompt = prompt || undefined;
-    const outcome = await runClientInteractive({
-        appendPromptHistory: (value) => appendPromptHistory(value, session.env),
-        authConfig,
-        debugUi: whoami.debugUi,
-        serverModels,
-        serverSessionClient,
-        session,
-        initialPrompt,
-        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-    });
-    if (outcome.signedOut) {
-        if (sessionHasUserMessage(session)) {
-            saveSessionState(session);
+    try {
+        const outcome = await runClientInteractive({
+            appendPromptHistory: (value) => appendPromptHistory(value, session.env),
+            authConfig,
+            debugUi: whoami.debugUi,
+            serverModels,
+            serverSessionClient,
+            session,
+            initialPrompt,
+            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
+        });
+        if (outcome.signedOut) {
+            if (sessionHasUserMessage(session)) {
+                saveSessionState(session);
+            }
+            console.log(chalk.green('\n✓ Logged out.\n'));
+            return;
         }
-        console.log(chalk.green('\n✓ Logged out.\n'));
-        return;
+        await saveSessionBoth({ session, serverSessionClient });
+        printSessionExit(session);
+    }
+    finally {
+        await disposeSession(session);
     }
-    await saveSessionBoth({ session, serverSessionClient });
-    printSessionExit(session);
 }
 main().catch((error) => {
     if (isSignInCancelled(error)) {

package/dist/bin/browser-host.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { decodeFrames, encodeFrame, fragmentPayload, MAX_FRAME_BYTES } from '../src/browser/framing.js';
+import { BROWSER_PROTOCOL_VERSION, browserRuntimeDir, sessionKeyFromRecordFile, sessionSocketPath, socketIsFile, } from '../src/browser/protocol.js';
+const SCAN_INTERVAL_MS = 1000;
+const NUL = String.fromCharCode(0);
+const sessions = new Map();
+const runtimeDir = browserRuntimeDir(process.env);
+let extensionVersion = '';
+let extensionProfileId = '';
+let extensionPlatform = '';
+function log(message) {
+    process.stderr.write(`[thegitai-browser-host] ${message}\n`);
+}
+function writeToExtension(frame) {
+    const payload = Buffer.from(JSON.stringify(frame), 'utf8');
+    if (payload.length > MAX_FRAME_BYTES) {
+        for (const fragment of fragmentPayload(payload, crypto.randomUUID())) {
+            writeToExtension(fragment);
+        }
+        return;
+    }
+    process.stdout.write(encodeFrame(payload));
+}
+let inbound = Buffer.alloc(0);
+process.stdin.on('data', (chunk) => {
+    inbound = Buffer.concat([inbound, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8')]);
+    const { frames, rest, unparseable } = decodeFrames(inbound);
+    inbound = rest;
+    for (let i = 0; i < unparseable; i += 1) {
+        log('discarded an unparseable frame from the extension');
+    }
+    for (const frame of frames)
+        handleExtensionFrame(frame);
+});
+process.stdin.on('end', () => {
+    for (const link of sessions.values())
+        link.socket.destroy();
+    process.exit(0);
+});
+function describeParentBrowser() {
+    const cmdline = process.platform === 'win32' ? windowsParentCommandLine() : unixParentCommandLine();
+    return describeFromCommandLine(cmdline);
+}
+function windowsParentCommandLine() {
+    const PASS_THROUGH = /^(cmd|conhost|powershell|pwsh|node)\.exe$/i;
+    try {
+        const rows = execFileSync('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            'Get-CimInstance Win32_Process | ForEach-Object {' +
+                ' "{0}`t{1}`t{2}`t{3}" -f $_.ProcessId, $_.ParentProcessId, $_.Name, $_.CommandLine }',
+        ], {
+            encoding: 'utf8',
+            timeout: 15000,
+            maxBuffer: 8 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const byPid = new Map();
+        for (const line of rows.split(/\r?\n/)) {
+            const [pid, parent, name, ...rest] = line.split('\t');
+            const id = Number(pid);
+            if (!Number.isInteger(id))
+                continue;
+            byPid.set(id, {
+                parent: Number(parent),
+                name: String(name ?? ''),
+                command: rest.join('\t'),
+            });
+        }
+        let current = byPid.get(process.ppid);
+        for (let hop = 0; hop < 4 && current && PASS_THROUGH.test(current.name); hop += 1) {
+            current = byPid.get(current.parent);
+        }
+        if (!current?.command)
+            return [];
+        return (current.command.match(/"[^"]*"|\S+/g) ?? []).map((token) => token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1) : token);
+    }
+    catch {
+        return [];
+    }
+}
+function unixParentCommandLine() {
+    try {
+        return fs.readFileSync(`/proc/${process.ppid}/cmdline`, 'utf8').split(NUL);
+    }
+    catch {
+        return [];
+    }
+}
+function describeFromCommandLine(cmdline) {
+    try {
+        if (cmdline.length === 0)
+            throw new Error('no command line');
+        const brand = path
+            .basename(cmdline[0] ?? '')
+            .replace(/\.exe$/i, '')
+            .replace(/[-_](browser|stable|beta|dev|unstable|bin)$/i, '')
+            .replace(/[-_]+/g, ' ')
+            .replace(/\b[a-z]/g, (letter) => letter.toUpperCase())
+            .trim() || 'Chrome';
+        const profileArg = cmdline.find((part) => part.startsWith('--profile-directory='));
+        const userDataArg = cmdline.find((part) => part.startsWith('--user-data-dir='));
+        const profile = profileArg ? profileArg.slice('--profile-directory='.length) : 'Default';
+        const suffix = userDataArg
+            ? ` (${path.basename(userDataArg.slice('--user-data-dir='.length))})`
+            : '';
+        return { browser: brand, profile: `${profile}${suffix}` };
+    }
+    catch {
+        return { browser: 'Chrome', profile: 'Default' };
+    }
+}
+const parent = describeParentBrowser();
+function browserKey() {
+    const seed = extensionProfileId || `${parent.browser} ${parent.profile}`;
+    return crypto.createHash('sha256').update(seed).digest('hex').slice(0, 12);
+}
+function identity() {
+    return {
+        key: browserKey(),
+        browser: parent.browser,
+        profile: parent.profile !== 'Default' || !extensionProfileId
+            ? parent.profile
+            : `profile ${extensionProfileId.slice(0, 6)}`,
+        platform: extensionPlatform || process.platform,
+        extensionVersion,
+    };
+}
+function handleExtensionFrame(frame) {
+    if (frame?.t === 'hello') {
+        extensionVersion = String(frame.extensionVersion ?? '');
+        extensionProfileId = String(frame.profileId ?? '');
+        extensionPlatform = String(frame.platform ?? '');
+        writeToExtension({ t: 'hello', protocol: BROWSER_PROTOCOL_VERSION });
+        publishSessions();
+        for (const link of sessions.values())
+            sendHello(link);
+        return;
+    }
+    if (frame?.t === 'res' || frame?.t === 'event') {
+        const target = frame.session ? sessions.get(frame.session) : null;
+        const { session: _routed, ...rest } = frame;
+        if (target) {
+            writeToSession(target, rest);
+            return;
+        }
+        if (frame.t === 'event') {
+            for (const link of sessions.values())
+                writeToSession(link, rest);
+        }
+    }
+}
+function writeToSession(link, frame) {
+    try {
+        link.socket.write(`${JSON.stringify(frame)}\n`);
+    }
+    catch {
+    }
+}
+function sendHello(link) {
+    writeToSession(link, { t: 'hello', protocol: BROWSER_PROTOCOL_VERSION, browser: identity() });
+}
+function publishSessions() {
+    writeToExtension({
+        t: 'sessions',
+        sessions: [...sessions.values()].map((link) => ({
+            session: link.key,
+            label: link.record.label,
+            cwd: link.record.cwd,
+        })),
+    });
+}
+function connectToSession(record, socketPath) {
+    if (sessions.has(record.session))
+        return;
+    const socket = net.createConnection(socketPath);
+    socket.setNoDelay(true);
+    const link = { key: record.session, socket, record };
+    socket.on('connect', () => {
+        sessions.set(record.session, link);
+        sendHello(link);
+        publishSessions();
+        log(`attached to session ${record.session} (${record.cwd})`);
+    });
+    let buffer = '';
+    socket.on('data', (chunk) => {
+        buffer += chunk.toString('utf8');
+        let newline = buffer.indexOf('\n');
+        while (newline !== -1) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            newline = buffer.indexOf('\n');
+            if (!line.trim())
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            writeToExtension({ ...frame, session: record.session });
+        }
+    });
+    const drop = () => {
+        if (sessions.get(record.session) === link) {
+            sessions.delete(record.session);
+            publishSessions();
+        }
+        socket.destroy();
+    };
+    socket.on('close', drop);
+    socket.on('error', () => {
+        drop();
+    });
+}
+function scanForSessions() {
+    let entries;
+    try {
+        entries = fs.readdirSync(runtimeDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const sessionKey = sessionKeyFromRecordFile(entry);
+        if (!sessionKey)
+            continue;
+        const recordPath = path.join(runtimeDir, entry);
+        let record;
+        try {
+            record = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (record.protocol !== BROWSER_PROTOCOL_VERSION)
+            continue;
+        try {
+            process.kill(record.pid, 0);
+        }
+        catch (error) {
+            if (error?.code !== 'EPERM') {
+                try {
+                    fs.unlinkSync(recordPath);
+                    if (socketIsFile())
+                        fs.unlinkSync(sessionSocketPath(runtimeDir, sessionKey));
+                }
+                catch {
+                }
+                continue;
+            }
+        }
+        connectToSession(record, sessionSocketPath(runtimeDir, sessionKey));
+    }
+}
+setInterval(scanForSessions, SCAN_INTERVAL_MS);
+scanForSessions();
+log(`started for ${parent.browser} / ${parent.profile}`);

package/dist/src/agent-mode.js

@@ -9,6 +9,16 @@ const PLAN_MODE_TOOL_NAMES = new Set([
     'run_command',
     'shell_job_output',
     'update_todos',
+    'browser',
+    'browser_tabs',
+    'browser_read_page',
+    'browser_get_page_text',
+    'browser_find',
+    'browser_console',
+    'browser_downloads',
+    'browser_network',
+    'browser_screenshot',
+    'browser_batch',
 ]);
 const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
     'pwd',

package/dist/src/api/chat.js

@@ -10,6 +10,7 @@ import { collectProjectOrientation } from '../project-orientation.js';
 import { describeSessionImageStore } from '../core/session-image-store.js';
 import { autoAttachImages } from '../core/image-path-extractor.js';
 import { formatTurnFailureMarker } from '../turn-failure-marker.js';
+import { browserExtensionSeen, releaseBrowserAfterTurn } from '../browser/session-bridge.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -549,7 +550,9 @@ export async function sendServerUserMessage({ config, session, input, imageAttac
         projectOrientation: collectProjectOrientation(session.rootDir) ?? undefined,
         sessionImageStore: describeSessionImageStore(session.env) ?? undefined,
         imageAttachments: imageAttachmentsForServer(requestImageAttachments),
-        maxToolSteps: session.maxToolSteps,
+        ...(session.maxToolStepsWasExplicit || !browserExtensionSeen(session.env)
+            ? { maxToolSteps: session.maxToolSteps }
+            : {}),
         autoYes: session.autoYes,
         agentMode: session.agentMode,
     };
@@ -623,5 +626,6 @@ export async function sendServerUserMessage({ config, session, input, imageAttac
     }
     finally {
         signal?.removeEventListener('abort', preserveOnAbort);
+        releaseBrowserAfterTurn();
     }
 }

package/dist/src/api/models.js

@@ -122,6 +122,16 @@ export function validateServerModel(modelId, serverModels) {
     }
     return requested;
 }
+export function resolveResumedSessionModel(storedModelId, serverModels) {
+    if (serverModels.models.some((model) => model.id === storedModelId)) {
+        return { modelId: storedModelId, fellBack: false };
+    }
+    const fallbackId = serverModels.models[0]?.id;
+    return {
+        modelId: fallbackId ?? storedModelId,
+        fellBack: fallbackId != null,
+    };
+}
 export function updateSelectedModelCache({ config, selectedModelId, serverModels, env = process.env, }) {
     writeCachedServerModels({
         serverUrl: normalizeServerUrl(config.serverUrl),

package/dist/src/browser/bridge.js

@@ -0,0 +1,232 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { registerNativeHost } from './native-host.js';
+import { BROWSER_PROTOCOL_VERSION, browserRuntimeDir, protocolMismatchMessage, sessionKeyFromRecordFile, sessionRecordPath, sessionSocketPath, socketIsFile, } from './protocol.js';
+const DEFAULT_TIMEOUT_MS = 30000;
+export class BrowserBridgeError extends Error {
+    code;
+    constructor(message, code = 'browser_error') {
+        super(message);
+        this.name = 'BrowserBridgeError';
+        this.code = code;
+    }
+}
+function safeUnlink(target) {
+    try {
+        fs.unlinkSync(target);
+    }
+    catch {
+    }
+}
+export function startBrowserBridge({ sessionKey, label, cwd, env = process.env, }) {
+    const dir = browserRuntimeDir(env);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const socketPath = sessionSocketPath(dir, sessionKey);
+    const recordPath = sessionRecordPath(dir, sessionKey);
+    if (socketIsFile())
+        safeUnlink(socketPath);
+    const browsers = new Map();
+    const listeners = new Set();
+    let selected = null;
+    let closed = false;
+    const registration = registerNativeHost({ env });
+    const server = net.createServer((socket) => {
+        socket.setNoDelay(true);
+        let buffer = '';
+        let key = null;
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            let newline = buffer.indexOf('\n');
+            while (newline !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf('\n');
+                if (!line.trim())
+                    continue;
+                let frame;
+                try {
+                    frame = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (frame.t === 'hello') {
+                    if (frame.protocol !== BROWSER_PROTOCOL_VERSION) {
+                        const message = protocolMismatchMessage(frame.protocol);
+                        for (const listener of listeners)
+                            listener('protocol_mismatch', { message });
+                        socket.destroy();
+                        return;
+                    }
+                    const announced = frame.browser?.key ?? crypto.randomUUID();
+                    const existing = key ? browsers.get(key) : null;
+                    if (existing) {
+                        if (announced !== key) {
+                            browsers.delete(key);
+                            browsers.set(announced, existing);
+                            if (selected === key)
+                                selected = announced;
+                        }
+                        existing.identity = frame.browser;
+                        existing.socket = socket;
+                    }
+                    else {
+                        browsers.set(announced, {
+                            identity: frame.browser,
+                            socket,
+                            pending: new Map(),
+                        });
+                        if (!selected)
+                            selected = announced;
+                    }
+                    key = announced;
+                    for (const listener of listeners) {
+                        listener('connected', { browser: frame.browser });
+                    }
+                    continue;
+                }
+                const browser = key ? browsers.get(key) : null;
+                if (!browser)
+                    continue;
+                if (frame.t === 'res') {
+                    const pending = browser.pending.get(frame.id);
+                    if (!pending)
+                        continue;
+                    browser.pending.delete(frame.id);
+                    clearTimeout(pending.timer);
+                    if (frame.ok)
+                        pending.resolve(frame.result);
+                    else
+                        pending.reject(new BrowserBridgeError(frame.error ?? 'Browser operation failed.', frame.code ?? 'browser_error'));
+                    continue;
+                }
+                if (frame.t === 'event') {
+                    for (const listener of listeners)
+                        listener(frame.event, frame.data ?? {});
+                }
+            }
+        });
+        const drop = () => {
+            if (!key)
+                return;
+            const browser = browsers.get(key);
+            browsers.delete(key);
+            if (selected === key)
+                selected = browsers.keys().next().value ?? null;
+            for (const pending of browser?.pending.values() ?? []) {
+                clearTimeout(pending.timer);
+                pending.reject(new BrowserBridgeError(`The browser disconnected while ${pending.op} was in flight, so its outcome is unknown. Check the page before doing anything that could repeat.`, 'disconnected'));
+            }
+            for (const listener of listeners)
+                listener('disconnected', { browser: key });
+        };
+        socket.on('close', drop);
+        socket.on('error', drop);
+    });
+    server.listen(socketPath, () => {
+        try {
+            fs.chmodSync(socketPath, 0o600);
+        }
+        catch {
+        }
+        const announcement = {
+            protocol: BROWSER_PROTOCOL_VERSION,
+            session: sessionKey,
+            pid: process.pid,
+            label,
+            cwd,
+            startedAt: new Date().toISOString(),
+        };
+        try {
+            fs.writeFileSync(recordPath, `${JSON.stringify(announcement)}\n`, { mode: 0o600 });
+        }
+        catch {
+        }
+    });
+    server.on('error', () => {
+    });
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        for (const browser of browsers.values())
+            browser.socket.destroy();
+        browsers.clear();
+        server.close();
+        safeUnlink(socketPath);
+        safeUnlink(recordPath);
+    };
+    process.once('exit', close);
+    return {
+        sessionKey,
+        status() {
+            return {
+                connected: browsers.size > 0,
+                browsers: [...browsers.values()].map((browser) => browser.identity),
+                selected,
+                socketPath,
+                registrationErrors: registration.errors,
+            };
+        },
+        selectBrowser(key) {
+            if (browsers.has(key))
+                selected = key;
+        },
+        onEvent(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        request(op, args = {}, options = {}) {
+            const target = selected ? browsers.get(selected) : null;
+            if (!target) {
+                return Promise.reject(new BrowserBridgeError('No browser is connected to this session.', 'not_connected'));
+            }
+            const id = crypto.randomUUID();
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    target.pending.delete(id);
+                    reject(new BrowserBridgeError(`The browser did not answer ${op} within ${Math.round(timeoutMs / 1000)}s, so its outcome is unknown. Look at the page before repeating anything that changes state.`, 'timeout'));
+                }, timeoutMs);
+                target.pending.set(id, { resolve, reject, timer, op });
+                target.socket.write(`${JSON.stringify({ t: 'req', id, op, args })}\n`, (error) => {
+                    if (!error)
+                        return;
+                    target.pending.delete(id);
+                    clearTimeout(timer);
+                    reject(new BrowserBridgeError(`Could not reach the browser: ${error.message}`, 'write_failed'));
+                });
+            });
+        },
+        close,
+    };
+}
+export function pruneStaleSessions(env = process.env) {
+    const dir = browserRuntimeDir(env);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const key = sessionKeyFromRecordFile(entry);
+        if (!key)
+            continue;
+        const file = path.join(dir, entry);
+        try {
+            const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+            process.kill(record.pid, 0);
+        }
+        catch (error) {
+            if (error?.code === 'EPERM')
+                continue;
+            safeUnlink(file);
+            if (socketIsFile())
+                safeUnlink(sessionSocketPath(dir, key));
+        }
+    }
+}

package/dist/src/browser/framing.js

@@ -0,0 +1,42 @@
+export const MAX_FRAME_BYTES = 900 * 1024;
+export const FRAGMENT_BYTES = 512 * 1024;
+export function encodeFrame(payload) {
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(payload.length, 0);
+    return Buffer.concat([header, payload]);
+}
+export function fragmentPayload(payload, id) {
+    const total = Math.ceil(payload.length / FRAGMENT_BYTES);
+    const frames = [];
+    for (let part = 0; part < total; part += 1) {
+        frames.push({
+            t: 'fragment',
+            id,
+            part,
+            total,
+            data: payload.subarray(part * FRAGMENT_BYTES, (part + 1) * FRAGMENT_BYTES).toString('base64'),
+        });
+    }
+    return frames;
+}
+export function decodeFrames(inbound) {
+    const frames = [];
+    let rest = inbound;
+    let unparseable = 0;
+    for (;;) {
+        if (rest.length < 4)
+            break;
+        const length = rest.readUInt32LE(0);
+        if (rest.length < 4 + length)
+            break;
+        const body = rest.subarray(4, 4 + length);
+        rest = rest.subarray(4 + length);
+        try {
+            frames.push(JSON.parse(body.toString('utf8')));
+        }
+        catch {
+            unparseable += 1;
+        }
+    }
+    return { frames, rest, unparseable };
+}