@cheatron/native-mock 1.0.0

package/dist/thread.js

@@ -0,0 +1,113 @@
+import { Kernel32Impl as Kernel32 } from './kernel32';
+import { ThreadAccess, ContextFlags, CONTEXT, CONTEXT_SIZE, } from './constants';
+import koffi from 'koffi';
+import { log } from './logger';
+/**
+ * Handle management registry for automatic cleanup
+ */
+const registry = new FinalizationRegistry((handle) => {
+    if (handle) {
+        log.trace('Thread', 'Closing orphaned handle via GC');
+        Kernel32.CloseHandle(handle);
+    }
+});
+/**
+ * Represents a thread handle
+ */
+export class Thread {
+    _handle;
+    constructor(handle, autoClose = true) {
+        this._handle = handle;
+        if (autoClose && handle) {
+            registry.register(this, handle, this);
+        }
+    }
+    static open(threadId, access = ThreadAccess.ALL_ACCESS) {
+        log.debug('Thread', `Opening thread ${threadId}`, { access });
+        const handle = Kernel32.OpenThread(access, 0, threadId);
+        if (!handle) {
+            log.error('Thread', `Failed to open thread ${threadId}`);
+            throw new Error(`Failed to open thread ${threadId}`);
+        }
+        return new Thread(handle);
+    }
+    static current() {
+        return currentThread;
+    }
+    static currentId() {
+        return Kernel32.GetCurrentThreadId();
+    }
+    isValid() {
+        return this._handle !== null && this._handle !== undefined;
+    }
+    close() {
+        if (this.isValid()) {
+            log.debug('Thread', 'Closing thread handle');
+            const h = this._handle;
+            this._handle = null;
+            registry.unregister(this);
+            Kernel32.CloseHandle(h);
+        }
+    }
+    suspend() {
+        if (!this.isValid())
+            throw new Error('Thread handle is closed');
+        const count = Kernel32.SuspendThread(this._handle);
+        if (count === 0xffffffff) {
+            log.error('Thread', 'SuspendThread failed');
+            throw new Error('SuspendThread failed');
+        }
+        return count;
+    }
+    resume() {
+        if (!this.isValid())
+            throw new Error('Thread handle is closed');
+        const count = Kernel32.ResumeThread(this._handle);
+        if (count === 0xffffffff) {
+            log.error('Thread', 'ResumeThread failed');
+            throw new Error('ResumeThread failed');
+        }
+        return count;
+    }
+    getContext(flags = ContextFlags.FULL) {
+        if (!this.isValid())
+            throw new Error('Thread handle is closed');
+        const buf = Buffer.alloc(CONTEXT_SIZE);
+        // ContextFlags is at offset 0x30 (after 6 × uint64 P*Home registers)
+        buf.writeUInt32LE(flags, 0x30);
+        const success = Kernel32.GetThreadContext(this._handle, buf);
+        if (!success) {
+            log.error('Thread', 'GetThreadContext failed');
+            throw new Error('GetThreadContext failed');
+        }
+        return koffi.decode(buf, CONTEXT);
+    }
+    setContext(ctx) {
+        if (!this.isValid())
+            throw new Error('Thread handle is closed');
+        const buf = Buffer.alloc(CONTEXT_SIZE);
+        koffi.encode(buf, CONTEXT, ctx);
+        const success = Kernel32.SetThreadContext(this._handle, buf);
+        if (!success) {
+            log.error('Thread', 'SetThreadContext failed');
+            throw new Error('SetThreadContext failed');
+        }
+    }
+    get handle() {
+        return this._handle;
+    }
+}
+/**
+ * Represents the current thread (singleton)
+ */
+export class CurrentThread extends Thread {
+    constructor() {
+        // Current thread uses a pseudo-handle that doesn't need closing
+        super(Kernel32.GetCurrentThread(), false);
+    }
+    close() {
+        this._handle = null;
+    }
+}
+// Export a pre-initialized instance of the current thread
+export const currentThread = new CurrentThread();

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@cheatron/native-mock",
+  "version": "1.0.0",
+  "description": "Pure JavaScript mock implementation of Win32 native modules for testing without native dependencies",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "cheatron",
+    "win32",
+    "native",
+    "mock",
+    "kernel32",
+    "simulation",
+    "testing"
+  ],
+  "author": "Cheatron",
+  "homepage": "https://github.com/Cheatron/cheatron-native-mock#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cheatron/cheatron-native-mock.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cheatron/cheatron-native-mock/issues"
+  },
+  "dependencies": {
+    "@cheatron/log": "^1.0.1",
+    "@cheatron/native-mock-koffi": "^1.0.0",
+    "win32-def": "^26.1.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/bun": "latest",
+    "add": "^2.0.6",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1",
+    "typescript": "^5",
+    "typescript-eslint": "^8.56.0"
+  },
+  "overrides": {
+    "koffi": "npm:@cheatron/native-mock-koffi@^1.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "lint": "eslint \"src/**/*.{js,ts,jsx,tsx}\" --cache",
+    "lint:fix": "eslint \"src/**/*.{js,ts,jsx,tsx}\" --fix",
+    "format": "prettier --write \"{src,tests}/**/*.{js,ts,jsx,tsx,css,md,json}\"",
+    "format:check": "prettier --check \"{src,tests}/**/*.{js,ts,jsx,tsx,css,md,json}\""
+  }
+}