@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/src/server/domains/debugger/handlers/session-management.js

@@ -1,3 +1,4 @@
+import { argString, argObject } from '../../../domains/shared/parse-args.js';
 function getErrorMessage(error) {
     if (typeof error === 'object' && error !== null && 'message' in error) {
         const message = error.message;
@@ -13,8 +14,8 @@ export class SessionManagementHandlers {
         this.deps = deps;
     }
     async handleSaveSession(args) {
-        const filePath = args.filePath;
-        const metadata = args.metadata;
+        const filePath = argString(args, 'filePath');
+        const metadata = argObject(args, 'metadata');
         try {
             const savedPath = await this.deps.debuggerManager.saveSession(filePath, metadata);
             return {
@@ -47,8 +48,8 @@ export class SessionManagementHandlers {
         }
     }
     async handleLoadSession(args) {
-        const filePath = args.filePath;
-        const sessionData = args.sessionData;
+        const filePath = argString(args, 'filePath');
+        const sessionData = argString(args, 'sessionData');
         try {
             if (filePath) {
                 await this.deps.debuggerManager.loadSessionFromFile(filePath);
@@ -89,7 +90,7 @@ export class SessionManagementHandlers {
         }
     }
     async handleExportSession(args) {
-        const metadata = args.metadata;
+        const metadata = argObject(args, 'metadata');
         try {
             const session = this.deps.debuggerManager.exportSession(metadata);
             return {

package/dist/src/server/domains/debugger/handlers/watch-expressions.js

@@ -1,3 +1,4 @@
+import { argString } from '../../../domains/shared/parse-args.js';
 function getErrorMessage(error) {
     if (typeof error === 'object' && error !== null && 'message' in error) {
         const message = error.message;
@@ -14,8 +15,8 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchAdd(args) {
         try {
-            const expression = args.expression;
-            const name = args.name;
+            const expression = argString(args, 'expression', '');
+            const name = argString(args, 'name');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const watchId = watchManager.addWatch(expression, name);
             return {
@@ -50,7 +51,7 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchRemove(args) {
         try {
-            const watchId = args.watchId;
+            const watchId = argString(args, 'watchId', '');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const removed = watchManager.removeWatch(watchId);
             return {
@@ -115,7 +116,7 @@ export class WatchExpressionsHandlers {
     }
     async handleWatchEvaluateAll(args) {
         try {
-            const callFrameId = args.callFrameId;
+            const callFrameId = argString(args, 'callFrameId');
             const watchManager = this.deps.debuggerManager.getWatchManager();
             const results = await watchManager.evaluateAll(callFrameId);
             return {

package/dist/src/server/domains/debugger/handlers/xhr-breakpoint.js

@@ -1,3 +1,4 @@
+import { argString } from '../../../domains/shared/parse-args.js';
 function hasEnsureAdvancedFeatures(manager) {
     return typeof manager.ensureAdvancedFeatures === 'function';
 }
@@ -22,7 +23,7 @@ export class XHRBreakpointHandlers {
     }
     async handleXHRBreakpointSet(args) {
         try {
-            const urlPattern = args.urlPattern;
+            const urlPattern = argString(args, 'urlPattern', '');
             await this.ensureAdvancedFeaturesIfSupported();
             const xhrManager = this.deps.debuggerManager.getXHRManager();
             const breakpointId = await xhrManager.setXHRBreakpoint(urlPattern);
@@ -57,7 +58,7 @@ export class XHRBreakpointHandlers {
     }
     async handleXHRBreakpointRemove(args) {
         try {
-            const breakpointId = args.breakpointId;
+            const breakpointId = argString(args, 'breakpointId', '');
             await this.ensureAdvancedFeaturesIfSupported();
             const xhrManager = this.deps.debuggerManager.getXHRManager();
             const removed = await xhrManager.removeXHRBreakpoint(breakpointId);

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

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

package/dist/src/server/domains/encoding/encoding-msgpack.d.ts

@@ -0,0 +1,7 @@
+import type { MsgPackDecodeResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare function decodeMsgPack(buffer: Buffer): unknown;
+export declare function decodeMsgPackValue(buffer: Buffer, startOffset: number, depth: number): MsgPackDecodeResult;
+export declare function decodeMsgPackArray(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
+export declare function decodeMsgPackMap(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
+export declare function msgPackMapKey(value: unknown): string;
+export declare function ensureRange(buffer: Buffer, offset: number, length: number): void;

package/dist/src/server/domains/encoding/encoding-msgpack.js

@@ -0,0 +1,266 @@
+import { bigIntToSafeValue } from '../../domains/encoding/encoding-protobuf.js';
+export function decodeMsgPack(buffer) {
+    const decoded = decodeMsgPackValue(buffer, 0, 0);
+    if (decoded.offset !== buffer.length) {
+        throw new Error(`MessagePack decode ended early: consumed ${decoded.offset} of ${buffer.length} bytes`);
+    }
+    return decoded.value;
+}
+export function decodeMsgPackValue(buffer, startOffset, depth) {
+    if (depth > 64) {
+        throw new Error('MessagePack decode depth exceeds safety limit');
+    }
+    const prefix = buffer[startOffset];
+    if (prefix === undefined) {
+        throw new Error(`Unexpected EOF at offset ${startOffset}`);
+    }
+    let offset = startOffset + 1;
+    if (prefix <= 0x7f) {
+        return { value: prefix, offset };
+    }
+    if (prefix >= 0xe0) {
+        return { value: prefix - 0x100, offset };
+    }
+    if (prefix >= 0xa0 && prefix <= 0xbf) {
+        const length = prefix & 0x1f;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix >= 0x90 && prefix <= 0x9f) {
+        const length = prefix & 0x0f;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix >= 0x80 && prefix <= 0x8f) {
+        const length = prefix & 0x0f;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xc0)
+        return { value: null, offset };
+    if (prefix === 0xc2)
+        return { value: false, offset };
+    if (prefix === 0xc3)
+        return { value: true, offset };
+    if (prefix === 0xcc) {
+        ensureRange(buffer, offset, 1);
+        const value = buffer.readUInt8(offset);
+        return { value, offset: offset + 1 };
+    }
+    if (prefix === 0xcd) {
+        ensureRange(buffer, offset, 2);
+        const value = buffer.readUInt16BE(offset);
+        return { value, offset: offset + 2 };
+    }
+    if (prefix === 0xce) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readUInt32BE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xcf) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readBigUInt64BE(offset);
+        return { value: bigIntToSafeValue(value), offset: offset + 8 };
+    }
+    if (prefix === 0xd0) {
+        ensureRange(buffer, offset, 1);
+        const value = buffer.readInt8(offset);
+        return { value, offset: offset + 1 };
+    }
+    if (prefix === 0xd1) {
+        ensureRange(buffer, offset, 2);
+        const value = buffer.readInt16BE(offset);
+        return { value, offset: offset + 2 };
+    }
+    if (prefix === 0xd2) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readInt32BE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xd3) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readBigInt64BE(offset);
+        return { value: bigIntToSafeValue(value), offset: offset + 8 };
+    }
+    if (prefix === 0xca) {
+        ensureRange(buffer, offset, 4);
+        const value = buffer.readFloatBE(offset);
+        return { value, offset: offset + 4 };
+    }
+    if (prefix === 0xcb) {
+        ensureRange(buffer, offset, 8);
+        const value = buffer.readDoubleBE(offset);
+        return { value, offset: offset + 8 };
+    }
+    if (prefix === 0xd9) {
+        ensureRange(buffer, offset, 1);
+        const length = buffer.readUInt8(offset);
+        offset += 1;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xda) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xdb) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        ensureRange(buffer, offset, length);
+        const value = buffer.subarray(offset, offset + length).toString('utf8');
+        return { value, offset: offset + length };
+    }
+    if (prefix === 0xc4) {
+        ensureRange(buffer, offset, 1);
+        const length = buffer.readUInt8(offset);
+        offset += 1;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xc5) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xc6) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        ensureRange(buffer, offset, length);
+        const payload = buffer.subarray(offset, offset + length);
+        return {
+            value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
+            offset: offset + length,
+        };
+    }
+    if (prefix === 0xdc) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xdd) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        return decodeMsgPackArray(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xde) {
+        ensureRange(buffer, offset, 2);
+        const length = buffer.readUInt16BE(offset);
+        offset += 2;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix === 0xdf) {
+        ensureRange(buffer, offset, 4);
+        const length = buffer.readUInt32BE(offset);
+        offset += 4;
+        return decodeMsgPackMap(buffer, offset, length, depth + 1);
+    }
+    if (prefix >= 0xd4 && prefix <= 0xd8) {
+        const sizeByPrefix = {
+            0xd4: 1,
+            0xd5: 2,
+            0xd6: 4,
+            0xd7: 8,
+            0xd8: 16,
+        };
+        const size = sizeByPrefix[prefix];
+        ensureRange(buffer, offset, 1 + size);
+        const extType = buffer.readInt8(offset);
+        const payload = buffer.subarray(offset + 1, offset + 1 + size);
+        return {
+            value: {
+                type: 'ext',
+                extType,
+                base64: payload.toString('base64'),
+                hex: payload.toString('hex'),
+            },
+            offset: offset + 1 + size,
+        };
+    }
+    if (prefix === 0xc7 || prefix === 0xc8 || prefix === 0xc9) {
+        const lengthBytes = prefix === 0xc7 ? 1 : prefix === 0xc8 ? 2 : 4;
+        ensureRange(buffer, offset, lengthBytes);
+        const length = lengthBytes === 1
+            ? buffer.readUInt8(offset)
+            : lengthBytes === 2
+                ? buffer.readUInt16BE(offset)
+                : buffer.readUInt32BE(offset);
+        offset += lengthBytes;
+        ensureRange(buffer, offset, 1 + length);
+        const extType = buffer.readInt8(offset);
+        const payload = buffer.subarray(offset + 1, offset + 1 + length);
+        return {
+            value: {
+                type: 'ext',
+                extType,
+                base64: payload.toString('base64'),
+                hex: payload.toString('hex'),
+            },
+            offset: offset + 1 + length,
+        };
+    }
+    throw new Error(`Unsupported MessagePack prefix 0x${prefix.toString(16)} at offset ${startOffset}`);
+}
+export function decodeMsgPackArray(buffer, startOffset, length, depth) {
+    let offset = startOffset;
+    const values = [];
+    for (let index = 0; index < length; index += 1) {
+        const decoded = decodeMsgPackValue(buffer, offset, depth);
+        values.push(decoded.value);
+        offset = decoded.offset;
+    }
+    return { value: values, offset };
+}
+export function decodeMsgPackMap(buffer, startOffset, length, depth) {
+    let offset = startOffset;
+    const mapValue = {};
+    for (let index = 0; index < length; index += 1) {
+        const keyDecoded = decodeMsgPackValue(buffer, offset, depth);
+        offset = keyDecoded.offset;
+        const valueDecoded = decodeMsgPackValue(buffer, offset, depth);
+        offset = valueDecoded.offset;
+        const key = msgPackMapKey(keyDecoded.value);
+        mapValue[key] = valueDecoded.value;
+    }
+    return { value: mapValue, offset };
+}
+export function msgPackMapKey(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value === null)
+        return 'null';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function ensureRange(buffer, offset, length) {
+    if (offset < 0 || length < 0 || offset + length > buffer.length) {
+        throw new Error(`Unexpected EOF while reading ${length} bytes at offset ${offset}`);
+    }
+}

package/dist/src/server/domains/encoding/encoding-protobuf.d.ts

@@ -0,0 +1,10 @@
+import type { ProtobufParseResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare function parseProtobufMessage(buffer: Buffer, depth: number, maxDepth: number): ProtobufParseResult;
+export declare function decodeLengthDelimited(payload: Buffer, depth: number, maxDepth: number): unknown;
+export declare function tryParseVarint(buffer: Buffer, startOffset: number): {
+    value?: bigint;
+    offset?: number;
+    error?: string;
+};
+export declare function protobufWireTypeName(wireType: number): string;
+export declare function bigIntToSafeValue(value: bigint): number | string;

package/dist/src/server/domains/encoding/encoding-protobuf.js

@@ -0,0 +1,221 @@
+export function parseProtobufMessage(buffer, depth, maxDepth) {
+    const fields = [];
+    let offset = 0;
+    let fieldIndex = 0;
+    while (offset < buffer.length) {
+        const keyInfo = tryParseVarint(buffer, offset);
+        if (keyInfo.error) {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: keyInfo.error,
+            };
+        }
+        const keyValue = keyInfo.value;
+        offset = keyInfo.offset;
+        const fieldNumber = Number(keyValue >> 3n);
+        const wireType = Number(keyValue & 0x07n);
+        if (fieldNumber <= 0) {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: `Invalid field number ${fieldNumber} at offset ${offset}`,
+            };
+        }
+        if (wireType === 0) {
+            const varintInfo = tryParseVarint(buffer, offset);
+            if (varintInfo.error) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: varintInfo.error,
+                };
+            }
+            offset = varintInfo.offset;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: bigIntToSafeValue(varintInfo.value),
+            });
+        }
+        else if (wireType === 1) {
+            if (offset + 8 > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Unexpected EOF for fixed64 at offset ${offset}`,
+                };
+            }
+            const raw = buffer.subarray(offset, offset + 8);
+            const fixed64 = raw.readBigUInt64LE(0);
+            offset += 8;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: {
+                    uint64: bigIntToSafeValue(fixed64),
+                    hex: raw.toString('hex'),
+                },
+            });
+        }
+        else if (wireType === 2) {
+            const lengthInfo = tryParseVarint(buffer, offset);
+            if (lengthInfo.error) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: lengthInfo.error,
+                };
+            }
+            offset = lengthInfo.offset;
+            const lengthBigInt = lengthInfo.value;
+            if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Length-delimited field is too large at offset ${offset}`,
+                };
+            }
+            const length = Number(lengthBigInt);
+            if (length < 0 || offset + length > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Invalid length-delimited field length=${length} at offset ${offset}`,
+                };
+            }
+            const payload = buffer.subarray(offset, offset + length);
+            offset += length;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: decodeLengthDelimited(payload, depth, maxDepth),
+            });
+        }
+        else if (wireType === 5) {
+            if (offset + 4 > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Unexpected EOF for fixed32 at offset ${offset}`,
+                };
+            }
+            const raw = buffer.subarray(offset, offset + 4);
+            const fixed32 = raw.readUInt32LE(0);
+            offset += 4;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: {
+                    uint32: fixed32,
+                    hex: raw.toString('hex'),
+                },
+            });
+        }
+        else {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: `Unsupported wire type ${wireType} at offset ${offset}`,
+            };
+        }
+        fieldIndex += 1;
+    }
+    return {
+        fields,
+        bytesConsumed: offset,
+    };
+}
+export function decodeLengthDelimited(payload, depth, maxDepth) {
+    if (payload.length === 0) {
+        return { kind: 'empty', length: 0 };
+    }
+    if (depth < maxDepth) {
+        const nested = parseProtobufMessage(payload, depth + 1, maxDepth);
+        if (!nested.error && nested.bytesConsumed === payload.length && nested.fields.length > 0) {
+            return {
+                kind: 'message',
+                fields: nested.fields,
+            };
+        }
+    }
+    const text = toSafeUtf8(payload);
+    if (text !== null && isMostlyPrintableText(text)) {
+        return {
+            kind: 'string',
+            value: text,
+        };
+    }
+    return {
+        kind: 'bytes',
+        length: payload.length,
+        hex: payload.toString('hex'),
+        base64: payload.toString('base64'),
+    };
+}
+export function tryParseVarint(buffer, startOffset) {
+    let result = 0n;
+    let shift = 0n;
+    let offset = startOffset;
+    for (let index = 0; index < 10; index += 1) {
+        const current = buffer[offset];
+        if (current === undefined) {
+            return { error: `Unexpected EOF while parsing varint at offset ${offset}` };
+        }
+        const byte = BigInt(current);
+        result |= (byte & 0x7fn) << shift;
+        offset += 1;
+        if ((byte & 0x80n) === 0n) {
+            return { value: result, offset };
+        }
+        shift += 7n;
+    }
+    return { error: `Varint exceeds 10 bytes at offset ${startOffset}` };
+}
+export function protobufWireTypeName(wireType) {
+    if (wireType === 0)
+        return 'varint';
+    if (wireType === 1)
+        return 'fixed64';
+    if (wireType === 2)
+        return 'length-delimited';
+    if (wireType === 5)
+        return 'fixed32';
+    return 'unknown';
+}
+export function bigIntToSafeValue(value) {
+    const max = BigInt(Number.MAX_SAFE_INTEGER);
+    const min = BigInt(Number.MIN_SAFE_INTEGER);
+    if (value <= max && value >= min) {
+        return Number(value);
+    }
+    return value.toString();
+}
+function toSafeUtf8(buffer) {
+    const text = buffer.toString('utf8');
+    if ((text.match(/\uFFFD/g) ?? []).length > 0) {
+        return null;
+    }
+    return text;
+}
+function isMostlyPrintableText(text) {
+    if (text.length === 0) {
+        return true;
+    }
+    let printable = 0;
+    for (const ch of text) {
+        const code = ch.charCodeAt(0);
+        if ((code >= 0x20 && code <= 0x7e) || code === 0x09 || code === 0x0a || code === 0x0d) {
+            printable += 1;
+        }
+    }
+    return printable / text.length >= 0.85;
+}