@modelprofile.com/browser-runtime 1.0.0

package/dist_ts/classes.framed.js

@@ -0,0 +1,557 @@
+import * as plugins from './plugins.js';
+import { validateAgentAction, validateAgentActionResult } from './actions.js';
+import { BrowserRuntimeError } from './errors.js';
+import { assertJsonWithoutBytes, randomId, validateBoundedString, validateExactKeys, validateInteger, waitBounded, } from './utils.js';
+const protocolVersion = 1;
+const hardMaxFrameBytes = 256 * 1024;
+const hardMaxPendingRequests = 16;
+const hardRequestTimeoutMs = 60_000;
+class JsonFramedChannel {
+    readable;
+    writable;
+    maxFrameBytes;
+    writeTimeoutMs;
+    onMessage;
+    onClose;
+    buffer = plugins.Buffer.alloc(0);
+    writeTail = Promise.resolve();
+    started = false;
+    closed = false;
+    queuedBytes = 0;
+    onDataBound = (chunk) => {
+        this.onData(chunk);
+    };
+    onCloseBound = () => {
+        this.closeFromStream();
+    };
+    constructor(readable, writable, maxFrameBytes, writeTimeoutMs, onMessage, onClose) {
+        this.readable = readable;
+        this.writable = writable;
+        this.maxFrameBytes = maxFrameBytes;
+        this.writeTimeoutMs = writeTimeoutMs;
+        this.onMessage = onMessage;
+        this.onClose = onClose;
+    }
+    start() {
+        if (this.started || this.closed)
+            return;
+        this.started = true;
+        this.readable.on('data', this.onDataBound);
+        this.readable.once('end', this.onCloseBound);
+        this.readable.once('close', this.onCloseBound);
+        this.readable.once('error', this.onCloseBound);
+        this.writable.once('close', this.onCloseBound);
+        this.writable.once('error', this.onCloseBound);
+    }
+    send(message) {
+        if (this.closed)
+            return Promise.reject(new BrowserRuntimeError('PROTOCOL_ERROR'));
+        assertJsonWithoutBytes(message, this.maxFrameBytes);
+        const payload = plugins.Buffer.from(JSON.stringify(message), 'utf8');
+        if (payload.byteLength > this.maxFrameBytes) {
+            return Promise.reject(new BrowserRuntimeError('PROTOCOL_ERROR'));
+        }
+        const header = plugins.Buffer.allocUnsafe(4);
+        header.writeUInt32BE(payload.byteLength, 0);
+        const frame = plugins.Buffer.concat([header, payload]);
+        if (this.queuedBytes + frame.byteLength > this.maxFrameBytes * hardMaxPendingRequests) {
+            return Promise.reject(new BrowserRuntimeError('BUSY'));
+        }
+        this.queuedBytes += frame.byteLength;
+        const write = this.writeTail.then(() => this.write(frame)).finally(() => {
+            this.queuedBytes -= frame.byteLength;
+        });
+        this.writeTail = write.catch(() => undefined);
+        return write;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.removeListeners();
+        if (typeof this.readable.destroy === 'function')
+            this.readable.destroy();
+        if (typeof this.writable.destroy === 'function')
+            this.writable.destroy();
+        await waitBounded(this.writeTail, this.writeTimeoutMs).catch(() => undefined);
+        this.onClose();
+    }
+    onData(chunkArg) {
+        if (this.closed)
+            return;
+        const chunk = typeof chunkArg === 'string'
+            ? plugins.Buffer.from(chunkArg, 'utf8')
+            : chunkArg;
+        this.buffer = plugins.Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.byteLength >= 4) {
+            const length = this.buffer.readUInt32BE(0);
+            if (length < 2 || length > this.maxFrameBytes) {
+                void this.close();
+                return;
+            }
+            if (this.buffer.byteLength < length + 4)
+                return;
+            const payload = this.buffer.subarray(4, length + 4);
+            this.buffer = this.buffer.subarray(length + 4);
+            try {
+                const message = JSON.parse(payload.toString('utf8'));
+                assertJsonWithoutBytes(message, this.maxFrameBytes);
+                this.onMessage(message);
+            }
+            catch {
+                void this.close();
+                return;
+            }
+        }
+        if (this.buffer.byteLength > this.maxFrameBytes + 4)
+            void this.close();
+    }
+    write(frame) {
+        return new Promise((resolve, reject) => {
+            if (this.closed || !this.writable.writable) {
+                reject(new BrowserRuntimeError('PROTOCOL_ERROR'));
+                return;
+            }
+            let settled = false;
+            const timer = setTimeout(() => {
+                finish(new BrowserRuntimeError('TIMEOUT'));
+                this.closeFromStream();
+            }, this.writeTimeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.writable.off('error', onError);
+                this.writable.off('close', onClose);
+            };
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const onError = (error) => finish(error);
+            const onClose = () => finish(new BrowserRuntimeError('PROTOCOL_ERROR'));
+            this.writable.once('error', onError);
+            this.writable.once('close', onClose);
+            this.writable.write(frame, (error) => finish(error ?? undefined));
+        });
+    }
+    closeFromStream() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.removeListeners();
+        if (typeof this.readable.destroy === 'function')
+            this.readable.destroy();
+        if (typeof this.writable.destroy === 'function')
+            this.writable.destroy();
+        this.onClose();
+    }
+    removeListeners() {
+        this.readable.off('data', this.onDataBound);
+        this.readable.off('end', this.onCloseBound);
+        this.readable.off('close', this.onCloseBound);
+        this.readable.off('error', this.onCloseBound);
+        this.writable.off('close', this.onCloseBound);
+        this.writable.off('error', this.onCloseBound);
+    }
+}
+export class BrowserRuntimeFramedServerPeer {
+    runtime;
+    onClosed;
+    trustedPeerId;
+    trustedScopeId;
+    trustedSessionId;
+    channel;
+    activeRequests = new Map();
+    lease;
+    started = false;
+    closePromise;
+    closing = false;
+    dispatches = new Set();
+    constructor(runtime, options, onClosed = () => undefined) {
+        this.runtime = runtime;
+        this.onClosed = onClosed;
+        this.trustedPeerId = validateBoundedString(options.peerId, 'peerId', 1, 128);
+        this.trustedScopeId = validateBoundedString(options.scopeId, 'scopeId', 1, 128);
+        this.trustedSessionId = validateBoundedString(options.sessionId, 'sessionId', 1, 128);
+        if (!(options.readable instanceof plugins.stream.Readable)
+            || !(options.writable instanceof plugins.stream.Writable)) {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        this.channel = new JsonFramedChannel(options.readable, options.writable, hardMaxFrameBytes, hardRequestTimeoutMs, (message) => this.handleMessage(message), () => { void this.closeFromStream().catch(() => undefined); });
+    }
+    get peerId() {
+        return this.trustedPeerId;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.channel.start();
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = this.closeInternal().catch((error) => {
+            this.closePromise = undefined;
+            throw error;
+        });
+        return this.closePromise;
+    }
+    handleMessage(message) {
+        if (this.closing)
+            return;
+        let id = 'invalid';
+        try {
+            const request = validateExactKeys(message, ['version', 'id', 'method', 'capabilityToken', 'action', 'targetRequestId'], 'framed request');
+            if (request.version !== protocolVersion)
+                throw new BrowserRuntimeError('PROTOCOL_ERROR');
+            id = validateBoundedString(request.id, 'id', 1, 128);
+            const method = validateBoundedString(request.method, 'method', 1, 32);
+            if (this.activeRequests.size >= hardMaxPendingRequests
+                && (method !== 'cancel' || this.activeRequests.size >= hardMaxPendingRequests + 4)) {
+                throw new BrowserRuntimeError('BUSY');
+            }
+            const controller = new AbortController();
+            if (this.activeRequests.has(id))
+                throw new BrowserRuntimeError('PROTOCOL_ERROR');
+            this.activeRequests.set(id, controller);
+            const dispatch = this.dispatchRequest(id, method, request, controller).finally(() => {
+                this.activeRequests.delete(id);
+                this.dispatches.delete(dispatch);
+            });
+            this.dispatches.add(dispatch);
+        }
+        catch (error) {
+            void this.sendError(id, error);
+        }
+    }
+    async dispatchRequest(id, method, request, controller) {
+        try {
+            let result;
+            if (method === 'acquire') {
+                validateExactKeys(request, ['version', 'id', 'method', 'capabilityToken'], 'acquire request');
+                if (this.lease)
+                    throw new BrowserRuntimeError('BUSY');
+                const capabilityToken = validateBoundedString(request.capabilityToken, 'capabilityToken', 16, 512);
+                this.lease = await this.runtime.acquireLease({
+                    capabilityToken,
+                    peerId: this.trustedPeerId,
+                    expectedRole: 'agent',
+                    expectedSource: 'flex',
+                    scopeId: this.trustedScopeId,
+                    sessionId: this.trustedSessionId,
+                    signal: controller.signal,
+                });
+                if (this.closing || controller.signal.aborted) {
+                    await this.lease.release();
+                    this.lease = undefined;
+                    throw new BrowserRuntimeError('ABORTED');
+                }
+                result = {
+                    leaseId: this.lease.leaseId,
+                    role: this.lease.role,
+                    scopeId: this.trustedScopeId,
+                    sessionId: this.trustedSessionId,
+                };
+            }
+            else if (method === 'execute') {
+                validateExactKeys(request, ['version', 'id', 'method', 'action'], 'execute request');
+                const lease = this.requireLease();
+                const action = validateAgentAction(request.action);
+                result = await lease.executeAgentAction(action, { signal: controller.signal });
+            }
+            else if (method === 'cancel') {
+                validateExactKeys(request, ['version', 'id', 'method', 'targetRequestId'], 'cancel request');
+                const targetRequestId = validateBoundedString(request.targetRequestId, 'targetRequestId', 1, 128);
+                const target = this.activeRequests.get(targetRequestId);
+                target?.abort(new BrowserRuntimeError('ABORTED'));
+                const cancelled = Boolean(target);
+                result = { cancelled };
+            }
+            else if (method === 'release') {
+                validateExactKeys(request, ['version', 'id', 'method'], 'release request');
+                const lease = this.requireLease();
+                await lease.release();
+                this.lease = undefined;
+                result = { released: true };
+            }
+            else {
+                throw new BrowserRuntimeError('PROTOCOL_ERROR');
+            }
+            assertJsonWithoutBytes(result, hardMaxFrameBytes);
+            await this.channel.send({ version: protocolVersion, id, ok: true, result });
+        }
+        catch (error) {
+            await this.sendError(id, error);
+        }
+    }
+    requireLease() {
+        if (!this.lease)
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+        return this.lease;
+    }
+    async sendError(id, error) {
+        const runtimeError = error instanceof BrowserRuntimeError
+            ? error
+            : new BrowserRuntimeError('PROTOCOL_ERROR');
+        await this.channel.send({
+            version: protocolVersion,
+            id,
+            ok: false,
+            error: { code: runtimeError.code, message: runtimeError.publicMessage },
+        }).catch(() => undefined);
+    }
+    async closeInternal() {
+        this.closing = true;
+        for (const controller of this.activeRequests.values()) {
+            controller.abort(new BrowserRuntimeError('ABORTED'));
+        }
+        const dispatchResult = await waitBounded(Promise.allSettled([...this.dispatches]).then(() => undefined), hardRequestTimeoutMs);
+        if (!dispatchResult.settled) {
+            await this.runtime.disconnectPeer(this.trustedPeerId);
+        }
+        await this.lease?.release();
+        this.lease = undefined;
+        await this.runtime.disconnectPeer(this.trustedPeerId);
+        await this.channel.close();
+        this.onClosed();
+    }
+    async closeFromStream() {
+        if (this.closePromise)
+            return;
+        this.closePromise = (async () => {
+            this.closing = true;
+            for (const controller of this.activeRequests.values()) {
+                controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+            await waitBounded(Promise.allSettled([...this.dispatches]).then(() => undefined), hardRequestTimeoutMs);
+            await this.lease?.release();
+            this.lease = undefined;
+            await this.runtime.disconnectPeer(this.trustedPeerId);
+            this.onClosed();
+        })().catch((error) => {
+            this.closePromise = undefined;
+            throw error;
+        });
+        await this.closePromise;
+    }
+}
+export class BrowserRuntimeFramedClient {
+    channel;
+    maxPendingRequests;
+    requestTimeoutMs;
+    pending = new Map();
+    acquired = false;
+    started = false;
+    closePromise;
+    scopeIdValue;
+    sessionIdValue;
+    constructor(options) {
+        this.scopeIdValue = validateBoundedString(options.scopeId, 'scopeId', 1, 128);
+        this.sessionIdValue = validateBoundedString(options.sessionId, 'sessionId', 1, 128);
+        if (!(options.readable instanceof plugins.stream.Readable)
+            || !(options.writable instanceof plugins.stream.Writable)) {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        const maxFrameBytes = options.maxFrameBytes === undefined
+            ? hardMaxFrameBytes
+            : validateInteger(options.maxFrameBytes, 'maxFrameBytes', 1024, hardMaxFrameBytes);
+        this.maxPendingRequests = options.maxPendingRequests === undefined
+            ? hardMaxPendingRequests
+            : validateInteger(options.maxPendingRequests, 'maxPendingRequests', 1, hardMaxPendingRequests);
+        this.requestTimeoutMs = options.requestTimeoutMs === undefined
+            ? hardRequestTimeoutMs
+            : validateInteger(options.requestTimeoutMs, 'requestTimeoutMs', 100, hardRequestTimeoutMs);
+        this.channel = new JsonFramedChannel(options.readable, options.writable, maxFrameBytes, this.requestTimeoutMs, (message) => this.handleResponse(message), () => this.handleClose());
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.channel.start();
+    }
+    get scopeId() {
+        return this.scopeIdValue;
+    }
+    get sessionId() {
+        return this.sessionIdValue;
+    }
+    async acquire(capabilityTokenArg, signal) {
+        if (this.acquired)
+            throw new BrowserRuntimeError('BUSY');
+        signal?.throwIfAborted();
+        const capabilityToken = validateBoundedString(capabilityTokenArg, 'capabilityToken', 16, 512);
+        this.start();
+        const id = randomId(12);
+        const acquisition = this.requestWithId(id, 'acquire', { capabilityToken });
+        const onAbort = () => {
+            void this.request('cancel', { targetRequestId: id }).catch(() => undefined);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            await acquisition;
+            signal?.throwIfAborted();
+            this.acquired = true;
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    async executeAgentAction(actionArg, options = {}) {
+        if (!this.acquired)
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+        options.signal?.throwIfAborted();
+        const action = validateAgentAction(actionArg);
+        const id = randomId(12);
+        const requestPromise = this.requestWithId(id, 'execute', { action });
+        const onAbort = () => {
+            void this.request('cancel', { targetRequestId: id }).catch(() => undefined);
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            const result = await requestPromise;
+            assertJsonWithoutBytes(result, hardMaxFrameBytes);
+            return validateAgentActionResult(result);
+        }
+        finally {
+            options.signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    asToolBrowserContext() {
+        return {
+            execute: async (input, options) => {
+                const record = validateExactKeys(input, ['action', 'url', 'selector', 'text', 'timeoutMs'], 'browser tool input');
+                const actionName = validateBoundedString(record.action ?? 'snapshot', 'action', 1, 32);
+                let action;
+                if (actionName === 'navigate') {
+                    action = { action: 'navigate', url: String(record.url ?? '') };
+                }
+                else if (actionName === 'snapshot') {
+                    action = { action: 'snapshot' };
+                }
+                else if (actionName === 'screenshot') {
+                    action = { action: 'screenshot' };
+                }
+                else if (actionName === 'click') {
+                    action = { action: 'click', selector: String(record.selector ?? '') };
+                }
+                else if (actionName === 'fill') {
+                    action = {
+                        action: 'fill',
+                        selector: String(record.selector ?? ''),
+                        text: String(record.text ?? ''),
+                    };
+                }
+                else if (actionName === 'press') {
+                    action = {
+                        action: 'press',
+                        selector: String(record.selector ?? ''),
+                        key: String(record.text ?? ''),
+                    };
+                }
+                else {
+                    throw new BrowserRuntimeError('INVALID_INPUT');
+                }
+                if (record.timeoutMs !== undefined) {
+                    const timeoutMs = validateInteger(record.timeoutMs, 'timeoutMs', 100, 120_000);
+                    if (action.action === 'navigate'
+                        || action.action === 'click'
+                        || action.action === 'fill'
+                        || action.action === 'press')
+                        action.timeoutMs = timeoutMs;
+                }
+                return this.executeAgentAction(action, { signal: options?.abortSignal });
+            },
+        };
+    }
+    async release() {
+        if (!this.acquired)
+            return;
+        await this.request('release', {});
+        this.acquired = false;
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = this.closeInternal();
+        return this.closePromise;
+    }
+    request(method, fields) {
+        return this.requestWithId(randomId(12), method, fields);
+    }
+    async requestWithId(id, method, fields) {
+        this.start();
+        if (this.pending.size >= this.maxPendingRequests)
+            throw new BrowserRuntimeError('BUSY');
+        const responsePromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new BrowserRuntimeError('TIMEOUT'));
+            }, this.requestTimeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        void responsePromise.catch(() => undefined);
+        try {
+            await this.channel.send({ version: protocolVersion, id, method, ...fields });
+        }
+        catch (error) {
+            const pending = this.pending.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                pending.reject(error);
+            }
+        }
+        return responsePromise;
+    }
+    handleResponse(message) {
+        try {
+            const response = validateExactKeys(message, ['version', 'id', 'ok', 'result', 'error'], 'response');
+            if (response.version !== protocolVersion || typeof response.ok !== 'boolean') {
+                throw new BrowserRuntimeError('PROTOCOL_ERROR');
+            }
+            const id = validateBoundedString(response.id, 'id', 1, 128);
+            const pending = this.pending.get(id);
+            if (!pending)
+                throw new BrowserRuntimeError('PROTOCOL_ERROR');
+            clearTimeout(pending.timer);
+            this.pending.delete(id);
+            if (response.ok) {
+                validateExactKeys(message, ['version', 'id', 'ok', 'result'], 'success response');
+                assertJsonWithoutBytes(response.result, hardMaxFrameBytes);
+                pending.resolve(response.result);
+            }
+            else {
+                validateExactKeys(message, ['version', 'id', 'ok', 'error'], 'error response');
+                const error = validateExactKeys(response.error, ['code', 'message'], 'protocol error');
+                const code = validateBoundedString(error.code, 'error code', 1, 64);
+                pending.reject(new BrowserRuntimeError(code));
+            }
+        }
+        catch {
+            void this.close();
+        }
+    }
+    handleClose() {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new BrowserRuntimeError('PROTOCOL_ERROR'));
+        }
+        this.pending.clear();
+        this.acquired = false;
+    }
+    async closeInternal() {
+        let releaseError;
+        await this.release().catch((error) => { releaseError = error; });
+        await this.channel.close();
+        this.handleClose();
+        if (releaseError)
+            throw releaseError;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.framed.js","sourceRoot":"","sources":["../ts/classes.framed.ts"],"names":[],"mappings":"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"}