@jshookmcp/jshook 0.2.2 → 0.2.3

package/dist/src/server/sandbox/MCPBridge.js

@@ -1,12 +1,34 @@
+import { randomUUID } from 'node:crypto';
 export class MCPBridge {
     ctx;
     allowlist = null;
+    pendingCalls = [];
     constructor(ctx) {
         this.ctx = ctx;
     }
     setAllowlist(toolNames) {
         this.allowlist = toolNames ? new Set(toolNames) : null;
     }
+    enqueue(toolName, args = {}) {
+        const registeredNames = this.ctx.selectedTools?.map((t) => t.name) ?? [];
+        if (!registeredNames.includes(toolName)) {
+            throw new Error(`Tool "${toolName}" is not a registered MCP tool`);
+        }
+        if (this.allowlist && !this.allowlist.has(toolName)) {
+            throw new Error(`Tool "${toolName}" is not in the sandbox allowlist`);
+        }
+        const id = randomUUID().slice(0, 8);
+        this.pendingCalls.push({ id, toolName, args });
+        return id;
+    }
+    drainPending() {
+        const calls = [...this.pendingCalls];
+        this.pendingCalls.length = 0;
+        return calls;
+    }
+    hasPending() {
+        return this.pendingCalls.length > 0;
+    }
     async call(toolName, args = {}) {
         if (this.allowlist && !this.allowlist.has(toolName)) {
             throw new Error(`Tool "${toolName}" is not in the sandbox allowlist`);

package/dist/src/server/sandbox/QuickJSSandbox.d.ts

@@ -1,11 +1,14 @@
-import type { SandboxOptions, SandboxResult } from '../sandbox/types.js';
+import type { SandboxOptions, SandboxResult, OrchestrationOptions, OrchestrationResult } from '../sandbox/types.js';
 import type { MCPBridge } from '../sandbox/MCPBridge.js';
 export declare class QuickJSSandbox {
     private bridge;
     setBridge(bridge: MCPBridge): void;
     execute(code: string, options?: SandboxOptions): Promise<SandboxResult>;
+    executeWithOrchestration(code: string, bridge: MCPBridge, options?: OrchestrationOptions): Promise<OrchestrationResult>;
+    private _executeOneRound;
     private _injectConsole;
     private _injectGlobals;
     private _injectHelpers;
     private _injectBridge;
+    private _injectBridgeForOrchestration;
 }

package/dist/src/server/sandbox/QuickJSSandbox.js

@@ -2,6 +2,7 @@ import { getQuickJS } from 'quickjs-emscripten';
 import { SANDBOX_HELPER_SOURCE } from '../sandbox/SandboxHelpers.js';
 const DEFAULT_TIMEOUT_MS = 1_000;
 const DEFAULT_MEMORY_LIMIT_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_BRIDGE_CALLS = 10;
 function marshalToQuickJS(ctx, value) {
     if (value === null || value === undefined)
         return ctx.undefined;
@@ -129,6 +130,127 @@ export class QuickJSSandbox {
             runtime.dispose();
         }
     }
+    async executeWithOrchestration(code, bridge, options = {}) {
+        const maxBridgeCalls = options.maxBridgeCalls ?? DEFAULT_MAX_BRIDGE_CALLS;
+        const startTime = Date.now();
+        const allLogs = [];
+        const allBridgeCalls = [];
+        if (options.bridgeAllowlist) {
+            bridge.setAllowlist(options.bridgeAllowlist);
+        }
+        let bridgeResults = {};
+        let lastOutput;
+        let round = 0;
+        while (round <= maxBridgeCalls) {
+            const roundGlobals = {
+                ...(options.globals ?? {}),
+                __bridgeRound: round,
+            };
+            if (round > 0) {
+                roundGlobals.__bridgeResults = bridgeResults;
+            }
+            const roundResult = await this._executeOneRound(code, bridge, {
+                ...options,
+                globals: roundGlobals,
+            });
+            allLogs.push(...roundResult.logs);
+            if (!roundResult.ok || roundResult.timedOut) {
+                return {
+                    ...roundResult,
+                    logs: allLogs,
+                    durationMs: Date.now() - startTime,
+                    bridgeCallCount: allBridgeCalls.length,
+                    bridgeCalls: allBridgeCalls,
+                };
+            }
+            lastOutput = roundResult.output;
+            if (!bridge.hasPending()) {
+                break;
+            }
+            const pending = bridge.drainPending();
+            const roundResults = {};
+            for (const req of pending) {
+                try {
+                    const result = await bridge.call(req.toolName, req.args);
+                    roundResults[req.id] = result;
+                    allBridgeCalls.push({ toolName: req.toolName, args: req.args, result });
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    roundResults[req.id] = { __error: true, message: errorMsg };
+                    allBridgeCalls.push({ toolName: req.toolName, args: req.args, result: { __error: true, message: errorMsg } });
+                }
+            }
+            bridgeResults = { ...bridgeResults, ...roundResults };
+            round++;
+        }
+        return {
+            ok: true,
+            output: lastOutput,
+            timedOut: false,
+            durationMs: Date.now() - startTime,
+            logs: allLogs,
+            bridgeCallCount: allBridgeCalls.length,
+            bridgeCalls: allBridgeCalls,
+        };
+    }
+    async _executeOneRound(code, bridge, options = {}) {
+        const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const memoryLimitBytes = options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES;
+        const QuickJS = await getQuickJS();
+        const runtime = QuickJS.newRuntime();
+        runtime.setMemoryLimit(memoryLimitBytes);
+        const startTime = Date.now();
+        let timedOut = false;
+        runtime.setInterruptHandler(() => {
+            if (Date.now() - startTime > timeoutMs) {
+                timedOut = true;
+                return true;
+            }
+            return false;
+        });
+        const context = runtime.newContext();
+        const logs = [];
+        try {
+            this._injectConsole(context, logs);
+            this._injectHelpers(context);
+            this._injectBridgeForOrchestration(context, bridge, logs);
+            if (options.globals) {
+                this._injectGlobals(context, options.globals);
+            }
+            const result = context.evalCode(code, 'sandbox-eval.js');
+            if (result.error) {
+                const errorMsg = context.dump(result.error);
+                result.error.dispose();
+                if (timedOut) {
+                    return { ok: false, error: 'Execution timed out', timedOut: true, durationMs: Date.now() - startTime, logs };
+                }
+                return {
+                    ok: false,
+                    error: typeof errorMsg === 'object' ? JSON.stringify(errorMsg) : String(errorMsg),
+                    timedOut: false,
+                    durationMs: Date.now() - startTime,
+                    logs,
+                };
+            }
+            const output = unmarshalFromQuickJS(context, result.value);
+            result.value.dispose();
+            return { ok: true, output, timedOut: false, durationMs: Date.now() - startTime, logs };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+                timedOut,
+                durationMs: Date.now() - startTime,
+                logs,
+            };
+        }
+        finally {
+            context.dispose();
+            runtime.dispose();
+        }
+    }
     _injectConsole(ctx, logs) {
         const consoleObj = ctx.newObject();
         const logFn = ctx.newFunction('log', (...args) => {
@@ -181,4 +303,31 @@ export class QuickJSSandbox {
         listFn.dispose();
         mcpObj.dispose();
     }
+    _injectBridgeForOrchestration(ctx, bridge, logs) {
+        const mcpObj = ctx.newObject();
+        const callFn = ctx.newFunction('call', (nameHandle, argsHandle) => {
+            const name = ctx.getString(nameHandle);
+            const args = ctx.dump(argsHandle) ?? {};
+            try {
+                const callId = bridge.enqueue(name, args);
+                logs.push(`[mcp.call] enqueued ${name}(${JSON.stringify(args)}) → ${callId}`);
+                return marshalToQuickJS(ctx, { __bridgeCall: true, callId });
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                logs.push(`[mcp.call] rejected ${name}: ${errorMsg}`);
+                return marshalToQuickJS(ctx, { __bridgeCall: false, error: errorMsg });
+            }
+        });
+        const listFn = ctx.newFunction('listTools', () => {
+            const tools = bridge.listAvailableTools();
+            return marshalToQuickJS(ctx, tools);
+        });
+        ctx.setProp(mcpObj, 'call', callFn);
+        ctx.setProp(mcpObj, 'listTools', listFn);
+        ctx.setProp(ctx.global, 'mcp', mcpObj);
+        callFn.dispose();
+        listFn.dispose();
+        mcpObj.dispose();
+    }
 }