@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/logger-BmWzC2lM.mjs

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+//#region src/utils/logger.ts
+const SENSITIVE_KEYS = /^(auth(orization)?|cookie|set[_-]?cookie|x[_-]?api[_-]?key|token|access[_-]?token|refresh[_-]?token|id[_-]?token|secret|client[_-]?secret|password|passwd|api[_-]?key|private[_-]?key|credentials?|session[_-]?id|csrf[_-]?token)$/i;
+/** Patterns that look like secrets in values (Bearer tokens, JWTs, long hex strings). */
+const SENSITIVE_VALUE_PATTERNS = /^(Bearer\s+\S|eyJ[A-Za-z0-9_-]{10,}|[A-Fa-f0-9]{32,}|sk[_-][A-Za-z0-9]{20,})/;
+/** JSON.stringify replacer that redacts sensitive fields. */
+function sensitiveReplacer(key, value) {
+	if (key && SENSITIVE_KEYS.test(key) && typeof value === "string") return "[REDACTED]";
+	if (typeof value === "string" && SENSITIVE_VALUE_PATTERNS.test(value)) return "[REDACTED]";
+	return value;
+}
+var Logger = class {
+	level;
+	listeners = [];
+	constructor(level = "info") {
+		this.level = level;
+	}
+	shouldLog(level) {
+		const levels = [
+			"debug",
+			"info",
+			"warn",
+			"error"
+		];
+		return levels.indexOf(level) >= levels.indexOf(this.level);
+	}
+	formatMessage(level, message, ...args) {
+		const prefix = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level.toUpperCase()}]`;
+		let formattedArgs = "";
+		if (args.length > 0) try {
+			formattedArgs = " " + JSON.stringify(args, sensitiveReplacer, void 0);
+		} catch {
+			formattedArgs = " [unserializable]";
+		}
+		return `${prefix} ${message}${formattedArgs}`;
+	}
+	emit(level, message, args) {
+		for (const listener of this.listeners) try {
+			listener(level, message, args);
+		} catch {}
+	}
+	onLog(listener) {
+		this.listeners.push(listener);
+		return () => {
+			this.listeners = this.listeners.filter((l) => l !== listener);
+		};
+	}
+	debug(message, ...args) {
+		if (this.shouldLog("debug")) {
+			console.error(chalk.gray(this.formatMessage("debug", message, ...args)));
+			this.emit("debug", message, args);
+		}
+	}
+	info(message, ...args) {
+		if (this.shouldLog("info")) {
+			console.error(chalk.blue(this.formatMessage("info", message, ...args)));
+			this.emit("info", message, args);
+		}
+	}
+	warn(message, ...args) {
+		if (this.shouldLog("warn")) {
+			console.error(chalk.yellow(this.formatMessage("warn", message, ...args)));
+			this.emit("warn", message, args);
+		}
+	}
+	error(message, ...args) {
+		/* v8 ignore next 4 */
+		if (this.shouldLog("error")) {
+			console.error(chalk.red(this.formatMessage("error", message, ...args)));
+			this.emit("error", message, args);
+		}
+	}
+	success(message, ...args) {
+		if (this.shouldLog("info")) {
+			console.error(chalk.green(this.formatMessage("info", message, ...args)));
+			this.emit("info", message, args);
+		}
+	}
+	setLevel(level) {
+		this.level = level;
+	}
+};
+const logger = new Logger(process.env.LOG_LEVEL || "info");
+//#endregion
+export { logger as t };

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

@@ -0,0 +1,204 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+//#region packages/extension-sdk/src/workflow.d.ts
+interface RetryPolicy {
+  maxAttempts: number;
+  backoffMs: number;
+  multiplier?: number;
+}
+interface ToolNode {
+  readonly kind: 'tool';
+  readonly id: string;
+  readonly toolName: string;
+  readonly input?: Record<string, unknown>;
+  readonly inputFrom?: Record<string, string>;
+  readonly timeoutMs?: number;
+  readonly retry?: RetryPolicy;
+}
+interface SequenceNode {
+  readonly kind: 'sequence';
+  readonly id: string;
+  readonly steps: WorkflowNode[];
+}
+interface ParallelNode {
+  readonly kind: 'parallel';
+  readonly id: string;
+  readonly steps: WorkflowNode[];
+  readonly maxConcurrency?: number;
+  readonly failFast?: boolean;
+}
+interface BranchNode {
+  readonly kind: 'branch';
+  readonly id: string;
+  readonly predicateId: string;
+  readonly predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>;
+  readonly whenTrue: WorkflowNode;
+  readonly whenFalse?: WorkflowNode;
+}
+interface FallbackNode {
+  readonly kind: 'fallback';
+  readonly id: string;
+  readonly primary: WorkflowNode;
+  readonly fallback: WorkflowNode;
+}
+type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode | FallbackNode;
+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;
+}
+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;
+}
+type WorkflowRouteKind = 'preset' | 'workflow';
+interface WorkflowRouteMetadata {
+  readonly kind: WorkflowRouteKind;
+  readonly triggerPatterns: RegExp[];
+  readonly steps: WorkflowRouteStep[];
+  readonly requiredDomains: string[];
+  readonly priority: number;
+}
+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;
+  readonly route?: WorkflowRouteMetadata;
+  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;
+}
+//#endregion
+//#region packages/extension-sdk/src/plugin.d.ts
+type ToolProfileId = 'search' | 'workflow' | 'full';
+type ToolArgs$1 = Record<string, unknown>;
+type ToolResponse = CallToolResult;
+type PluginState = 'loaded' | 'validated' | 'registered' | 'activated' | 'deactivated' | 'unloaded';
+interface PluginLifecycleContext {
+  readonly pluginId: string;
+  readonly pluginRoot: string;
+  readonly config: Record<string, unknown>;
+  readonly state: PluginState;
+  registerMetric(metricName: string): void;
+  invokeTool(name: string, args?: ToolArgs$1): Promise<ToolResponse>;
+  hasPermission(capability: string): boolean;
+  getConfig<T = unknown>(path: string, fallback?: T): T;
+  setRuntimeData(key: string, value: unknown): void;
+  getRuntimeData<T = unknown>(key: string): T | undefined;
+}
+type ExtensionToolHandler = (args: ToolArgs$1, ctx: PluginLifecycleContext) => Promise<ToolResponse>;
+interface ExtensionToolDefinition {
+  name: string;
+  description: string;
+  schema: Record<string, unknown>;
+  handler: ExtensionToolHandler;
+  profiles?: ToolProfileId[];
+}
+type ExtensionWorkflowDefinition = WorkflowContract;
+declare const jsonResponse: (payload: Record<string, unknown>) => ToolResponse;
+declare const errorResponse: (tool: string, error: unknown, extra?: Record<string, unknown>) => ToolResponse;
+declare class ExtensionBuilder {
+  private readonly _id;
+  private readonly _version;
+  private _name;
+  private _description;
+  private _author;
+  private _sourceRepo;
+  private _compatibleCore;
+  private _profiles;
+  private _tools;
+  private _workflows;
+  private _allowCommands;
+  private _allowHosts;
+  private _allowTools;
+  private _metrics;
+  private _configDefaults;
+  private _onLoadHandler?;
+  private _onValidateHandler?;
+  private _onActivateHandler?;
+  private _onDeactivateHandler?;
+  constructor(id: string, version: string);
+  get id(): string;
+  get version(): string;
+  get pluginName(): string;
+  get pluginDescription(): string;
+  get pluginAuthor(): string;
+  get pluginSourceRepo(): string;
+  get compatibleCoreRange(): string;
+  get profiles(): ToolProfileId[];
+  get tools(): ExtensionToolDefinition[];
+  get workflows(): ExtensionWorkflowDefinition[];
+  get allowedCommands(): string[];
+  get allowedHosts(): string[];
+  get allowedTools(): string[];
+  get declaredMetrics(): string[];
+  get configDefaults(): Record<string, unknown>;
+  get onLoadHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+  get onValidateHandler(): ((ctx: PluginLifecycleContext) => Promise<{
+    valid: boolean;
+    errors: string[];
+  }> | {
+    valid: boolean;
+    errors: string[];
+  }) | undefined;
+  get onActivateHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+  get onDeactivateHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+  name(n: string): this;
+  description(desc: string): this;
+  author(a: string): this;
+  sourceRepo(url: string): this;
+  compatibleCore(range: string): this;
+  mergeMetadata(meta: {
+    name?: string;
+    description?: string;
+    author?: string;
+    source_repo?: string;
+  }): this;
+  profile(p: ToolProfileId | ToolProfileId[]): this;
+  allowCommand(cmd: string | string[]): this;
+  allowHost(host: string | string[]): this;
+  allowTool(tool: string | string[]): this;
+  metric(m: string | string[]): this;
+  configDefault(key: string, value: unknown): this;
+  tool(name: string, desc: string, schema: Record<string, unknown>, handler: ExtensionToolHandler, profiles?: ToolProfileId[]): this;
+  workflow(workflow: ExtensionWorkflowDefinition | ExtensionWorkflowDefinition[]): this;
+  onLoad(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+  onValidate(h: (ctx: PluginLifecycleContext) => Promise<{
+    valid: boolean;
+    errors: string[];
+  }> | {
+    valid: boolean;
+    errors: string[];
+  }): this;
+  onActivate(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+  onDeactivate(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+}
+declare function createExtension(id: string, version: string): ExtensionBuilder;
+//#endregion
+//#region src/server/types.d.ts
+type ToolArgs = Record<string, unknown>;
+//#endregion
+//#region src/server/extensions/plugin-config.d.ts
+declare function getPluginBooleanConfig(ctx: PluginLifecycleContext, pluginId: string, key: string, fallback: boolean): boolean;
+type BoostTier = 'search' | 'workflow' | 'full';
+declare function getPluginBoostTier(pluginId: string): BoostTier;
+//#endregion
+//#region src/server/extensions/plugin-env.d.ts
+declare function loadPluginEnv(manifestLocation: string): void;
+//#endregion
+export { type ExtensionBuilder, type PluginLifecycleContext, type ToolArgs, createExtension, errorResponse, getPluginBooleanConfig, getPluginBoostTier, jsonResponse, loadPluginEnv };

package/dist/server/plugin-api.mjs

@@ -0,0 +1,293 @@
+import "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import dotenv from "dotenv";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+//#region src/server/extensions/plugin-config.ts
+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 === void 0) return void 0;
+	const value = raw.trim().toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(value)) return true;
+	if ([
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(value)) return false;
+}
+function getPluginBooleanConfig(ctx, pluginId, key, fallback) {
+	for (const candidate of envCandidates(pluginId, key)) {
+		const parsed = parseBoolean(process.env[candidate]);
+		if (parsed !== void 0) return parsed;
+	}
+	return ctx.getConfig(`plugins.${pluginId}.${key}`, fallback);
+}
+const VALID_BOOST_TIERS = new Set([
+	"search",
+	"workflow",
+	"full"
+]);
+/**
+* Resolve the minimum boost tier at which a plugin's tools are auto-registered.
+* Checks PLUGIN_<ID>_BOOST_DOMAIN, then MCP_DEFAULT_PLUGIN_BOOST_TIER, then 'full'.
+*/
+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";
+}
+//#endregion
+//#region src/server/extensions/plugin-env.ts
+const loadedEnvPaths = /* @__PURE__ */ new Set();
+function toManifestUrl(manifestLocation) {
+	return manifestLocation.startsWith("file:") ? new URL(manifestLocation) : pathToFileURL(manifestLocation);
+}
+/**
+* Load plugin-local `.env` once per plugin directory.
+*
+* Main process `.env` is loaded by core config bootstrap first, so this only
+* adds per-plugin overrides without clobbering existing values.
+*/
+function loadPluginEnv(manifestLocation) {
+	const envPath = join(fileURLToPath(new URL(".", toManifestUrl(manifestLocation))), ".env");
+	if (loadedEnvPaths.has(envPath)) return;
+	if (existsSync(envPath)) dotenv.config({
+		path: envPath,
+		override: false
+	});
+	loadedEnvPaths.add(envPath);
+}
+promisify(execFile);
+function toTextResponse(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+function toErrorResponse(tool, error, extra = {}) {
+	return toTextResponse({
+		success: false,
+		tool,
+		error: error instanceof Error ? error.message : String(error),
+		...extra
+	});
+}
+//#endregion
+//#region packages/extension-sdk/src/plugin.ts
+/** Build a success JSON response for an MCP tool. Alias of `toTextResponse`. */
+const jsonResponse = toTextResponse;
+/** Build an error JSON response for an MCP tool. Alias of `toErrorResponse`. */
+const errorResponse = toErrorResponse;
+var ExtensionBuilder = class {
+	_id;
+	_version;
+	_name = "";
+	_description = "";
+	_author = "";
+	_sourceRepo = "";
+	_compatibleCore = ">=0.1.0";
+	_profiles = ["full"];
+	_tools = [];
+	_workflows = [];
+	_allowCommands = [];
+	_allowHosts = [];
+	_allowTools = [];
+	_metrics = [];
+	_configDefaults = {};
+	_onLoadHandler;
+	_onValidateHandler;
+	_onActivateHandler;
+	_onDeactivateHandler;
+	constructor(id, version) {
+		this._id = id;
+		this._version = version;
+	}
+	get id() {
+		return this._id;
+	}
+	get version() {
+		return this._version;
+	}
+	get pluginName() {
+		return this._name;
+	}
+	get pluginDescription() {
+		return this._description;
+	}
+	get pluginAuthor() {
+		return this._author;
+	}
+	get pluginSourceRepo() {
+		return this._sourceRepo;
+	}
+	get compatibleCoreRange() {
+		return this._compatibleCore;
+	}
+	get profiles() {
+		return this._profiles;
+	}
+	get tools() {
+		return this._tools;
+	}
+	get workflows() {
+		return this._workflows;
+	}
+	get allowedCommands() {
+		return this._allowCommands;
+	}
+	get allowedHosts() {
+		return this._allowHosts;
+	}
+	get allowedTools() {
+		return this._allowTools;
+	}
+	get declaredMetrics() {
+		return this._metrics;
+	}
+	get configDefaults() {
+		return this._configDefaults;
+	}
+	get onLoadHandler() {
+		return this._onLoadHandler;
+	}
+	get onValidateHandler() {
+		return this._onValidateHandler;
+	}
+	get onActivateHandler() {
+		return this._onActivateHandler;
+	}
+	get onDeactivateHandler() {
+		return this._onDeactivateHandler;
+	}
+	name(n) {
+		this._name = n;
+		return this;
+	}
+	description(desc) {
+		this._description = desc;
+		return this;
+	}
+	author(a) {
+		this._author = a;
+		return this;
+	}
+	sourceRepo(url) {
+		this._sourceRepo = url;
+		return this;
+	}
+	compatibleCore(range) {
+		this._compatibleCore = range;
+		return this;
+	}
+	/**
+	* Merge external metadata (e.g. from meta.yaml) into the builder.
+	* Only fills in fields that the builder chain has NOT explicitly set
+	* (i.e. still at their default empty-string value).
+	*/
+	mergeMetadata(meta) {
+		if (!this._name && meta.name) this._name = meta.name;
+		if (!this._description && meta.description) this._description = meta.description;
+		if (!this._author && meta.author) this._author = meta.author;
+		if (!this._sourceRepo && meta.source_repo) this._sourceRepo = meta.source_repo;
+		return this;
+	}
+	profile(p) {
+		this._profiles = Array.isArray(p) ? p : [p];
+		return this;
+	}
+	allowCommand(cmd) {
+		this._allowCommands.push(...Array.isArray(cmd) ? cmd : [cmd]);
+		return this;
+	}
+	allowHost(host) {
+		this._allowHosts.push(...Array.isArray(host) ? host : [host]);
+		return this;
+	}
+	allowTool(tool) {
+		this._allowTools.push(...Array.isArray(tool) ? tool : [tool]);
+		return this;
+	}
+	metric(m) {
+		this._metrics.push(...Array.isArray(m) ? m : [m]);
+		return this;
+	}
+	configDefault(key, value) {
+		this._configDefaults[key] = value;
+		return this;
+	}
+	/**
+	* Register a tool exposed by this extension.
+	*
+	* @param name    Unique tool name (must not collide with built-in tools).
+	* @param desc    Human-readable description shown to the AI model.
+	* @param schema  JSON-Schema **properties** object — the builder automatically
+	*                wraps it in `{ type: 'object', properties: … }`, so you only
+	*                need to pass the inner properties map.
+	*                Example: `{ text: { type: 'string', description: 'Input' } }`
+	* @param handler Async function `(args, ctx) => ToolResponse`.
+	* @param profiles Optional profile tiers for this specific tool (defaults to extension-level profiles).
+	*/
+	tool(name, desc, schema, handler, profiles) {
+		this._tools.push({
+			name,
+			description: desc,
+			schema: {
+				type: "object",
+				properties: schema
+			},
+			handler,
+			profiles
+		});
+		return this;
+	}
+	/**
+	* Register one or more workflow contracts exposed by this extension.
+	*
+	* These workflows are registered by the core extension manager alongside
+	* standalone workflow roots, while still preserving plugin ownership.
+	*/
+	workflow(workflow) {
+		this._workflows.push(...Array.isArray(workflow) ? workflow : [workflow]);
+		return this;
+	}
+	onLoad(h) {
+		this._onLoadHandler = h;
+		return this;
+	}
+	onValidate(h) {
+		this._onValidateHandler = h;
+		return this;
+	}
+	onActivate(h) {
+		this._onActivateHandler = h;
+		return this;
+	}
+	onDeactivate(h) {
+		this._onDeactivateHandler = h;
+		return this;
+	}
+};
+function createExtension(id, version) {
+	return new ExtensionBuilder(id, version);
+}
+//#endregion
+export { createExtension, errorResponse, getPluginBooleanConfig, getPluginBoostTier, jsonResponse, loadPluginEnv };

package/dist/types-BBjOqye-.mjs

@@ -0,0 +1,37 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { promisify } from "util";
+import { exec, execFile } from "child_process";
+//#region src/modules/process/memory/types.ts
+/**
+* Shared types and utility helpers for the memory sub-modules.
+*/
+var types_exports = /* @__PURE__ */ __exportAll({
+	execAsync: () => execAsync,
+	execFileAsync: () => execFileAsync,
+	executePowerShellScript: () => executePowerShellScript
+});
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+function getPowerShellExecutable() {
+	return process.platform === "win32" ? "powershell.exe" : "powershell";
+}
+async function executePowerShellScript(script, options = {}) {
+	const args = [
+		"-NoProfile",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-EncodedCommand",
+		Buffer.from(script, "utf16le").toString("base64")
+	];
+	const { stdout, stderr } = await execFileAsync(getPowerShellExecutable(), args, {
+		maxBuffer: options.maxBuffer ?? 1024 * 1024,
+		timeout: options.timeout,
+		windowsHide: true
+	});
+	return {
+		stdout: String(stdout ?? ""),
+		stderr: String(stderr ?? "")
+	};
+}
+//#endregion
+export { types_exports as i, execFileAsync as n, executePowerShellScript as r, execAsync as t };