@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/workflows/WorkflowContract.d.ts

@@ -9,6 +9,7 @@ export interface ToolNode {
     readonly id: string;
     readonly toolName: string;
     readonly input?: Record<string, unknown>;
+    readonly inputFrom?: Record<string, string>;
     readonly timeoutMs?: number;
     readonly retry?: RetryPolicy;
 }
@@ -36,11 +37,29 @@ export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
 export interface WorkflowExecutionContext {
     readonly workflowRunId: string;
     readonly profile: string;
+    readonly stepResults: ReadonlyMap<string, unknown>;
     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 WorkflowRouteStep {
+    readonly id: string;
+    readonly toolName: string;
+    readonly description: string;
+    readonly prerequisites: string[];
+    readonly parallel?: boolean;
+    readonly expectedInputs?: Record<string, string>;
+    readonly evidenceNodeType?: string;
+}
+export type WorkflowRouteKind = 'preset' | 'workflow';
+export interface WorkflowRouteMetadata {
+    readonly kind: WorkflowRouteKind;
+    readonly triggerPatterns: RegExp[];
+    readonly steps: WorkflowRouteStep[];
+    readonly requiredDomains: string[];
+    readonly priority: number;
+}
 export interface WorkflowContract {
     readonly kind: 'workflow-contract';
     readonly version: 1;
@@ -50,6 +69,7 @@ export interface WorkflowContract {
     readonly tags?: string[];
     readonly timeoutMs?: number;
     readonly defaultMaxConcurrency?: number;
+    readonly route?: WorkflowRouteMetadata;
     build(ctx: WorkflowExecutionContext): WorkflowNode;
     onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
     onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
@@ -69,10 +89,12 @@ type AnyWorkflowNodeBuilder = WorkflowNodeBuilder<WorkflowNode>;
 export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
     private toolName;
     private _input?;
+    private _inputFrom?;
     private _retry?;
     private _timeoutMs?;
     constructor(id: string, toolName: string);
     input(input: Record<string, unknown>): this;
+    inputFrom(mapping: Record<string, string>): this;
     retry(policy: RetryPolicy): this;
     timeout(ms: number): this;
     build(): ToolNode;
@@ -117,6 +139,7 @@ export declare class WorkflowBuilder {
     private _tags?;
     private _timeoutMs?;
     private _defaultMaxConcurrency?;
+    private _route?;
     private _buildFn;
     private _onStart?;
     private _onFinish?;
@@ -126,6 +149,7 @@ export declare class WorkflowBuilder {
     tags(tags: string[]): this;
     timeoutMs(timeout: number): this;
     defaultMaxConcurrency(max: number): this;
+    route(route: WorkflowRouteMetadata): this;
     buildGraph(fn: (ctx: WorkflowExecutionContext) => AnyWorkflowNodeBuilder): this;
     onStart(fn: (ctx: WorkflowExecutionContext) => Promise<void> | void): this;
     onFinish(fn: (ctx: WorkflowExecutionContext, result: unknown) => Promise<void> | void): this;

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

@@ -7,6 +7,7 @@ export class WorkflowNodeBuilder {
 export class ToolNodeBuilder extends WorkflowNodeBuilder {
     toolName;
     _input;
+    _inputFrom;
     _retry;
     _timeoutMs;
     constructor(id, toolName) {
@@ -17,6 +18,10 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
         this._input = input;
         return this;
     }
+    inputFrom(mapping) {
+        this._inputFrom = mapping;
+        return this;
+    }
     retry(policy) {
         this._retry = policy;
         return this;
@@ -31,6 +36,7 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
             id: this.id,
             toolName: this.toolName,
             input: this._input,
+            inputFrom: this._inputFrom,
             retry: this._retry,
             timeoutMs: this._timeoutMs,
         };
@@ -174,6 +180,7 @@ export class WorkflowBuilder {
     _tags;
     _timeoutMs;
     _defaultMaxConcurrency;
+    _route;
     _buildFn;
     _onStart;
     _onFinish;
@@ -198,6 +205,10 @@ export class WorkflowBuilder {
         this._defaultMaxConcurrency = max;
         return this;
     }
+    route(route) {
+        this._route = route;
+        return this;
+    }
     buildGraph(fn) {
         this._buildFn = (ctx) => fn(ctx).build();
         return this;
@@ -226,6 +237,7 @@ export class WorkflowBuilder {
             tags: this._tags,
             timeoutMs: this._timeoutMs,
             defaultMaxConcurrency: this._defaultMaxConcurrency,
+            route: this._route,
             build: this._buildFn,
             onStart: this._onStart,
             onFinish: this._onFinish,

package/dist/src/server/workflows/WorkflowEngine.d.ts

@@ -16,6 +16,7 @@ interface WorkflowSpan {
 export interface ExecuteWorkflowOptions {
     profile?: string;
     config?: JsonRecord;
+    preflightMode?: 'warn' | 'strict' | 'skip';
     nodeInputOverrides?: Record<string, Record<string, unknown>>;
     timeoutMs?: number;
 }

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

@@ -1,4 +1,14 @@
 import { randomUUID } from 'node:crypto';
+import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
+import { getRoutingState } from '../ToolRouter.probe.js';
+class PreflightError extends Error {
+    warnings;
+    constructor(warnings) {
+        super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
+        this.warnings = warnings;
+        this.name = 'PreflightError';
+    }
+}
 function extractConfigValue(config, path, fallback) {
     const segments = path.split('.').filter(Boolean);
     let current = config;
@@ -77,9 +87,29 @@ function collectSuccessStats(value) {
     }
     return { success: 0, failure: 0 };
 }
-async function runToolNode(ctx, node, overrides) {
+function resolveInputFrom(mapping, stepResults) {
+    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];
+    }
+    return resolved;
+}
+async function runToolNode(ctx, node, overrides, executionContext) {
+    const fromResolved = node.inputFrom
+        ? resolveInputFrom(node.inputFrom, executionContext.stepResults)
+        : {};
     const mergedInput = {
         ...node.input,
+        ...fromResolved,
         ...overrides?.[node.id],
     };
     const runAttempt = async () => {
@@ -113,7 +143,7 @@ async function runToolNode(ctx, node, overrides) {
 }
 async function runParallelNode(ctx, node, executionContext, options) {
     const concurrency = Math.max(1, node.maxConcurrency ?? 4);
-    const results = new Array(node.steps.length);
+    const results = Array.from({ length: node.steps.length });
     let nextIndex = 0;
     let stopped = false;
     const worker = async () => {
@@ -177,7 +207,7 @@ async function executeNode(ctx, node, executionContext, options) {
     let result;
     switch (node.kind) {
         case 'tool':
-            result = await runToolNode(ctx, node, options.nodeInputOverrides);
+            result = await runToolNode(ctx, node, options.nodeInputOverrides, executionContext);
             break;
         case 'sequence': {
             const sequenceNode = node;
@@ -210,6 +240,52 @@ async function executeNode(ctx, node, executionContext, options) {
     executionContext.emitSpan('workflow.node.finish', { nodeId: node.id, kind: node.kind });
     return result;
 }
+function collectToolNodes(node) {
+    switch (node.kind) {
+        case 'tool':
+            return [node];
+        case 'sequence':
+        case 'parallel':
+            return node.steps.flatMap((step) => collectToolNodes(step));
+        case 'branch':
+            return [
+                ...collectToolNodes(node.whenTrue),
+                ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
+            ];
+        default:
+            return [];
+    }
+}
+function getEvidenceState(ctx) {
+    try {
+        const evidenceGraph = ctx.getDomainInstance('evidenceGraph');
+        return evidenceGraph
+            ? { hasGraph: true, nodeCount: evidenceGraph.nodeCount, edgeCount: evidenceGraph.edgeCount }
+            : { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+    catch {
+        return { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+}
+function collectUnsatisfiedPrerequisites(graph, routingState) {
+    const prerequisites = getEffectivePrerequisites();
+    const warnings = [];
+    for (const toolNode of collectToolNodes(graph)) {
+        const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
+        for (const prerequisite of toolPrerequisites) {
+            if (prerequisite.check(routingState)) {
+                continue;
+            }
+            warnings.push({
+                nodeId: toolNode.id,
+                toolName: toolNode.toolName,
+                condition: prerequisite.condition,
+                fix: prerequisite.fix,
+            });
+        }
+    }
+    return warnings;
+}
 export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const runId = randomUUID();
     const profile = options.profile ?? String(ctx.baseTier ?? 'workflow');
@@ -241,8 +317,65 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     try {
         await workflow.onStart?.(executionContext);
         const graph = workflow.build(executionContext);
+        const preflightMode = options.preflightMode ?? 'warn';
+        let preflightWarnings = [];
+        if (preflightMode === 'skip') {
+            executionContext.emitSpan('workflow.preflight', {
+                mode: preflightMode,
+                skipped: true,
+                evidenceState: getEvidenceState(ctx),
+                warningCount: 0,
+            });
+        }
+        else {
+            try {
+                const routingState = await getRoutingState(ctx);
+                const evidenceState = getEvidenceState(ctx);
+                preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    routingState,
+                    evidenceState,
+                    warningCount: preflightWarnings.length,
+                    warnings: preflightWarnings,
+                });
+                if (preflightMode === 'strict' && preflightWarnings.length > 0) {
+                    throw new PreflightError(preflightWarnings);
+                }
+            }
+            catch (error) {
+                if (error instanceof PreflightError) {
+                    throw error;
+                }
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    warningCount: 0,
+                    skipped: true,
+                    error: error instanceof Error ? error.message : String(error),
+                    evidenceState: getEvidenceState(ctx),
+                });
+            }
+        }
         const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
         await workflow.onFinish?.(executionContext, result);
+        try {
+            const evidenceGraph = typeof ctx.getDomainInstance === 'function'
+                ? ctx.getDomainInstance('evidenceGraph')
+                : undefined;
+            if (evidenceGraph && evidenceGraph.nodeCount > 0) {
+                stepResults.set('__evidenceSnapshot', evidenceGraph.exportJson());
+                executionContext.emitSpan('workflow.evidence.auto-export', {
+                    nodeCount: evidenceGraph.nodeCount,
+                    edgeCount: evidenceGraph.edgeCount,
+                });
+            }
+        }
+        catch (exportError) {
+            executionContext.emitSpan('workflow.evidence.auto-export', {
+                skipped: true,
+                error: exportError instanceof Error ? exportError.message : String(exportError),
+            });
+        }
         return {
             workflowId: workflow.id,
             displayName: workflow.displayName,

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

@@ -1,24 +1,10 @@
 export interface Config {
-    llm: LLMConfig;
     puppeteer: PuppeteerConfig;
     mcp: MCPConfig;
     cache: CacheConfig;
     performance: PerformanceConfig;
     search: SearchConfig;
 }
-export interface LLMConfig {
-    provider: 'openai' | 'anthropic';
-    openai?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-    anthropic?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-}
 export interface PuppeteerConfig {
     headless: boolean;
     timeout: number;

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

@@ -6,7 +6,6 @@ export interface Transformation {
 }
 export interface DeobfuscateOptions {
     code: string;
-    llm?: 'gpt-4' | 'claude';
     aggressive?: boolean;
     preserveLogic?: boolean;
     renameVariables?: boolean;

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

@@ -1,5 +1,5 @@
 export type { CodeLocation, Result } from './common.js';
-export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
+export type { Config, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
 export type { BrowserContext } from './browser.js';
 export type { CollectCodeOptions, CodeFile, CollectCodeResult, DependencyGraph, DependencyNode, DependencyEdge, } from './collector.js';
 export type { ObfuscationType, Transformation, DeobfuscateOptions, DeobfuscateResult, DeobfuscateMappingRule, DeobfuscateSavedArtifact, DeobfuscateBundleModuleSummary, DeobfuscateBundleSummary, } from './deobfuscator.js';

package/dist/src/utils/DetailedDataManager.js

@@ -51,6 +51,8 @@ export class DetailedDataManager {
         return Object(value)[key];
     }
     smartHandle(data, threshold = DETAILED_DATA_SMART_THRESHOLD_BYTES) {
+        if (data === null || data === undefined || typeof data !== 'object')
+            return data;
         const { json: jsonStr, size } = this.serializeWithMemo(data);
         if (size <= threshold) {
             return data;

package/dist/src/utils/RingBuffer.js

@@ -6,7 +6,7 @@ export class RingBuffer {
     count = 0;
     constructor(capacity) {
         this.capacity = capacity;
-        this.buf = new Array(capacity);
+        this.buf = Array.from({ length: capacity });
     }
     get length() {
         return this.count;
@@ -37,7 +37,7 @@ export class RingBuffer {
         return item;
     }
     clear() {
-        this.buf = new Array(Math.min(64, this.capacity));
+        this.buf = Array.from({ length: Math.min(64, this.capacity) });
         this.head = 0;
         this.tail = 0;
         this.count = 0;
@@ -48,14 +48,14 @@ export class RingBuffer {
         }
     }
     toArray() {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = this.buf[(this.head + i) % this.buf.length];
         }
         return result;
     }
     map(fn) {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = fn(this.buf[(this.head + i) % this.buf.length], i);
         }
@@ -63,7 +63,7 @@ export class RingBuffer {
     }
     grow() {
         const newSize = Math.min(this.buf.length * 2, this.capacity);
-        const newBuf = new Array(newSize);
+        const newBuf = Array.from({ length: newSize });
         for (let i = 0; i < this.count; i++) {
             newBuf[i] = this.buf[(this.head + i) % this.buf.length];
         }

package/dist/src/utils/TokenBudgetManager.js

@@ -257,7 +257,7 @@ export class TokenBudgetManager {
             tokens,
             percentage: Math.round((tokens / this.currentUsage) * 100),
         }))
-            .sort((a, b) => b.tokens - a.tokens)
+            .toSorted((a, b) => b.tokens - a.tokens)
             .slice(0, 10);
         const suggestions = this.generateSuggestions(topTools);
         const recentCalls = this.toolCallHistory.slice(-20);

package/dist/src/utils/UnifiedCacheManager.d.ts

@@ -29,7 +29,7 @@ export interface GlobalCacheStats {
     recommendations: string[];
 }
 export declare class UnifiedCacheManager {
-    private static instance;
+    protected static instance: UnifiedCacheManager;
     private readonly GLOBAL_MAX_SIZE;
     private readonly LOW_HIT_RATE_THRESHOLD;
     private caches;

package/dist/src/utils/UnifiedCacheManager.js

@@ -110,7 +110,7 @@ export class UnifiedCacheManager {
             if (cacheStats.hitRate !== undefined &&
                 cacheStats.hitRate < avgHitRate * this.LOW_HIT_RATE_THRESHOLD) {
                 const cache = this.caches.get(cacheStats.name);
-                if (cache && cache.clear) {
+                if (cache?.clear) {
                     try {
                         await cache.clear();
                         logger.info(`Cleared low hit rate cache: ${cacheStats.name} (${(cacheStats.hitRate * 100).toFixed(1)}%)`);
@@ -125,10 +125,10 @@ export class UnifiedCacheManager {
     async cleanupLargeItems() {
         logger.info('Cleaning up large caches...');
         const stats = await this.getGlobalStats();
-        const sortedCaches = stats.caches.sort((a, b) => b.size - a.size);
+        const sortedCaches = stats.caches.toSorted((a, b) => b.size - a.size);
         for (const cacheStats of sortedCaches.slice(0, 2)) {
             const cache = this.caches.get(cacheStats.name);
-            if (cache && cache.clear) {
+            if (cache?.clear) {
                 try {
                     await cache.clear();
                     logger.info(`Cleared large cache: ${cacheStats.name} (${cacheStats.sizeMB}MB)`);

package/dist/src/utils/artifactRetention.js

@@ -38,7 +38,7 @@ export async function cleanupArtifacts(options) {
     if (cutoff > 0) {
         const agedOut = remaining
             .filter((entry) => entry.mtimeMs < cutoff)
-            .sort((a, b) => a.mtimeMs - b.mtimeMs);
+            .toSorted((a, b) => a.mtimeMs - b.mtimeMs);
         if (agedOut.length > 0) {
             const agedOutPaths = new Set(agedOut.map((entry) => entry.path));
             remaining = remaining.filter((entry) => !agedOutPaths.has(entry.path));
@@ -54,7 +54,7 @@ export async function cleanupArtifacts(options) {
     if (config.maxTotalBytes > 0) {
         let totalBytes = remaining.reduce((sum, entry) => sum + entry.size, 0);
         if (totalBytes > config.maxTotalBytes) {
-            const sizeCandidates = [...remaining].sort((a, b) => a.mtimeMs - b.mtimeMs);
+            const sizeCandidates = [...remaining].toSorted((a, b) => a.mtimeMs - b.mtimeMs);
             const removedPaths = new Set();
             for (const entry of sizeCandidates) {
                 if (totalBytes <= config.maxTotalBytes)

package/dist/src/utils/betterSqlite3.d.ts

@@ -0,0 +1,11 @@
+export type BetterSqlite3Issue = 'missing' | 'abi-mismatch' | 'load-failed';
+export interface BetterSqlite3ProbeResult {
+    status: 'ok' | 'missing' | 'warn';
+    detail: string;
+    version: string | null;
+    issue?: BetterSqlite3Issue;
+}
+export declare function isBetterSqlite3RelatedError(error: unknown): boolean;
+export declare function classifyBetterSqlite3Issue(error: unknown): BetterSqlite3Issue;
+export declare function formatBetterSqlite3Error(error: unknown): string;
+export declare function probeBetterSqlite3(): BetterSqlite3ProbeResult;

package/dist/src/utils/betterSqlite3.js

@@ -0,0 +1,88 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const BETTER_SQLITE3_VERSION = '12.6.2';
+const INSTALL_HINT = `pnpm add -O better-sqlite3@${BETTER_SQLITE3_VERSION}`;
+const REBUILD_HINT = 'npm rebuild better-sqlite3 --foreground-scripts';
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export function isBetterSqlite3RelatedError(error) {
+    return /better-sqlite3|better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(extractErrorMessage(error));
+}
+export function classifyBetterSqlite3Issue(error) {
+    const message = extractErrorMessage(error);
+    if (/Cannot find module 'better-sqlite3'|Cannot find package 'better-sqlite3'|better-sqlite3 is not installed/i.test(message)) {
+        return 'missing';
+    }
+    if (/better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version|module was compiled against/i.test(message)) {
+        return 'abi-mismatch';
+    }
+    return 'load-failed';
+}
+export function formatBetterSqlite3Error(error) {
+    const issue = classifyBetterSqlite3Issue(error);
+    const message = extractErrorMessage(error);
+    if (issue === 'missing') {
+        return `better-sqlite3 is not installed. Install the optional trace backend with \`${INSTALL_HINT}\`.`;
+    }
+    if (issue === 'abi-mismatch') {
+        return `better-sqlite3 is installed but its native binary is incompatible with the current Node.js runtime (${process.version}, ABI ${process.versions.modules}). Rebuild it with \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
+    }
+    return `better-sqlite3 failed to initialize. Try \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
+}
+function readBetterSqlite3Version() {
+    try {
+        const packageJsonPath = require.resolve('better-sqlite3/package.json');
+        const packageJson = require(packageJsonPath);
+        return packageJson.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function probeBetterSqlite3() {
+    const version = readBetterSqlite3Version();
+    if (!version) {
+        return {
+            status: 'missing',
+            detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
+            version: null,
+            issue: 'missing',
+        };
+    }
+    try {
+        const Database = require('better-sqlite3');
+        const db = new Database(':memory:');
+        try {
+            db.prepare('SELECT 1 AS ok').get();
+        }
+        finally {
+            db.close();
+        }
+        return {
+            status: 'ok',
+            detail: `installed (${version}) — native trace backend healthy`,
+            version,
+        };
+    }
+    catch (error) {
+        const issue = classifyBetterSqlite3Issue(error);
+        if (issue === 'missing') {
+            return {
+                status: 'missing',
+                detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
+                version,
+                issue,
+            };
+        }
+        return {
+            status: 'warn',
+            detail: `installed (${version}) but ${formatBetterSqlite3Error(error)}`,
+            version,
+            issue,
+        };
+    }
+}

package/dist/src/utils/browserExecutable.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'fs';
-import puppeteer from 'rebrowser-puppeteer-core';
+import { executablePath } from 'rebrowser-puppeteer-core';
 const ENV_KEYS = ['CHROME_PATH', 'PUPPETEER_EXECUTABLE_PATH', 'BROWSER_EXECUTABLE_PATH'];
 let cachedBrowserPath = null;
 function resolveFromEnvironment() {
@@ -13,7 +13,7 @@ function resolveFromEnvironment() {
 }
 function resolveFromPuppeteer() {
     try {
-        const candidate = puppeteer.executablePath('chrome');
+        const candidate = executablePath('chrome');
         if (candidate && existsSync(candidate)) {
             return candidate;
         }

package/dist/src/utils/cliFastPath.js

@@ -1,13 +1,26 @@
 import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 function getPackageVersion(moduleUrl) {
     try {
-        const packageJsonUrl = new URL('../package.json', moduleUrl);
-        const packageJson = JSON.parse(readFileSync(packageJsonUrl, 'utf8'));
-        return packageJson.version ?? '0.0.0';
+        let dirUrl = new URL('.', moduleUrl);
+        for (let i = 0; i < 5; i++) {
+            try {
+                const candidate = fileURLToPath(new URL('package.json', dirUrl));
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version)
+                    return pkg.version;
+            }
+            catch {
+            }
+            const parentUrl = new URL('../', dirUrl);
+            if (parentUrl.href === dirUrl.href)
+                break;
+            dirUrl = parentUrl;
+        }
     }
     catch {
-        return process.env.npm_package_version ?? '0.0.0';
     }
+    return process.env.npm_package_version ?? '0.0.0';
 }
 function buildHelpText(version) {
     return [
@@ -21,8 +34,6 @@ function buildHelpText(version) {
         '  Starts the MCP server by default.',
         '',
         'Common environment variables:',
-        '  OPENAI_API_KEY',
-        '  DEFAULT_LLM_PROVIDER=openai|anthropic',
         '  MCP_TRANSPORT=stdio|http',
         '  MCP_TOOL_PROFILE=search|workflow|full',
         '',