@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/src/server/domains/hooks/preset-definitions.security.js

@@ -2,140 +2,140 @@ import { buildHookCode } from '../../domains/hooks/preset-builder.js';
 export const SECURITY_PRESETS = {
     'anti-debug-bypass': {
         description: ' Block anti-debugging: setInterval/setTimeout debugger traps, console.clear spam, timing attacks (performance.now freeze), outerWidth/outerHeight devtools detection',
-        buildCode: (cs, lc) => buildHookCode('anti-debug-bypass', `
-  window.__aiHooks['preset-anti-debug-bypass'] = window.__aiHooks['preset-anti-debug-bypass'] || [];
-  // 1. Block setInterval/setTimeout containing debugger/devtools
-  const _si = window.setInterval;
-  window.setInterval = function(fn, delay) {
-    const rest = Array.prototype.slice.call(arguments, 2);
-    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
-    if (fnStr.includes('debugger') || fnStr.includes('devtools') || fnStr.includes('disable-devtool')) {
-      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setInterval', fn: fnStr.substring(0, 200), ts: Date.now() });
-      return -1;
-    }
-    return _si.apply(this, [fn, delay].concat(rest));
-  };
-  const _st = window.setTimeout;
-  window.setTimeout = function(fn, delay) {
-    const rest = Array.prototype.slice.call(arguments, 2);
-    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
-    if (fnStr.includes('debugger') || fnStr.includes('devtools')) {
-      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setTimeout', fn: fnStr.substring(0, 200), ts: Date.now() });
-      return -1;
-    }
-    return _st.apply(this, [fn, delay].concat(rest));
-  };
-  // 2. Suppress console.clear spam
-  console.clear = function() {
-    window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'console.clear', ts: Date.now() });
-  };
-  // 3. Freeze performance.now to defeat timing attacks
-  const _pn = performance.now.bind(performance);
-  let _t = _pn();
-  performance.now = function() { return (_t += 0.001); };
-  // 4. Fix outerWidth/outerHeight DevTools size detection
-  Object.defineProperty(window, 'outerWidth', { get: function() { return window.innerWidth; }, configurable: true });
+        buildCode: (cs, lc) => buildHookCode('anti-debug-bypass', `
+  window.__aiHooks['preset-anti-debug-bypass'] = window.__aiHooks['preset-anti-debug-bypass'] || [];
+  // 1. Block setInterval/setTimeout containing debugger/devtools
+  const _si = window.setInterval;
+  window.setInterval = function(fn, delay) {
+    const rest = Array.prototype.slice.call(arguments, 2);
+    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
+    if (fnStr.includes('debugger') || fnStr.includes('devtools') || fnStr.includes('disable-devtool')) {
+      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setInterval', fn: fnStr.substring(0, 200), ts: Date.now() });
+      return -1;
+    }
+    return _si.apply(this, [fn, delay].concat(rest));
+  };
+  const _st = window.setTimeout;
+  window.setTimeout = function(fn, delay) {
+    const rest = Array.prototype.slice.call(arguments, 2);
+    const fnStr = typeof fn === 'function' ? fn.toString() : String(fn);
+    if (fnStr.includes('debugger') || fnStr.includes('devtools')) {
+      window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'setTimeout', fn: fnStr.substring(0, 200), ts: Date.now() });
+      return -1;
+    }
+    return _st.apply(this, [fn, delay].concat(rest));
+  };
+  // 2. Suppress console.clear spam
+  console.clear = function() {
+    window.__aiHooks['preset-anti-debug-bypass'].push({ blocked: 'console.clear', ts: Date.now() });
+  };
+  // 3. Freeze performance.now to defeat timing attacks
+  const _pn = performance.now.bind(performance);
+  let _t = _pn();
+  performance.now = function() { return (_t += 0.001); };
+  // 4. Fix outerWidth/outerHeight DevTools size detection
+  Object.defineProperty(window, 'outerWidth', { get: function() { return window.innerWidth; }, configurable: true });
   Object.defineProperty(window, 'outerHeight', { get: function() { return window.innerHeight; }, configurable: true });`, cs, lc),
     },
     'crypto-key-capture': {
         description: ' Force extractable:true on all WebCrypto importKey calls and capture plaintext/ciphertext + key material for encrypt/decrypt/sign/verify',
-        buildCode: (cs, lc) => buildHookCode('crypto-key-capture', `
-  if (window.crypto && window.crypto.subtle) {
-    const _subtle = window.crypto.subtle;
-    const _importKey = _subtle.importKey.bind(_subtle);
-    const _encrypt  = _subtle.encrypt.bind(_subtle);
-    const _decrypt  = _subtle.decrypt.bind(_subtle);
-    const _sign     = _subtle.sign.bind(_subtle);
-    const _verify   = _subtle.verify.bind(_subtle);
-    const _exportKey = _subtle.exportKey.bind(_subtle);
-    const toHex = function(buf) {
-      return Array.from(new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer || buf))
-        .map(function(b) { return b.toString(16).padStart(2,'0'); }).join('');
-    };
-    const tryExport = async function(key) {
-      try { return await _exportKey('jwk', key); } catch(e) { return null; }
-    };
-    _subtle.importKey = async function(format, keyData, algorithm, extractable, usages) {
-      {{STACK_CODE}}
-      const keyHex = (keyData instanceof ArrayBuffer || ArrayBuffer.isView(keyData)) ? toHex(keyData) : JSON.stringify(keyData);
-      const __msg = '[Hook:importKey] format=' + format + ' algo=' + JSON.stringify(algorithm) + ' key=' + keyHex.substring(0,64);
-      {{LOG_FN}}
-      const key = await _importKey(format, keyData, algorithm, true, usages);
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'importKey', format, algorithm: JSON.stringify(algorithm), keyHex, stack: __stack, ts: Date.now() });
-      return key;
-    };
-    _subtle.encrypt = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const plainHex = toHex(data);
-      const result = await _encrypt(algo, key, data);
-      const cipherHex = toHex(result);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:encrypt] algo=' + JSON.stringify(algo) + ' plain=' + plainHex.substring(0,64);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'encrypt', algo: JSON.stringify(algo), plainHex, cipherHex, key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
-    _subtle.decrypt = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const result = await _decrypt(algo, key, data);
-      const plainHex = toHex(result);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:decrypt] algo=' + JSON.stringify(algo) + ' plain=' + new TextDecoder().decode(new Uint8Array(result instanceof ArrayBuffer ? result : result.buffer, 0, Math.min(100, (result.byteLength || result.length || 0))));
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'decrypt', algo: JSON.stringify(algo), plainHex, key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
-    _subtle.sign = async function(algo, key, data) {
-      {{STACK_CODE}}
-      const result = await _sign(algo, key, data);
-      const keyJwk = await tryExport(key);
-      const __msg = '[Hook:sign] algo=' + JSON.stringify(algo);
-      {{LOG_FN}}
-      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'sign', algo: JSON.stringify(algo), sigHex: toHex(result), key: keyJwk, stack: __stack, ts: Date.now() });
-      return result;
-    };
+        buildCode: (cs, lc) => buildHookCode('crypto-key-capture', `
+  if (window.crypto && window.crypto.subtle) {
+    const _subtle = window.crypto.subtle;
+    const _importKey = _subtle.importKey.bind(_subtle);
+    const _encrypt  = _subtle.encrypt.bind(_subtle);
+    const _decrypt  = _subtle.decrypt.bind(_subtle);
+    const _sign     = _subtle.sign.bind(_subtle);
+    const _verify   = _subtle.verify.bind(_subtle);
+    const _exportKey = _subtle.exportKey.bind(_subtle);
+    const toHex = function(buf) {
+      return Array.from(new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer || buf))
+        .map(function(b) { return b.toString(16).padStart(2,'0'); }).join('');
+    };
+    const tryExport = async function(key) {
+      try { return await _exportKey('jwk', key); } catch(e) { return null; }
+    };
+    _subtle.importKey = async function(format, keyData, algorithm, extractable, usages) {
+      {{STACK_CODE}}
+      const keyHex = (keyData instanceof ArrayBuffer || ArrayBuffer.isView(keyData)) ? toHex(keyData) : JSON.stringify(keyData);
+      const __msg = '[Hook:importKey] format=' + format + ' algo=' + JSON.stringify(algorithm) + ' key=' + keyHex.substring(0,64);
+      {{LOG_FN}}
+      const key = await _importKey(format, keyData, algorithm, true, usages);
+      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'importKey', format, algorithm: JSON.stringify(algorithm), keyHex, stack: __stack, ts: Date.now() });
+      return key;
+    };
+    _subtle.encrypt = async function(algo, key, data) {
+      {{STACK_CODE}}
+      const plainHex = toHex(data);
+      const result = await _encrypt(algo, key, data);
+      const cipherHex = toHex(result);
+      const keyJwk = await tryExport(key);
+      const __msg = '[Hook:encrypt] algo=' + JSON.stringify(algo) + ' plain=' + plainHex.substring(0,64);
+      {{LOG_FN}}
+      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'encrypt', algo: JSON.stringify(algo), plainHex, cipherHex, key: keyJwk, stack: __stack, ts: Date.now() });
+      return result;
+    };
+    _subtle.decrypt = async function(algo, key, data) {
+      {{STACK_CODE}}
+      const result = await _decrypt(algo, key, data);
+      const plainHex = toHex(result);
+      const keyJwk = await tryExport(key);
+      const __msg = '[Hook:decrypt] algo=' + JSON.stringify(algo) + ' plain=' + new TextDecoder().decode(new Uint8Array(result instanceof ArrayBuffer ? result : result.buffer, 0, Math.min(100, (result.byteLength || result.length || 0))));
+      {{LOG_FN}}
+      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'decrypt', algo: JSON.stringify(algo), plainHex, key: keyJwk, stack: __stack, ts: Date.now() });
+      return result;
+    };
+    _subtle.sign = async function(algo, key, data) {
+      {{STACK_CODE}}
+      const result = await _sign(algo, key, data);
+      const keyJwk = await tryExport(key);
+      const __msg = '[Hook:sign] algo=' + JSON.stringify(algo);
+      {{LOG_FN}}
+      window.__aiHooks['preset-crypto-key-capture'].push({ fn:'sign', algo: JSON.stringify(algo), sigHex: toHex(result), key: keyJwk, stack: __stack, ts: Date.now() });
+      return result;
+    };
   }`, cs, lc),
     },
     'webassembly-full': {
         description: ' Hook WebAssembly.instantiate to log all import calls, export names, and memory creation',
-        buildCode: (cs, lc) => buildHookCode('webassembly-full', `
-  if (typeof WebAssembly !== 'undefined') {
-    const _inst = WebAssembly.instantiate;
-    WebAssembly.instantiate = async function(bufferSource, importObject) {
-      {{STACK_CODE}}
-      const size = bufferSource && (bufferSource.byteLength || bufferSource.length) || 0;
-      const __msg = '[Hook:WASM.instantiate] size=' + size;
-      {{LOG_FN}}
-      // Wrap all imported functions to trace calls
-      if (importObject && typeof importObject === 'object') {
-        Object.keys(importObject).forEach(function(modName) {
-          const mod = importObject[modName];
-          if (mod && typeof mod === 'object') {
-            Object.keys(mod).forEach(function(fnName) {
-              if (typeof mod[fnName] === 'function') {
-                const _fn = mod[fnName];
-                mod[fnName] = function() {
-                  const args = Array.prototype.slice.call(arguments);
-                  window.__aiHooks['preset-webassembly-full'].push({ type:'import_call', mod: modName, fn: fnName, args: args.map(function(a){ return typeof a === 'number' ? a : '?'; }), ts: Date.now() });
-                  return _fn.apply(this, args);
-                };
-              }
-            });
-          }
-        });
-      }
-      const result = await _inst(bufferSource, importObject);
-      const exports = result && result.instance ? Object.keys(result.instance.exports) : [];
-      window.__aiHooks['preset-webassembly-full'].push({ type:'instantiated', size, exports, importMods: importObject ? Object.keys(importObject) : [], stack: __stack, ts: Date.now() });
-      return result;
-    };
-    // Also hook WebAssembly.Memory creation
-    const _Memory = WebAssembly.Memory;
-    WebAssembly.Memory = function(descriptor) {
-      window.__aiHooks['preset-webassembly-full'].push({ type:'memory_created', initial: descriptor && descriptor.initial, maximum: descriptor && descriptor.maximum, shared: descriptor && descriptor.shared, ts: Date.now() });
-      return new _Memory(descriptor);
-    };
-    WebAssembly.Memory.prototype = _Memory.prototype;
+        buildCode: (cs, lc) => buildHookCode('webassembly-full', `
+  if (typeof WebAssembly !== 'undefined') {
+    const _inst = WebAssembly.instantiate;
+    WebAssembly.instantiate = async function(bufferSource, importObject) {
+      {{STACK_CODE}}
+      const size = bufferSource && (bufferSource.byteLength || bufferSource.length) || 0;
+      const __msg = '[Hook:WASM.instantiate] size=' + size;
+      {{LOG_FN}}
+      // Wrap all imported functions to trace calls
+      if (importObject && typeof importObject === 'object') {
+        Object.keys(importObject).forEach(function(modName) {
+          const mod = importObject[modName];
+          if (mod && typeof mod === 'object') {
+            Object.keys(mod).forEach(function(fnName) {
+              if (typeof mod[fnName] === 'function') {
+                const _fn = mod[fnName];
+                mod[fnName] = function() {
+                  const args = Array.prototype.slice.call(arguments);
+                  window.__aiHooks['preset-webassembly-full'].push({ type:'import_call', mod: modName, fn: fnName, args: args.map(function(a){ return typeof a === 'number' ? a : '?'; }), ts: Date.now() });
+                  return _fn.apply(this, args);
+                };
+              }
+            });
+          }
+        });
+      }
+      const result = await _inst(bufferSource, importObject);
+      const exports = result && result.instance ? Object.keys(result.instance.exports) : [];
+      window.__aiHooks['preset-webassembly-full'].push({ type:'instantiated', size, exports, importMods: importObject ? Object.keys(importObject) : [], stack: __stack, ts: Date.now() });
+      return result;
+    };
+    // Also hook WebAssembly.Memory creation
+    const _Memory = WebAssembly.Memory;
+    WebAssembly.Memory = function(descriptor) {
+      window.__aiHooks['preset-webassembly-full'].push({ type:'memory_created', initial: descriptor && descriptor.initial, maximum: descriptor && descriptor.maximum, shared: descriptor && descriptor.shared, ts: Date.now() });
+      return new _Memory(descriptor);
+    };
+    WebAssembly.Memory.prototype = _Memory.prototype;
   }`, cs, lc),
     },
 };

package/dist/src/server/domains/macro/definitions.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const macroTools: Tool[];

package/dist/src/server/domains/macro/definitions.js

@@ -0,0 +1,45 @@
+export const macroTools = [
+    {
+        name: 'run_macro',
+        description: 'Execute a registered macro by ID. Macros chain multiple MCP tools in sequence with inline progress reporting and atomic bailout.\n\nBuilt-in macros:\n- `deobfuscate_ast_flow` — deobfuscate → advanced deobfuscation → extract function tree\n- `unpacker_flow` — detect packer → extract → deobfuscate → beautify\n\nUser-defined macros are loaded from JSON files in `macros/` directory.\n\nUse `list_macros` to see all available macros.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                macroId: {
+                    type: 'string',
+                    description: 'ID of the macro to execute (e.g., "deobfuscate_ast_flow")',
+                },
+                inputOverrides: {
+                    type: 'object',
+                    description: 'Optional per-step input overrides keyed by step ID (e.g., { "deobfuscate": { "code": "..." } })',
+                    additionalProperties: {
+                        type: 'object',
+                        additionalProperties: true,
+                    },
+                },
+            },
+            required: ['macroId'],
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'list_macros',
+        description: 'List all available macros (built-in + user-defined from macros/ directory).',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+];

package/dist/src/server/domains/macro/handlers.d.ts

@@ -0,0 +1,9 @@
+import type { MCPServerContext } from '../../MCPServer.context.js';
+export declare class MacroToolHandlers {
+    private readonly runner;
+    private macros;
+    constructor(ctx: MCPServerContext);
+    private ensureMacrosLoaded;
+    handleRunMacro(args: Record<string, unknown>): Promise<unknown>;
+    handleListMacros(): Promise<unknown>;
+}

package/dist/src/server/domains/macro/handlers.js

@@ -0,0 +1,82 @@
+import { resolve } from 'node:path';
+import { MacroRunner } from '../../macros/MacroRunner.js';
+import { MacroConfigLoader } from '../../macros/MacroConfigLoader.js';
+import { BUILTIN_MACROS } from '../../macros/builtins/index.js';
+import { getProjectRoot } from '../../../utils/outputPaths.js';
+export class MacroToolHandlers {
+    runner;
+    macros = null;
+    constructor(ctx) {
+        this.runner = new MacroRunner(ctx);
+    }
+    async ensureMacrosLoaded() {
+        if (this.macros)
+            return this.macros;
+        this.macros = new Map();
+        for (const m of BUILTIN_MACROS) {
+            this.macros.set(m.id, m);
+        }
+        try {
+            const userMacros = await MacroConfigLoader.loadFromDirectory(resolve(getProjectRoot(), 'macros'));
+            for (const m of userMacros) {
+                this.macros.set(m.id, m);
+            }
+        }
+        catch {
+        }
+        return this.macros;
+    }
+    async handleRunMacro(args) {
+        const macroId = args.macroId;
+        const inputOverrides = args.inputOverrides;
+        if (!macroId || typeof macroId !== 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ ok: false, error: 'macroId parameter is required' }),
+                    },
+                ],
+            };
+        }
+        const macros = await this.ensureMacrosLoaded();
+        const def = macros.get(macroId);
+        if (!def) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            error: `Macro "${macroId}" not found`,
+                            available: Array.from(macros.keys()),
+                        }),
+                    },
+                ],
+            };
+        }
+        const result = await this.runner.execute(def, inputOverrides);
+        const report = this.runner.formatProgressReport(result);
+        return {
+            content: [{ type: 'text', text: report }],
+        };
+    }
+    async handleListMacros() {
+        const macros = await this.ensureMacrosLoaded();
+        const list = Array.from(macros.values()).map((m) => ({
+            id: m.id,
+            displayName: m.displayName,
+            description: m.description,
+            tags: m.tags,
+            stepCount: m.steps.length,
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ macros: list, count: list.length }),
+                },
+            ],
+        };
+    }
+}

package/dist/src/server/domains/macro/index.d.ts

@@ -0,0 +1,2 @@
+export { macroTools } from '../../domains/macro/definitions.js';
+export { MacroToolHandlers } from '../../domains/macro/handlers.js';

package/dist/src/server/domains/macro/index.js

@@ -0,0 +1,2 @@
+export { macroTools } from '../../domains/macro/definitions.js';
+export { MacroToolHandlers } from '../../domains/macro/handlers.js';

package/dist/src/server/domains/macro/manifest.d.ts

@@ -0,0 +1,57 @@
+import type { MCPServerContext } from '../../domains/shared/registry.js';
+import { MacroToolHandlers } from '../../domains/macro/handlers.js';
+type H = MacroToolHandlers;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "macro";
+    depKey: "macroHandlers";
+    profiles: "full"[];
+    ensure: typeof ensure;
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "macro";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
+export default manifest;

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

@@ -0,0 +1,36 @@
+import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
+import { macroTools } from '../../domains/macro/definitions.js';
+import { MacroToolHandlers } from '../../domains/macro/handlers.js';
+const DOMAIN = 'macro';
+const DEP_KEY = 'macroHandlers';
+const t = toolLookup(macroTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+function ensure(ctx) {
+    const existing = ctx.getDomainInstance(DEP_KEY);
+    if (existing)
+        return existing;
+    const handlers = new MacroToolHandlers(ctx);
+    ctx.setDomainInstance(DEP_KEY, handlers);
+    return handlers;
+}
+const manifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: DOMAIN,
+    depKey: DEP_KEY,
+    profiles: ['full'],
+    ensure,
+    registrations: [
+        {
+            tool: t('run_macro'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleRunMacro(a)),
+        },
+        {
+            tool: t('list_macros'),
+            domain: DOMAIN,
+            bind: b((h) => h.handleListMacros()),
+        },
+    ],
+};
+export default manifest;

package/dist/src/server/domains/maintenance/definitions.js

@@ -8,6 +8,12 @@ export const tokenBudgetTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'manual_token_cleanup',
@@ -18,6 +24,12 @@ export const tokenBudgetTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'reset_token_budget',
@@ -27,6 +39,12 @@ export const tokenBudgetTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
 ];
 export const extensionTools = [
@@ -37,6 +55,12 @@ export const extensionTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'reload_extensions',
@@ -46,6 +70,12 @@ export const extensionTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'browse_extension_registry',
@@ -60,6 +90,12 @@ export const extensionTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'install_extension',
@@ -79,6 +115,12 @@ export const extensionTools = [
             },
             required: ['slug'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
 ];
 export const cacheTools = [
@@ -90,6 +132,12 @@ export const cacheTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'smart_cache_cleanup',
@@ -104,6 +152,12 @@ export const cacheTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'clear_all_caches',
@@ -113,6 +167,12 @@ export const cacheTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
 ];
 export const artifactTools = [
@@ -137,6 +197,12 @@ export const artifactTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'doctor_environment',
@@ -151,5 +217,11 @@ export const artifactTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
 ];