@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/server/extensions/plugin-config.js

@@ -1,41 +0,0 @@
-function normalizeSegment(value) {
-    return value.trim().replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toUpperCase();
-}
-function envCandidates(pluginId, key) {
-    const pluginSegment = normalizeSegment(pluginId);
-    const keySegment = normalizeSegment(key);
-    return [
-        `PLUGIN_${pluginSegment}_${keySegment}`,
-        `PLUGINS_${pluginSegment}_${keySegment}`,
-    ];
-}
-function parseBoolean(raw) {
-    if (raw == null)
-        return undefined;
-    const value = raw.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(value))
-        return true;
-    if (['0', 'false', 'no', 'off'].includes(value))
-        return false;
-    return undefined;
-}
-export function getPluginBooleanConfig(ctx, pluginId, key, fallback) {
-    for (const candidate of envCandidates(pluginId, key)) {
-        const parsed = parseBoolean(process.env[candidate]);
-        if (parsed !== undefined)
-            return parsed;
-    }
-    return ctx.getConfig(`plugins.${pluginId}.${key}`, fallback);
-}
-const VALID_BOOST_TIERS = new Set(['search', 'minimal', 'workflow', 'full']);
-export function getPluginBoostTier(pluginId) {
-    for (const candidate of envCandidates(pluginId, 'BOOST_DOMAIN')) {
-        const raw = process.env[candidate]?.trim().toLowerCase();
-        if (raw && VALID_BOOST_TIERS.has(raw))
-            return raw;
-    }
-    const globalDefault = process.env.MCP_DEFAULT_PLUGIN_BOOST_TIER?.trim().toLowerCase();
-    if (globalDefault && VALID_BOOST_TIERS.has(globalDefault))
-        return globalDefault;
-    return 'full';
-}

package/dist/server/extensions/types.d.ts

@@ -1,61 +0,0 @@
-import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { PluginContract, PluginLifecycleContext, PluginState } from '../plugins/PluginContract.js';
-import type { WorkflowContract } from '../workflows/WorkflowContract.js';
-export interface ExtensionToolRecord {
-    name: string;
-    domain: string;
-    source: string;
-    tool: Tool;
-    registeredTool?: RegisteredTool;
-    boostTier?: string;
-    handler?: Function;
-}
-export interface ExtensionPluginRecord {
-    id: string;
-    name: string;
-    source: string;
-    domains: string[];
-    workflows: string[];
-    tools: string[];
-}
-export interface ExtensionPluginRuntimeRecord {
-    plugin: PluginContract;
-    lifecycleContext: PluginLifecycleContext;
-    state: PluginState;
-    source: string;
-}
-export interface ExtensionWorkflowRuntimeRecord {
-    workflow: WorkflowContract;
-    source: string;
-}
-export interface ExtensionWorkflowRecord {
-    id: string;
-    displayName: string;
-    source: string;
-    description?: string;
-    tags?: string[];
-    timeoutMs?: number;
-    defaultMaxConcurrency?: number;
-}
-export interface ExtensionListResult {
-    pluginRoots: string[];
-    workflowRoots: string[];
-    pluginCount: number;
-    workflowCount: number;
-    toolCount: number;
-    lastReloadAt?: string;
-    plugins: ExtensionPluginRecord[];
-    workflows: ExtensionWorkflowRecord[];
-    tools: Array<{
-        name: string;
-        domain: string;
-        source: string;
-    }>;
-}
-export interface ExtensionReloadResult extends ExtensionListResult {
-    addedTools: number;
-    removedTools: number;
-    errors: string[];
-    warnings: string[];
-}

package/dist/server/observability/InstrumentationContract.d.ts

@@ -1,37 +0,0 @@
-export type MetricType = 'counter' | 'gauge' | 'histogram';
-export interface SpanLike {
-    readonly name: string;
-    readonly startTime: number;
-    end(attrs?: Record<string, unknown>): void;
-    addEvent(name: string, attrs?: Record<string, unknown>): void;
-}
-export interface InstrumentationContract {
-    startSpan(name: string, attrs?: Record<string, unknown>): SpanLike;
-    emitMetric(name: string, value: number, type: MetricType, attrs?: Record<string, unknown>): void;
-    flush?(): Promise<void>;
-}
-export declare const SpanNames: {
-    readonly toolExecute: "tool.execute";
-    readonly toolValidateInput: "tool.validate_input";
-    readonly registryDiscovery: "registry.discovery";
-    readonly pluginLifecycle: "plugin.lifecycle";
-    readonly workflowRun: "workflow.run";
-    readonly workflowStep: "workflow.step";
-    readonly bridgeRequest: "bridge.request";
-    readonly captchaSolve: "captcha.solve";
-};
-export declare const MetricNames: {
-    readonly toolCallsTotal: "tool_calls_total";
-    readonly toolErrorsTotal: "tool_errors_total";
-    readonly toolDurationMs: "tool_duration_ms";
-    readonly workflowRunsTotal: "workflow_runs_total";
-    readonly workflowErrorsTotal: "workflow_errors_total";
-    readonly workflowDurationMs: "workflow_duration_ms";
-    readonly bridgeRequestsTotal: "bridge_requests_total";
-    readonly bridgeDurationMs: "bridge_duration_ms";
-    readonly pluginActiveTotal: "plugin_active_total";
-};
-export declare class NoopInstrumentation implements InstrumentationContract {
-    startSpan(name: string): SpanLike;
-    emitMetric(): void;
-}

package/dist/server/observability/InstrumentationContract.js

@@ -1,34 +0,0 @@
-export const SpanNames = {
-    toolExecute: 'tool.execute',
-    toolValidateInput: 'tool.validate_input',
-    registryDiscovery: 'registry.discovery',
-    pluginLifecycle: 'plugin.lifecycle',
-    workflowRun: 'workflow.run',
-    workflowStep: 'workflow.step',
-    bridgeRequest: 'bridge.request',
-    captchaSolve: 'captcha.solve',
-};
-export const MetricNames = {
-    toolCallsTotal: 'tool_calls_total',
-    toolErrorsTotal: 'tool_errors_total',
-    toolDurationMs: 'tool_duration_ms',
-    workflowRunsTotal: 'workflow_runs_total',
-    workflowErrorsTotal: 'workflow_errors_total',
-    workflowDurationMs: 'workflow_duration_ms',
-    bridgeRequestsTotal: 'bridge_requests_total',
-    bridgeDurationMs: 'bridge_duration_ms',
-    pluginActiveTotal: 'plugin_active_total',
-};
-export class NoopInstrumentation {
-    startSpan(name) {
-        const startTime = Date.now();
-        return {
-            name,
-            startTime,
-            end() { },
-            addEvent() { },
-        };
-    }
-    emitMetric() {
-    }
-}

package/dist/server/plugin-api.d.ts

@@ -1,5 +0,0 @@
-export type { DomainManifest, ToolHandlerDeps } from './registry/contracts.js';
-export type { PluginContract, PluginLifecycleContext } from './plugins/PluginContract.js';
-export type { ToolArgs } from './types.js';
-export { getPluginBooleanConfig, getPluginBoostTier } from './extensions/plugin-config.js';
-export { loadPluginEnv } from './extensions/plugin-env.js';

package/dist/server/plugins/PluginContract.d.ts

@@ -1,76 +0,0 @@
-import type { DomainManifest, ToolProfileId } from '../registry/contracts.js';
-import type { WorkflowContract } from '../workflows/WorkflowContract.js';
-import type { ToolArgs, ToolResponse } from '../types.js';
-export type PluginState = 'loaded' | 'validated' | 'registered' | 'activated' | 'deactivated' | 'unloaded';
-export declare const PluginLifecycleOrder: PluginState[];
-export interface PluginPermission {
-    network?: {
-        allowHosts: string[];
-    };
-    process?: {
-        allowCommands: string[];
-    };
-    filesystem?: {
-        readRoots: string[];
-        writeRoots: string[];
-    };
-    toolExecution?: {
-        allowTools: string[];
-    };
-}
-export interface PluginActivationPolicy {
-    profiles?: ToolProfileId[];
-    envFlags?: string[];
-    onStartup?: boolean;
-}
-export interface PluginContributes {
-    domains?: DomainManifest[];
-    workflows?: WorkflowContract[];
-    configDefaults?: Record<string, unknown>;
-    metrics?: string[];
-}
-export interface PluginManifest {
-    readonly kind: 'plugin-manifest';
-    readonly version: 1;
-    readonly id: string;
-    readonly name: string;
-    readonly pluginVersion: string;
-    readonly entry: string;
-    readonly description?: string;
-    readonly compatibleCore: string;
-    readonly permissions: PluginPermission;
-    readonly activation?: PluginActivationPolicy;
-    readonly contributes?: PluginContributes;
-    readonly checksum?: string;
-    readonly signature?: string;
-}
-export interface PluginValidationResult {
-    valid: boolean;
-    errors: string[];
-    warnings?: string[];
-}
-export declare function defaultValidationResult(): PluginValidationResult;
-export interface PluginLifecycleContext {
-    readonly pluginId: string;
-    readonly pluginRoot: string;
-    readonly config: Record<string, unknown>;
-    readonly state: PluginState;
-    registerDomain(manifest: DomainManifest): void;
-    registerWorkflow(workflow: WorkflowContract): void;
-    registerMetric(metricName: string): void;
-    invokeTool(name: string, args?: ToolArgs): Promise<ToolResponse>;
-    hasPermission(capability: keyof PluginPermission): boolean;
-    getConfig<T = unknown>(path: string, fallback?: T): T;
-    setRuntimeData(key: string, value: unknown): void;
-    getRuntimeData<T = unknown>(key: string): T | undefined;
-}
-export interface PluginContract {
-    readonly manifest: PluginManifest;
-    onLoad(ctx: PluginLifecycleContext): Promise<void> | void;
-    onValidate?(ctx: PluginLifecycleContext): Promise<PluginValidationResult> | PluginValidationResult;
-    onRegister?(ctx: PluginLifecycleContext): Promise<void> | void;
-    onActivate?(ctx: PluginLifecycleContext): Promise<void> | void;
-    onDeactivate?(ctx: PluginLifecycleContext): Promise<void> | void;
-    onUnload?(ctx: PluginLifecycleContext): Promise<void> | void;
-}
-export declare function isValidLifecycleTransition(from: PluginState, to: PluginState): boolean;

package/dist/server/plugins/PluginContract.js

@@ -1,16 +0,0 @@
-export const PluginLifecycleOrder = [
-    'loaded',
-    'validated',
-    'registered',
-    'activated',
-    'deactivated',
-    'unloaded',
-];
-export function defaultValidationResult() {
-    return { valid: true, errors: [] };
-}
-export function isValidLifecycleTransition(from, to) {
-    const idxFrom = PluginLifecycleOrder.indexOf(from);
-    const idxTo = PluginLifecycleOrder.indexOf(to);
-    return idxTo === idxFrom + 1 || (from === 'activated' && to === 'deactivated');
-}

package/dist/server/plugins/examples/minimal-plugin/manifest.d.ts

@@ -1,3 +0,0 @@
-import type { PluginContract } from '../../../plugins/PluginContract.js';
-declare const plugin: PluginContract;
-export default plugin;

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

@@ -1,102 +0,0 @@
-const helloTool = {
-    name: 'plugin_hello',
-    description: 'Minimal example plugin tool. Returns a greeting message.\n\n' +
-        'This tool demonstrates the plugin system — it is contributed by the ' +
-        '"example.minimal-hello" plugin and only available when that plugin is activated.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'Name to greet (default: "world")',
-            },
-        },
-    },
-};
-function bindHello(depKey) {
-    return (deps) => async (args) => {
-        const handlers = deps[depKey];
-        return handlers.handleHello(args);
-    };
-}
-const exampleDomain = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: 'example-hello',
-    depKey: 'exampleHelloHandlers',
-    profiles: ['workflow', 'full'],
-    ensure() {
-        return {
-            async handleHello(args) {
-                const name = args.name || 'world';
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Hello, ${name}! This response comes from the minimal example plugin.`,
-                                timestamp: new Date().toISOString(),
-                            }),
-                        },
-                    ],
-                };
-            },
-        };
-    },
-    registrations: [
-        {
-            tool: helloTool,
-            domain: 'example-hello',
-            bind: bindHello('exampleHelloHandlers'),
-        },
-    ],
-};
-function validateConfig(ctx) {
-    const enabled = ctx.getConfig('plugins.example-hello.enabled', true);
-    if (!enabled) {
-        return { valid: false, errors: ['Plugin disabled by config'] };
-    }
-    return { valid: true, errors: [] };
-}
-const plugin = {
-    manifest: {
-        kind: 'plugin-manifest',
-        version: 1,
-        id: 'example.minimal-hello',
-        name: 'Minimal Hello Plugin',
-        pluginVersion: '0.1.0',
-        entry: 'manifest.ts',
-        description: 'A minimal example plugin that contributes a single greeting tool.',
-        compatibleCore: '>=0.1.0',
-        permissions: {
-            network: { allowHosts: [] },
-            process: { allowCommands: [] },
-            filesystem: { readRoots: [], writeRoots: [] },
-            toolExecution: { allowTools: ['plugin_hello'] },
-        },
-        activation: {
-            onStartup: false,
-            profiles: ['workflow', 'full'],
-        },
-        contributes: {
-            domains: [exampleDomain],
-            workflows: [],
-            configDefaults: {
-                'plugins.example-hello.enabled': true,
-            },
-            metrics: ['plugin_hello_calls_total'],
-        },
-    },
-    onLoad(ctx) {
-        ctx.setRuntimeData('loadedAt', new Date().toISOString());
-    },
-    onValidate(ctx) {
-        return validateConfig(ctx);
-    },
-    onRegister(ctx) {
-        ctx.registerDomain(exampleDomain);
-        ctx.registerMetric('plugin_hello_calls_total');
-    },
-};
-export default plugin;

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

@@ -1,21 +0,0 @@
-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' | 'minimal' | 'workflow' | 'full';
-export interface ToolHandlerDeps {
-    readonly [depKey: string]: unknown;
-}
-export interface ToolRegistration {
-    readonly tool: Tool;
-    readonly domain: string;
-    readonly bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
-}
-export interface DomainManifest<TDepKey extends string = string, THandler = unknown, TDomain extends string = string> {
-    readonly kind: 'domain-manifest';
-    readonly version: 1;
-    readonly domain: TDomain;
-    readonly depKey: TDepKey;
-    readonly profiles: readonly ToolProfileId[];
-    readonly registrations: readonly ToolRegistration[];
-    readonly ensure: (ctx: MCPServerContext) => THandler;
-}

package/dist/server/registry/index.js

@@ -1,147 +0,0 @@
-import { discoverDomainManifests } from '../registry/discovery.js';
-import { logger } from '../../utils/logger.js';
-let _manifests = null;
-let _registrations = null;
-let _initPromise = null;
-let _domainsView = null;
-let _toolNamesView = null;
-async function init() {
-    if (_manifests !== null)
-        return;
-    if (_initPromise) {
-        await _initPromise;
-        return;
-    }
-    _initPromise = (async () => {
-        const discovered = await discoverDomainManifests();
-        _manifests = discovered;
-        const uniqueByToolName = new Map();
-        for (const m of discovered) {
-            for (const r of m.registrations) {
-                const existing = uniqueByToolName.get(r.tool.name);
-                if (existing) {
-                    logger.warn(`[registry] Duplicate tool name "${r.tool.name}": domain "${r.domain}" conflicts with "${existing.domain}" — keeping first`);
-                }
-                else {
-                    uniqueByToolName.set(r.tool.name, r);
-                }
-            }
-        }
-        _registrations = [...uniqueByToolName.values()];
-        _domainsView = new Set(_manifests.map(m => m.domain));
-        _toolNamesView = new Set(_registrations.map(r => r.tool.name));
-    })();
-    await _initPromise;
-}
-export async function initRegistry() {
-    await init();
-}
-function getManifests() {
-    if (!_manifests)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _manifests;
-}
-function getRegistrations() {
-    if (!_registrations)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _registrations;
-}
-export function getAllManifests() {
-    return getManifests();
-}
-export function getAllRegistrations() {
-    return getRegistrations();
-}
-export function getAllDomains() {
-    if (!_domainsView)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _domainsView;
-}
-export function getAllToolNames() {
-    if (!_toolNamesView)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _toolNamesView;
-}
-export function buildToolGroups() {
-    const groups = {};
-    for (const r of getRegistrations()) {
-        (groups[r.domain] ??= []).push(r.tool);
-    }
-    return groups;
-}
-export function buildToolDomainMap() {
-    const map = new Map();
-    for (const r of getRegistrations()) {
-        if (!map.has(r.tool.name))
-            map.set(r.tool.name, r.domain);
-    }
-    return map;
-}
-export function buildAllTools() {
-    return getRegistrations().map(r => r.tool);
-}
-export function buildHandlerMapFromRegistry(deps, selectedToolNames) {
-    const regs = selectedToolNames
-        ? getRegistrations().filter(r => selectedToolNames.has(r.tool.name))
-        : [...getRegistrations()];
-    return Object.fromEntries(regs.map(r => [r.tool.name, r.bind(deps)]));
-}
-export function buildProfileDomains() {
-    const profiles = {
-        search: new Set(),
-        minimal: new Set(),
-        workflow: new Set(),
-        full: new Set(),
-    };
-    for (const m of getManifests()) {
-        for (const p of m.profiles) {
-            profiles[p]?.add(m.domain);
-        }
-    }
-    const result = {};
-    for (const [p, domains] of Object.entries(profiles)) {
-        result[p] = [...domains];
-    }
-    const isSubset = (a, b) => {
-        const bSet = new Set(b);
-        return a.every(x => bSet.has(x));
-    };
-    if (!isSubset(result['search'], result['minimal'])) {
-        logger.warn('[registry] Profile hierarchy: search not subset of minimal');
-    }
-    if (!isSubset(result['minimal'], result['workflow'])) {
-        logger.warn('[registry] Profile hierarchy: minimal not subset of workflow');
-    }
-    if (!isSubset(result['workflow'], result['full'])) {
-        logger.warn('[registry] Profile hierarchy: workflow not subset of full');
-    }
-    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/server/workflows/WorkflowContract.d.ts

@@ -1,66 +0,0 @@
-export interface RetryPolicy {
-    maxAttempts: number;
-    backoffMs: number;
-    multiplier?: number;
-}
-export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch';
-export interface ToolNode {
-    readonly kind: 'tool';
-    readonly id: string;
-    readonly toolName: string;
-    readonly input?: Record<string, unknown>;
-    readonly timeoutMs?: number;
-    readonly retry?: RetryPolicy;
-}
-export interface SequenceNode {
-    readonly kind: 'sequence';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-}
-export interface ParallelNode {
-    readonly kind: 'parallel';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-    readonly maxConcurrency?: number;
-    readonly failFast?: boolean;
-}
-export interface BranchNode {
-    readonly kind: 'branch';
-    readonly id: string;
-    readonly predicateId: string;
-    readonly predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>;
-    readonly whenTrue: WorkflowNode;
-    readonly whenFalse?: WorkflowNode;
-}
-export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
-export interface WorkflowExecutionContext {
-    readonly workflowRunId: string;
-    readonly profile: string;
-    invokeTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    emitSpan(name: string, attrs?: Record<string, unknown>): void;
-    emitMetric(name: string, value: number, type: 'counter' | 'gauge' | 'histogram', attrs?: Record<string, unknown>): void;
-    getConfig<T = unknown>(path: string, fallback?: T): T;
-}
-export interface WorkflowContract {
-    readonly kind: 'workflow-contract';
-    readonly version: 1;
-    readonly id: string;
-    readonly displayName: string;
-    readonly description?: string;
-    readonly tags?: string[];
-    readonly timeoutMs?: number;
-    readonly defaultMaxConcurrency?: number;
-    build(ctx: WorkflowExecutionContext): WorkflowNode;
-    onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
-    onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
-    onError?(ctx: WorkflowExecutionContext, error: Error): Promise<void> | void;
-}
-export interface ToolNodeOptions {
-    input?: Record<string, unknown>;
-    retry?: RetryPolicy;
-    timeoutMs?: number;
-}
-export declare function toolNode(id: string, toolName: string, options?: ToolNodeOptions): ToolNode;
-export declare function sequenceNode(id: string, steps: WorkflowNode[]): SequenceNode;
-export declare function parallelNode(id: string, steps: WorkflowNode[], maxConcurrency?: number, failFast?: boolean): ParallelNode;
-export declare function branchNode(id: string, predicateId: string, whenTrue: WorkflowNode, whenFalse?: WorkflowNode, predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>): BranchNode;

package/dist/server/workflows/WorkflowContract.js

@@ -1,12 +0,0 @@
-export function toolNode(id, toolName, options) {
-    return { kind: 'tool', id, toolName, input: options?.input, retry: options?.retry, timeoutMs: options?.timeoutMs };
-}
-export function sequenceNode(id, steps) {
-    return { kind: 'sequence', id, steps };
-}
-export function parallelNode(id, steps, maxConcurrency = 4, failFast = false) {
-    return { kind: 'parallel', id, steps, maxConcurrency, failFast };
-}
-export function branchNode(id, predicateId, whenTrue, whenFalse, predicateFn) {
-    return { kind: 'branch', id, predicateId, predicateFn, whenTrue, whenFalse };
-}