@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/utils/environmentDoctor.js

@@ -5,22 +5,30 @@ import { ToolRegistry } from '../modules/external/ToolRegistry.js';
 import { GHIDRA_BRIDGE_ENDPOINT, IDA_BRIDGE_ENDPOINT } from '../constants.js';
 import { getProjectRoot } from './outputPaths.js';
 import { getArtifactRetentionConfig } from './artifactRetention.js';
+import { probeBetterSqlite3 } from './betterSqlite3.js';
 const execFileAsync = promisify(execFile);
 const require = createRequire(import.meta.url);
 export async function runEnvironmentDoctor(options) {
     const includeBridgeHealth = options?.includeBridgeHealth ?? true;
     const registry = new ToolRegistry();
     const externalResults = await registry.probeAll(true);
+    const gitCommand = await checkCommand('git', ['--version']);
+    const pythonCommand = await checkCommand('python', ['--version']);
+    const pnpmCommand = await checkPnpmCommand();
+    const corepackCommand = normalizeCorepackCheck(await checkCommand('corepack', ['--version']), pnpmCommand);
     const packages = [
         checkPackage('@modelcontextprotocol/sdk'),
         checkPackage('rebrowser-puppeteer-core'),
+        checkBetterSqlite3(),
         checkPackage('camoufox-js', 'Optional Firefox anti-detect driver'),
         checkPackage('playwright-core', 'Optional browser automation dependency'),
+        checkNativeMemory(),
     ];
     const commands = [
-        await checkCommand('git', ['--version']),
-        await checkCommand('python', ['--version']),
-        await checkCommand('pnpm', ['--version']),
+        gitCommand,
+        pythonCommand,
+        pnpmCommand,
+        corepackCommand,
         ...Object.entries(externalResults).map(([name, result]) => ({
             name,
             status: (result.available ? 'ok' : 'missing'),
@@ -127,17 +135,118 @@ function checkPackage(packageName, missingHint) {
         };
     }
 }
-async function checkCommand(command, args) {
+function checkBetterSqlite3() {
+    const result = probeBetterSqlite3();
+    return {
+        name: 'better-sqlite3',
+        status: result.status,
+        detail: result.detail,
+    };
+}
+function isPnpmOperational(pnpm) {
+    return pnpm.status === 'ok' || pnpm.detail.includes('npx fallback works');
+}
+async function checkPnpmCommand() {
+    const direct = await checkCommand('pnpm', ['--version']);
+    if (direct.status === 'ok') {
+        return direct;
+    }
+    const npxFallback = await checkCommand('npx', ['pnpm', '--version'], 10_000);
+    if (npxFallback.status === 'ok') {
+        return {
+            name: 'pnpm',
+            status: 'warn',
+            detail: `direct pnpm command unavailable; npx fallback works (${npxFallback.detail})`,
+        };
+    }
+    return direct;
+}
+function normalizeCorepackCheck(corepack, pnpm) {
+    if (corepack.status !== 'missing' || !isPnpmOperational(pnpm)) {
+        return corepack;
+    }
+    return {
+        name: corepack.name,
+        status: 'warn',
+        detail: process.platform === 'win32'
+            ? pnpm.detail.includes('npx fallback works')
+                ? 'corepack not found; use `npx pnpm` directly (common with nvm4w-managed Node on Windows)'
+                : 'corepack not found; standalone pnpm is available (common with nvm4w-managed Node on Windows)'
+            : pnpm.detail.includes('npx fallback works')
+                ? 'corepack not found; use `npx pnpm` directly'
+                : 'corepack not found; standalone pnpm is available',
+    };
+}
+function checkNativeMemory() {
+    try {
+        const koffiPkg = require.resolve('koffi/package.json');
+        const koffiJson = require(koffiPkg);
+        const koffiVersion = koffiJson.version ?? 'unknown';
+        if (process.platform === 'win32') {
+            return {
+                name: 'native-memory',
+                status: 'ok',
+                detail: `koffi ${koffiVersion} — Win32 kernel32.dll available`,
+            };
+        }
+        if (process.platform === 'darwin') {
+            try {
+                const koffi = require('koffi');
+                const lib = koffi.load('/usr/lib/libSystem.B.dylib');
+                lib.unload();
+                return {
+                    name: 'native-memory',
+                    status: 'ok',
+                    detail: `koffi ${koffiVersion} — macOS libSystem.B.dylib available (Mach APIs need root + SIP config)`,
+                };
+            }
+            catch {
+                return {
+                    name: 'native-memory',
+                    status: 'warn',
+                    detail: `koffi ${koffiVersion} installed but cannot load libSystem.B.dylib`,
+                };
+            }
+        }
+        return {
+            name: 'native-memory',
+            status: 'warn',
+            detail: `koffi ${koffiVersion} — no native FFI memory provider for ${process.platform} (proc-based ops available on Linux)`,
+        };
+    }
+    catch {
+        return {
+            name: 'native-memory',
+            status: 'missing',
+            detail: 'koffi not installed — native memory tools unavailable. Install with: pnpm add koffi',
+        };
+    }
+}
+async function checkCommand(command, args, timeout = 4000) {
     try {
         const { stdout, stderr } = await execFileAsync(command, args, {
-            timeout: 4000,
+            timeout,
             windowsHide: true,
         });
         const detail = `${stdout || stderr}`.trim().split(/\r?\n/)[0] || 'available';
         return { name: command, status: 'ok', detail };
     }
     catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
+        let finalError = error;
+        if (process.platform === 'win32') {
+            try {
+                const { stdout, stderr } = await execFileAsync('cmd', ['/c', command, ...args], {
+                    timeout,
+                    windowsHide: true,
+                });
+                const detail = `${stdout || stderr}`.trim().split(/\r?\n/)[0] || 'available';
+                return { name: command, status: 'ok', detail: `${detail} (via cmd)` };
+            }
+            catch (cmdError) {
+                finalError = cmdError;
+            }
+        }
+        const detail = finalError instanceof Error ? finalError.message : String(finalError);
         const missing = /ENOENT|not recognized|not found/i.test(detail);
         return {
             name: command,
@@ -168,25 +277,43 @@ async function checkHttpEndpoint(name, url) {
 }
 function buildPlatformLimitations() {
     const limitations = [];
-    if (process.platform !== 'win32') {
-        limitations.push('Memory write / injection tools are Windows-only; on Linux/macOS prefer browser hooks, network capture, or Frida-based alternatives.');
+    if (process.platform === 'darwin') {
+        limitations.push('26 cross-platform memory tools available (scan, pointer-chain, structure-analysis, heap). ' +
+            '15 Windows-only tools unavailable (PE analysis, anti-cheat, code injection, speedhack, hardware breakpoints).');
+        limitations.push('Native memory operations (mach_vm_read/write) require root privileges and may require SIP configuration on ARM64.');
     }
-    if (process.platform === 'linux') {
+    else if (process.platform === 'linux') {
+        limitations.push('Process management available via /proc. Native FFI memory provider not implemented — memory read/write uses /proc/pid/mem (requires root or CAP_SYS_PTRACE).');
         limitations.push('Camoufox runs on Linux, but some Chrome/CDP-heavy workflows are better served by the Chrome driver.');
     }
-    if (process.platform === 'darwin') {
-        limitations.push('macOS users should expect some Windows-native process tooling to be unavailable.');
+    else if (process.platform !== 'win32') {
+        limitations.push(`Platform ${process.platform} is not supported for native memory operations. Use Windows or macOS.`);
     }
     return limitations;
 }
 function buildRecommendations(packages, commands, bridges, limitations) {
     const recommendations = [];
+    const pnpmCommand = commands.find((item) => item.name === 'pnpm');
+    const corepackCommand = commands.find((item) => item.name === 'corepack');
+    if (packages.some((item) => item.name === 'better-sqlite3' && item.status !== 'ok')) {
+        recommendations.push('Install or rebuild the optional SQLite trace backend with `pnpm add -O better-sqlite3@12.6.2` or `npm rebuild better-sqlite3 --foreground-scripts` under the active Node version if you need trace tooling.');
+    }
     if (packages.some((item) => item.name === 'camoufox-js' && item.status !== 'ok')) {
         recommendations.push('Install optional browser dependencies with `pnpm run install:full` if you need Camoufox support.');
     }
     if (commands.some((item) => item.name.startsWith('wabt.') && item.status !== 'ok')) {
         recommendations.push('Install wabt if you need full WASM disassembly/decompilation; otherwise the server will stay in basic mode.');
     }
+    if (pnpmCommand && !isPnpmOperational(pnpmCommand)) {
+        recommendations.push('Install pnpm or enable Corepack (`corepack enable`) before running package-management workflows.');
+    }
+    else if (pnpmCommand?.detail.includes('npx fallback works')) {
+        recommendations.push('Use `npx pnpm` directly on this machine or repair the local pnpm/Corepack shim if scripts expect bare `pnpm`.');
+    }
+    else if (corepackCommand?.status === 'warn' &&
+        corepackCommand.detail.includes('standalone pnpm')) {
+        recommendations.push('Use `pnpm` or `npx pnpm` directly on this machine; `corepack` is optional and may be absent on nvm4w-managed Windows installs.');
+    }
     if (bridges.some((item) => item.status !== 'ok')) {
         recommendations.push('Check local bridge endpoints (Ghidra / IDA / Burp) before relying on native-bridge workflows.');
     }

package/dist/src/utils/outputPaths.js

@@ -1,9 +1,14 @@
 import { mkdir } from 'node:fs/promises';
 import { basename, dirname, extname, isAbsolute, normalize, relative, resolve, sep, } from 'node:path';
 import { fileURLToPath } from 'node:url';
-const currentFile = fileURLToPath(import.meta.url);
-const currentDir = dirname(currentFile);
-const projectRoot = resolve(currentDir, '..', '..');
+const defaultProjectRoot = fileURLToPath(new URL('../..', import.meta.url));
+function resolveProjectRoot(env = process.env) {
+    const requestedRoot = env.MCP_PROJECT_ROOT?.trim();
+    if (!requestedRoot) {
+        return defaultProjectRoot;
+    }
+    return normalize(isAbsolute(requestedRoot) ? requestedRoot : resolve(defaultProjectRoot, requestedRoot));
+}
 function isInside(baseDir, targetPath) {
     const rel = relative(baseDir, targetPath);
     if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
@@ -11,11 +16,11 @@ function isInside(baseDir, targetPath) {
     }
     return true;
 }
-function resolveWithinProject(inputPath) {
-    const candidate = isAbsolute(inputPath) ? normalize(inputPath) : resolve(projectRoot, inputPath);
-    return isInside(projectRoot, candidate)
+function resolveWithinProject(inputPath, baseRoot = getProjectRoot()) {
+    const candidate = isAbsolute(inputPath) ? normalize(inputPath) : resolve(baseRoot, inputPath);
+    return isInside(baseRoot, candidate)
         ? candidate
-        : resolve(projectRoot, 'screenshots', 'external', normalize(inputPath).split(/[\\/]/).pop() || 'output.bin');
+        : resolve(baseRoot, 'screenshots', 'external', normalize(inputPath).split(/[\\/]/).pop() || 'output.bin');
 }
 function withDefaultExtension(filePath, extension) {
     if (extname(filePath)) {
@@ -24,20 +29,22 @@ function withDefaultExtension(filePath, extension) {
     return `${filePath}.${extension.replace(/^\./, '')}`;
 }
 export function getProjectRoot() {
-    return projectRoot;
+    return resolveProjectRoot();
 }
 export function resolveOutputDirectory(inputDir, fallbackDir = 'screenshots') {
+    const projectRoot = getProjectRoot();
     const requested = inputDir?.trim();
     if (!requested) {
         return resolve(projectRoot, fallbackDir);
     }
-    const resolved = resolveWithinProject(requested);
+    const resolved = resolveWithinProject(requested, projectRoot);
     if (isInside(projectRoot, resolved)) {
         return resolved;
     }
     return resolve(projectRoot, fallbackDir);
 }
 export async function resolveScreenshotOutputPath(options) {
+    const projectRoot = getProjectRoot();
     const extension = options.type === 'jpeg' ? 'jpg' : 'png';
     const fallbackDir = options.fallbackDir || 'screenshots/manual';
     const fallbackName = options.fallbackName || 'page';

package/dist/src/utils/parallel.js

@@ -44,9 +44,7 @@ export async function parallelExecute(items, executor, options = {}) {
                 duration: Date.now() - startTime,
             };
         })();
-        const wrappedTask = task.then(() => {
-            executing.delete(wrappedTask);
-        }, () => {
+        const wrappedTask = task.finally(() => {
             executing.delete(wrappedTask);
         });
         executing.add(wrappedTask);

package/package.json

@@ -1,8 +1,55 @@
 {
   "name": "@jshookmcp/jshook",
-  "version": "0.2.3",
-  "description": "MCP server with 249 built-in tools (242 domain tools across 17 domains plus 7 built-in meta-tools) for AI-assisted JavaScript analysis and security analysis — browser automation, CDP debugging, network monitoring, JS hooks, code analysis, and workflow orchestration",
-  "mcpName": "io.github.vmoranv/jshookmcp",
+  "version": "0.2.6",
+  "description": "MCP server with 337 built-in tools across 24 domains for AI-assisted JavaScript analysis and security analysis — browser automation, CDP debugging, network monitoring, JS hooks, code analysis, and workflow orchestration",
+  "keywords": [
+    "ai",
+    "anti-detection",
+    "ast",
+    "browser-automation",
+    "captcha",
+    "chrome-devtools",
+    "claude",
+    "code-analysis",
+    "cryptography-detection",
+    "debugger",
+    "deobfuscation",
+    "hook",
+    "hooking",
+    "javascript",
+    "javascript-analysis",
+    "mcp",
+    "model-context-protocol",
+    "network-monitoring",
+    "obfuscation",
+    "puppeteer",
+    "security-analysis",
+    "web-scraping"
+  ],
+  "homepage": "https://github.com/vmoranv/jshookmcp#readme",
+  "bugs": {
+    "url": "https://github.com/vmoranv/jshookmcp/issues"
+  },
+  "license": "AGPL-3.0-only",
+  "author": {
+    "name": "vmoranv",
+    "url": "https://github.com/vmoranv"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vmoranv/jshookmcp.git"
+  },
+  "bin": {
+    "jshook": "dist/src/index.js",
+    "jshookmcp": "dist/src/index.js"
+  },
+  "files": [
+    "dist",
+    "workflows",
+    "src/native/scripts",
+    "scripts/postinstall.cjs"
+  ],
+  "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "exports": {
@@ -15,136 +62,90 @@
       "types": "./dist/src/server/plugin-api.d.ts"
     }
   },
-  "type": "module",
-  "files": [
-    "dist",
-    "src/native/scripts",
-    "scripts/postinstall.cjs"
-  ],
-  "bin": {
-    "jshook": "dist/src/index.js",
-    "jshookmcp": "dist/src/index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/vmoranv/jshookmcp.git"
-  },
-  "bugs": {
-    "url": "https://github.com/vmoranv/jshookmcp/issues"
-  },
-  "homepage": "https://github.com/vmoranv/jshookmcp#readme",
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "javascript",
-    "javascript-analysis",
-    "security-analysis",
-    "hook",
-    "hooking",
-    "deobfuscation",
-    "ai",
-    "claude",
-    "puppeteer",
-    "chrome-devtools",
-    "debugger",
-    "web-scraping",
-    "anti-detection",
-    "captcha",
-    "browser-automation",
-    "network-monitoring",
-    "ast",
-    "obfuscation",
-    "cryptography-detection",
-    "code-analysis"
-  ],
-  "author": {
-    "name": "vmoranv",
-    "url": "https://github.com/vmoranv"
-  },
-  "license": "AGPL-3.0-only",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
     "@babel/generator": "^7.29.1",
     "@babel/parser": "^7.29.0",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
+    "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
-    "dotenv": "^17.3.1",
+    "dotenv": "^17.4.0",
     "koffi": "^2.15.1",
     "openai": "^6.25.0",
     "ora": "^9.3.0",
+    "quickjs-emscripten": "^0.32.0",
     "rebrowser-puppeteer-core": "^24.8.1",
     "tinyglobby": "^0.2.15",
     "zod": "^4.3.6"
   },
-  "optionalDependencies": {
-    "camoufox-js": "^0.9.1",
-    "playwright-core": "^1.58.2",
-    "webcrack": "^2.15.1"
-  },
   "devDependencies": {
-    "@huggingface/transformers": "^3.8.1",
     "@types/babel__generator": "^7.27.0",
     "@types/babel__traverse": "^7.28.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.56.1",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.2",
     "cross-env": "^10.1.0",
-    "eslint": "^10.0.2",
     "estree-walker": "^2.0.2",
-    "lefthook": "^2.1.3",
+    "lefthook": "^2.1.4",
     "medium-zoom": "^1.1.0",
-    "nodemon": "^3.1.14",
-    "oxlint": "^1.56.0",
-    "prettier": "^3.8.1",
-    "quickjs-emscripten": "^0.32.0",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
     "tsc-alias": "^1.8.16",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vite": "^6.0.0",
+    "vite": "^8.0.2",
     "vitepress": "1.6.4",
-    "vitest": "^4.0.18",
+    "vitest": "^4.1.2",
     "vue": "^3.5.30"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "12.6.2",
+    "camoufox-js": "^0.9.1",
+    "playwright-core": "^1.58.2",
+    "webcrack": "^2.15.1"
+  },
   "engines": {
-    "node": ">=20.0.0"
+    "node": "^20.19.0 || >=22.12.0"
   },
+  "mcpName": "io.github.vmoranv/jshookmcp",
   "scripts": {
     "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json --resolve-full-paths && pnpm -C packages/extension-sdk build && node scripts/copy-native-scripts.mjs && node scripts/generate-entry-reexport.mjs && node scripts/fix-bin-permissions.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.build.json && pnpm -C packages/extension-sdk typecheck",
     "dev": "tsx --conditions=development watch src/index.ts",
     "start": "node dist/src/index.js",
     "doctor": "tsx src/cli/doctor.ts",
-    "docs:generate": "node scripts/generate-vitepress-reference.mjs && prettier \"docs/reference/**/*.md\" \"docs/en/reference/**/*.md\" --write",
+    "docs:generate": "node scripts/generate-vitepress-reference.mjs",
     "docs:dev": "vitepress dev docs --host 127.0.0.1 --port 5173",
     "docs:build": "pnpm run docs:generate && vitepress build docs",
     "docs:preview": "vitepress preview docs --host 127.0.0.1 --port 4173",
     "lint:md": "pnpm dlx markdownlint-cli2",
-    "format:docs": "pnpm run docs:generate && prettier docs .github README.md README.zh.md CONTRIBUTING.md --write",
-    "check:docs-format": "prettier docs .github README.md README.zh.md CONTRIBUTING.md --check",
-    "lint:ox": "oxlint src/ tests/",
-    "lint": "eslint src --ext .ts",
-    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "oxlint src/ tests/",
+    "lint:fix": "oxlint --fix src/ tests/",
+    "format": "oxfmt \"src/**\" \"tests/**\" \"!tests/tmp/**\" --write --no-error-on-unmatched-pattern",
+    "format:check": "oxfmt \"src/**\" \"tests/**\" \"!tests/tmp/**\" --check --no-error-on-unmatched-pattern",
     "test": "vitest run",
     "test:e2e": "cross-env E2E_TARGET_URL=https://vmoranv.github.io/jshookmcp/ vitest run --config tests/e2e/vitest.e2e.config.ts",
-    "test:coverage": "cross-env ENABLE_INJECTION_TOOLS=true vitest run --coverage",
+    "test:coverage": "node -e \"require('fs').mkdirSync('coverage/.tmp', { recursive: true })\" && cross-env ENABLE_INJECTION_TOOLS=true COVERAGE_FULL=true vitest run --coverage",
     "package:verify-bin": "node scripts/verify-packed-bin.mjs",
     "package:verify-install": "node scripts/verify-packed-install.mjs",
     "package:verify-release": "node scripts/verify-release-artifact.mjs",
-    "audit:tools": "node scripts/audit-tools.mjs",
-    "check": "pnpm run lint:ox && pnpm run lint && pnpm run typecheck && pnpm run test",
+    "audit:tools": "tsx scripts/audit-tools.mjs",
+    "git:refresh-noise": "node scripts/refresh-git-noise.mjs",
+    "check": "pnpm run metadata:check && pnpm run lint && pnpm run format:check && pnpm run typecheck && pnpm run test",
     "package": "pnpm pack",
     "postinstall": "node scripts/postinstall.cjs",
-    "install:full": "pnpm install && pnpm exec camoufox-js fetch"
+    "install:full": "pnpm install && pnpm exec camoufox-js fetch",
+    "metadata:sync": "node scripts/generate-metadata.mjs --write",
+    "metadata:check": "node scripts/generate-metadata.mjs --check",
+    "check:docs-format": "pnpm run lint:md"
   }
 }

package/scripts/postinstall.cjs

@@ -2,36 +2,63 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 
-const repoGitDir = path.join(process.cwd(), '.git');
-const localBin = path.join(
-  process.cwd(),
-  'node_modules',
-  '.bin',
-  process.platform === 'win32' ? 'lefthook.cmd' : 'lefthook'
-);
-
-if (!fs.existsSync(repoGitDir)) {
-  process.exit(0);
-}
+const repoGitDir = path.join(process.cwd(), '.git');
+const localBin = path.join(
+  process.cwd(),
+  'node_modules',
+  '.bin',
+  process.platform === 'win32' ? 'lefthook.cmd' : 'lefthook'
+);
+const isCi = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+
+if (isCi || !fs.existsSync(repoGitDir)) {
+  process.exit(0);
+}
 
 if (!fs.existsSync(localBin)) {
   console.warn('[postinstall] lefthook not found locally; skipping git hook installation.');
   process.exit(0);
 }
 
-const result = spawnSync(localBin, ['install'], {
-  stdio: 'inherit',
-  shell: process.platform === 'win32',
-});
-
-if (result.error) {
-  console.warn(
-    `[postinstall] lefthook install failed to spawn: ${result.error.message}; skipping git hook installation.`
-  );
-} else if (result.status !== 0) {
-  console.warn(
-    `[postinstall] lefthook install exited with status ${result.status}; skipping git hook installation.`
-  );
-}
-
-process.exit(0);
+const hooksPathResult = spawnSync('git', ['config', '--local', '--get', 'core.hooksPath'], {
+  encoding: 'utf8',
+  shell: process.platform === 'win32',
+});
+
+const configuredHooksPath = hooksPathResult.status === 0 ? hooksPathResult.stdout.trim() : '';
+if (configuredHooksPath) {
+  const resolvedHooksPath = path.resolve(process.cwd(), configuredHooksPath);
+  const defaultHooksPath = path.resolve(repoGitDir, 'hooks');
+
+  if (resolvedHooksPath === defaultHooksPath) {
+    process.exit(0);
+  }
+
+  console.warn(
+    `[postinstall] core.hooksPath is already set to "${configuredHooksPath}"; skipping git hook installation.`
+  );
+  process.exit(0);
+}
+
+const result = spawnSync(localBin, ['install'], {
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe'],
+  shell: process.platform === 'win32',
+});
+
+if (result.error) {
+  console.warn(
+    `[postinstall] lefthook install failed to spawn: ${result.error.message}; skipping git hook installation.`
+  );
+} else if (result.status !== 0) {
+  const firstDetailLine = [result.stdout, result.stderr]
+    .join('\n')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+  console.warn(
+    `[postinstall] lefthook install exited with status ${result.status}; skipping git hook installation${firstDetailLine ? ` (${firstDetailLine})` : ''}.`
+  );
+}
+
+process.exit(0);

package/workflows/anti-bot-diagnoser/.jshook-install.json

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "kind": "workflow",
+  "slug": "anti-bot-diagnoser",
+  "id": "workflow.anti-bot-diagnoser.v1",
+  "source": {
+    "type": "git",
+    "repo": "https://github.com/vmoranv/jshook_workflow_anti_bot_diagnoser",
+    "ref": "main",
+    "commit": "b7e270de2a0cbb90ed431bd9de4fcd101cc53439",
+    "subpath": ".",
+    "entry": "workflow.ts"
+  }
+}

package/workflows/anti-bot-diagnoser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vmoranv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.