@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/plugins/PluginContract.js

@@ -1 +1 @@
-export { ExtensionBuilder, createExtension, } from '../../../packages/extension-sdk/src/plugin.js';
+export { ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';

package/dist/src/server/plugins/examples/minimal-plugin/manifest.js

@@ -6,10 +6,10 @@ export default createExtension('example.minimal', '1.0.0')
     .tool('echo', 'Echoes back the input', {
     type: 'object',
     properties: { text: { type: 'string' } },
-    required: ['text']
+    required: ['text'],
 }, async (args) => {
     return {
-        content: [{ type: 'text', text: `Echo: ${args.text}` }]
+        content: [{ type: 'text', text: `Echo: ${args.text}` }],
     };
 })
     .onLoad(async (ctx) => {

package/dist/src/server/registry/contracts.d.ts

@@ -1,13 +1,13 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { ToolArgs } from '../types.js';
 import type { MCPServerContext } from '../MCPServer.context.js';
-export type ToolProfileId = 'search' | 'workflow' | 'full';
+export type ToolProfileId = 'search' | 'workflow' | 'full' | 'restricted';
 export interface ToolHandlerDeps {
     readonly [depKey: string]: unknown;
 }
 export interface ToolRegistration {
     readonly tool: Tool;
-    readonly domain: string;
+    readonly domain?: string;
     readonly bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
     readonly profiles?: readonly ToolProfileId[];
 }
@@ -16,7 +16,24 @@ export interface DomainManifest<TDepKey extends string = string, THandler = unkn
     readonly version: 1;
     readonly domain: TDomain;
     readonly depKey: TDepKey;
+    readonly secondaryDepKeys?: readonly string[];
     readonly profiles: readonly ToolProfileId[];
     readonly registrations: readonly ToolRegistration[];
     readonly ensure: (ctx: MCPServerContext) => THandler;
+    readonly workflowRule?: {
+        readonly patterns: readonly RegExp[];
+        readonly priority: number;
+        readonly tools: readonly string[];
+        readonly hint: string;
+    };
+    readonly prerequisites?: Readonly<Record<string, ReadonlyArray<{
+        readonly condition: string;
+        readonly fix: string;
+    }>>>;
+    readonly toolDependencies?: ReadonlyArray<{
+        readonly from: string;
+        readonly to: string;
+        readonly relation: 'requires' | 'precedes' | 'suggests';
+        readonly weight?: number;
+    }>;
 }

package/dist/src/server/registry/discovery.js

@@ -35,7 +35,7 @@ async function discoverManifestPaths() {
         logger.error('[discovery] Cannot read domains directory:', err);
         return [];
     }
-    const directories = entries.filter(e => e.isDirectory());
+    const directories = entries.filter((e) => e.isDirectory());
     const resolved = await Promise.all(directories.map(async (entry) => {
         for (const ext of ['manifest.js', 'manifest.ts']) {
             const manifestPath = join(domainsDir, entry.name, ext);
@@ -83,7 +83,11 @@ export async function discoverDomainManifests() {
             seenDomains.add(manifest.domain);
             seenDepKeys.add(manifest.depKey);
             manifests.push(manifest);
-            logger.info('[discovery] Loaded domain "' + manifest.domain + '" (' + String(manifest.registrations.length) + ' tools)');
+            logger.info('[discovery] Loaded domain "' +
+                manifest.domain +
+                '" (' +
+                String(manifest.registrations.length) +
+                ' tools)');
         }
         catch (err) {
             logger.error('[discovery] Failed to load manifest: ' + absPath, err);
@@ -93,6 +97,10 @@ export async function discoverDomainManifests() {
         }
     }
     const totalTools = manifests.reduce((n, m) => n + m.registrations.length, 0);
-    logger.info('[discovery] Discovered ' + String(manifests.length) + ' domains, ' + String(totalTools) + ' tools total');
+    logger.info('[discovery] Discovered ' +
+        String(manifests.length) +
+        ' domains, ' +
+        String(totalTools) +
+        ' tools total');
     return manifests;
 }

package/dist/src/server/registry/index.d.ts

@@ -6,12 +6,9 @@ export declare function getAllManifests(): readonly DomainManifest[];
 export declare function getAllRegistrations(): readonly ToolRegistration[];
 export declare function getAllDomains(): ReadonlySet<string>;
 export declare function getAllToolNames(): ReadonlySet<string>;
+export declare function getRegistrationByName(name: string): ToolRegistration | undefined;
 export declare function buildToolGroups(): Record<string, Tool[]>;
 export declare function buildToolDomainMap(): ReadonlyMap<string, string>;
 export declare function buildAllTools(): Tool[];
 export declare function buildHandlerMapFromRegistry(deps: ToolHandlerDeps, selectedToolNames?: ReadonlySet<string>): Record<string, ToolHandler>;
 export declare function buildProfileDomains(): Record<ToolProfileId, string[]>;
-export declare const ALL_DOMAINS: ReadonlySet<string>;
-export declare const ALL_TOOL_NAMES: ReadonlySet<string>;
-export declare const ALL_MANIFESTS: readonly DomainManifest[];
-export declare const ALL_REGISTRATIONS: readonly ToolRegistration[];

package/dist/src/server/registry/index.js

@@ -5,6 +5,7 @@ let _registrations = null;
 let _initPromise = null;
 let _domainsView = null;
 let _toolNamesView = null;
+let _registrationsByName = null;
 async function init() {
     if (_manifests !== null)
         return;
@@ -18,18 +19,19 @@ async function init() {
         const uniqueByToolName = new Map();
         for (const m of discovered) {
             for (const r of m.registrations) {
-                const existing = uniqueByToolName.get(r.tool.name);
+                const registration = r.domain ? r : { ...r, domain: m.domain };
+                const existing = uniqueByToolName.get(registration.tool.name);
                 if (existing) {
-                    logger.warn(`[registry] Duplicate tool name "${r.tool.name}": domain "${r.domain}" conflicts with "${existing.domain}" — keeping first`);
+                    logger.warn(`[registry] Duplicate tool name "${registration.tool.name}": domain "${registration.domain}" conflicts with "${existing.domain}" — keeping first`);
                 }
                 else {
-                    uniqueByToolName.set(r.tool.name, r);
+                    uniqueByToolName.set(registration.tool.name, registration);
                 }
             }
         }
         _registrations = [...uniqueByToolName.values()];
-        _domainsView = new Set(_manifests.map(m => m.domain));
-        _toolNamesView = new Set(_registrations.map(r => r.tool.name));
+        _domainsView = new Set(_manifests.map((m) => m.domain));
+        _toolNamesView = new Set(_registrations.map((r) => r.tool.name));
     })();
     await _initPromise;
 }
@@ -62,6 +64,12 @@ export function getAllToolNames() {
         throw new Error('[registry] Not initialised - call initRegistry() first.');
     return _toolNamesView;
 }
+export function getRegistrationByName(name) {
+    if (!_registrationsByName) {
+        _registrationsByName = new Map(getRegistrations().map((r) => [r.tool.name, r]));
+    }
+    return _registrationsByName.get(name);
+}
 export function buildToolGroups() {
     const groups = {};
     for (const r of getRegistrations()) {
@@ -78,13 +86,13 @@ export function buildToolDomainMap() {
     return map;
 }
 export function buildAllTools() {
-    return getRegistrations().map(r => r.tool);
+    return getRegistrations().map((r) => r.tool);
 }
 export function buildHandlerMapFromRegistry(deps, selectedToolNames) {
     const regs = selectedToolNames
-        ? getRegistrations().filter(r => selectedToolNames.has(r.tool.name))
+        ? getRegistrations().filter((r) => selectedToolNames.has(r.tool.name))
         : [...getRegistrations()];
-    return Object.fromEntries(regs.map(r => [r.tool.name, r.bind(deps)]));
+    return Object.fromEntries(regs.map((r) => [r.tool.name, r.bind(deps)]));
 }
 export function buildProfileDomains() {
     const profiles = {
@@ -103,7 +111,7 @@ export function buildProfileDomains() {
     }
     const isSubset = (a, b) => {
         const bSet = new Set(b);
-        return a.every(x => bSet.has(x));
+        return a.every((x) => bSet.has(x));
     };
     if (!isSubset(result['search'], result['workflow'])) {
         logger.warn('[registry] Profile hierarchy: search not subset of workflow');
@@ -113,31 +121,3 @@ export function buildProfileDomains() {
     }
     return result;
 }
-export const ALL_DOMAINS = new Proxy(new Set(), {
-    get(_t, p) {
-        const real = getAllDomains();
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});
-export const ALL_TOOL_NAMES = new Proxy(new Set(), {
-    get(_t, p) {
-        const real = getAllToolNames();
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});
-export const ALL_MANIFESTS = new Proxy([], {
-    get(_t, p) {
-        const real = getAllManifests();
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});
-export const ALL_REGISTRATIONS = new Proxy([], {
-    get(_t, p) {
-        const real = getAllRegistrations();
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});

package/dist/src/server/registry/types.d.ts

@@ -1,5 +1,5 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export type { ToolRegistration, ToolHandlerDeps, ToolProfileId, DomainManifest } from '../registry/contracts.js';
+export type { ToolRegistration, ToolHandlerDeps, ToolProfileId, DomainManifest, } from '../registry/contracts.js';
 export type ToolDomain = string;
 export type ToolHandlerMapDependencies = Record<string, unknown>;
 export declare function toolLookup(tools: readonly Tool[]): (name: string) => Tool;

package/dist/src/server/registry/types.js

@@ -1,5 +1,5 @@
 export function toolLookup(tools) {
-    const map = new Map(tools.map(t => [t.name, t]));
+    const map = new Map(tools.map((t) => [t.name, t]));
     return (name) => {
         const tool = map.get(name);
         if (!tool)

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

@@ -0,0 +1,6 @@
+import type { QuickJSSandbox } from '../sandbox/QuickJSSandbox.js';
+import type { SandboxOptions, SandboxResult } from '../sandbox/types.js';
+export interface AutoCorrectedResult extends SandboxResult {
+    retryCount: number;
+}
+export declare function executeWithRetry(sandbox: QuickJSSandbox, code: string, options?: SandboxOptions, maxRetries?: number): Promise<AutoCorrectedResult>;

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

@@ -0,0 +1,17 @@
+export async function executeWithRetry(sandbox, code, options = {}, maxRetries = 2) {
+    let lastResult = null;
+    let currentCode = code;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        lastResult = await sandbox.execute(currentCode, options);
+        if (lastResult.ok) {
+            return { ...lastResult, retryCount: attempt };
+        }
+        if (lastResult.timedOut) {
+            return { ...lastResult, retryCount: attempt };
+        }
+        if (attempt < maxRetries) {
+            currentCode = `/* Previous error (attempt ${attempt + 1}): ${lastResult.error ?? 'unknown error'} */\n${code}`;
+        }
+    }
+    return { ...lastResult, retryCount: maxRetries };
+}

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

@@ -0,0 +1,17 @@
+import type { MCPServerContext } from '../MCPServer.context.js';
+export interface DynamicToolEntry {
+    name: string;
+    prefixedName: string;
+    description: string;
+    handler: (args: Record<string, unknown>) => Promise<unknown>;
+}
+export declare class DynamicToolRegistry {
+    private readonly ctx;
+    private readonly tools;
+    constructor(ctx: MCPServerContext);
+    registerDynamicTool(name: string, description: string, handler: (args: Record<string, unknown>) => Promise<unknown>): string;
+    unregisterDynamicTool(prefixedName: string): boolean;
+    listDynamicTools(): DynamicToolEntry[];
+    getHandler(prefixedName: string): DynamicToolEntry | undefined;
+    clearAll(): void;
+}

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

@@ -0,0 +1,46 @@
+const DYNAMIC_PREFIX = 'sandbox_';
+export class DynamicToolRegistry {
+    ctx;
+    tools = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    registerDynamicTool(name, description, handler) {
+        const prefixedName = `${DYNAMIC_PREFIX}${name}`;
+        const entry = {
+            name,
+            prefixedName,
+            description,
+            handler,
+        };
+        this.tools.set(prefixedName, entry);
+        const toolDef = {
+            name: prefixedName,
+            description: `[Sandbox] ${description}`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    args: {
+                        type: 'object',
+                        description: 'Arguments to pass to the dynamic tool.',
+                    },
+                },
+                required: [],
+            },
+        };
+        this.ctx.registerSingleTool(toolDef);
+        return prefixedName;
+    }
+    unregisterDynamicTool(prefixedName) {
+        return this.tools.delete(prefixedName);
+    }
+    listDynamicTools() {
+        return Array.from(this.tools.values());
+    }
+    getHandler(prefixedName) {
+        return this.tools.get(prefixedName);
+    }
+    clearAll() {
+        this.tools.clear();
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { MCPServerContext } from '../MCPServer.context.js';
+export interface BridgeCallRequest {
+    id: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export declare class MCPBridge {
+    private readonly ctx;
+    private allowlist;
+    private readonly pendingCalls;
+    constructor(ctx: MCPServerContext);
+    setAllowlist(toolNames: string[] | null): void;
+    enqueue(toolName: string, args?: Record<string, unknown>): string;
+    drainPending(): BridgeCallRequest[];
+    hasPending(): boolean;
+    call(toolName: string, args?: Record<string, unknown>): Promise<unknown>;
+    listAvailableTools(): string[];
+}

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

@@ -0,0 +1,65 @@
+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`);
+        }
+        const available = this.listAvailableTools();
+        if (!available.includes(toolName)) {
+            throw new Error(`Tool "${toolName}" is not a registered MCP tool`);
+        }
+        const response = await this.ctx.executeToolWithTracking(toolName, args);
+        if (response.content && Array.isArray(response.content)) {
+            const textParts = [];
+            for (const item of response.content) {
+                if (item.type === 'text') {
+                    textParts.push(item.text);
+                }
+            }
+            const combined = textParts.join('\n');
+            try {
+                return JSON.parse(combined);
+            }
+            catch {
+                return combined;
+            }
+        }
+        return response;
+    }
+    listAvailableTools() {
+        const allTools = this.ctx.selectedTools.map((t) => t.name);
+        if (this.allowlist) {
+            return allTools.filter((n) => this.allowlist.has(n));
+        }
+        return allTools;
+    }
+}

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

@@ -0,0 +1,14 @@
+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;
+}