@devscholar/node-ps1-dotnet 0.0.0

package/scripts/PsHost.ps1

@@ -0,0 +1,11 @@
+# scripts/PsHost.ps1
+param($PipeName)
+
+$ScriptDir = Split-Path $MyInvocation.MyCommand.Path
+
+Import-Module "$ScriptDir\PsBridge" -Force
+
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+$ErrorActionPreference = "Stop"
+
+[PsHostEntry]::Run($PipeName)

package/src/index.ts

@@ -0,0 +1,510 @@
+// src/index.ts
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as cp from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { getPowerShellPath } from './utils.ts';
+import { IpcSync } from './ipc.ts';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const gcRegistry = new FinalizationRegistry((id: string) => {
+    try { node_ps1_dotnet._release(id); } catch {}
+});
+
+const callbackRegistry = new Map<string, Function>();
+const typeMetadataCache = new Map<string, Map<string, string>>();
+const globalTypeCache = new Map<string, Map<string, string>>();
+const pendingInspectRequests = new Map<string, string[]>();
+const pendingInspectTimeout = new Map<string, NodeJS.Timeout>();
+
+let ipc: IpcSync | null = null;
+let proc: cp.ChildProcess | null = null;
+let initialized = false;
+let cachedRuntimeInfo: { frameworkMoniker: string; runtimeVersion: string } | null = null;
+
+function cleanup() {
+    if (!initialized) return;
+    initialized = false;
+    
+    if (ipc) {
+        try {
+            ipc.close();
+        } catch {}
+    }
+    
+    if (proc && !proc.killed) {
+        try {
+            // Windows 下强制杀死进程，防止标准流卡死 Node.js 的事件循环
+            proc.kill('SIGKILL');
+        } catch {}
+    }
+    
+    proc = null;
+    ipc = null;
+}
+
+function initialize() {
+    if (initialized) return;
+    
+    const pipeName = `PsNode_${process.pid}_${Math.floor(Math.random() * 10000)}`;
+    const scriptPath = path.join(__dirname, '..', 'scripts', 'PsHost.ps1');
+
+    if (!fs.existsSync(scriptPath)) {
+        throw new Error(`Cannot find PsHost.ps1: ${scriptPath}`);
+    }
+
+    const powerShellPath = getPowerShellPath();
+    proc = cp.spawn(powerShellPath, [
+        '-NoProfile', '-ExecutionPolicy', 'Bypass',
+        '-Command', `& '${scriptPath}' -PipeName '${pipeName}'`
+    ], { stdio: 'inherit', windowsHide: false });
+
+    // 让子进程尽量不阻止 Node.js 退出
+    proc.unref();
+
+    proc.on('exit', (code) => {
+        process.exit(0);
+    });
+
+    // 修复脚本跑完后无法停机卡死的 Bug：
+    // 当 V8 执行到底，事件循环清空时，触发 beforeExit -> 强杀子进程并立刻退出
+    process.on('beforeExit', () => {
+        cleanup();
+        process.exit(0); 
+    });
+    
+    process.on('exit', () => {
+        cleanup();
+    });
+    
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(0);
+    });
+    
+    process.on('SIGTERM', () => {
+        cleanup();
+        process.exit(0);
+    });
+    
+    process.on('uncaughtException', (err) => {
+        console.error('Uncaught Exception:', err);
+        cleanup();
+        process.exit(1);
+    });
+
+    ipc = new IpcSync(pipeName, (res: any) => {
+        const cb = callbackRegistry.get(res.callbackId!);
+        if (cb) {
+            const wrappedArgs = (res.args || []).map((arg: any) => {
+                if (arg && arg.type === 'ref' && arg.props) {
+                    return createProxyWithInlineProps(arg);
+                }
+                return createProxy(arg);
+            });
+            return cb(...wrappedArgs);
+        }
+        return null;
+    });
+
+    ipc.connect();
+    initialized = true;
+}
+
+const typeNameCache = new Map<string, string>();
+
+function getObjectTypeName(id: string): string | null {
+    if (typeNameCache.has(id)) {
+        return typeNameCache.get(id)!;
+    }
+    try {
+        const res = ipc!.send({ action: 'GetTypeName', targetId: id });
+        if (res && res.typeName) {
+            typeNameCache.set(id, res.typeName);
+            return res.typeName;
+        }
+    } catch {}
+    return null;
+}
+
+function getTypeMembers(typeName: string, memberNames: string[]): Map<string, string> | null {
+    if (globalTypeCache.has(typeName)) {
+        const cached = globalTypeCache.get(typeName)!;
+        const result = new Map<string, string>();
+        let allFound = true;
+        for (const name of memberNames) {
+            if (cached.has(name)) {
+                result.set(name, cached.get(name)!);
+            } else {
+                allFound = false;
+            }
+        }
+        if (allFound) return result;
+    }
+
+    try {
+        const res = ipc!.send({ action: 'InspectType', typeName, memberNames });
+        if (res && res.members) {
+            if (!globalTypeCache.has(typeName)) {
+                globalTypeCache.set(typeName, new Map());
+            }
+            const cache = globalTypeCache.get(typeName)!;
+            for (const [name, type] of Object.entries(res.members as Record<string, string>)) {
+                cache.set(name, type);
+            }
+            return new Map(Object.entries(res.members as Record<string, string>));
+        }
+    } catch {}
+    return null;
+}
+
+function ensureMemberTypeCached(id: string, memberName: string, memberCache: Map<string, string>) {
+    if (memberCache.has(memberName)) return;
+
+    const typeName = getObjectTypeName(id);
+    if (typeName) {
+        const members = getTypeMembers(typeName, [memberName]);
+        if (members && members.has(memberName)) {
+            memberCache.set(memberName, members.get(memberName)!);
+            return;
+        }
+    }
+
+    try {
+        const inspectRes = ipc!.send({ action: 'Inspect', targetId: id, memberName });
+        memberCache.set(memberName, inspectRes.memberType);
+    } catch {
+        memberCache.set(memberName, 'method');
+    }
+}
+
+function createProxyWithInlineProps(meta: any): any {
+    if (meta.type !== 'ref') return createProxy(meta);
+
+    const id = meta.id!;
+    const inlineProps = meta.props || {};
+
+    if (!typeMetadataCache.has(id)) {
+        typeMetadataCache.set(id, new Map());
+    }
+    const memberCache = typeMetadataCache.get(id)!;
+
+    class Stub {}
+
+    const proxy = new Proxy(Stub, {
+        get: (target: any, prop: string) => {
+            if (prop === '__ref') return id;
+            if (prop === '__inlineProps') return inlineProps;
+            if (typeof prop !== 'string') return undefined;
+
+            if (inlineProps.hasOwnProperty(prop)) {
+                memberCache.set(prop, 'property');
+                return inlineProps[prop];
+            }
+
+            if (prop.startsWith('add_')) {
+                const eventName = prop.substring(4);
+                return (callback: Function) => {
+                    const cbId = `cb_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, callback);
+                    ipc!.send({ action: 'AddEvent', targetId: id, eventName, callbackId: cbId });
+                };
+            }
+
+            let memType = memberCache.get(prop);
+
+            if (!memType) {
+                ensureMemberTypeCached(id, prop, memberCache);
+                memType = memberCache.get(prop);
+            }
+
+            if (memType === 'property') {
+                const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [] });
+                return createProxy(res);
+            } else {
+                return (...args: any[]) => {
+                    const netArgs = args.map((a: any) => {
+                        if (a && a.__ref) return { __ref: a.__ref };
+                        if (typeof a === 'function') {
+                            const cbId = `cb_arg_${Date.now()}_${Math.random()}`;
+                            callbackRegistry.set(cbId, a);
+                            return { type: 'callback', callbackId: cbId };
+                        }
+                        return a;
+                    });
+                    const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: netArgs });
+                    return createProxy(res);
+                };
+            }
+        },
+
+        set: (target: any, prop: string, value: any) => {
+            if (typeof prop !== 'string') return false;
+            const netArg = (value && value.__ref) ? { __ref: value.__ref } : value;
+            ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [netArg] });
+            memberCache.set(prop, 'property');
+            return true;
+        },
+
+        construct: (target: any, args: any[]) => {
+            const netArgs = args.map((a: any) => {
+                if (a && a.__ref) return { __ref: a.__ref };
+                if (typeof a === 'function') {
+                    const cbId = `cb_ctor_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, a);
+                    return { type: 'callback', callbackId: cbId };
+                }
+                return a;
+            });
+            const res = ipc!.send({ action: 'New', typeId: id, args: netArgs });
+            return createProxy(res);
+        },
+
+        apply: () => { throw new Error("Cannot call .NET object as a function. Need 'new'?"); }
+    });
+
+    gcRegistry.register(proxy, id);
+    return proxy;
+}
+
+function createLazyArray(arr: any[]): any {
+    return new Proxy(arr, {
+        get(target, prop) {
+            if (typeof prop === 'symbol') return target[prop];
+            const index = Number(prop);
+            if (!isNaN(index) && index >= 0 && index < target.length) {
+                return createProxy(target[index]);
+            }
+            if (prop === 'length') return target.length;
+            if (prop === 'map' || prop === 'filter' || prop === 'forEach' || prop === 'reduce') {
+                return (...args: any[]) => {
+                    const transformed = target.map((item: any) => createProxy(item));
+                    return transformed[prop](...args);
+                };
+            }
+            if (prop === 'slice') {
+                return (...args: any[]) => {
+                    const sliced = target.slice(...args);
+                    return sliced.map((item: any) => createProxy(item));
+                };
+            }
+            return undefined;
+        }
+    });
+}
+
+const LARGE_ARRAY_THRESHOLD = 50;
+
+function createProxy(meta: any): any {
+    if (meta.type === 'primitive' || meta.type === 'null') return meta.value;
+
+    if (meta.type === 'array') {
+        const arr = meta.value;
+        if (arr.length <= LARGE_ARRAY_THRESHOLD) {
+            return arr.map((item: any) => createProxy(item));
+        }
+        return createLazyArray(arr);
+    }
+
+    if (meta.type === 'task') {
+        const taskId = meta.id;
+        return new Promise((resolve, reject) => {
+            try {
+                const res = ipc!.send({ action: 'AwaitTask', taskId: taskId });
+                resolve(createProxy(res));
+            } catch (e) {
+                reject(e);
+            } finally {
+                try { ipc!.send({ action: 'Release', targetId: taskId }); } catch {}
+            }
+        });
+    }
+
+    if (meta.type === 'namespace') {
+        const nsName = meta.value;
+        return new Proxy({}, {
+            get: (target: any, prop: string) => {
+                if (typeof prop !== 'string') return undefined;
+                return node_ps1_dotnet._load(`${nsName}.${prop}`);
+            }
+        });
+    }
+
+    if (meta.type !== 'ref') return null;
+
+    const id = meta.id!;
+
+    if (!typeMetadataCache.has(id)) {
+        typeMetadataCache.set(id, new Map());
+    }
+    const memberCache = typeMetadataCache.get(id)!;
+
+    class Stub {}
+
+    const proxy = new Proxy(Stub, {
+        get: (target: any, prop: string) => {
+            if (prop === '__ref') return id;
+            if (typeof prop !== 'string') return undefined;
+
+            if (prop.startsWith('add_')) {
+                const eventName = prop.substring(4);
+                return (callback: Function) => {
+                    const cbId = `cb_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, callback);
+                    ipc!.send({ action: 'AddEvent', targetId: id, eventName, callbackId: cbId });
+                };
+            }
+
+            let memType = memberCache.get(prop);
+
+            if (!memType) {
+                ensureMemberTypeCached(id, prop, memberCache);
+                memType = memberCache.get(prop);
+            }
+
+            if (memType === 'property') {
+                const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [] });
+                return createProxy(res);
+            } else {
+                return (...args: any[]) => {
+                    const netArgs = args.map((a: any) => {
+                        if (a && a.__ref) return { __ref: a.__ref };
+                        if (typeof a === 'function') {
+                            const cbId = `cb_arg_${Date.now()}_${Math.random()}`;
+                            callbackRegistry.set(cbId, a);
+                            return { type: 'callback', callbackId: cbId };
+                        }
+                        return a;
+                    });
+                    const res = ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: netArgs });
+                    return createProxy(res);
+                };
+            }
+        },
+
+        set: (target: any, prop: string, value: any) => {
+            if (typeof prop !== 'string') return false;
+            const netArg = (value && value.__ref) ? { __ref: value.__ref } : value;
+            ipc!.send({ action: 'Invoke', targetId: id, methodName: prop, args: [netArg] });
+            memberCache.set(prop, 'property');
+            return true;
+        },
+
+        construct: (target: any, args: any[]) => {
+            const netArgs = args.map((a: any) => {
+                if (a && a.__ref) return { __ref: a.__ref };
+                if (typeof a === 'function') {
+                    const cbId = `cb_ctor_${Date.now()}_${Math.random()}`;
+                    callbackRegistry.set(cbId, a);
+                    return { type: 'callback', callbackId: cbId };
+                }
+                return a;
+            });
+            const res = ipc!.send({ action: 'New', typeId: id, args: netArgs });
+            return createProxy(res);
+        },
+
+        apply: () => { throw new Error("Cannot call .NET object as a function. Need 'new'?"); }
+    });
+
+    gcRegistry.register(proxy, id);
+    return proxy;
+}
+
+export const node_ps1_dotnet = {
+    _load(typeName: string): any {
+        initialize();
+        const res = ipc!.send({ action: 'GetType', typeName });
+        return createProxy(res);
+    },
+
+    _release(id: string) {
+        if (ipc) {
+            try { ipc!.send({ action: 'Release', targetId: id }); } catch {}
+        }
+    },
+
+    _close() {
+        if (proc) proc.kill();
+        cleanup();
+    },
+
+    _getAssembly(assemblyName: string): any {
+        return this._load(assemblyName);
+    },
+
+    _loadAssembly(assemblyName: string): any {
+        initialize();
+        const res = ipc!.send({ action: 'LoadAssembly', assemblyName });
+        return createProxy(res);
+    },
+
+    _getRuntimeInfo(): { frameworkMoniker: string; runtimeVersion: string } {
+        if (cachedRuntimeInfo) return cachedRuntimeInfo;
+        initialize();
+        const res = ipc!.send({ action: 'GetRuntimeInfo' });
+        cachedRuntimeInfo = {
+            frameworkMoniker: res.frameworkMoniker || 'netstandard2.0',
+            runtimeVersion: res.runtimeVersion || '0.0.0'
+        };
+        return cachedRuntimeInfo;
+    }
+};
+
+function createNamespaceProxy(assemblyName: string) {
+    return new Proxy({}, {
+        get: (target: any, prop: string) => {
+            if (typeof prop !== 'string') return undefined;
+            if (prop === 'then') return undefined; // 处理 Promise 检查
+            return node_ps1_dotnet._load(`${assemblyName}.${prop}`);
+        }
+    });
+}
+
+const dotnetProxy = new Proxy(function() {} as any, {
+    get: (target: any, prop: string) => {
+        if (prop === 'default') return dotnetProxy;
+        if (prop === 'then') return undefined;
+        if (prop === 'load') return (assemblyNameOrFilePath: string) => {
+            node_ps1_dotnet._loadAssembly(assemblyNameOrFilePath);
+        };
+        if (prop === 'frameworkMoniker') {
+            return node_ps1_dotnet._getRuntimeInfo().frameworkMoniker;
+        }
+        if (prop === 'runtimeVersion') {
+            return node_ps1_dotnet._getRuntimeInfo().runtimeVersion;
+        }
+        if (prop === '__inspect') {
+            return (targetId: string, memberName: string) => ipc!.send({ action: 'Inspect', targetId, memberName });
+        }
+        return node_ps1_dotnet._load(prop);
+    },
+    apply: (target: any, argArray: any[], newTarget: any) => {
+        return createNamespaceProxy(argArray[0]);
+    }
+});
+
+function createExportNamespaceProxy(namespacePrefix: string): any {
+    const cache = new Map<string, any>();
+    
+    return new Proxy({} as any, {
+        get: (target: any, prop: string) => {
+            if (typeof prop !== 'string') return undefined;
+            if (prop === 'then') return undefined;
+            
+            const fullName = `${namespacePrefix}.${prop}`;
+            if (cache.has(fullName)) {
+                return cache.get(fullName);
+            }
+            
+            const result = node_ps1_dotnet._load(fullName);
+            cache.set(fullName, result);
+            return result;
+        }
+    });
+}
+
+export default dotnetProxy;
+export const System = createExportNamespaceProxy('System');

package/src/ipc.ts

@@ -0,0 +1,182 @@
+// src/ipc.ts
+import * as fs from 'node:fs';
+import type { ProtocolResponse, CommandRequest } from './types.ts';
+
+declare const Deno: any;
+
+const MAX_LINE_LENGTH = 1024 * 1024 * 2; // 2MB buffer per line
+const CHUNK_SIZE = 16 * 1024; // 16KB chunk size for buffering
+const isDeno = typeof Deno !== 'undefined';
+
+export class IpcSync {
+    public fd: number = 0;
+    private exited: boolean = false;
+
+    private readBuffer = isDeno ? new Uint8Array(CHUNK_SIZE) : Buffer.alloc(CHUNK_SIZE);
+    private resultBuffer = isDeno ? new Uint8Array(MAX_LINE_LENGTH) : Buffer.alloc(MAX_LINE_LENGTH);
+    private bufferOffset = 0;
+    private bufferLength = 0;
+
+    constructor(
+        private pipeName: string,
+        private onEvent: (msg: ProtocolResponse) => any 
+    ) {}
+
+    private readLineSync(): string | null {
+        let resultOffset = 0;
+        
+        while (true) {
+            if (this.bufferOffset >= this.bufferLength) {
+                try {
+                    if (isDeno) {
+                        this.readBuffer.fill(0);
+                    } else {
+                        (this.readBuffer as Buffer).fill(0);
+                    }
+                    const bytesRead = fs.readSync(this.fd, this.readBuffer, 0, CHUNK_SIZE, null);
+                    if (bytesRead === 0) {
+                        if (resultOffset === 0) return null;
+                        break;
+                    }
+                    this.bufferOffset = 0;
+                    this.bufferLength = bytesRead;
+                } catch (e) {
+                    return null;
+                }
+            }
+            
+            let lineEnd = -1;
+            for (let i = this.bufferOffset; i < this.bufferLength; i++) {
+                if (this.readBuffer[i] === 10) {
+                    lineEnd = i;
+                    break;
+                }
+            }
+            
+            if (lineEnd !== -1) {
+                const lineLength = lineEnd - this.bufferOffset;
+                if (resultOffset + lineLength > MAX_LINE_LENGTH) {
+                    throw new Error("IPC Pipe line length exceeded max limit.");
+                }
+                if (isDeno) {
+                    this.resultBuffer.set(this.readBuffer.subarray(this.bufferOffset, lineEnd), resultOffset);
+                } else {
+                    (this.readBuffer as Buffer).copy(this.resultBuffer as Buffer, resultOffset, this.bufferOffset, lineEnd);
+                }
+                resultOffset += lineLength;
+                this.bufferOffset = lineEnd + 1;
+                break;
+            }
+            
+            const availableLength = this.bufferLength - this.bufferOffset;
+            if (resultOffset + availableLength > MAX_LINE_LENGTH) {
+                throw new Error("IPC Pipe line length exceeded max limit.");
+            }
+            if (isDeno) {
+                this.resultBuffer.set(this.readBuffer.subarray(this.bufferOffset, this.bufferLength), resultOffset);
+            } else {
+                (this.readBuffer as Buffer).copy(this.resultBuffer as Buffer, resultOffset, this.bufferOffset, this.bufferLength);
+            }
+            resultOffset += availableLength;
+            this.bufferOffset = this.bufferLength;
+        }
+
+        if (resultOffset === 0) return '';
+        
+        if (isDeno) {
+            return new TextDecoder().decode(this.resultBuffer.subarray(0, resultOffset));
+        } else {
+            return (this.resultBuffer as Buffer).toString('utf8', 0, resultOffset);
+        }
+    }
+
+    private tryConnect(pipePath: string): boolean {
+        try {
+            this.fd = fs.openSync(pipePath, 'r+');
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    connect() {
+        const pipePath = `\\\\.\\pipe\\${this.pipeName}`;
+        const start = Date.now();
+        let delay = 1;
+        const maxDelay = 100;
+
+        while (true) {
+            if (this.tryConnect(pipePath)) break;
+
+            if (Date.now() - start > 5000) {
+                throw new Error(`Timeout connecting pipe: ${pipePath}`);
+            }
+
+            const target = Date.now() + delay;
+            while (Date.now() < target) {
+                if (this.tryConnect(pipePath)) return;
+            }
+
+            delay = Math.min(delay * 1.5, maxDelay);
+        }
+    }
+
+    send(cmd: CommandRequest): ProtocolResponse {
+        if (this.exited) {
+            return { type: 'exit', message: '' };
+        }
+
+        try {
+            fs.writeSync(this.fd, JSON.stringify(cmd) + '\n');
+        } catch (e) {
+            throw new Error("Pipe closed (Write failed)");
+        }
+
+        while (true) {
+            const line = this.readLineSync();
+            if (line === null) throw new Error("Pipe closed (Read EOF)");
+            if (!line.trim()) continue;
+
+            let res: ProtocolResponse;
+            try {
+                res = JSON.parse(line);
+            } catch (e) {
+                throw new Error(`Pipe closed (Invalid JSON): ${line}`);
+            }
+
+            if (res.type === 'event') {
+                let result = null;
+                try {
+                    result = this.onEvent(res);
+                } catch (e) {
+                    console.error("Callback Error:", e);
+                }
+                
+                const reply = { type: 'reply', result: result };
+                try {
+                    fs.writeSync(this.fd, JSON.stringify(reply) + '\n');
+                } catch {}
+                continue;
+            }
+
+            if (res.type === 'error') throw new Error(`Host Error: ${res.message}`);
+            
+            if (res.type === 'exit') {
+                this.exited = true;
+                return res;
+            }
+            
+            return res;
+        }
+    }
+
+    close() {
+        this.exited = true;
+        if (this.fd) {
+            try {
+                fs.closeSync(this.fd);
+            } catch {}
+            this.fd = 0;
+        }
+    }
+}