@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/workflow/manifest.js

@@ -1,66 +0,0 @@
-import { bindByDepKey, ensureBrowserCore, toolLookup } from '../../domains/shared/registry.js';
-import { workflowToolDefinitions } from '../../domains/workflow/definitions.js';
-import { WorkflowHandlers } from '../../domains/workflow/index.js';
-const DOMAIN = 'workflow';
-const DEP_KEY = 'workflowHandlers';
-const t = toolLookup(workflowToolDefinitions);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    ensureBrowserCore(ctx);
-    const browserHandlers = ctx.handlerDeps.browserHandlers;
-    const advancedHandlers = ctx.handlerDeps.advancedHandlers;
-    if (!ctx.workflowHandlers) {
-        ctx.workflowHandlers = new WorkflowHandlers({
-            browserHandlers: browserHandlers,
-            advancedHandlers: advancedHandlers,
-            serverContext: ctx,
-        });
-    }
-    return ctx.workflowHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    workflowRule: {
-        patterns: [/(workflow|extension|run)/i, /(工作流|扩展|运行)/i],
-        priority: 95,
-        tools: ['run_extension_workflow', 'list_extension_workflows'],
-        hint: 'Extension workflow: list available workflows -> run the best matching workflow',
-    },
-    registrations: [
-        {
-            tool: t('web_api_capture_session'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleWebApiCaptureSession(a)),
-        },
-        {
-            tool: t('register_account_flow'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleRegisterAccountFlow(a)),
-        },
-        {
-            tool: t('page_script_register'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageScriptRegister(a)),
-        },
-        { tool: t('page_script_run'), domain: DOMAIN, bind: b((h, a) => h.handlePageScriptRun(a)) },
-        { tool: t('api_probe_batch'), domain: DOMAIN, bind: b((h, a) => h.handleApiProbeBatch(a)) },
-        { tool: t('js_bundle_search'), domain: DOMAIN, bind: b((h, a) => h.handleJsBundleSearch(a)) },
-        { tool: t('batch_register'), domain: DOMAIN, bind: b((h, a) => h.handleBatchRegister(a)) },
-        {
-            tool: t('list_extension_workflows'),
-            domain: DOMAIN,
-            bind: b((h) => h.handleListExtensionWorkflows()),
-        },
-        {
-            tool: t('run_extension_workflow'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleRunExtensionWorkflow(a)),
-        },
-    ],
-};
-export default manifest;

package/dist/src/server/evidence/ReverseEvidenceGraph.d.ts

@@ -1,20 +0,0 @@
-import type { EvidenceNode, EvidenceNodeType, EvidenceEdge, EvidenceEdgeType, EvidenceGraphSnapshot } from './types.js';
-export declare function _resetIdCounter(): void;
-export declare class ReverseEvidenceGraph {
-    private readonly nodes;
-    private readonly edges;
-    addNode(type: EvidenceNodeType, label: string, metadata?: Record<string, unknown>): EvidenceNode;
-    addEdge(sourceId: string, targetId: string, type: EvidenceEdgeType, metadata?: Record<string, unknown>): EvidenceEdge;
-    getNode(id: string): EvidenceNode | undefined;
-    removeNode(id: string): boolean;
-    getEdgesFrom(nodeId: string): EvidenceEdge[];
-    getEdgesTo(nodeId: string): EvidenceEdge[];
-    get nodeCount(): number;
-    get edgeCount(): number;
-    getEvidenceChain(nodeId: string, direction?: 'forward' | 'backward'): EvidenceNode[];
-    queryByUrl(url: string): EvidenceNode[];
-    queryByFunction(name: string): EvidenceNode[];
-    queryByScriptId(scriptId: string): EvidenceNode[];
-    exportJson(): EvidenceGraphSnapshot;
-    exportMarkdown(): string;
-}

package/dist/src/server/evidence/ReverseEvidenceGraph.js

@@ -1,208 +0,0 @@
-let nextId = 1;
-function generateId(prefix) {
-    return `${prefix}-${nextId++}`;
-}
-export function _resetIdCounter() {
-    nextId = 1;
-}
-export class ReverseEvidenceGraph {
-    nodes = new Map();
-    edges = new Map();
-    addNode(type, label, metadata = {}) {
-        const node = {
-            id: generateId(type),
-            type,
-            label,
-            metadata,
-            createdAt: Date.now(),
-        };
-        this.nodes.set(node.id, node);
-        return node;
-    }
-    addEdge(sourceId, targetId, type, metadata) {
-        if (!this.nodes.has(sourceId))
-            throw new Error(`Source node "${sourceId}" not found`);
-        if (!this.nodes.has(targetId))
-            throw new Error(`Target node "${targetId}" not found`);
-        const edge = {
-            id: generateId('edge'),
-            source: sourceId,
-            target: targetId,
-            type,
-            metadata,
-        };
-        this.edges.set(edge.id, edge);
-        return edge;
-    }
-    getNode(id) {
-        return this.nodes.get(id);
-    }
-    removeNode(id) {
-        if (!this.nodes.has(id))
-            return false;
-        this.nodes.delete(id);
-        for (const [edgeId, edge] of this.edges) {
-            if (edge.source === id || edge.target === id) {
-                this.edges.delete(edgeId);
-            }
-        }
-        return true;
-    }
-    getEdgesFrom(nodeId) {
-        return [...this.edges.values()].filter((e) => e.source === nodeId);
-    }
-    getEdgesTo(nodeId) {
-        return [...this.edges.values()].filter((e) => e.target === nodeId);
-    }
-    get nodeCount() {
-        return this.nodes.size;
-    }
-    get edgeCount() {
-        return this.edges.size;
-    }
-    getEvidenceChain(nodeId, direction = 'forward') {
-        const start = this.nodes.get(nodeId);
-        if (!start)
-            return [];
-        const visited = new Set();
-        const queue = [nodeId];
-        const result = [];
-        while (queue.length > 0) {
-            const current = queue.shift();
-            if (visited.has(current))
-                continue;
-            visited.add(current);
-            const node = this.nodes.get(current);
-            if (node)
-                result.push(node);
-            const connectedEdges = direction === 'forward' ? this.getEdgesFrom(current) : this.getEdgesTo(current);
-            for (const edge of connectedEdges) {
-                const nextNodeId = direction === 'forward' ? edge.target : edge.source;
-                if (!visited.has(nextNodeId)) {
-                    queue.push(nextNodeId);
-                }
-            }
-        }
-        return result;
-    }
-    queryByUrl(url) {
-        const matchingNodes = [...this.nodes.values()].filter((n) => {
-            if (n.type === 'request' && typeof n.metadata.url === 'string') {
-                return n.metadata.url.includes(url);
-            }
-            if (typeof n.metadata.url === 'string') {
-                return n.metadata.url.includes(url);
-            }
-            return false;
-        });
-        const allNodes = new Set();
-        for (const node of matchingNodes) {
-            for (const n of this.getEvidenceChain(node.id, 'forward')) {
-                allNodes.add(n.id);
-            }
-            for (const n of this.getEvidenceChain(node.id, 'backward')) {
-                allNodes.add(n.id);
-            }
-        }
-        return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
-    }
-    queryByFunction(name) {
-        const matchingNodes = [...this.nodes.values()].filter((n) => {
-            if (n.type === 'function' && typeof n.metadata.functionName === 'string') {
-                return n.metadata.functionName.includes(name);
-            }
-            if (n.label.includes(name) && (n.type === 'function' || n.type === 'breakpoint-hook')) {
-                return true;
-            }
-            return false;
-        });
-        const allNodes = new Set();
-        for (const node of matchingNodes) {
-            for (const n of this.getEvidenceChain(node.id, 'forward')) {
-                allNodes.add(n.id);
-            }
-            for (const n of this.getEvidenceChain(node.id, 'backward')) {
-                allNodes.add(n.id);
-            }
-        }
-        return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
-    }
-    queryByScriptId(scriptId) {
-        const matchingNodes = [...this.nodes.values()].filter((n) => {
-            if (n.type === 'script' && n.metadata.scriptId === scriptId)
-                return true;
-            return false;
-        });
-        const allNodes = new Set();
-        for (const node of matchingNodes) {
-            for (const n of this.getEvidenceChain(node.id, 'forward')) {
-                allNodes.add(n.id);
-            }
-            for (const n of this.getEvidenceChain(node.id, 'backward')) {
-                allNodes.add(n.id);
-            }
-        }
-        return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
-    }
-    exportJson() {
-        return {
-            version: 1,
-            nodes: [...this.nodes.values()],
-            edges: [...this.edges.values()],
-            exportedAt: new Date().toISOString(),
-        };
-    }
-    exportMarkdown() {
-        const lines = [];
-        lines.push('# Reverse Evidence Graph Report');
-        lines.push('');
-        lines.push(`**Exported:** ${new Date().toISOString()}`);
-        lines.push(`**Nodes:** ${this.nodes.size} | **Edges:** ${this.edges.size}`);
-        lines.push('');
-        const byType = new Map();
-        for (const node of this.nodes.values()) {
-            const list = byType.get(node.type) ?? [];
-            list.push(node);
-            byType.set(node.type, list);
-        }
-        const typeOrder = [
-            'request',
-            'initiator-stack',
-            'script',
-            'function',
-            'breakpoint-hook',
-            'captured-data',
-            'replay-artifact',
-        ];
-        for (const type of typeOrder) {
-            const nodes = byType.get(type);
-            if (!nodes || nodes.length === 0)
-                continue;
-            lines.push(`## ${type} (${nodes.length})`);
-            lines.push('');
-            for (const node of nodes) {
-                lines.push(`### ${node.label}`);
-                lines.push(`- **ID:** \`${node.id}\``);
-                lines.push(`- **Created:** ${new Date(node.createdAt).toISOString()}`);
-                const metaKeys = Object.keys(node.metadata);
-                if (metaKeys.length > 0) {
-                    for (const key of metaKeys) {
-                        const val = node.metadata[key];
-                        const display = typeof val === 'string' ? val : JSON.stringify(val);
-                        lines.push(`- **${key}:** ${display}`);
-                    }
-                }
-                const outEdges = this.getEdgesFrom(node.id);
-                const inEdges = this.getEdgesTo(node.id);
-                if (outEdges.length > 0) {
-                    lines.push(`- **→ Out:** ${outEdges.map((e) => `${e.type} → \`${e.target}\``).join(', ')}`);
-                }
-                if (inEdges.length > 0) {
-                    lines.push(`- **← In:** ${inEdges.map((e) => `\`${e.source}\` ${e.type} →`).join(', ')}`);
-                }
-                lines.push('');
-            }
-        }
-        return lines.join('\n');
-    }
-}

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

@@ -1,2 +0,0 @@
-export { ReverseEvidenceGraph, _resetIdCounter } from './ReverseEvidenceGraph.js';
-export type { EvidenceNode, EvidenceNodeType, EvidenceEdge, EvidenceEdgeType, EvidenceGraphSnapshot, } from './types.js';

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

@@ -1 +0,0 @@
-export { ReverseEvidenceGraph, _resetIdCounter } from './ReverseEvidenceGraph.js';

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

@@ -1,22 +0,0 @@
-export type EvidenceNodeType = 'request' | 'initiator-stack' | 'script' | 'function' | 'breakpoint-hook' | 'captured-data' | 'replay-artifact';
-export type EvidenceEdgeType = 'initiates' | 'contains' | 'triggers' | 'captures' | 'replays' | 'loads' | 'references';
-export interface EvidenceNode {
-    readonly id: string;
-    readonly type: EvidenceNodeType;
-    label: string;
-    metadata: Record<string, unknown>;
-    readonly createdAt: number;
-}
-export interface EvidenceEdge {
-    readonly id: string;
-    readonly source: string;
-    readonly target: string;
-    readonly type: EvidenceEdgeType;
-    metadata?: Record<string, unknown>;
-}
-export interface EvidenceGraphSnapshot {
-    version: 1;
-    nodes: EvidenceNode[];
-    edges: EvidenceEdge[];
-    exportedAt: string;
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/src/server/extensions/ExtensionManager.d.ts

@@ -1,5 +0,0 @@
-import type { MCPServerContext } from '../MCPServer.context.js';
-import type { ExtensionListResult, ExtensionReloadResult } from '../extensions/types.js';
-export declare function listExtensions(ctx: MCPServerContext): ExtensionListResult;
-export declare function reloadExtensions(ctx: MCPServerContext): Promise<ExtensionReloadResult>;
-export declare function ensureWorkflowsLoaded(ctx: MCPServerContext): Promise<void>;

package/dist/src/server/extensions/ExtensionManager.discovery.d.ts

@@ -1,2 +0,0 @@
-export declare function discoverPluginFiles(pluginRoots: string[]): Promise<string[]>;
-export declare function discoverWorkflowFiles(workflowRoots: string[]): Promise<string[]>;

package/dist/src/server/extensions/ExtensionManager.discovery.js

@@ -1,172 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { basename, dirname, relative, resolve } from 'node:path';
-import { glob } from 'tinyglobby';
-import { INSTALLED_EXTENSION_METADATA_FILENAME, } from '../extensions/types.js';
-async function collectMatchingFiles(roots, matcher) {
-    const files = new Set();
-    for (const root of roots) {
-        let matchedPaths;
-        try {
-            matchedPaths = await glob('**/*', {
-                cwd: root,
-                absolute: true,
-                onlyFiles: true,
-                ignore: ['**/node_modules/**', '**/.git/**', '**/.pnpm/**'],
-            });
-        }
-        catch {
-            continue;
-        }
-        for (const file of matchedPaths) {
-            if (matcher(basename(file))) {
-                files.add(file);
-            }
-        }
-    }
-    return [...files].toSorted((a, b) => a.localeCompare(b));
-}
-function normalizeExtensionCandidateKey(root, file) {
-    const normalizedRoot = root
-        .replace(/\\/g, '/')
-        .replace(/\/+/g, '/')
-        .replace(/^\/+|\/+$/g, '')
-        .toLowerCase();
-    const relDir = relative(root, dirname(file))
-        .replace(/^[/\\]+/, '')
-        .replace(/\\/g, '/')
-        .replace(/\/+/g, '/')
-        .replace(/^\/+|\/+$/g, '')
-        .toLowerCase();
-    if (!relDir || relDir === 'dist') {
-        return `${normalizedRoot}::`;
-    }
-    const normalizedRelDir = relDir.endsWith('/dist') ? relDir.slice(0, -'/dist'.length) : relDir;
-    return `${normalizedRoot}::${normalizedRelDir}`;
-}
-function extensionRank(candidate) {
-    if (candidate.isJs)
-        return 0;
-    if (candidate.isTs)
-        return 1;
-    return 2;
-}
-function isInstalledExtensionMetadata(value, kind) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const record = value;
-    if (record.version !== 1 || record.kind !== kind)
-        return false;
-    if (typeof record.slug !== 'string' || typeof record.id !== 'string')
-        return false;
-    if (!record.source || typeof record.source !== 'object')
-        return false;
-    const source = record.source;
-    return (typeof source.type === 'string' &&
-        typeof source.repo === 'string' &&
-        typeof source.ref === 'string' &&
-        typeof source.commit === 'string' &&
-        typeof source.subpath === 'string' &&
-        typeof source.entry === 'string');
-}
-async function collectInstalledEntryCandidates(roots, kind) {
-    const candidates = [];
-    for (const [rootIndex, root] of roots.entries()) {
-        const metadataFiles = await collectMatchingFiles([root], (filename) => filename === INSTALLED_EXTENSION_METADATA_FILENAME);
-        for (const metadataFile of metadataFiles) {
-            let metadataRaw;
-            try {
-                metadataRaw = JSON.parse(await readFile(metadataFile, 'utf8'));
-            }
-            catch {
-                continue;
-            }
-            if (!isInstalledExtensionMetadata(metadataRaw, kind)) {
-                continue;
-            }
-            const entryPath = metadataRaw.source.entry.trim();
-            if (!entryPath) {
-                continue;
-            }
-            const file = resolve(dirname(metadataFile), entryPath);
-            if (!existsSync(file)) {
-                continue;
-            }
-            candidates.push({
-                file,
-                key: normalizeExtensionCandidateKey(root, file),
-                isJs: file.endsWith('.js'),
-                isTs: file.endsWith('.ts'),
-                rootIndex,
-                priority: 0,
-            });
-        }
-    }
-    return candidates;
-}
-function deduplicateCandidates(candidates) {
-    const byKey = new Map();
-    for (const candidate of candidates.toSorted((a, b) => a.file.localeCompare(b.file))) {
-        const existing = byKey.get(candidate.key);
-        if (!existing) {
-            byKey.set(candidate.key, candidate);
-            continue;
-        }
-        const existingRoot = existing.rootIndex;
-        const candidateRoot = candidate.rootIndex;
-        const existingPriority = existing.priority;
-        const candidatePriority = candidate.priority;
-        const existingExtRank = extensionRank(existing);
-        const candidateExtRank = extensionRank(candidate);
-        const shouldReplace = candidateRoot < existingRoot ||
-            (candidateRoot === existingRoot && candidatePriority < existingPriority) ||
-            (candidateRoot === existingRoot &&
-                candidatePriority === existingPriority &&
-                candidateExtRank < existingExtRank) ||
-            (candidateRoot === existingRoot &&
-                candidatePriority === existingPriority &&
-                candidateExtRank === existingExtRank &&
-                candidate.file.localeCompare(existing.file) < 0);
-        if (shouldReplace) {
-            byKey.set(candidate.key, candidate);
-        }
-    }
-    return [...byKey.values()].map((item) => item.file).toSorted((a, b) => a.localeCompare(b));
-}
-export async function discoverPluginFiles(pluginRoots) {
-    const candidates = await collectInstalledEntryCandidates(pluginRoots, 'plugin');
-    for (const [rootIndex, root] of pluginRoots.entries()) {
-        const files = await collectMatchingFiles([root], (filename) => filename === 'manifest.js' || filename === 'manifest.ts');
-        for (const file of files) {
-            candidates.push({
-                file,
-                key: normalizeExtensionCandidateKey(root, file),
-                isJs: file.endsWith('.js'),
-                isTs: file.endsWith('.ts'),
-                rootIndex,
-                priority: 1,
-            });
-        }
-    }
-    return deduplicateCandidates(candidates);
-}
-export async function discoverWorkflowFiles(workflowRoots) {
-    const candidates = await collectInstalledEntryCandidates(workflowRoots, 'workflow');
-    for (const [rootIndex, root] of workflowRoots.entries()) {
-        const files = await collectMatchingFiles([root], (filename) => filename.endsWith('.workflow.js') ||
-            filename.endsWith('.workflow.ts') ||
-            filename === 'workflow.js' ||
-            filename === 'workflow.ts');
-        for (const file of files) {
-            candidates.push({
-                file,
-                key: normalizeExtensionCandidateKey(root, file),
-                isJs: file.endsWith('.js'),
-                isTs: file.endsWith('.ts'),
-                rootIndex,
-                priority: 1,
-            });
-        }
-    }
-    return deduplicateCandidates(candidates);
-}

package/dist/src/server/extensions/ExtensionManager.guards.d.ts

@@ -1,4 +0,0 @@
-import type { ExtensionBuilder } from '../plugins/PluginContract.js';
-import type { WorkflowContract } from '../workflows/WorkflowContract.js';
-export declare function isExtensionBuilder(value: unknown): value is ExtensionBuilder;
-export declare function isWorkflowContract(value: unknown): value is WorkflowContract;

package/dist/src/server/extensions/ExtensionManager.guards.js

@@ -1,18 +0,0 @@
-export function isExtensionBuilder(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return !!(typeof candidate.id === 'string' &&
-        typeof candidate.version === 'string' &&
-        Array.isArray(candidate.tools));
-}
-export function isWorkflowContract(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return !!(candidate.kind === 'workflow-contract' &&
-        candidate.version === 1 &&
-        typeof candidate.id === 'string' &&
-        typeof candidate.displayName === 'string' &&
-        typeof candidate.build === 'function');
-}

package/dist/src/server/extensions/ExtensionManager.integrity.d.ts

@@ -1,11 +0,0 @@
-import type { ExtensionBuilder } from '../plugins/PluginContract.js';
-export declare function sha256Hex(filePath: string): Promise<string>;
-export declare function normalizeHex(value: string): string;
-export declare function isPluginSignatureRequired(): boolean;
-export declare function isPluginStrictLoad(): boolean;
-export declare function parseDigestAllowlist(raw: string | undefined): Set<string>;
-export declare function verifyPluginIntegrity(plugin: ExtensionBuilder, currentVersion: string): Promise<{
-    ok: boolean;
-    errors: string[];
-    warnings: string[];
-}>;

package/dist/src/server/extensions/ExtensionManager.integrity.js

@@ -1,48 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { isCompatibleVersion } from './ExtensionManager.version.js';
-export async function sha256Hex(filePath) {
-    const content = await readFile(filePath);
-    return createHash('sha256').update(content).digest('hex');
-}
-export function normalizeHex(value) {
-    return value.trim().toLowerCase().replace(/^0x/, '');
-}
-function isTruthyEnv(value) {
-    return ['1', 'true'].includes(value.toLowerCase());
-}
-export function isPluginSignatureRequired() {
-    const raw = process.env.MCP_PLUGIN_SIGNATURE_REQUIRED;
-    if (raw === undefined || raw.trim() === '') {
-        return process.env.NODE_ENV === 'production';
-    }
-    return isTruthyEnv(raw);
-}
-export function isPluginStrictLoad() {
-    const raw = process.env.MCP_PLUGIN_STRICT_LOAD;
-    if (raw === undefined || raw.trim() === '') {
-        return isPluginSignatureRequired();
-    }
-    return isTruthyEnv(raw) || isPluginSignatureRequired();
-}
-export function parseDigestAllowlist(raw) {
-    const value = raw?.trim();
-    if (!value)
-        return new Set();
-    return new Set(value
-        .split(',')
-        .map((item) => normalizeHex(item))
-        .filter((item) => item.length > 0));
-}
-export async function verifyPluginIntegrity(plugin, currentVersion) {
-    const errors = [];
-    const warnings = [];
-    if (!isCompatibleVersion(plugin.compatibleCoreRange, currentVersion)) {
-        errors.push(`Plugin ${plugin.id} incompatible with core ${currentVersion}; requires ${plugin.compatibleCoreRange}`);
-    }
-    return {
-        ok: errors.length === 0,
-        errors,
-        warnings,
-    };
-}