@byokit/openclaw 0.5.1 → 0.6.2

package/dist/bridge.js

@@ -41,7 +41,7 @@ export function writePlugin(dir, o) {
         id: o.id,
         name: 'BYOKit bridge',
         activation: { onStartup: true },
-        contracts: { tools: o.tools.map((t) => t.name) },
+        contracts: { tools: o.tools.map((t) => t.name), ...(o.browser ? { agentToolResultMiddleware: ['openclaw', 'codex'] } : {}) },
         configSchema: { type: 'object', additionalProperties: false },
     };
     const table = {
@@ -50,6 +50,7 @@ export function writePlugin(dir, o) {
         permitParam,
         // true: engine builtins (web_fetch, memory, ...) are gated too, not only the app's tools.
         gateBuiltins: o.gateBuiltins,
+        ...(o.browser ? { browser: true } : {}),
         tools: o.tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })),
     };
     for (const [file, data] of [['openclaw.plugin.json', manifest], ['tools.json', table]]) {
@@ -67,7 +68,11 @@ export class Bridge {
     approvalTimeoutMs;
     onAsk;
     onAskGone;
+    beforeAgentRun;
+    browserCapabilities;
     server;
+    closing = Promise.resolve();
+    sockets = new Set();
     runs = new Map();
     // Every live registration per session key, each with its run's subset of the app's tools (RunSpec.tools; none: all
     // of them). Runs sharing a key share the narrowest: a tool must be in every live subset.
@@ -85,18 +90,28 @@ export class Bridge {
         this.approvalTimeoutMs = Math.min(o.approvalTimeoutMs, MAX_APPROVAL_TIMEOUT_MS);
         this.onAsk = o.onAsk;
         this.onAskGone = o.onAskGone;
+        this.beforeAgentRun = o.beforeAgentRun;
+        this.browserCapabilities = o.browserCapabilities;
     }
-    start() {
+    async start() {
         if (this.server)
-            return Promise.resolve();
+            return;
         this.stopped = false;
-        // A stale socket file from a crashed run is not a listener; a live one survives unlinking.
+        await this.closing;
+        if (this.stopped || this.server)
+            return;
+        // Old listener teardown must finish before it can unlink a newly rebound Unix socket.
         rmSync(this.path, { force: true });
-        this.server = createServer((socket) => this.serve(socket));
-        return new Promise((resolve, reject) => {
-            this.server.once('error', reject);
-            this.server.listen(this.path, () => {
-                this.server.removeListener('error', reject);
+        const server = createServer(socket => {
+            this.sockets.add(socket);
+            socket.once('close', () => this.sockets.delete(socket));
+            this.serve(socket);
+        });
+        this.server = server;
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(this.path, () => {
+                server.removeListener('error', reject);
                 resolve();
             });
         });
@@ -110,14 +125,28 @@ export class Bridge {
             this.onAskGone(id);
         }
         this.parked.clear();
-        this.server?.close();
+        // Tool subsets survive reconnect (B3); submission authority does not survive a lost engine transport.
+        for (const entries of this.live.values())
+            for (const entry of entries)
+                entry.runId = undefined;
+        // Preserve already-ended refusal replies; abort outstanding calls through their close signal (N7).
+        for (const socket of this.sockets)
+            if (!socket.writableEnded)
+                socket.destroy();
+        const server = this.server;
         this.server = undefined;
-        void rm(this.path, { force: true }).catch(() => { });
+        if (server)
+            this.closing = new Promise(resolve => server.close(() => resolve()))
+                .then(() => rm(this.path, { force: true }).catch(() => { }));
     }
-    /** Register one run; the returned release ends only this registration (the key stays while another run holds it). */
-    register(run, tools) {
+    isRegisteredRun(key, runId) {
+        return !this.stopped && typeof runId === 'string' && !!runId
+            && (this.live.get(key) ?? []).some(entry => entry.runId === runId);
+    }
+    /** Register one run; release revokes only this exact registration, even when sessions overlap. */
+    register(run, tools, runId) {
         this.runs.set(run.sessionKey, run);
-        const entry = tools ? { tools: new Set(tools) } : {};
+        const entry = { ...(tools ? { tools: new Set(tools) } : {}), runId };
         const list = this.live.get(run.sessionKey);
         if (list)
             list.push(entry);
@@ -225,6 +254,24 @@ export class Bridge {
         }
         if (!isRecord(message) || typeof message.kind !== 'string')
             return this.deny(socket, 'not a gate request');
+        if (message.kind === 'browser-capabilities') {
+            if (!this.browserCapabilities || this.stopped)
+                return this.deny(socket, 'browser unavailable');
+            try {
+                this.reply(socket, { capabilities: this.browserCapabilities() });
+            }
+            catch {
+                this.deny(socket, 'browser unavailable');
+            }
+            return;
+        }
+        if (message.kind === 'before-agent-run') {
+            if (typeof message.key !== 'string' || !message.key || !this.beforeAgentRun)
+                return this.deny(socket, 'run unavailable');
+            void this.beforeAgentRun(message.key, typeof message.runId === 'string' ? message.runId : undefined)
+                .then(allow => this.reply(socket, { allow }), () => this.deny(socket, 'run unavailable'));
+            return;
+        }
         if (message.kind === 'gate')
             return void this.gate(socket, message);
         if (message.kind === 'call')

package/dist/browser/broker.d.ts

@@ -0,0 +1,63 @@
+import type { Member } from '../types.ts';
+import type { LiveFrame, LiveInput } from '../browser.ts';
+export type BrokerOptions = {
+    executablePath: string;
+    profileDir: string;
+    member: Member;
+    onExit(code: number | null): void;
+};
+export type LeaseBinding = {
+    epoch: number;
+    nonce: string;
+    origin: string;
+    knownIdps: string[];
+};
+export type PrivateState = {
+    origin: string;
+    secure: boolean;
+    offOrigin: boolean;
+} | undefined;
+export type Broker = {
+    bindLease(l: LeaseBinding | null): void;
+    confirmOrigin(l: {
+        epoch: number;
+        nonce: string;
+    }, origin: string): boolean;
+    privateState(): PrivateState;
+    clearSite(origins: string[]): Promise<void>;
+    endpoint(): {
+        cdpUrl: string;
+    };
+    fence(on: boolean): Promise<void>;
+    agentTab(): string | undefined;
+    originOf(targetId: string): Promise<string>;
+    openPrivate(url: string): Promise<string>;
+    closePrivate(): Promise<void>;
+    probe(url: string, verify: (p: Probe) => Promise<boolean>, timeoutMs: number): Promise<'ok' | 'fail' | 'timeout'>;
+    attachViewer(o: {
+        lease?: {
+            epoch: number;
+            nonce: string;
+        };
+        maxWidth?: number;
+    }): ViewerSession;
+    navigateAgent(url: string | 'reload'): Promise<void>;
+    close(): Promise<void>;
+};
+export type Probe = {
+    url: string;
+    status: number;
+    exists(selector: string): Promise<boolean>;
+};
+export type ViewerSession = {
+    frames: AsyncIterable<LiveFrame>;
+    states: AsyncIterable<NonNullable<PrivateState>>;
+    input(i: LiveInput): void;
+    close(): void;
+};
+/** Chromium refused to start without its sandbox (e.g. unprivileged user namespaces disabled). The broker never runs it unsandboxed. */
+export declare class BrowserSandboxUnavailable extends Error {
+    readonly reason = "sandbox-unavailable";
+    constructor();
+}
+export declare function launchBroker(o: BrokerOptions): Promise<Broker>;