@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/platform/handlers/platform-utils.js

@@ -1,241 +0,0 @@
-import { readFile, readdir, stat, mkdir } from 'node:fs/promises';
-import { basename, extname, join, normalize, relative, resolve, sep } from 'node:path';
-import { homedir } from 'node:os';
-import { resolveArtifactPath } from '../../../../utils/artifacts.js';
-import { logger } from '../../../../utils/logger.js';
-export function toTextResponse(payload) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(payload, null, 2),
-            },
-        ],
-    };
-}
-export function toErrorResponse(tool, error, extra = {}) {
-    return toTextResponse({
-        success: false,
-        tool,
-        error: error instanceof Error ? error.message : String(error),
-        ...extra,
-    });
-}
-export function getCollectorState(collector) {
-    void collector;
-    return 'attached';
-}
-export function parseStringArg(args, key, required = false) {
-    const value = args[key];
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed.length > 0) {
-            return trimmed;
-        }
-    }
-    if (required) {
-        throw new Error(`${key} must be a non-empty string`);
-    }
-    return undefined;
-}
-export function parseBooleanArg(args, key, defaultValue) {
-    const value = args[key];
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'number') {
-        if (value === 1)
-            return true;
-        if (value === 0)
-            return false;
-    }
-    if (typeof value === 'string') {
-        const normalized = value.trim().toLowerCase();
-        if (['true', '1', 'yes', 'on'].includes(normalized))
-            return true;
-        if (['false', '0', 'no', 'off'].includes(normalized))
-            return false;
-    }
-    return defaultValue;
-}
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function toStringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const output = [];
-    for (const item of value) {
-        if (typeof item === 'string') {
-            const trimmed = item.trim();
-            if (trimmed.length > 0) {
-                output.push(trimmed);
-            }
-        }
-    }
-    return output;
-}
-export function toDisplayPath(absolutePath) {
-    const relPath = relative(process.cwd(), absolutePath).replace(/\\/g, '/');
-    if (relPath.length === 0) {
-        return '.';
-    }
-    return relPath.startsWith('..') ? absolutePath.replace(/\\/g, '/') : relPath;
-}
-export async function pathExists(targetPath) {
-    try {
-        await stat(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function getDefaultSearchPaths() {
-    const userProfile = process.env.USERPROFILE ?? homedir();
-    const appData = process.env.APPDATA ?? join(userProfile, 'AppData', 'Roaming');
-    const candidates = [join(userProfile, 'Documents'), join(appData)];
-    const knownSubPatterns = ['Applet', 'XPlugin', 'MiniApp'];
-    const resolvedPaths = [];
-    for (const base of candidates) {
-        for (const sub of knownSubPatterns) {
-            resolvedPaths.push(resolve(base, sub));
-        }
-    }
-    return Array.from(new Set(resolvedPaths));
-}
-export async function walkDirectory(rootDir, onFile) {
-    const stack = [resolve(rootDir)];
-    while (stack.length > 0) {
-        const currentDir = stack.pop();
-        if (!currentDir) {
-            continue;
-        }
-        let entries;
-        try {
-            entries = (await readdir(currentDir, {
-                withFileTypes: true,
-            }));
-        }
-        catch (error) {
-            logger.debug('walkDirectory skip unreadable directory', {
-                currentDir,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            continue;
-        }
-        for (const entry of entries) {
-            const absolutePath = join(currentDir, String(entry.name));
-            if (entry.isDirectory()) {
-                stack.push(absolutePath);
-                continue;
-            }
-            if (!entry.isFile()) {
-                continue;
-            }
-            try {
-                const fileStats = await stat(absolutePath);
-                await onFile(absolutePath, fileStats);
-            }
-            catch (error) {
-                logger.warn('walkDirectory skip unreadable file', {
-                    absolutePath,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-    }
-}
-export async function resolveOutputDirectory(toolName, target, requestedDir) {
-    if (requestedDir) {
-        const absolutePath = resolve(requestedDir);
-        await mkdir(absolutePath, { recursive: true });
-        return { absolutePath, displayPath: toDisplayPath(absolutePath) };
-    }
-    const { absolutePath: markerPath, displayPath: markerDisplayPath } = await resolveArtifactPath({
-        category: 'tmp',
-        toolName,
-        target,
-        ext: 'tmpdir',
-    });
-    const generatedDir = markerPath.replace(/\.tmpdir$/i, '');
-    await mkdir(generatedDir, { recursive: true });
-    return {
-        absolutePath: generatedDir,
-        displayPath: markerDisplayPath.replace(/\.tmpdir$/i, ''),
-    };
-}
-export function sanitizeArchiveRelativePath(rawPath) {
-    const normalizedPath = normalize(rawPath.replace(/\\/g, '/')).replace(/\\/g, '/');
-    const segments = normalizedPath
-        .split('/')
-        .filter((segment) => segment.length > 0 && segment !== '.' && segment !== '..');
-    return segments.join('/');
-}
-export function resolveSafeOutputPath(rootDir, rawRelativePath) {
-    const sanitized = sanitizeArchiveRelativePath(rawRelativePath);
-    const fallbackName = basename(rawRelativePath) || 'unnamed.bin';
-    const safeRelative = sanitized.length > 0 ? sanitized : fallbackName;
-    const outputPath = resolve(rootDir, safeRelative);
-    const normalizedRoot = resolve(rootDir);
-    if (outputPath !== normalizedRoot && !outputPath.startsWith(`${normalizedRoot}${sep}`)) {
-        throw new Error(`Path traversal blocked: ${rawRelativePath}`);
-    }
-    return outputPath;
-}
-export async function readJsonFileSafe(filePath) {
-    try {
-        const raw = await readFile(filePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        return isRecord(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function checkExternalCommand(command, versionArgs, label) {
-    try {
-        const { execFile } = await import('node:child_process');
-        const { promisify } = await import('node:util');
-        const execFileAsync = promisify(execFile);
-        const { stdout, stderr } = await execFileAsync(command, versionArgs, {
-            timeout: 10_000,
-        });
-        const version = (stdout || stderr).trim().split('\n')[0] ?? '';
-        return toTextResponse({
-            success: true,
-            tool: label,
-            available: true,
-            version,
-        });
-    }
-    catch (error) {
-        return toTextResponse({
-            success: true,
-            tool: label,
-            available: false,
-            reason: error instanceof Error ? error.message : String(error),
-            installHint: label === 'frida' ? 'pip install frida-tools' : 'https://github.com/skylot/jadx/releases',
-        });
-    }
-}
-export function extractAppIdFromPath(filePath) {
-    const normalizedPath = filePath.replace(/\\/g, '/');
-    const pathPatterns = [
-        /\/([a-zA-Z]{2,4}[a-zA-Z0-9]{6,})\//,
-        /\/Applet\/([^/]+)\//i,
-    ];
-    for (const pattern of pathPatterns) {
-        const match = normalizedPath.match(pattern);
-        if (match?.[1]) {
-            return match[1];
-        }
-    }
-    const base = basename(filePath, extname(filePath));
-    const fileMatch = base.match(/([a-zA-Z]{2,4}[a-zA-Z0-9]{6,})/);
-    if (fileMatch?.[1]) {
-        return fileMatch[1];
-    }
-    return null;
-}

package/dist/src/server/domains/platform/handlers/v8-bytecode-handler.d.ts

@@ -1,2 +0,0 @@
-import { toTextResponse } from '../../../domains/platform/handlers/platform-utils.js';
-export declare function handleV8BytecodeDecompile(args: Record<string, unknown>): Promise<ReturnType<typeof toTextResponse>>;

package/dist/src/server/domains/platform/handlers/v8-bytecode-handler.js

@@ -1,207 +0,0 @@
-import { readFile, stat } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { extname } from 'node:path';
-import { toTextResponse, toErrorResponse, parseStringArg, pathExists, } from '../../../domains/platform/handlers/platform-utils.js';
-const execFileAsync = promisify(execFile);
-const V8_MAGIC = Buffer.from([0xc0, 0xde]);
-const BYTENODE_MAGIC = Buffer.from('BYTN');
-const JSC_EXTENSIONS = new Set(['.jsc', '.bin']);
-function detectFormat(buffer, filePath) {
-    const ext = extname(filePath).toLowerCase();
-    if (buffer.length >= 4 && buffer.subarray(0, 4).equals(BYTENODE_MAGIC)) {
-        return 'bytenode';
-    }
-    if (buffer.length >= 2 && buffer.subarray(0, 2).equals(V8_MAGIC)) {
-        return 'v8-raw';
-    }
-    if (JSC_EXTENSIONS.has(ext)) {
-        return 'jsc-extension';
-    }
-    const v8Markers = [
-        Buffer.from('Ldar'),
-        Buffer.from('Star'),
-        Buffer.from('LdaSmi'),
-        Buffer.from('CallRuntime'),
-    ];
-    for (const marker of v8Markers) {
-        if (buffer.indexOf(marker) !== -1) {
-            return 'v8-heuristic';
-        }
-    }
-    return null;
-}
-async function tryView8(filePath) {
-    try {
-        const { stdout, stderr } = await execFileAsync('python', ['-m', 'view8', filePath], {
-            timeout: 60_000,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        if (stdout && stdout.trim().length > 0) {
-            return { ok: true, output: stdout };
-        }
-        return { ok: false, error: stderr || 'Empty output from view8' };
-    }
-    catch {
-        try {
-            const { stdout } = await execFileAsync('python3', ['-m', 'view8', filePath], {
-                timeout: 60_000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-            if (stdout && stdout.trim().length > 0) {
-                return { ok: true, output: stdout };
-            }
-            return { ok: false, error: 'Empty output from view8' };
-        }
-        catch {
-            return { ok: false, error: 'view8 not available. Install with: pip install view8' };
-        }
-    }
-}
-function extractConstantPool(buffer) {
-    const strings = [];
-    const numbers = [];
-    const seen = new Set();
-    const MIN_STRING_LEN = 4;
-    const MAX_STRING_LEN = 2000;
-    let currentString = '';
-    for (let i = 0; i < buffer.length; i++) {
-        const byte = buffer[i];
-        if (byte >= 0x20 && byte <= 0x7e) {
-            currentString += String.fromCharCode(byte);
-        }
-        else {
-            if (currentString.length >= MIN_STRING_LEN && currentString.length <= MAX_STRING_LEN) {
-                if (isLikelyCodeString(currentString) && !seen.has(currentString)) {
-                    seen.add(currentString);
-                    strings.push(currentString);
-                }
-            }
-            currentString = '';
-        }
-    }
-    for (let i = 0; i < buffer.length - 3; i++) {
-        if (buffer[i + 1] === 0x00 && buffer[i] >= 0x20 && buffer[i] <= 0x7e) {
-            let utf16str = '';
-            let j = i;
-            while (j < buffer.length - 1 &&
-                buffer[j] >= 0x20 &&
-                buffer[j] <= 0x7e &&
-                buffer[j + 1] === 0x00) {
-                utf16str += String.fromCharCode(buffer[j]);
-                j += 2;
-            }
-            if (utf16str.length >= MIN_STRING_LEN && utf16str.length <= MAX_STRING_LEN) {
-                if (isLikelyCodeString(utf16str) && !seen.has(utf16str)) {
-                    seen.add(utf16str);
-                    strings.push(utf16str);
-                }
-            }
-        }
-    }
-    return { strings, numbers };
-}
-function isLikelyCodeString(s) {
-    if (new Set(s).size <= 2)
-        return false;
-    const specialRatio = (s.match(/[^a-zA-Z0-9_\-.\s/\\:;=+*&|!?,'"(){}[\]<>@#$%^~`]/g) ?? []).length / s.length;
-    if (specialRatio > 0.3)
-        return false;
-    const codePatterns = [
-        /[a-zA-Z_$][a-zA-Z0-9_$]*/,
-        /function\s/,
-        /return\s/,
-        /const\s/,
-        /let\s/,
-        /var\s/,
-        /require\(/,
-        /module\.exports/,
-        /import\s/,
-        /\.prototype\./,
-        /\.call\(/,
-        /\.apply\(/,
-        /async\s/,
-        /await\s/,
-        /Promise/,
-        /https?:\/\//,
-        /[a-zA-Z]+Error/,
-    ];
-    return codePatterns.some((p) => p.test(s));
-}
-export async function handleV8BytecodeDecompile(args) {
-    try {
-        const filePath = parseStringArg(args, 'filePath', true);
-        if (!filePath) {
-            throw new Error('filePath is required — path to a .jsc or V8 bytecode file');
-        }
-        if (!(await pathExists(filePath))) {
-            return toTextResponse({
-                success: false,
-                tool: 'v8_bytecode_decompile',
-                error: `File does not exist: ${filePath}`,
-            });
-        }
-        const fileStat = await stat(filePath);
-        if (fileStat.size > 50 * 1024 * 1024) {
-            return toTextResponse({
-                success: false,
-                tool: 'v8_bytecode_decompile',
-                error: `File too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Maximum: 50MB.`,
-            });
-        }
-        const buffer = await readFile(filePath);
-        const format = detectFormat(buffer, filePath);
-        if (!format) {
-            return toTextResponse({
-                success: false,
-                tool: 'v8_bytecode_decompile',
-                filePath,
-                fileSize: fileStat.size,
-                error: 'Not a recognized V8 bytecode format. Expected .jsc, bytenode, or V8 serialized bytecode.',
-                hint: 'Ensure the file is a V8 compiled bytecode file (created by bytenode or v8.serialize).',
-            });
-        }
-        const result = {
-            success: false,
-            tool: 'v8_bytecode_decompile',
-            filePath,
-            fileSize: fileStat.size,
-            detectedFormat: format,
-            strategy: 'pending',
-        };
-        const view8Result = await tryView8(filePath);
-        if (view8Result.ok && view8Result.output) {
-            result.success = true;
-            result.strategy = 'view8';
-            result.pseudocode =
-                view8Result.output.length > 50_000
-                    ? view8Result.output.slice(0, 50_000) +
-                        '\n\n... [truncated, total ' +
-                        view8Result.output.length +
-                        ' chars]'
-                    : view8Result.output;
-            return toTextResponse(result);
-        }
-        const { strings } = extractConstantPool(buffer);
-        if (strings.length > 0) {
-            result.success = true;
-            result.strategy = 'constant-pool-extraction';
-            result.strings = strings.slice(0, 500);
-            result.note = [
-                `view8 unavailable (${view8Result.error}). Used built-in constant pool extraction.`,
-                `Found ${strings.length} code-relevant strings. These include function names, identifiers, URLs, and string literals from the original source.`,
-                `For full decompilation, install view8: pip install view8`,
-            ].join(' ');
-        }
-        else {
-            result.success = false;
-            result.strategy = 'none';
-            result.error = `Could not decompile. view8: ${view8Result.error}. Built-in extraction found no code strings.`;
-            result.note = 'The bytecode may be heavily optimized or use an unsupported V8 version.';
-        }
-        return toTextResponse(result);
-    }
-    catch (error) {
-        return toErrorResponse('v8_bytecode_decompile', error);
-    }
-}

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

@@ -1,97 +0,0 @@
-import type { CodeCollector } from '../../domains/shared/modules.js';
-export declare class PlatformToolHandlers {
-    private miniapp;
-    private electron;
-    private bridge;
-    constructor(collector: CodeCollector);
-    handleMiniappPkgScan(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleMiniappPkgUnpack(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleMiniappPkgAnalyze(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleAsarExtract(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronInspectApp(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleFridaBridge(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleJadxBridge(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronScanUserdata(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleAsarSearch(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronCheckFuses(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronPatchFuses(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleV8BytecodeDecompile(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronLaunchDebug(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronDebugStatus(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleElectronIPCSniff(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}

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

@@ -1,67 +0,0 @@
-import { ExternalToolRunner } from '../../domains/shared/modules.js';
-import { ToolRegistry } from '../../domains/shared/modules.js';
-import { MiniappHandlers } from '../../domains/platform/handlers/miniapp-handlers.js';
-import { ElectronHandlers } from '../../domains/platform/handlers/electron-handlers.js';
-import { BridgeHandlers } from '../../domains/platform/handlers/bridge-handlers.js';
-import { handleElectronScanUserdata } from '../../domains/platform/handlers/electron-userdata-handler.js';
-import { handleElectronCheckFuses, handleElectronPatchFuses, } from '../../domains/platform/handlers/electron-fuse-handler.js';
-import { handleV8BytecodeDecompile } from '../../domains/platform/handlers/v8-bytecode-handler.js';
-import { handleElectronLaunchDebug, handleElectronDebugStatus, } from '../../domains/platform/handlers/electron-dual-cdp.js';
-import { handleElectronIPCSniff } from '../../domains/platform/handlers/electron-ipc-sniffer.js';
-export class PlatformToolHandlers {
-    miniapp;
-    electron;
-    bridge;
-    constructor(collector) {
-        const registry = new ToolRegistry();
-        const runner = new ExternalToolRunner(registry);
-        this.miniapp = new MiniappHandlers(runner, collector);
-        this.electron = new ElectronHandlers(collector);
-        this.bridge = new BridgeHandlers(runner);
-    }
-    handleMiniappPkgScan(args) {
-        return this.miniapp.handleMiniappPkgScan(args);
-    }
-    handleMiniappPkgUnpack(args) {
-        return this.miniapp.handleMiniappPkgUnpack(args);
-    }
-    handleMiniappPkgAnalyze(args) {
-        return this.miniapp.handleMiniappPkgAnalyze(args);
-    }
-    handleAsarExtract(args) {
-        return this.electron.handleAsarExtract(args);
-    }
-    handleElectronInspectApp(args) {
-        return this.electron.handleElectronInspectApp(args);
-    }
-    handleFridaBridge(args) {
-        return this.bridge.handleFridaBridge(args);
-    }
-    handleJadxBridge(args) {
-        return this.bridge.handleJadxBridge(args);
-    }
-    handleElectronScanUserdata(args) {
-        return handleElectronScanUserdata(args);
-    }
-    handleAsarSearch(args) {
-        return this.electron.handleAsarSearch(args);
-    }
-    handleElectronCheckFuses(args) {
-        return handleElectronCheckFuses(args);
-    }
-    handleElectronPatchFuses(args) {
-        return handleElectronPatchFuses(args);
-    }
-    handleV8BytecodeDecompile(args) {
-        return handleV8BytecodeDecompile(args);
-    }
-    handleElectronLaunchDebug(args) {
-        return handleElectronLaunchDebug(args);
-    }
-    handleElectronDebugStatus(args) {
-        return handleElectronDebugStatus(args);
-    }
-    handleElectronIPCSniff(args) {
-        return handleElectronIPCSniff(args);
-    }
-}

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

@@ -1,2 +0,0 @@
-export { platformTools } from '../../domains/platform/definitions.js';
-export { PlatformToolHandlers } from '../../domains/platform/handlers.js';

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

@@ -1,2 +0,0 @@
-export { platformTools } from '../../domains/platform/definitions.js';
-export { PlatformToolHandlers } from '../../domains/platform/handlers.js';

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

@@ -1,57 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-import { PlatformToolHandlers } from '../../domains/platform/index.js';
-type H = PlatformToolHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "platform";
-    depKey: "platformHandlers";
-    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: "platform";
-        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;