@arcticnotes/node-wsh 0.0.9 → 0.0.10

package/README.md

@@ -18,10 +18,10 @@ In JavaScript code:
 ```javascript
 import {WindowsScriptingHost} from '@arcticnotes/node-wsh';
 
-const wsh = await WindowsScriptingHost.connect();
-const WScript = wsh.WScript;
+const WSH = await WindowsScriptingHost.connect();
+const WScript = WSH.global( 'WScript');
 console.log(WScript.Version);
-await wsh.disconnect();
+await WSH.disconnect();
 ```
 
 ## Dependencies

package/lib/node/node-wsh.js

@@ -5,8 +5,6 @@ import { Syncline} from "@arcticnotes/syncline";
 const COMMAND = 'cscript.exe';
 const ARGS = [ '//E:jscript', '//NoLogo'];
 const SCRIPT_FILE = PATH.join( PATH.dirname( import.meta.dirname), 'wsh', 'host.js');
-const PROXY = Symbol();
-const TRACE_REF = 1;
 
 export class WindowsScriptingHost extends EventEmitter {
 
@@ -15,83 +13,36 @@ export class WindowsScriptingHost extends EventEmitter {
 		const args = options.args || ARGS;
 		const scriptFile = options.scriptFile || SCRIPT_FILE;
 		const trace = options.trace || 0;
-		return new WindowsScriptingHost( await Syncline.spawn( command, [ ...args, scriptFile], { trace}), options);
+		return new WindowsScriptingHost( await Syncline.spawn( command, [ ...args, scriptFile], { trace}));
 	}
 
 	#syncline;
-	#proxies;
-	#WScript;
-	#GetObject;
-	#Enumerator;
-
-	constructor( syncline, options) {
-		super();
-		this.#syncline = syncline;
-		this.#syncline.on( 'stderr', line => console.log( 'wsh:', line));
-		this.#syncline.on( 'stdout', line => console.log( 'wsh:', line));
-		this.#proxies = new Proxies( syncline, options, this);
-		this.#WScript = this.#proxies.getOrCreateObject( 0);
-		this.#GetObject = this.#proxies.getOrCreateFunction( 1);
-		this.#Enumerator = this.#proxies.getOrCreateFunction( 2);
-	}
-
-	get remoteObjects() {
-		const proxies = this.#proxies;
-		return {
-			get count() {
-				return proxies.count;
-			},
-		};
-	}
-
-	get WScript() {
-		return this.#WScript;
-	}
-
-	get GetObject() {
-		return this.#GetObject;
-	}
-
-	get Enumerator() {
-		return this.#Enumerator;
-	}
-
-	async disconnect() {
-		await this.#syncline.close();
-	}
-}
-
-class Proxies {
-
-	#syncline;
-	#trace;
-	#eventEmitter;
 	#finalizer = new FinalizationRegistry( this.#finalized.bind( this));
 	#ref2proxy = new Map();
-	#proxy2ref = new Map();
+	#proxy2ref = new WeakMap();
 
 	#objectHandler = {
 
-		proxies: this,
+		wsh: this,
 	
 		get( target, prop) {
 			if( prop === Symbol.toPrimitive)
-				return () => `ref#${ this.proxies.#proxy2ref.get( target[ PROXY])}`;
-			const encodedTarget = this.proxies.#encode( target[ PROXY]);
-			const encodedProp = this.proxies.#encode( prop);
-			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'get', encodedTarget, encodedProp])));
+				return () => `ref#${ target.ref}`;
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedProp = this.wsh.#encode( prop);
+			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'get', encodedTarget, encodedProp])));
 			switch( output[ 0]) {
-				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'value': return this.wsh.#decode( output[ 1]);
 				case 'error': throw new Error( output[ 1]);
 				default: throw new Error( `unknown status: ${ output[ 0]}`);
 			}
 		},
 
 		set( target, prop, value) {
-			const encodedTarget = this.proxies.#encode( target[ PROXY]);
-			const encodedProp = this.proxies.#encode( prop);
-			const encodedValue = this.proxies.#encode( value);
-			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'set', encodedTarget, encodedProp, encodedValue])));
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedProp = this.wsh.#encode( prop);
+			const encodedValue = this.wsh.#encode( value);
+			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'set', encodedTarget, encodedProp, encodedValue])));
 			switch( output[ 0]) {
 				case 'set': return;
 				case 'error': throw new Error( output[ 1]);
@@ -102,85 +53,96 @@ class Proxies {
 
 	#functionHandler = {
 
-		proxies: this,
+		wsh: this,
 
 		get( target, prop) {
 			if( prop === Symbol.toPrimitive)
-				return () => `ref#${ this.proxies.#proxy2ref.get( target[ PROXY])}`;
+				return () => `ref#${ target.ref}`;
 			return undefined;
 		},
 
 		apply( target, thisArg, argumentList) {
-			const encodedTarget = this.proxies.#encode( target[ PROXY]);
-			const encodedThisArg = this.proxies.#encode( thisArg);
-			const encodedArgumentList = this.proxies.#encode( argumentList);
-			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'apply', encodedTarget, encodedThisArg, encodedArgumentList])));
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedThisArg = this.wsh.#encode( thisArg);
+			const encodedArgumentList = this.wsh.#encode( argumentList);
+			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'apply', encodedTarget, encodedThisArg, encodedArgumentList])));
 			switch( output[ 0]) {
-				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'value': return this.wsh.#decode( output[ 1]);
 				case 'error': throw new Error( output[ 1]);
 				default: throw new Error( `unknown status: ${ output[ 0]}`);
 			}
 		},
 
 		construct( target, argumentList) {
-			const encodedTarget = this.proxies.#encode( target[ PROXY]);
-			const encodedArgumentList = this.proxies.#encode( argumentList);
-			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'construct', encodedTarget, encodedArgumentList])));
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedArgumentList = this.wsh.#encode( argumentList);
+			const output = JSON.parse( this.wsh.#syncline.exchange( JSON.stringify( [ 'construct', encodedTarget, encodedArgumentList])));
 			switch( output[ 0]) {
-				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'value': return this.wsh.#decode( output[ 1]);
 				case 'error': throw new Error( output[ 1]);
 				default: throw new Error( `unknown status: ${ output[ 0]}`);
 			}
 		},
 	};
 
-	constructor( syncline, options, eventEmitter) {
+	constructor( syncline) {
+		super();
 		this.#syncline = syncline;
-		this.#trace = options.trace;
-		this.#eventEmitter = eventEmitter;
+		this.#syncline.on( 'stderr', line => console.log( 'wsh:', line));
+		this.#syncline.on( 'stdout', line => console.log( 'wsh:', line));
 	}
 
-	get count() {
-		return this.#ref2proxy.size;
+	get remoteObjects() {
+		const proxies = this;
+		return {
+			get count() {
+				return proxies.#ref2proxy.size;
+			},
+		};
+	}
+
+	global( name) {
+		const output = JSON.parse( this.#syncline.exchange( JSON.stringify( [ 'global', name])));
+		switch( output[ 0]) {
+			case 'value': return this.#decode( output[ 1]);
+			case 'error': throw new Error( output[ 1]);
+			default: throw new Error( `unknown status: ${ output[ 0]}`);
+		}
+	}
+
+	async disconnect() {
+		await this.#syncline.close();
 	}
 
-	getOrCreateObject( ref) {
+	#getOrCreateObject( ref) {
 		return this.#getOrCreate( ref, this.#objectHandler);
 	}
 
-	getOrCreateFunction( ref) {
+	#getOrCreateFunction( ref) {
 		return this.#getOrCreate( ref, this.#functionHandler);
 	}
 
 	#getOrCreate( ref, handler) {
-		const existingProxy = this.#ref2proxy.get( ref);
+		const existingWeakRef = this.#ref2proxy.get( ref);
+		const existingProxy = existingWeakRef && existingWeakRef.deref();
 		if( existingProxy)
 			return existingProxy;
 
-		const target = handler === this.#objectHandler? new RemoteObject(): function() {};
+		const target = handler === this.#objectHandler? new RemoteObject( ref): new RemoteFunction( ref);
 		const newProxy = new Proxy( target, handler);
-		target[ PROXY] = newProxy;
-		this.#ref2proxy.set( ref, newProxy);
+		target.proxy = newProxy;
+		this.#ref2proxy.set( ref, new WeakRef( newProxy)); // may be overwriting a dead WeakRef
 		this.#proxy2ref.set( newProxy, ref);
 		this.#finalizer.register( newProxy, ref);
-		this.#eventEmitter.emit( 'ref', ref, newProxy);
+		this.emit( 'ref', ref, newProxy);
 		return newProxy;
 	}
 
 	#finalized( ref) {
+		if( this.#ref2proxy.get( ref).deref() === undefined) // otherwise, it's overwritten by a refreshed proxy
+			this.#ref2proxy.delete( ref);
 		const output = this.#syncline.exchange( JSON.stringify( [ 'unref', ref]));
-		if( this.#trace >= TRACE_REF)
-			switch( output[ 0]) {
-				case 'error':
-					console.log( `failed to unref: ${ ref}`);
-					break;
-				case 'done':
-					console.log( `unreferenced: ${ ref}`);
-					break;
-				default:
-					console.log( `unknown response: ${ output[ 0]}`);
-			}
-		this.#eventEmitter.emit( 'unref', ref);
+		this.emit( 'unref', ref);
 	}
 
 	#encode( decoded) {
@@ -202,7 +164,7 @@ class Proxies {
 				}
 				if( decoded instanceof RemoteObject) {
 					const objref = this.#proxy2ref.get( decoded);
-					if( objref === undefined)
+					if( objref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
 						throw new Error( `remote object reference not found: ${ decoded}`);
 					return { type: 'objref', value: objref};
 				}
@@ -212,7 +174,7 @@ class Proxies {
 				return encoded;
 			case 'function':
 				const funref = this.#proxy2ref.get( decoded);
-				if( funref === undefined)
+				if( funref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
 					throw new Error( `functions from node are disallowed: ${ decoded}`);
 				return { type: 'funref', value: funref};
 			case 'bigint':
@@ -246,9 +208,9 @@ class Proxies {
 							decoded[ name] = this.#decode( value);
 						return decoded;
 					case 'objref':
-						return this.getOrCreateObject( encoded.value);
+						return this.#getOrCreateObject( encoded.value);
 					case 'funref':
-						return this.getOrCreateFunction( encoded.value);
+						return this.#getOrCreateFunction( encoded.value);
 					default:
 						throw new Error( `illegal value: ${ encoded}`);
 				}
@@ -263,4 +225,46 @@ class Proxies {
 }
 
 class RemoteObject {
+
+	#ref;
+	#proxy;
+
+	constructor( ref) {
+		this.#ref = ref;
+	}
+
+	get ref() {
+		return this.#ref;
+	}
+
+	get proxy() {
+		return this.#proxy;
+	}
+
+	set proxy( proxy) {
+		this.#proxy = proxy;
+	}
+}
+
+class RemoteFunction extends Function {
+
+	#ref;
+	#proxy;
+
+	constructor( ref) {
+		super();
+		this.#ref = ref;
+	}
+
+	get ref() {
+		return this.#ref;
+	}
+
+	get proxy() {
+		return this.#proxy;
+	}
+
+	set proxy( proxy) {
+		this.#proxy = proxy;
+	}
 }

package/lib/wsh/host.js

@@ -2,12 +2,9 @@
 
 var FSO = new ActiveXObject( 'Scripting.FileSystemObject');
 var OBJECT_TOSTRING = Object.toString();
-var REFERENCES = { // must match node-wsh.js
-	'0': { type: 'obj', value: WScript},
-	'1': { type: 'fun', value: GetObject},
-	'2': { type: 'fun', value: Enumerator}
-};
-var nextRefId = 3;
+var GLOBAL = this;
+var REFERENCES = {}
+var nextRefId = 0;
 
 eval( FSO.OpenTextFile( FSO.BuildPath( FSO.GetParentFolderName( WScript.ScriptFullName), 'json2.js')).ReadAll());
 
@@ -145,6 +142,9 @@ function decodePotentialMethod( encoded) {
 		try {
 			input = JSON.parse( WScript.StdIn.ReadLine());
 			switch( input[ 0]) {
+				case 'global': // [ 'global', name] => [ 'value', value]
+					output = [ 'value', encode( GLOBAL[ input[ 1]])];
+					break;
 				case 'unref': // [ 'unref', ref] => [ 'done']
 					if( REFERENCES[ input[ 1]] === undefined)
 						throw new Error( 'unknown ref: ' + input[ 1]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arcticnotes/node-wsh",
-	"version": "0.0.9",
+	"version": "0.0.10",
 	"description": "A Node.js package that runs Windows Scripting Host (WSH) as a child process and exposes the resources from the WSH world to the Node.js world",
 	"author": "Paul <paul@arcticnotes.com>",
 	"license": "MIT",