@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/utils/config.js

@@ -1,12 +1,10 @@
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 import { config as dotenvConfig } from 'dotenv';
 import { z } from 'zod';
 import { DEFAULT_SEARCH_CONFIG } from '../config/search-defaults.js';
-const currentFilename = fileURLToPath(import.meta.url);
-const currentDirname = dirname(currentFilename);
-export const projectRoot = join(currentDirname, '..', '..');
-const envPath = join(projectRoot, '.env');
+export const projectRoot = fileURLToPath(new URL('../..', import.meta.url));
+const envPath = fileURLToPath(new URL('../../.env', import.meta.url));
 let envLoaded = false;
 function loadEnvIfNeeded() {
     if (envLoaded) {
@@ -34,13 +32,6 @@ const envBool = (fallback) => z
     .optional()
     .transform((v) => (v === undefined ? fallback : v === 'true'));
 const ConfigSchema = z.object({
-    DEFAULT_LLM_PROVIDER: z.enum(['openai', 'anthropic']).optional().default('openai'),
-    OPENAI_API_KEY: z.string().optional().default(''),
-    OPENAI_MODEL: z.string().optional().default('gpt-4-turbo-preview'),
-    OPENAI_BASE_URL: z.string().optional(),
-    ANTHROPIC_API_KEY: z.string().optional().default(''),
-    ANTHROPIC_MODEL: z.string().optional().default('claude-3-5-sonnet-20241022'),
-    ANTHROPIC_BASE_URL: z.string().optional(),
     PUPPETEER_HEADLESS: envBool(false),
     PUPPETEER_TIMEOUT: envInt(30000).pipe(z.number().min(1000).max(300000)),
     PUPPETEER_EXECUTABLE_PATH: z.string().optional(),
@@ -192,19 +183,6 @@ export function getConfig() {
         : join(projectRoot, cacheDir);
     const search = buildSearchConfig();
     return {
-        llm: {
-            provider: (env.DEFAULT_LLM_PROVIDER || 'openai'),
-            openai: {
-                apiKey: env.OPENAI_API_KEY || '',
-                model: env.OPENAI_MODEL || 'gpt-4-turbo-preview',
-                baseURL: env.OPENAI_BASE_URL,
-            },
-            anthropic: {
-                apiKey: env.ANTHROPIC_API_KEY || '',
-                model: env.ANTHROPIC_MODEL || 'claude-3-5-sonnet-20241022',
-                baseURL: env.ANTHROPIC_BASE_URL,
-            },
-        },
         puppeteer: {
             headless: parsed.success
                 ? env.PUPPETEER_HEADLESS

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.2",
-  "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.5",
+  "description": "MCP server with 327 built-in tools across 23 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,63 +62,17 @@
       "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",
@@ -81,32 +82,24 @@
     "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",
     "cross-env": "^10.1.0",
-    "eslint": "^10.0.2",
     "estree-walker": "^2.0.2",
     "lefthook": "^2.1.3",
     "medium-zoom": "^1.1.0",
     "nodemon": "^3.1.14",
-    "prettier": "^3.8.1",
-    "quickjs-emscripten": "^0.32.0",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.56.0",
     "tsc-alias": "^1.8.16",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
@@ -115,34 +108,45 @@
     "vitest": "^4.0.18",
     "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"
   },
+  "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.json && pnpm -C packages/extension-sdk typecheck",
+    "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": "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",
     "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 && 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

@@ -1,37 +1,37 @@
-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);
-}
-
-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 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);
+}
+
+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);

package/src/native/scripts/linux/enum-windows.sh

@@ -1,12 +1,12 @@
-#!/bin/bash
-# enum-windows.sh
-# Linux window enumeration script (placeholder)
-
-TARGET_PID=$1
-
-# Use xdotool or wmctrl for window enumeration
-# This is a placeholder for future implementation
-
-if command -v xdotool &> /dev/null; then
-    xdotool search --pid "$TARGET_PID" --name "" get-window-name
-fi
+#!/bin/bash
+# enum-windows.sh
+# Linux window enumeration script (placeholder)
+
+TARGET_PID=$1
+
+# Use xdotool or wmctrl for window enumeration
+# This is a placeholder for future implementation
+
+if command -v xdotool &> /dev/null; then
+    xdotool search --pid "$TARGET_PID" --name "" get-window-name
+fi