@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/native/platform/darwin/DarwinAPI.js

@@ -0,0 +1,225 @@
+import koffi from 'koffi';
+import { logger } from '../../../utils/logger.js';
+export const KERN = {
+    SUCCESS: 0,
+    INVALID_ADDRESS: 1,
+    PROTECTION_FAILURE: 2,
+    NO_SPACE: 3,
+    INVALID_ARGUMENT: 4,
+    FAILURE: 5,
+    RESOURCE_SHORTAGE: 6,
+    NOT_RECEIVER: 7,
+    NO_ACCESS: 8,
+    MEMORY_FAILURE: 9,
+    MEMORY_ERROR: 10,
+    ALREADY_IN_SET: 11,
+    NOT_IN_SET: 12,
+    NAME_EXISTS: 13,
+    ABORTED: 14,
+    INVALID_NAME: 15,
+    INVALID_TASK: 16,
+    INVALID_RIGHT: 17,
+    INVALID_VALUE: 18,
+    UREFS_OVERFLOW: 19,
+    INVALID_CAPABILITY: 20,
+    RIGHT_EXISTS: 21,
+    INVALID_HOST: 22,
+    MEMORY_PRESENT: 23,
+    MEMORY_DATA_MOVED: 24,
+    MEMORY_RESTART_COPY: 25,
+    INVALID_PROCESSOR_SET: 26,
+    POLICY_LIMIT: 27,
+    INVALID_POLICY: 28,
+    INVALID_OBJECT: 29,
+    ALREADY_WAITING: 30,
+    DEFAULT_SET: 31,
+    EXCEPTION_PROTECTED: 32,
+    INVALID_LEDGER: 33,
+    INVALID_MEMORY_CONTROL: 34,
+    INVALID_SECURITY: 35,
+    NOT_DEPRESSED: 36,
+    TERMINATED: 37,
+    LOCK_SET_DESTROYED: 38,
+    LOCK_UNSTABLE: 39,
+    LOCK_OWNED: 40,
+    LOCK_OWNED_SELF: 41,
+    SEMAPHORE_DESTROYED: 42,
+    RPC_SERVER_TERMINATED: 43,
+    RPC_TERMINATE_ORPHAN: 44,
+    RPC_CONTINUE_ORPHAN: 45,
+    NOT_SUPPORTED: 46,
+    NODE_DOWN: 47,
+    NOT_WAITING: 48,
+    OPERATION_TIMED_OUT: 49,
+    CODESIGN_ERROR: 50,
+    POLICY_STATIC: 51,
+};
+const KERN_NAMES = {
+    [KERN.SUCCESS]: 'KERN_SUCCESS',
+    [KERN.INVALID_ADDRESS]: 'KERN_INVALID_ADDRESS',
+    [KERN.PROTECTION_FAILURE]: 'KERN_PROTECTION_FAILURE',
+    [KERN.NO_SPACE]: 'KERN_NO_SPACE',
+    [KERN.INVALID_ARGUMENT]: 'KERN_INVALID_ARGUMENT',
+    [KERN.FAILURE]: 'KERN_FAILURE',
+    [KERN.NO_ACCESS]: 'KERN_NO_ACCESS',
+    [KERN.INVALID_TASK]: 'KERN_INVALID_TASK',
+    [KERN.INVALID_RIGHT]: 'KERN_INVALID_RIGHT',
+    [KERN.CODESIGN_ERROR]: 'KERN_CODESIGN_ERROR',
+};
+export function kernReturnName(kr) {
+    return KERN_NAMES[kr] ?? `KERN_UNKNOWN(${kr})`;
+}
+export const VM_PROT = {
+    NONE: 0x00,
+    READ: 0x01,
+    WRITE: 0x02,
+    EXECUTE: 0x04,
+    ALL: 0x07,
+};
+export const VM_REGION_BASIC_INFO_64 = 9;
+export const VM_REGION_BASIC_INFO_COUNT_64 = 9;
+export const VM_FLAGS = {
+    FIXED: 0x0000,
+    ANYWHERE: 0x0001,
+    PURGABLE: 0x0002,
+    RANDOM_ADDR: 0x0008,
+    OVERWRITE: 0x4000,
+};
+export const SM = {
+    COW: 1,
+    PRIVATE: 2,
+    EMPTY: 3,
+    SHARED: 4,
+    TRUESHARED: 5,
+    PRIVATE_ALIASED: 6,
+    SHARED_ALIASED: 7,
+    LARGE_PAGE: 8,
+};
+let libSystem = null;
+let koffiAvailableDarwin = null;
+export function isDarwin() {
+    return process.platform === 'darwin';
+}
+export function isKoffiAvailableOnDarwin() {
+    if (koffiAvailableDarwin !== null)
+        return koffiAvailableDarwin;
+    try {
+        const testLib = koffi.load('/usr/lib/libSystem.B.dylib');
+        testLib.unload();
+        koffiAvailableDarwin = true;
+        return true;
+    }
+    catch {
+        koffiAvailableDarwin = false;
+        return false;
+    }
+}
+function getLibSystem() {
+    if (!libSystem) {
+        libSystem = koffi.load('/usr/lib/libSystem.B.dylib');
+        logger.debug('Loaded libSystem.B.dylib via koffi');
+    }
+    return libSystem;
+}
+export function machTaskSelf() {
+    const fn = getLibSystem().func('uint32 mach_task_self_()');
+    return fn();
+}
+export function taskForPid(targetTask, pid) {
+    const fn = getLibSystem().func('int32 task_for_pid(uint32, int32, _Out_ uint32 *)');
+    const taskBuf = Buffer.alloc(4);
+    const kr = fn(targetTask, pid, taskBuf);
+    return {
+        kr,
+        task: taskBuf.readUInt32LE(0),
+    };
+}
+export function machPortDeallocate(task, name) {
+    const fn = getLibSystem().func('int32 mach_port_deallocate(uint32, uint32)');
+    return fn(task, name);
+}
+export function machVmReadOverwrite(task, address, size) {
+    const fn = getLibSystem().func('int32 mach_vm_read_overwrite(uint32, uint64, uint64, _Out_ uint8_t[len], uint64 len, _Out_ uint64 *)');
+    const data = Buffer.alloc(size);
+    const outsizeBuf = Buffer.alloc(8);
+    const kr = fn(task, address, BigInt(size), data, BigInt(size), outsizeBuf);
+    return {
+        kr,
+        data,
+        outsize: outsizeBuf.readBigUInt64LE(0),
+    };
+}
+export function machVmWrite(task, address, data) {
+    const fn = getLibSystem().func('int32 mach_vm_write(uint32, uint64, uint8_t *, uint32)');
+    return fn(task, address, data, data.length);
+}
+export function machVmRegion(task, address) {
+    const fn = getLibSystem().func('int32 mach_vm_region(uint32, _Inout_ uint64 *, _Out_ uint64 *, int32, _Out_ uint8_t[36], _Inout_ uint32 *, _Out_ uint32 *)');
+    const addressBuf = Buffer.alloc(8);
+    addressBuf.writeBigUInt64LE(address);
+    const sizeBuf = Buffer.alloc(8);
+    const infoBuf = Buffer.alloc(36);
+    const infoCntBuf = Buffer.alloc(4);
+    infoCntBuf.writeUInt32LE(VM_REGION_BASIC_INFO_COUNT_64);
+    const objectNameBuf = Buffer.alloc(4);
+    const kr = fn(task, addressBuf, sizeBuf, VM_REGION_BASIC_INFO_64, infoBuf, infoCntBuf, objectNameBuf);
+    const info = {
+        protection: infoBuf.readUInt32LE(0),
+        max_protection: infoBuf.readUInt32LE(4),
+        inheritance: infoBuf.readUInt32LE(8),
+        shared: infoBuf.readUInt32LE(12) !== 0,
+        reserved: infoBuf.readUInt32LE(16) !== 0,
+        offset: infoBuf.readBigUInt64LE(20),
+        behavior: infoBuf.readUInt32LE(28),
+        user_wired_count: infoBuf.readUInt32LE(32),
+    };
+    return {
+        kr,
+        address: addressBuf.readBigUInt64LE(0),
+        size: sizeBuf.readBigUInt64LE(0),
+        info,
+    };
+}
+export function machVmProtect(task, address, size, setMaximum, newProtection) {
+    const fn = getLibSystem().func('int32 mach_vm_protect(uint32, uint64, uint64, int32, int32)');
+    return fn(task, address, size, setMaximum ? 1 : 0, newProtection);
+}
+export function machVmAllocate(task, size, flags) {
+    const fn = getLibSystem().func('int32 mach_vm_allocate(uint32, _Inout_ uint64 *, uint64, int32)');
+    const addressBuf = Buffer.alloc(8);
+    addressBuf.writeBigUInt64LE(0n);
+    const kr = fn(task, addressBuf, size, flags);
+    return {
+        kr,
+        address: addressBuf.readBigUInt64LE(0),
+    };
+}
+export function machVmDeallocate(task, address, size) {
+    const fn = getLibSystem().func('int32 mach_vm_deallocate(uint32, uint64, uint64)');
+    return fn(task, address, size);
+}
+export function dyldImageCount() {
+    const fn = getLibSystem().func('uint32 _dyld_image_count()');
+    return fn();
+}
+export function dyldGetImageName(index) {
+    const fn = getLibSystem().func('const char * _dyld_get_image_name(uint32)');
+    const ptr = fn(index);
+    return ptr ? String(ptr) : '';
+}
+export function dyldGetImageVmaddrSlide(index) {
+    const fn = getLibSystem().func('int64 _dyld_get_image_vmaddr_slide(uint32)');
+    return BigInt(fn(index));
+}
+export function dyldGetImageHeader(index) {
+    const fn = getLibSystem().func('void * _dyld_get_image_header(uint32)');
+    return BigInt(fn(index));
+}
+export function unloadLibraries() {
+    if (libSystem) {
+        libSystem.unload();
+        libSystem = null;
+    }
+    koffiAvailableDarwin = null;
+    logger.debug('Unloaded macOS native libraries');
+}

package/dist/src/native/platform/darwin/DarwinMemoryProvider.d.ts

@@ -0,0 +1,17 @@
+import type { PlatformMemoryAPI } from '../PlatformMemoryAPI.js';
+import { MemoryProtection, type ProcessHandle, type MemoryRegionInfo, type MemoryReadResult, type MemoryWriteResult, type ProtectionChangeResult, type AllocationResult, type ModuleInfo, type PlatformAvailability } from '../types.js';
+export declare class DarwinMemoryProvider implements PlatformMemoryAPI {
+    readonly platform: "darwin";
+    checkAvailability(): Promise<PlatformAvailability>;
+    openProcess(pid: number, _writeAccess: boolean): ProcessHandle;
+    closeProcess(handle: ProcessHandle): void;
+    readMemory(handle: ProcessHandle, address: bigint, size: number): MemoryReadResult;
+    writeMemory(handle: ProcessHandle, address: bigint, data: Buffer): MemoryWriteResult;
+    queryRegion(handle: ProcessHandle, address: bigint): MemoryRegionInfo | null;
+    changeProtection(handle: ProcessHandle, address: bigint, size: number, newProtection: MemoryProtection): ProtectionChangeResult;
+    allocateMemory(handle: ProcessHandle, size: number, protection: MemoryProtection): AllocationResult;
+    freeMemory(handle: ProcessHandle, address: bigint, size: number): void;
+    enumerateModules(handle: ProcessHandle): ModuleInfo[];
+    private _enumerateModulesSelf;
+    private _enumerateModulesRemote;
+}

package/dist/src/native/platform/darwin/DarwinMemoryProvider.js

@@ -0,0 +1,230 @@
+import { MemoryProtection, } from '../types.js';
+import { isDarwin, isKoffiAvailableOnDarwin, machTaskSelf, taskForPid, machPortDeallocate, machVmReadOverwrite, machVmWrite, machVmRegion, machVmProtect, machVmAllocate, machVmDeallocate, dyldImageCount, dyldGetImageName, dyldGetImageHeader, kernReturnName, KERN, VM_PROT, VM_FLAGS, SM, } from './DarwinAPI.js';
+const handleMap = new WeakMap();
+function getDarwinHandle(handle) {
+    const h = handleMap.get(handle);
+    if (h === undefined)
+        throw new Error('Invalid ProcessHandle — not a Darwin handle');
+    return h;
+}
+function machProtToMemoryProtection(prot) {
+    let flags = MemoryProtection.NoAccess;
+    if (prot & VM_PROT.READ)
+        flags |= MemoryProtection.Read;
+    if (prot & VM_PROT.WRITE)
+        flags |= MemoryProtection.Write;
+    if (prot & VM_PROT.EXECUTE)
+        flags |= MemoryProtection.Execute;
+    return flags;
+}
+function memoryProtectionToMachProt(prot) {
+    let machProt = VM_PROT.NONE;
+    if (prot & MemoryProtection.Read)
+        machProt |= VM_PROT.READ;
+    if (prot & MemoryProtection.Write)
+        machProt |= VM_PROT.WRITE;
+    if (prot & MemoryProtection.Execute)
+        machProt |= VM_PROT.EXECUTE;
+    return machProt;
+}
+function darwinShareModeToType(shareMode) {
+    switch (shareMode) {
+        case SM.PRIVATE:
+        case SM.PRIVATE_ALIASED:
+        case SM.COW:
+            return 'private';
+        case SM.SHARED:
+        case SM.TRUESHARED:
+        case SM.SHARED_ALIASED:
+            return 'mapped';
+        case SM.EMPTY:
+            return 'unknown';
+        default:
+            return 'unknown';
+    }
+}
+export class DarwinMemoryProvider {
+    platform = 'darwin';
+    async checkAvailability() {
+        if (!isDarwin()) {
+            return { available: false, reason: 'Not running on macOS', platform: 'darwin' };
+        }
+        if (!isKoffiAvailableOnDarwin()) {
+            return {
+                available: false,
+                reason: 'koffi FFI library cannot load libSystem.B.dylib',
+                platform: 'darwin',
+            };
+        }
+        try {
+            const selfTask = machTaskSelf();
+            const { kr } = taskForPid(selfTask, process.pid);
+            if (kr !== KERN.SUCCESS) {
+                return {
+                    available: false,
+                    reason: `task_for_pid failed (${kernReturnName(kr)}). Run with sudo or add debugger entitlement.`,
+                    platform: 'darwin',
+                };
+            }
+        }
+        catch (err) {
+            return {
+                available: false,
+                reason: `task_for_pid permission check failed: ${err instanceof Error ? err.message : String(err)}`,
+                platform: 'darwin',
+            };
+        }
+        return { available: true, platform: 'darwin' };
+    }
+    openProcess(pid, _writeAccess) {
+        const selfTask = machTaskSelf();
+        const { kr, task } = taskForPid(selfTask, pid);
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`Failed to open process ${pid}: ${kernReturnName(kr)} (${kr}). ` +
+                (kr === KERN.FAILURE
+                    ? 'Run with sudo or sign with com.apple.security.cs.debugger entitlement.'
+                    : kr === KERN.INVALID_ARGUMENT
+                        ? 'Invalid PID — process may not exist.'
+                        : 'Check macOS permissions.'));
+        }
+        const handle = { pid, writeAccess: _writeAccess };
+        handleMap.set(handle, { task });
+        return handle;
+    }
+    closeProcess(handle) {
+        const h = getDarwinHandle(handle);
+        machPortDeallocate(machTaskSelf(), h.task);
+    }
+    readMemory(handle, address, size) {
+        const h = getDarwinHandle(handle);
+        const { kr, data, outsize } = machVmReadOverwrite(h.task, address, size);
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`mach_vm_read_overwrite failed at 0x${address.toString(16)}: ${kernReturnName(kr)} (${kr})`);
+        }
+        return { data, bytesRead: Number(outsize) };
+    }
+    writeMemory(handle, address, data) {
+        const h = getDarwinHandle(handle);
+        const kr = machVmWrite(h.task, address, data);
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`mach_vm_write failed at 0x${address.toString(16)}: ${kernReturnName(kr)} (${kr})`);
+        }
+        return { bytesWritten: data.length };
+    }
+    queryRegion(handle, address) {
+        const h = getDarwinHandle(handle);
+        const { kr, address: regionBase, size: regionSize, info } = machVmRegion(h.task, address);
+        if (kr !== KERN.SUCCESS) {
+            return null;
+        }
+        const protection = machProtToMemoryProtection(info.protection);
+        return {
+            baseAddress: regionBase,
+            size: Number(regionSize),
+            protection,
+            state: 'committed',
+            type: darwinShareModeToType(info.behavior),
+            isReadable: (protection & MemoryProtection.Read) !== 0,
+            isWritable: (protection & MemoryProtection.Write) !== 0,
+            isExecutable: (protection & MemoryProtection.Execute) !== 0,
+        };
+    }
+    changeProtection(handle, address, size, newProtection) {
+        const h = getDarwinHandle(handle);
+        const machProt = memoryProtectionToMachProt(newProtection);
+        const { kr: queryKr, info } = machVmRegion(h.task, address);
+        const oldProtection = queryKr === KERN.SUCCESS
+            ? machProtToMemoryProtection(info.protection)
+            : MemoryProtection.NoAccess;
+        const needsMaxProtAdjust = (machProt & VM_PROT.WRITE) !== 0 && (machProt & VM_PROT.EXECUTE) !== 0;
+        if (needsMaxProtAdjust) {
+            const maxKr = machVmProtect(h.task, address, BigInt(size), true, VM_PROT.ALL);
+            if (maxKr !== KERN.SUCCESS) {
+                throw new Error(`mach_vm_protect (set_maximum) failed at 0x${address.toString(16)}: ${kernReturnName(maxKr)} (${maxKr})`);
+            }
+        }
+        const kr = machVmProtect(h.task, address, BigInt(size), false, machProt);
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`mach_vm_protect failed at 0x${address.toString(16)}: ${kernReturnName(kr)} (${kr})`);
+        }
+        return { oldProtection };
+    }
+    allocateMemory(handle, size, protection) {
+        const h = getDarwinHandle(handle);
+        const { kr, address } = machVmAllocate(h.task, BigInt(size), VM_FLAGS.ANYWHERE);
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`mach_vm_allocate failed: ${kernReturnName(kr)} (${kr})`);
+        }
+        const machProt = memoryProtectionToMachProt(protection);
+        if (machProt !== (VM_PROT.READ | VM_PROT.WRITE)) {
+            const protKr = machVmProtect(h.task, address, BigInt(size), false, machProt);
+            if (protKr !== KERN.SUCCESS) {
+                machVmDeallocate(h.task, address, BigInt(size));
+                throw new Error(`mach_vm_protect after allocate failed: ${kernReturnName(protKr)} (${protKr})`);
+            }
+        }
+        return { address };
+    }
+    freeMemory(handle, address, size) {
+        const h = getDarwinHandle(handle);
+        const kr = machVmDeallocate(h.task, address, BigInt(size));
+        if (kr !== KERN.SUCCESS) {
+            throw new Error(`mach_vm_deallocate failed at 0x${address.toString(16)}: ${kernReturnName(kr)} (${kr})`);
+        }
+    }
+    enumerateModules(handle) {
+        const h = getDarwinHandle(handle);
+        const isSelf = handle.pid === process.pid;
+        if (isSelf) {
+            return this._enumerateModulesSelf();
+        }
+        return this._enumerateModulesRemote(h.task);
+    }
+    _enumerateModulesSelf() {
+        const count = dyldImageCount();
+        const modules = [];
+        for (let i = 0; i < count; i++) {
+            const name = dyldGetImageName(i);
+            const header = dyldGetImageHeader(i);
+            if (!name || header === 0n)
+                continue;
+            const basename = name.split('/').pop() ?? name;
+            modules.push({
+                name: basename,
+                baseAddress: header,
+                size: 0,
+            });
+        }
+        return modules;
+    }
+    _enumerateModulesRemote(task) {
+        const modules = [];
+        let address = 0n;
+        for (let i = 0; i < 10000; i++) {
+            const { kr, address: regionBase, size: regionSize, info } = machVmRegion(task, address);
+            if (kr !== KERN.SUCCESS)
+                break;
+            const isReadable = (info.protection & VM_PROT.READ) !== 0;
+            const isExecutable = (info.protection & VM_PROT.EXECUTE) !== 0;
+            if (isReadable && isExecutable && regionSize > 0n) {
+                try {
+                    const { kr: readKr, data } = machVmReadOverwrite(task, regionBase, 4);
+                    if (readKr === KERN.SUCCESS && data.length >= 4) {
+                        const magic = data.readUInt32LE(0);
+                        if (magic === 0xfeedfacf || magic === 0xfeedface) {
+                            modules.push({
+                                name: `module_0x${regionBase.toString(16)}`,
+                                baseAddress: regionBase,
+                                size: Number(regionSize),
+                            });
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            address = regionBase + regionSize;
+        }
+        return modules;
+    }
+}

package/dist/src/native/platform/darwin/index.d.ts

@@ -0,0 +1 @@
+export { DarwinMemoryProvider } from './DarwinMemoryProvider.js';

package/dist/src/native/platform/darwin/index.js

@@ -0,0 +1 @@
+export { DarwinMemoryProvider } from './DarwinMemoryProvider.js';

package/dist/src/native/platform/factory.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformMemoryAPI } from './PlatformMemoryAPI.js';
+export declare function createPlatformProvider(): PlatformMemoryAPI;
+export declare function getCurrentPlatform(): 'win32' | 'darwin' | 'unsupported';

package/dist/src/native/platform/factory.js

@@ -0,0 +1,31 @@
+import { createRequire } from 'module';
+const esmRequire = createRequire(import.meta.url);
+let cachedProvider = null;
+export function createPlatformProvider() {
+    if (cachedProvider)
+        return cachedProvider;
+    switch (process.platform) {
+        case 'win32': {
+            const { Win32MemoryProvider } = esmRequire('./win32/Win32MemoryProvider.js');
+            cachedProvider = new Win32MemoryProvider();
+            break;
+        }
+        case 'darwin': {
+            const { DarwinMemoryProvider } = esmRequire('./darwin/DarwinMemoryProvider.js');
+            cachedProvider = new DarwinMemoryProvider();
+            break;
+        }
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}. Memory operations require Windows or macOS.`);
+    }
+    if (!cachedProvider)
+        throw new Error('Failed to create memory provider');
+    return cachedProvider;
+}
+export function getCurrentPlatform() {
+    if (process.platform === 'win32')
+        return 'win32';
+    if (process.platform === 'darwin')
+        return 'darwin';
+    return 'unsupported';
+}

package/dist/src/native/platform/index.d.ts

@@ -0,0 +1,3 @@
+export type { PlatformMemoryAPI } from './PlatformMemoryAPI.js';
+export { createPlatformProvider, getCurrentPlatform } from './factory.js';
+export { MemoryProtection, type ProcessHandle, type MemoryRegionInfo, type MemoryRegionState, type MemoryRegionType, type ModuleInfo, type MemoryReadResult, type MemoryWriteResult, type ProtectionChangeResult, type AllocationResult, type PlatformAvailability, } from './types.js';

package/dist/src/native/platform/index.js

@@ -0,0 +1,2 @@
+export { createPlatformProvider, getCurrentPlatform } from './factory.js';
+export { MemoryProtection, } from './types.js';

package/dist/src/native/platform/types.d.ts

@@ -0,0 +1,50 @@
+export interface ProcessHandle {
+    readonly pid: number;
+    readonly writeAccess: boolean;
+}
+export declare enum MemoryProtection {
+    NoAccess = 0,
+    Read = 1,
+    Write = 2,
+    Execute = 4,
+    ReadWrite = 3,
+    ReadExecute = 5,
+    ReadWriteExecute = 7,
+    Guard = 8,
+    WriteCopy = 16
+}
+export type MemoryRegionState = 'committed' | 'reserved' | 'free';
+export type MemoryRegionType = 'image' | 'mapped' | 'private' | 'unknown';
+export interface MemoryRegionInfo {
+    readonly baseAddress: bigint;
+    readonly size: number;
+    readonly protection: MemoryProtection;
+    readonly state: MemoryRegionState;
+    readonly type: MemoryRegionType;
+    readonly isReadable: boolean;
+    readonly isWritable: boolean;
+    readonly isExecutable: boolean;
+}
+export interface ModuleInfo {
+    readonly name: string;
+    readonly baseAddress: bigint;
+    readonly size: number;
+}
+export interface MemoryReadResult {
+    readonly data: Buffer;
+    readonly bytesRead: number;
+}
+export interface MemoryWriteResult {
+    readonly bytesWritten: number;
+}
+export interface ProtectionChangeResult {
+    readonly oldProtection: MemoryProtection;
+}
+export interface AllocationResult {
+    readonly address: bigint;
+}
+export interface PlatformAvailability {
+    readonly available: boolean;
+    readonly reason?: string;
+    readonly platform: 'win32' | 'darwin';
+}

package/dist/src/native/platform/types.js

@@ -0,0 +1,12 @@
+export var MemoryProtection;
+(function (MemoryProtection) {
+    MemoryProtection[MemoryProtection["NoAccess"] = 0] = "NoAccess";
+    MemoryProtection[MemoryProtection["Read"] = 1] = "Read";
+    MemoryProtection[MemoryProtection["Write"] = 2] = "Write";
+    MemoryProtection[MemoryProtection["Execute"] = 4] = "Execute";
+    MemoryProtection[MemoryProtection["ReadWrite"] = 3] = "ReadWrite";
+    MemoryProtection[MemoryProtection["ReadExecute"] = 5] = "ReadExecute";
+    MemoryProtection[MemoryProtection["ReadWriteExecute"] = 7] = "ReadWriteExecute";
+    MemoryProtection[MemoryProtection["Guard"] = 8] = "Guard";
+    MemoryProtection[MemoryProtection["WriteCopy"] = 16] = "WriteCopy";
+})(MemoryProtection || (MemoryProtection = {}));

package/dist/src/native/platform/win32/Win32MemoryProvider.d.ts

@@ -0,0 +1,15 @@
+import type { PlatformMemoryAPI } from '../PlatformMemoryAPI.js';
+import { MemoryProtection, type ProcessHandle, type MemoryRegionInfo, type MemoryReadResult, type MemoryWriteResult, type ProtectionChangeResult, type AllocationResult, type ModuleInfo, type PlatformAvailability } from '../types.js';
+export declare class Win32MemoryProvider implements PlatformMemoryAPI {
+    readonly platform: "win32";
+    checkAvailability(): Promise<PlatformAvailability>;
+    openProcess(pid: number, writeAccess: boolean): ProcessHandle;
+    closeProcess(handle: ProcessHandle): void;
+    readMemory(handle: ProcessHandle, address: bigint, size: number): MemoryReadResult;
+    writeMemory(handle: ProcessHandle, address: bigint, data: Buffer): MemoryWriteResult;
+    queryRegion(handle: ProcessHandle, address: bigint): MemoryRegionInfo | null;
+    changeProtection(handle: ProcessHandle, address: bigint, size: number, newProtection: MemoryProtection): ProtectionChangeResult;
+    allocateMemory(handle: ProcessHandle, size: number, protection: MemoryProtection): AllocationResult;
+    freeMemory(handle: ProcessHandle, address: bigint, _size: number): void;
+    enumerateModules(handle: ProcessHandle): ModuleInfo[];
+}