@arcticnotes/node-wsh 0.0.9 → 0.0.11

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

@@ -3,10 +3,8 @@ import PATH from 'node:path';
 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;
+const ARGS = [ '//NoLogo'];
+const SCRIPT_FILE = PATH.join( PATH.dirname( import.meta.dirname), 'wsh', 'host.wsf');
 
 export class WindowsScriptingHost extends EventEmitter {
 
@@ -15,172 +13,119 @@ 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;
+	#closed = false;
 	#finalizer = new FinalizationRegistry( this.#finalized.bind( this));
 	#ref2proxy = new Map();
-	#proxy2ref = new Map();
-
-	#objectHandler = {
+	#proxy2ref = new WeakMap();
+	#handler = {
 
-		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]);
 				default: throw new Error( `unknown status: ${ output[ 0]}`);
 			}
 		},
-	};
-
-	#functionHandler = {
-
-		proxies: this,
-
-		get( target, prop) {
-			if( prop === Symbol.toPrimitive)
-				return () => `ref#${ this.proxies.#proxy2ref.get( target[ PROXY])}`;
-			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])));
+		apply( target, thisArg, argumentsList) {
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedThisArg = this.wsh.#encode( thisArg);
+			const encodedArgumentList = this.wsh.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
+			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])));
+		construct( target, argumentsList) {
+			const encodedTarget = this.wsh.#encode( target.proxy);
+			const encodedArgumentList = this.wsh.#encode( [ ...argumentsList]); // argumentsList may not be instanceof Array
+			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;
+			},
+		};
 	}
 
-	getOrCreateObject( ref) {
-		return this.#getOrCreate( ref, this.#objectHandler);
+	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]}`);
+		}
 	}
 
-	getOrCreateFunction( ref) {
-		return this.#getOrCreate( ref, this.#functionHandler);
+	async disconnect() {
+		this.#closed = true;
+		await this.#syncline.close();
 	}
 
-	#getOrCreate( ref, handler) {
-		const existingProxy = this.#ref2proxy.get( ref);
+	#getOrCreate( 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 newProxy = new Proxy( target, handler);
-		target[ PROXY] = newProxy;
-		this.#ref2proxy.set( ref, newProxy);
+		const target = new RemoteObject( ref);
+		const newProxy = new Proxy( target, this.#handler);
+		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) {
-		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);
+		if( this.#ref2proxy.get( ref).deref() === undefined) // otherwise, it's overwritten by a refreshed proxy
+			this.#ref2proxy.delete( ref);
+		if( !this.#closed)
+			this.#syncline.exchange( JSON.stringify( [ 'unref', ref]));
+		this.emit( 'unref', ref);
 	}
 
 	#encode( decoded) {
@@ -194,27 +139,24 @@ class Proxies {
 			case 'object':
 				if( decoded === null)
 					return decoded;
-				if( decoded instanceof Array) {
+				if( Array.isArray( decoded)) {
 					const encoded = [];
 					for( const item of decoded)
 						encoded.push( this.#encode( item));
 					return encoded;
 				}
-				if( decoded instanceof RemoteObject) {
-					const objref = this.#proxy2ref.get( decoded);
-					if( objref === undefined)
-						throw new Error( `remote object reference not found: ${ decoded}`);
-					return { type: 'objref', value: objref};
-				}
 				const encoded = { type: 'object', value: {}};
 				for( const [ name, value] of Object.entries( decoded))
 					encoded.value[ name] = this.#encode( value);
 				return encoded;
 			case 'function':
-				const funref = this.#proxy2ref.get( decoded);
-				if( funref === undefined)
-					throw new Error( `functions from node are disallowed: ${ decoded}`);
-				return { type: 'funref', value: funref};
+				if( decoded instanceof RemoteObject) {
+					const ref = this.#proxy2ref.get( decoded);
+					if( ref === undefined) // not because garbage-collected, because clearly `decoded` is still alive
+						throw new Error( `remote object reference not found: ${ decoded}`);
+					return { type: 'ref', value: ref};
+				}
+				throw new Error( `functions from node cannot be sent: ${ decoded}`);
 			case 'bigint':
 			case 'symbol':
 			default:
@@ -231,7 +173,7 @@ class Proxies {
 			case 'object':
 				if( encoded === null)
 					return encoded;
-				if( encoded instanceof Array) {
+				if( Array.isArray( encoded)) {
 					const decoded = [];
 					for( const item of encoded)
 						decoded.push( this.#decode( item));
@@ -245,10 +187,8 @@ class Proxies {
 						for( const [ name, value] of Object.entries( encoded.value))
 							decoded[ name] = this.#decode( value);
 						return decoded;
-					case 'objref':
-						return this.getOrCreateObject( encoded.value);
-					case 'funref':
-						return this.getOrCreateFunction( encoded.value);
+					case 'ref':
+						return this.#getOrCreate( encoded.value);
 					default:
 						throw new Error( `illegal value: ${ encoded}`);
 				}
@@ -262,5 +202,25 @@ class Proxies {
 	}
 }
 
-class RemoteObject {
+class RemoteObject 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

@@ -1,13 +1,18 @@
 // This file is in JScript, not in JavaScript. It is executed in Windows Scripting Host (WSH).
 
+function CreateVBArray( jsArray) {
+	var dict = new ActiveXObject( 'Scripting.Dictionary');
+	for( var i = 0; i < jsArray.length; i++)
+		dict.Add( i, jsArray[ i]);
+	dict.Add( 'length', jsArray.length);
+	return Dict2VBArray( dict);
+}
+
 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());
 
@@ -37,21 +42,12 @@ function decode( encoded) {
 					for( i in encoded.value)
 						decoded[ i] = decode( encoded.value[ i]);
 					return decoded;
-				case 'objref':
-					item = REFERENCES[ encoded.value];
-					if( item === undefined)
-						throw new Error( 'reference not found: ' + encoded.value);
-					if( item.type !== 'obj')
-						throw new Error( 'reference type mismatch: ' + encoded.value);
-					return item.value;
-				case 'funref':
+				case 'ref':
 					item = REFERENCES[ encoded.value];
 					if( item === undefined)
 						throw new Error( 'reference not found: ' + encoded.value);
 					if( item.type === 'potential-method')
 						throw new Error( 'potentially a method, cannot be evaluated standalone: ' + encoded.value);
-					if( item.type !== 'fun')
-						throw new Error( 'reference type mismatch: ' + encoded.value);
 					return item.value;
 				default:
 					throw new Error( 'unknown object type: ' + encoded.type);
@@ -90,19 +86,15 @@ function encode( decoded) {
 					encoded.value[ i] = encode( decoded[ i]);
 				return encoded;
 			}
-			for( i in REFERENCES)
-				if( REFERENCES[ i].value === decoded)
-					return { type: 'objref', value: i};
-			i = '' + nextRefId++;
-			REFERENCES[ i] = { type: 'obj', value: decoded};
-			return { type: 'objref', value: i};
+		// warning: intentional fall-through here!
+		case 'unknown':
 		case 'function':
 			for( i in REFERENCES)
 				if( REFERENCES[ i].value === decoded)
-					return { type: 'funref', value: i};
+					return { type: 'ref', value: i};
 			i = '' + nextRefId++;
-			REFERENCES[ i] = { type: 'fun', value: decoded};
-			return { type: 'funref', value: i};
+			REFERENCES[ i] = { value: decoded};
+			return { type: 'ref', value: i};
 		case 'symbol':
 		case 'bigint':
 		default:
@@ -115,22 +107,22 @@ function encodePotentialMethod( target, prop) {
 	var item;
 	for( i in REFERENCES) {
 		item = REFERENCES[ i];
-		if( item.type === 'potential-method' && item.target === target, item.prop === prop)
-			return { type: 'funref', value: i};
+		if( item.type === 'potential-method' && item.target === target && item.prop === prop)
+			return { type: 'ref', value: i};
 	}
 	i = '' + nextRefId++;
 	REFERENCES[ i] = { type: 'potential-method', target: target, prop: prop};
-	return { type: 'funref', value: i};
+	return { type: 'ref', value: i};
 }
 
 function decodePotentialMethod( encoded) {
 	var item;
-	if( typeof encoded === 'object' && encoded.type === 'funref') {
+	if( typeof encoded === 'object' && encoded.type === 'ref') {
 		item = REFERENCES[ encoded.value];
 		if( item.type === 'potential-method')
-			return { 'potential-method': true, target: item.target, prop: item.prop};
+			return item;
 	}
-	return { 'potential-method': false, value: decode( encoded)}
+	return { type: 'regular', value: decode( encoded)};
 }
 
 ( function() {
@@ -145,6 +137,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]);
@@ -174,11 +169,11 @@ function decodePotentialMethod( encoded) {
 					target = decodePotentialMethod( input[ 1]);
 					thisArg = decode( input[ 2]);
 					args = decode( input[ 3]);
-					if( target[ 'potential-method']) {
+					if( target.type === 'potential-method') {
 						if( thisArg === undefined)
-							throw new Error( 'potentially a method, can only be used as such');
+							throw new Error( 'potentially a method, use with a "this"');
 						if( thisArg !== target.target)
-							throw new Error( 'potentially a method, can only be used as such');
+							throw new Error( 'potentially a method, "this" has changed');
 						switch( args.length) {
 							case 0: output = [ 'value', encode( target.target[ target.prop]())]; break;
 							case 1: output = [ 'value', encode( target.target[ target.prop]( args[ 0]))]; break;

package/lib/wsh/host.vbs

@@ -0,0 +1,9 @@
+Function Dict2VBArray( dict)
+	Dim vbArray()
+	ReDim vbArray( dict.Item( "length") - 1)
+	Dim I
+	For I = 0 To dict.Item( "length") - 1
+		vbArray( I) = dict.Item( I)
+	Next
+	Dict2VBArray = vbArray
+End Function

package/lib/wsh/host.wsf

@@ -0,0 +1,4 @@
+<job>
+	<script language="VBScript" src="host.vbs" />
+	<script language="JScript" src="host.js" />
+</job>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arcticnotes/node-wsh",
-	"version": "0.0.9",
+	"version": "0.0.11",
 	"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",