@jshookmcp/jshook 0.2.5 → 0.2.6

package/dist/src/server/workflows/WorkflowEngine.js

@@ -1,6 +1,47 @@
 import { randomUUID } from 'node:crypto';
 import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
 import { getRoutingState } from '../ToolRouter.probe.js';
+class WorkflowDataBus {
+    store = new Map();
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    getValueAtPath(key, path) {
+        const value = this.store.get(key);
+        if (!value || typeof value !== 'object') {
+            return value;
+        }
+        const payload = parseToolPayload(value);
+        const obj = payload || value;
+        return path.split('.').reduce((current, segment) => {
+            if (current && typeof current === 'object') {
+                const arrayMatch = segment.match(/^(\d+)$/);
+                if (arrayMatch && Array.isArray(current)) {
+                    return current[Number(arrayMatch[1])];
+                }
+                return current[segment];
+            }
+            return undefined;
+        }, obj);
+    }
+    resolve(template) {
+        const match = template.match(/^\$\{(.+)\}$/);
+        if (!match || !match[1]) {
+            return template;
+        }
+        const ref = match[1];
+        const dotIndex = ref.indexOf('.');
+        if (dotIndex === -1) {
+            return this.store.get(ref);
+        }
+        const stepId = ref.slice(0, dotIndex);
+        const fieldPath = ref.slice(dotIndex + 1);
+        return this.getValueAtPath(stepId, fieldPath);
+    }
+}
 class PreflightError extends Error {
     warnings;
     constructor(warnings) {
@@ -87,28 +128,48 @@ function collectSuccessStats(value) {
     }
     return { success: 0, failure: 0 };
 }
-function resolveInputFrom(mapping, stepResults) {
+function resolveInputFrom(mapping, dataBus) {
     const resolved = {};
     for (const [targetKey, sourceRef] of Object.entries(mapping)) {
-        const dotIndex = sourceRef.indexOf('.');
-        if (dotIndex === -1) {
-            resolved[targetKey] = stepResults.get(sourceRef);
-            continue;
-        }
-        const stepId = sourceRef.slice(0, dotIndex);
-        const fieldPath = sourceRef.slice(dotIndex + 1);
-        const stepResult = stepResults.get(stepId);
-        const payload = parseToolPayload(stepResult) ?? stepResult;
-        resolved[targetKey] = payload?.[fieldPath];
+        const template = sourceRef.startsWith('${') ? sourceRef : `\${${sourceRef}}`;
+        resolved[targetKey] = dataBus.resolve(template);
     }
     return resolved;
 }
+function resolveInputValues(input, dataBus) {
+    if (!input)
+        return {};
+    const resolved = {};
+    for (const [key, value] of Object.entries(input)) {
+        resolved[key] = resolveValue(value, dataBus);
+    }
+    return resolved;
+}
+function resolveValue(value, dataBus) {
+    if (typeof value === 'string') {
+        return dataBus.resolve(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveValue(item, dataBus));
+    }
+    if (value && typeof value === 'object') {
+        const resolved = {};
+        for (const [k, v] of Object.entries(value)) {
+            resolved[k] = resolveValue(v, dataBus);
+        }
+        return resolved;
+    }
+    return value;
+}
 async function runToolNode(ctx, node, overrides, executionContext) {
     const fromResolved = node.inputFrom
-        ? resolveInputFrom(node.inputFrom, executionContext.stepResults)
+        ? resolveInputFrom(node.inputFrom, executionContext.dataBus)
+        : {};
+    const fromInputValues = node.input
+        ? resolveInputValues(node.input, executionContext.dataBus)
         : {};
     const mergedInput = {
-        ...node.input,
+        ...fromInputValues,
         ...fromResolved,
         ...overrides?.[node.id],
     };
@@ -118,6 +179,7 @@ async function runToolNode(ctx, node, overrides, executionContext) {
         if (failure) {
             throw new Error(failure);
         }
+        executionContext.dataBus.set(node.id, response);
         return response;
     };
     const retry = node.retry;
@@ -175,6 +237,38 @@ async function runParallelNode(ctx, node, executionContext, options) {
     await Promise.all(Array.from({ length: Math.min(concurrency, node.steps.length) }, () => worker()));
     return results;
 }
+function getWorkflowVariable(stepResults, keyPath) {
+    if (stepResults.has(keyPath)) {
+        return stepResults.get(keyPath);
+    }
+    const segments = keyPath.split('.');
+    const stepId = segments[0];
+    const fieldSegments = segments.slice(1);
+    if (!stepId || !stepResults.has(stepId)) {
+        return undefined;
+    }
+    let current = stepResults.get(stepId);
+    if (current && typeof current === 'object') {
+        const payload = parseToolPayload(current);
+        if (payload) {
+            current = payload;
+        }
+    }
+    for (const segment of fieldSegments) {
+        if (current && typeof current === 'object') {
+            const arrayMatch = segment.match(/^(\d+)$/);
+            if (arrayMatch && Array.isArray(current)) {
+                current = current[Number(arrayMatch[1])];
+                continue;
+            }
+            current = current[segment];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
 async function evaluatePredicate(node, ctx) {
     if (node.predicateFn) {
         return await node.predicateFn(ctx);
@@ -200,8 +294,66 @@ async function evaluatePredicate(node, ctx) {
             return false;
         return aggregate.success / total >= threshold / 100;
     }
+    const equalsMatch = node.predicateId.match(/^variable_equals_(.+?)_(.+)$/);
+    if (equalsMatch && equalsMatch[1] && equalsMatch[2]) {
+        const keyPath = equalsMatch[1];
+        const expectedValue = equalsMatch[2];
+        const actualValue = getWorkflowVariable(ctx.stepResults, keyPath);
+        return deepEquals(actualValue, expectedValue);
+    }
+    const containsMatch = node.predicateId.match(/^variable_contains_(.+?)_(.+)$/);
+    if (containsMatch && containsMatch[1] && containsMatch[2]) {
+        const keyPath = containsMatch[1];
+        const substring = containsMatch[2];
+        const value = getWorkflowVariable(ctx.stepResults, keyPath);
+        if (typeof value !== 'string' && !Array.isArray(value)) {
+            return false;
+        }
+        return String(value).includes(substring);
+    }
+    const matchesMatch = node.predicateId.match(/^variable_matches_(.+?)_(.+)$/);
+    if (matchesMatch && matchesMatch[1] && matchesMatch[2]) {
+        const keyPath = matchesMatch[1];
+        const pattern = matchesMatch[2];
+        const value = getWorkflowVariable(ctx.stepResults, keyPath);
+        if (typeof value !== 'string') {
+            return false;
+        }
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(value);
+        }
+        catch {
+            return false;
+        }
+    }
     throw new Error(`Unknown workflow predicateId "${node.predicateId}"`);
 }
+function deepEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        if (Array.isArray(a) !== Array.isArray(b)) {
+            return false;
+        }
+        if (Array.isArray(a)) {
+            const arrA = a;
+            const arrB = b;
+            return arrA.length === arrB.length && arrA.every((v, i) => deepEquals(v, arrB[i]));
+        }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        return keysA.every((key) => deepEquals(a[key], b[key]));
+    }
+    return false;
+}
 async function executeNode(ctx, node, executionContext, options) {
     executionContext.emitSpan('workflow.node.start', { nodeId: node.id, kind: node.kind });
     let result;
@@ -233,6 +385,22 @@ async function executeNode(ctx, node, executionContext, options) {
             }
             break;
         }
+        case 'fallback': {
+            const fallbackNode = node;
+            try {
+                result = await executeNode(ctx, fallbackNode.primary, executionContext, options);
+            }
+            catch (error) {
+                executionContext.emitSpan('workflow.node.fallback', {
+                    nodeId: fallbackNode.id,
+                    primaryNodeId: fallbackNode.primary.id,
+                    fallbackNodeId: fallbackNode.fallback.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                result = await executeNode(ctx, fallbackNode.fallback, executionContext, options);
+            }
+            break;
+        }
         default:
             throw new Error(`Unsupported workflow node kind: ${node.kind}`);
     }
@@ -252,6 +420,13 @@ function collectToolNodes(node) {
                 ...collectToolNodes(node.whenTrue),
                 ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
             ];
+        case 'fallback': {
+            const fallbackNode = node;
+            return [
+                ...collectToolNodes(fallbackNode.primary),
+                ...collectToolNodes(fallbackNode.fallback),
+            ];
+        }
         default:
             return [];
     }
@@ -294,6 +469,7 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const metrics = [];
     const spans = [];
     const stepResults = new Map();
+    const dataBus = new WorkflowDataBus();
     const mergedConfig = options.config
         ? { ...ctx.config, ...options.config }
         : ctx.config;
@@ -301,6 +477,7 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
         workflowRunId: runId,
         profile,
         stepResults,
+        dataBus,
         invokeTool(toolName, args) {
             return ctx.executeToolWithTracking(toolName, args);
         },

package/dist/src/types/deobfuscator.d.ts

@@ -60,4 +60,5 @@ export interface DeobfuscateResult {
     warnings?: string[];
     engine?: 'legacy' | 'webcrack' | 'hybrid';
     webcrackApplied?: boolean;
+    cached?: boolean;
 }

package/dist/src/utils/cache/CachedDecorator.d.ts

@@ -0,0 +1,8 @@
+import { PersistentCache } from './PersistentCache.js';
+export interface CachedOptions {
+    ttlMs?: number;
+    keyFn?: (...args: unknown[]) => string;
+    cache?: PersistentCache;
+}
+export declare function cached(options?: CachedOptions): (_target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function withCache<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, options?: CachedOptions): T;

package/dist/src/utils/cache/CachedDecorator.js

@@ -0,0 +1,55 @@
+import { PersistentCache } from './PersistentCache.js';
+function generateDefaultKey(...args) {
+    try {
+        return JSON.stringify(args);
+    }
+    catch {
+        return args.map((arg) => String(arg)).join('|');
+    }
+}
+export function cached(options = {}) {
+    return function (_target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const cache = options.cache ??
+            new PersistentCache({
+                name: `cached-${String(propertyKey)}`,
+                dbPath: '.jshookmcp/cache.db',
+            });
+        descriptor.value = async function (...args) {
+            const keyGenerator = options.keyFn ?? generateDefaultKey;
+            const key = keyGenerator(...args);
+            if (!cache.isReady()) {
+                await cache.init();
+            }
+            const hasKey = await cache.has(key);
+            if (hasKey) {
+                return await cache.get(key);
+            }
+            const result = await originalMethod.apply(this, args);
+            await cache.set(key, result, options.ttlMs);
+            return result;
+        };
+        return descriptor;
+    };
+}
+export function withCache(fn, options = {}) {
+    const cache = options.cache ??
+        new PersistentCache({
+            name: `withCache-${fn.name}`,
+            dbPath: '.jshookmcp/cache.db',
+        });
+    const keyGenerator = options.keyFn ?? generateDefaultKey;
+    return async function (...args) {
+        const key = keyGenerator(...args);
+        if (!cache.isReady()) {
+            await cache.init();
+        }
+        const hasKey = await cache.has(key);
+        if (hasKey) {
+            return await cache.get(key);
+        }
+        const result = await fn.apply(this, args);
+        await cache.set(key, result, options.ttlMs);
+        return result;
+    };
+}

package/dist/src/utils/cache/PersistentCache.d.ts

@@ -0,0 +1,33 @@
+export interface PersistentCacheOptions {
+    name?: string;
+    dbPath?: string;
+    defaultTTL?: number;
+    enabled?: boolean;
+}
+export declare class PersistentCache {
+    private db;
+    private options;
+    private initialized;
+    private stats;
+    constructor(options?: PersistentCacheOptions);
+    init(): Promise<void>;
+    private loadDatabase;
+    private resolveDbPath;
+    private createTables;
+    has(key: string): Promise<boolean>;
+    get<T>(key: string, ttlMs?: number): Promise<T | null>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    cleanup(): Promise<number>;
+    getStats(): Promise<{
+        entries: number;
+        size: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+        ttl: number;
+    }>;
+    close(): Promise<void>;
+    isReady(): boolean;
+}

package/dist/src/utils/cache/PersistentCache.js

@@ -0,0 +1,246 @@
+import { join } from 'path';
+import { mkdirSync, existsSync } from 'fs';
+import { logger } from '../logger.js';
+import { getProjectRoot } from '../outputPaths.js';
+let Database;
+try {
+    Database = require('better-sqlite3');
+}
+catch {
+}
+export class PersistentCache {
+    db = null;
+    options;
+    initialized = false;
+    stats = { hits: 0, misses: 0, sets: 0, deletes: 0 };
+    constructor(options = {}) {
+        this.options = {
+            name: options.name ?? 'default',
+            dbPath: options.dbPath ?? '.jshookmcp/cache.db',
+            defaultTTL: options.defaultTTL ?? 24 * 60 * 60 * 1000,
+            enabled: options.enabled ?? true,
+        };
+    }
+    async init() {
+        if (!this.options.enabled) {
+            logger.debug(`PersistentCache[${this.options.name}] is disabled`);
+            return;
+        }
+        if (this.initialized) {
+            return;
+        }
+        try {
+            const dbPath = this.resolveDbPath();
+            const dir = dbPath.substring(0, dbPath.lastIndexOf('/'));
+            if (dir && !existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const DatabaseConstructor = await this.loadDatabase();
+            if (!DatabaseConstructor) {
+                logger.warn(`PersistentCache[${this.options.name}]: better-sqlite3 not available, using no-op cache`);
+                return;
+            }
+            this.db = new DatabaseConstructor(dbPath);
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('synchronous = NORMAL');
+            this.createTables();
+            this.initialized = true;
+            logger.info(`PersistentCache[${this.options.name}] initialized at ${dbPath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to initialize PersistentCache[${this.options.name}]:`, error);
+            this.db = null;
+            this.initialized = false;
+        }
+    }
+    async loadDatabase() {
+        if (Database) {
+            return Database;
+        }
+        try {
+            const mod = await import('better-sqlite3');
+            return (mod.default ?? mod);
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveDbPath() {
+        const { dbPath } = this.options;
+        if (dbPath.startsWith('/') || /^[A-Z]:\\/i.test(dbPath)) {
+            return dbPath;
+        }
+        const projectRoot = getProjectRoot();
+        return join(projectRoot, dbPath);
+    }
+    createTables() {
+        if (!this.db)
+            return;
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cache_entries (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        expiresAt INTEGER NOT NULL,
+        createdAt INTEGER NOT NULL,
+        accessCount INTEGER DEFAULT 0,
+        lastAccessedAt INTEGER DEFAULT 0
+      )
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_expiresAt ON cache_entries(expiresAt)
+    `);
+    }
+    async has(key) {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return false;
+        }
+        try {
+            const now = Date.now();
+            const stmt = this.db.prepare('SELECT COUNT(*) as count FROM cache_entries WHERE key = ? AND expiresAt > ?');
+            const result = stmt.get(key, now);
+            return (result?.count ?? 0) > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async get(key, ttlMs) {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return null;
+        }
+        try {
+            const now = Date.now();
+            const stmt = this.db.prepare('SELECT * FROM cache_entries WHERE key = ? AND expiresAt > ?');
+            const entry = stmt.get(key, now);
+            if (!entry) {
+                this.stats.misses++;
+                return null;
+            }
+            if (ttlMs !== undefined) {
+                const remainingTTL = entry.expiresAt - now;
+                if (remainingTTL < ttlMs) {
+                    this.stats.misses++;
+                    return null;
+                }
+            }
+            this.db
+                .prepare('UPDATE cache_entries SET accessCount = accessCount + 1, lastAccessedAt = ? WHERE key = ?')
+                .run(now, key);
+            this.stats.hits++;
+            const wrapped = JSON.parse(entry.value);
+            return wrapped.data;
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] get error:`, error);
+            this.stats.misses++;
+            return null;
+        }
+    }
+    async set(key, value, ttlMs) {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return false;
+        }
+        try {
+            const now = Date.now();
+            const ttl = ttlMs ?? this.options.defaultTTL;
+            const expiresAt = now + ttl;
+            const wrappedValue = { __cached: true, data: value };
+            const serialized = JSON.stringify(wrappedValue);
+            const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO cache_entries (key, value, expiresAt, createdAt, accessCount, lastAccessedAt)
+        VALUES (?, ?, ?, ?, 0, ?)
+      `);
+            stmt.run(key, serialized, expiresAt, now, now);
+            this.stats.sets++;
+            return true;
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] set error:`, error);
+            return false;
+        }
+    }
+    async delete(key) {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return false;
+        }
+        try {
+            const stmt = this.db.prepare('DELETE FROM cache_entries WHERE key = ?');
+            const result = stmt.run(key);
+            if (result.changes > 0) {
+                this.stats.deletes++;
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] delete error:`, error);
+            return false;
+        }
+    }
+    async clear() {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return;
+        }
+        try {
+            this.db.exec('DELETE FROM cache_entries');
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] clear error:`, error);
+        }
+    }
+    async cleanup() {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return 0;
+        }
+        try {
+            const now = Date.now();
+            const stmt = this.db.prepare('DELETE FROM cache_entries WHERE expiresAt <= ?');
+            const result = stmt.run(now);
+            return result.changes;
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] cleanup error:`, error);
+            return 0;
+        }
+    }
+    async getStats() {
+        if (!this.options.enabled || !this.db || !this.initialized) {
+            return { entries: 0, size: 0, hits: 0, misses: 0, hitRate: 0, ttl: this.options.defaultTTL };
+        }
+        try {
+            const totalEntries = this.db.prepare('SELECT COUNT(*) as count FROM cache_entries').get();
+            const totalSize = this.db
+                .prepare('SELECT SUM(length(value)) as total FROM cache_entries')
+                .get();
+            const totalRequests = this.stats.hits + this.stats.misses;
+            const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+            return {
+                entries: totalEntries?.count ?? 0,
+                size: totalSize?.total ?? 0,
+                hits: this.stats.hits,
+                misses: this.stats.misses,
+                hitRate,
+                ttl: this.options.defaultTTL,
+            };
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] getStats error:`, error);
+            return { entries: 0, size: 0, hits: 0, misses: 0, hitRate: 0, ttl: this.options.defaultTTL };
+        }
+    }
+    async close() {
+        if (!this.db)
+            return;
+        try {
+            this.db.close();
+            this.db = null;
+            this.initialized = false;
+        }
+        catch (error) {
+            logger.error(`PersistentCache[${this.options.name}] close error:`, error);
+        }
+    }
+    isReady() {
+        return this.options.enabled && this.initialized && this.db !== null;
+    }
+}

package/dist/src/utils/cache/index.d.ts

@@ -0,0 +1,2 @@
+export { PersistentCache, type PersistentCacheOptions } from './PersistentCache.js';
+export { cached, withCache, type CachedOptions } from './CachedDecorator.js';

package/dist/src/utils/cache/index.js

@@ -0,0 +1,2 @@
+export { PersistentCache } from './PersistentCache.js';
+export { cached, withCache } from './CachedDecorator.js';