@harperfast/harper-pro 5.0.0-alpha.9 → 5.0.0-beta.2

package/core/server/http.ts

@@ -19,7 +19,7 @@ import { appendHeader, Headers } from './serverHelpers/Headers.ts';
 import { Blob } from '../resources/blob.ts';
 import { recordAction, recordActionBinary } from '../resources/analytics/write.ts';
 import { Readable } from 'node:stream';
-import { type HttpOptions, server } from './Server.ts';
+import { server, type ServerOptions, type HttpOptions } from './Server.ts';
 import { setPortServerMap, SERVERS } from './serverRegistry.ts';
 import { getComponentName } from '../components/componentLoader.ts';
 import { throttle } from './throttle.ts';
@@ -179,7 +179,7 @@ function getPorts(options) {
 			ports.push({ port: env.get(terms.CONFIG_PARAMS.HTTP_SECUREPORT), secure: true });
 	}
 
-	if (options?.isOperationsServer && env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET)) {
+	if (options?.usageType === 'operations-api' && env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET)) {
 		ports.push({
 			port: resolvePath(env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET)),
 			secure: false,
@@ -191,7 +191,7 @@ export function httpServer(listener, options) {
 	const servers = [];
 
 	for (const { port, secure } of getPorts(options)) {
-		servers.push(getHTTPServer(port, secure, options?.isOperationsServer, options?.mtls));
+		servers.push(getHTTPServer(port, secure, options));
 		if (typeof listener === 'function') {
 			httpResponders[options?.runFirst ? 'unshift' : 'push']({ listener, port: options?.port || port });
 		} else {
@@ -203,8 +203,9 @@ export function httpServer(listener, options) {
 
 	return servers;
 }
-
-function getHTTPServer(port, secure, isOperationsServer, isMtls) {
+function getHTTPServer(port: number, secure: boolean, options: ServerOptions) {
+	const { mtls: isMtls, usageType } = options || {};
+	const isOperationsServer = usageType === 'operations-api';
 	setPortServerMap(port, { protocol_name: secure ? 'HTTPS' : 'HTTP', name: getComponentName() });
 	if (!httpServers[port]) {
 		// TODO: These should all come from httpOptions or operationsApiOptions
@@ -243,7 +244,7 @@ function getHTTPServer(port, secure, isOperationsServer, isMtls) {
 				rejectUnauthorized: Boolean(mtlsRequired),
 				requestCert: Boolean(mtls || isMtls),
 				ticketKeys: getTicketKeys(),
-				SNICallback: createTLSSelector(isOperationsServer ? 'operations-api' : 'server', mtls),
+				SNICallback: createTLSSelector(usageType ?? 'server', mtls),
 				ciphers: tlsConfig.ciphers ?? tlsConfig[0]?.ciphers,
 			});
 		}
@@ -290,7 +291,9 @@ function getHTTPServer(port, secure, isOperationsServer, isMtls) {
 				if (!response.handlesHeaders) {
 					const headers = response.headers || new Headers();
 					if (!body) {
-						headers.set('Content-Length', '0');
+						if (request.method !== 'HEAD') {
+							headers.set('Content-Length', '0');
+						}
 						sentBody = true;
 					} else if (body.length >= 0) {
 						if (typeof body === 'string') headers.set('Content-Length', Buffer.byteLength(body));
@@ -517,7 +520,7 @@ type OnWebSocketOptions = {
 	port?: number;
 	securePort?: number;
 	maxPayload?: number;
-	isOperationsServer?: boolean;
+	usageType?: string;
 	mtls?: boolean;
 };
 const websocketListeners = [],
@@ -537,7 +540,7 @@ function onWebSocket(listener: (ws: WebSocket) => void, options: OnWebSocketOpti
 			name: getComponentName(),
 		});
 
-		const server = getHTTPServer(port, secure, options?.isOperationsServer, options?.mtls);
+		const server = getHTTPServer(port, secure, options);
 
 		if (!websocketServers[port]) {
 			websocketServers[port] = new WebSocketServer({
@@ -597,6 +600,7 @@ function onWebSocket(listener: (ws: WebSocket) => void, options: OnWebSocketOpti
 }
 
 function defaultNotFound(request, response) {
+	if (response.headersSent || response.writableEnded) return;
 	response.writeHead(404);
 	response.end('Not found\n');
 	logRequest(request, 404, 0, request.requestId);

package/core/server/loadRootComponents.js

@@ -28,6 +28,7 @@ async function loadRootComponents(isWorkerThread = false) {
 	await loadComponent(dirname(configUtils.getConfigFilePath()), resources, 'hdb', {
 		isRoot: true,
 		providedLoadedComponents: loadedComponents,
+		autoReload: false,
 	});
 	if (!process.env.HARPER_SAFE_MODE) {
 		// once the global plugins are loaded, we now load all the CF and run applications (and their components)

package/core/server/operationsServer.ts

@@ -61,7 +61,7 @@ async function operationsServer(options: ServerOptions & { resources?: Resources
 		//make sure the process waits for the server to be fully instantiated before moving forward
 		await server.ready();
 		if (!options) options = {};
-		options.isOperationsServer = true;
+		options.usageType = 'operations-api';
 		// fastify can't clean up properly
 		try {
 			// now that server is fully loaded/ready, start listening on port provided in config settings or just use
@@ -155,6 +155,7 @@ function buildServer(isHttps: boolean, resources: Resources): FastifyInstance {
 
 	app.register(function (instance, options, done) {
 		instance.setNotFoundHandler(function (request, reply) {
+			if (reply.sent || reply.raw.headersSent || reply.raw.writableEnded) return;
 			app.server.emit('unhandled', request.raw, reply.raw);
 		});
 		done();

package/core/server/threads/manageThreads.js

@@ -26,6 +26,9 @@ const ACKNOWLEDGEMENT = 'ack';
 let getThreadInfo;
 _assignPackageExport('threads', connectedPorts);
 
+const listenersByType = new Map();
+const messagesQueuedByType = new Map();
+
 module.exports = {
 	startWorker,
 	restartWorkers,
@@ -37,7 +40,6 @@ module.exports = {
 	onMessageByType,
 	broadcast,
 	broadcastWithAcknowledgement,
-	setChildListenerByType,
 	getWorkerIndex,
 	getWorkerCount,
 	getTicketKeys,
@@ -94,14 +96,20 @@ Object.defineProperty(server, 'workerCount', {
 		return getWorkerCount();
 	},
 });
-let childListenerByType = {
-	[REQUEST_THREAD_INFO](message, worker) {
-		sendThreadInfo(worker);
-	},
-	[RESOURCE_REPORT](message, worker) {
-		recordResourceReport(worker, message);
-	},
-};
+if (!parentPort) {
+	onMessageByType(REQUEST_THREAD_INFO, (message, worker) => {
+		if (worker) sendThreadInfo(worker);
+	});
+	onMessageByType(RESOURCE_REPORT, (message, worker) => {
+		if (worker) recordResourceReport(worker, message);
+	});
+}
+// postMessage type listeners that are registered in other ways or can be registered later
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.CHILD_STARTED, null);
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.SCHEMA, null);
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.USER, null);
+listenersByType.set(hdbTerms.ITC_EVENT_TYPES.COMPONENT_STATUS_REQUEST, null);
+
 function startWorker(path, options = {}) {
 	// Take a percentage of total memory to determine the max memory for each thread. The percentage is based
 	// on the thread count. Generally, it is unrealistic to efficiently use the majority of total memory for a single
@@ -200,9 +208,6 @@ function startWorker(path, options = {}) {
 			} else harperLogger.error(`Thread has been restarted ${worker.restarts} times and will not be restarted`);
 		}
 	});
-	worker.on('message', (message) => {
-		childListenerByType[message.type]?.(message, worker);
-	});
 	workers.push(worker);
 	startMonitoring();
 	if (options.onStarted) options.onStarted(worker); // notify that it is ready
@@ -316,9 +321,6 @@ async function restartWorkers(
 		});
 	}
 }
-function setChildListenerByType(type, listener) {
-	childListenerByType[type] = listener;
-}
 function shutdownWorkers(name) {
 	return restartWorkers(name, Infinity, false);
 }
@@ -331,11 +333,16 @@ const messageListeners = [];
 function onMessageFromWorkers(listener) {
 	messageListeners.push(listener);
 }
-const listenersByType = new Map();
 function onMessageByType(type, listener) {
 	let listeners = listenersByType.get(type);
 	if (!listeners) listenersByType.set(type, (listeners = []));
 	listeners.push(listener);
+	if (messagesQueuedByType.has(type)) {
+		for (let message of messagesQueuedByType.get(type)) {
+			listener(message);
+		}
+		messagesQueuedByType.delete(type);
+	}
 }
 
 const MAX_SYNC_BROADCAST = 10;
@@ -526,14 +533,24 @@ function notifyMessageListeners(message, port) {
 	for (let listener of messageListeners) {
 		listener(message, port);
 	}
-	let listeners = listenersByType.get(message.type);
-	if (listeners) {
-		for (let listener of listeners) {
-			try {
-				listener(message, port);
-			} catch (error) {
-				harperLogger.error(error);
+	if (message.type) {
+		let listeners = listenersByType.get(message.type);
+		if (listeners) {
+			for (let listener of listeners) {
+				try {
+					listener(message, port);
+				} catch (error) {
+					harperLogger.error(error);
+				}
 			}
+		} else if (listeners !== null) {
+			// null means it is registered for a later listener
+			harperLogger.warn?.(`No listener registered for worker message type ${message.type}, queuing message`);
+			let messages = messagesQueuedByType.get(message.type);
+			if (!messages) {
+				messagesQueuedByType.set(message.type, (messages = []));
+			}
+			messages.push(message);
 		}
 	}
 }
@@ -564,17 +581,14 @@ if (isMainThread) {
 	module.exports.watchDir = watchDir;
 	if (process.env.WATCH_DIR) watchDir(process.env.WATCH_DIR);
 } else {
-	parentPort.on('message', async (message) => {
-		const { type } = message;
-		if (type === hdbTerms.ITC_EVENT_TYPES.SHUTDOWN) {
-			module.exports.restartNumber = message.restartNumber;
-			parentPort.unref(); // remove this handle
-			setTimeout(() => {
-				harperLogger.warn('Thread did not voluntarily terminate', threadId);
-				// Note that if this occurs, you may want to use this to debug what is currently running:
-				// require('why-is-node-running')();
-				process.exit(0);
-			}, threadTerminationTimeout).unref(); // don't block the shutdown
-		}
+	onMessageByType(hdbTerms.ITC_EVENT_TYPES.SHUTDOWN, async (message) => {
+		module.exports.restartNumber = message.restartNumber;
+		parentPort.unref(); // remove this handle
+		setTimeout(() => {
+			harperLogger.warn('Thread did not voluntarily terminate', threadId);
+			// Note that if this occurs, you may want to use this to debug what is currently running:
+			// require('why-is-node-running')();
+			process.exit(0);
+		}, threadTerminationTimeout).unref(); // don't block the shutdown
 	});
 }

package/core/static/defaultConfig.yaml

@@ -27,6 +27,9 @@ applications:
   lockdown: freeze
   containment: vm
   dependencyContainment: false
+  allowedSpawnCommands:
+    - npm
+    - node
 componentsRoot: null
 localStudio:
   enabled: true

package/core/unitTests/apiTests/RESTProperties-test.mjs

@@ -81,8 +81,8 @@ describe('test REST with property updates', function () {
 			}
 		);
 		assert.equal(response.status, 400);
-		assert(response.data.includes('property name must be a string'));
-		assert(response.data.includes('property age must be an integer'));
+		assert(response.data.title.includes('property name must be a string'));
+		assert(response.data.title.includes('property age must be an integer'));
 	});
 
 	it('put with nested path', async () => {

package/core/unitTests/apiTests/basicREST-test.mjs

@@ -531,7 +531,7 @@ describe('test REST calls', () => {
 			},
 		});
 		assert.equal(response.status, 500);
-		assert(response.data.includes('Conflicting paths'));
+		assert(response.data.title.includes('Conflicting paths'));
 	});
 	it('Returns thrown plain object', async () => {
 		const response = await axios.get('http://localhost:9926/Echo/error-plain-object', {
@@ -541,7 +541,7 @@ describe('test REST calls', () => {
 			},
 		});
 		assert.equal(response.status, 500);
-		assert(response.data.message, 'Test error');
+		assert(response.data.title, 'Test error');
 	});
 	it('Returns correct error for bad body', async () => {
 		const response = await axios.get('http://localhost:9926/Echo/error-bad-body', {

package/core/unitTests/components/Scope.test.js

@@ -19,7 +19,8 @@ describe('Scope', () => {
 		this.resources = new Resources();
 		this.server = {};
 		this.directory = mkdtempSync(join(tmpdir(), 'harper.unit-test.scope-'));
-		this.name = basename(this.directory);
+		this.appName = basename(this.directory);
+		this.pluginName = 'plugin';
 		this.configFilePath = join(this.directory, 'config.yaml');
 		this.testFilePath = join(this.directory, 'test.js');
 		writeFileSync(this.testFilePath, '"foo";');
@@ -37,10 +38,11 @@ describe('Scope', () => {
 	});
 
 	it('should create a default entry handler', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { files: 'test.js' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { files: 'test.js' } }));
 
 		const scope = new Scope(
-			this.name,
+			this.appName,
+			this.pluginName,
 			this.directory,
 			this.configFilePath,
 			new ApplicationScope('test', this.resources, this.server)
@@ -92,10 +94,11 @@ describe('Scope', () => {
 	});
 
 	it('should create a default entry handler with urlPath', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { files: 'test.js', urlPath: 'abc' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { files: 'test.js', urlPath: 'abc' } }));
 
 		const scope = new Scope(
-			this.name,
+			this.appName,
+			this.pluginName,
 			this.directory,
 			this.configFilePath,
 			new ApplicationScope('test', this.resources, this.server)
@@ -148,9 +151,16 @@ describe('Scope', () => {
 	});
 
 	it('should call requestRestart if no entry handler is provided', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { files: '.' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { files: '.' } }));
 
-		const scope = new Scope(this.name, this.directory, this.configFilePath, this.resources, this.server);
+		const scope = new Scope(
+			this.appName,
+			this.pluginName,
+			this.directory,
+			this.configFilePath,
+			this.resources,
+			this.server
+		);
 
 		await scope.ready;
 
@@ -165,9 +175,16 @@ describe('Scope', () => {
 	});
 
 	it('should call requestRestart if no options handler is provided', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { files: '.' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { files: '.' } }));
 
-		const scope = new Scope(this.name, this.directory, this.configFilePath, this.resources, this.server);
+		const scope = new Scope(
+			this.appName,
+			this.pluginName,
+			this.directory,
+			this.configFilePath,
+			this.resources,
+			this.server
+		);
 
 		await scope.ready;
 
@@ -175,7 +192,7 @@ describe('Scope', () => {
 
 		assert.equal(restartNeeded(), false, 'requestRestart was not called');
 
-		await writeFile(this.configFilePath, stringify({ [this.name]: { files: '.', foo: 'bar' } }));
+		await writeFile(this.configFilePath, stringify({ [this.pluginName]: { files: '.', foo: 'bar' } }));
 
 		await waitFor(() => restartNeeded());
 
@@ -185,9 +202,16 @@ describe('Scope', () => {
 	});
 
 	it('should emit error for missing default entry handler', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { foo: 'bar' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { foo: 'bar' } }));
 
-		const scope = new Scope(this.name, this.directory, this.configFilePath, this.resources, this.server);
+		const scope = new Scope(
+			this.appName,
+			this.pluginName,
+			this.directory,
+			this.configFilePath,
+			this.resources,
+			this.server
+		);
 
 		await scope.ready;
 
@@ -219,9 +243,16 @@ describe('Scope', () => {
 	});
 
 	it('should support custom entry handlers', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { foo: 'bar' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { foo: 'bar' } }));
 
-		const scope = new Scope(this.name, this.directory, this.configFilePath, this.resources, this.server);
+		const scope = new Scope(
+			this.appName,
+			this.pluginName,
+			this.directory,
+			this.configFilePath,
+			this.resources,
+			this.server
+		);
 
 		await scope.ready;
 
@@ -249,9 +280,16 @@ describe('Scope', () => {
 	});
 
 	it('should support synchronous handleEntry with event-based initial load tracking', async () => {
-		writeFileSync(this.configFilePath, stringify({ [this.name]: { files: 'test.js' } }));
+		writeFileSync(this.configFilePath, stringify({ [this.pluginName]: { files: 'test.js' } }));
 
-		const scope = new Scope(this.name, this.directory, this.configFilePath, this.resources, this.server);
+		const scope = new Scope(
+			this.appName,
+			this.pluginName,
+			this.directory,
+			this.configFilePath,
+			this.resources,
+			this.server
+		);
 
 		await scope.ready;
 

package/core/unitTests/components/fixtures/testJSWithDeps/child-dir/circular.js

@@ -0,0 +1,4 @@
+import { MyComponent } from './in-child-dir.js';
+export function testCircularExport() {
+	return MyComponent;
+}

package/core/unitTests/components/fixtures/testJSWithDeps/child-dir/in-child-dir.js

@@ -3,10 +3,14 @@ import { Resource } from 'harperdb';
 import { connect } from 'mqtt'; // verify we can import from node_modules packages
 import 'micromatch';
 import 'needle';
+import { testCircularExport } from './circular.js';
 // TODO: Verify/support circular dependencies
 console.log('Verifying we can access console.log in transitive module in application');
+assert(testCircularExport);
 // verify we can't access parent global variables
 assert(typeof globalVariableFromParent, 'undefined', 'Global variable from parent value should not be present');
 
 export class MyComponent extends Resource {}
 export { connect };
+
+assert.equal(testCircularExport(), MyComponent);

package/core/unitTests/components/fixtures/testJSWithDeps/child-dir/typestrip.ts

@@ -0,0 +1,2 @@
+import type { Resource } from 'harper';
+export const isTyped: Resource = {}!;

package/core/unitTests/components/fixtures/testJSWithDeps/resources.js

@@ -2,6 +2,7 @@ import assert from 'node:assert'; // verify we can access safe node built-in mod
 import { Resource, getContext } from 'harper';
 import { MyComponent, connect as connectFromChild } from './child-dir/in-child-dir.js';
 import { connect } from 'mqtt'; // verify we can import from node_modules packages
+import { fork, spawn } from 'node:child_process';
 
 console.log('Verifying we can access console.log in application');
 // verify we can't access parent global variables
@@ -20,7 +21,49 @@ export const testExport = {
 		let _a = MyComponent;
 		return 'hello world';
 	},
+	async testLoadTypeScript() {
+		return await import('./child-dir/typestrip.ts');
+	},
 };
 export class TestComponent extends Resource {}
 
 export { MyComponent as 'my-component' };
+
+export const processSpawnTest = {
+	get() {}, // make it look like a resource
+	testFork() {
+		// Fork should work (allowed command)
+		const child = fork('npm', ['--version'], { name: 'test-npm-process' });
+		assert(child.pid, 'Fork should return a process with a PID');
+		return child;
+	},
+	testSpawnDisallowed() {
+		// Spawn with disallowed command should throw
+		try {
+			spawn('curl', ['https://example.com'], { name: 'test-curl-process' });
+			throw new Error('Should have thrown an error for disallowed command');
+		} catch (err) {
+			assert(err.message.includes('not allowed'), 'Should throw error about disallowed command');
+		}
+	},
+	testSpawnWithoutName() {
+		// Spawn without name should throw
+		try {
+			spawn('npm', ['build']);
+			throw new Error('Should have thrown an error for missing name');
+		} catch (err) {
+			assert(err.message.includes('name'), 'Should throw error about missing name');
+		}
+	},
+	testProcessReuse(childProcessPath) {
+		// First call should fork a new process
+		const child1 = fork(childProcessPath, [], { name: 'test-reuse-process' });
+		assert(child1.pid, 'First fork should return a process with a PID');
+
+		// Second call with same name should return wrapper for existing process
+		const child2 = fork(childProcessPath, [], { name: 'test-reuse-process' });
+		assert.equal(child1.pid, child2.pid, 'Second fork should return same PID');
+
+		return { child1, child2 };
+	},
+};

package/core/unitTests/components/fixtures/testJSWithDeps/test-child-process.js

@@ -0,0 +1,18 @@
+// Simple child process that stays alive until killed
+// Used for testing process reuse functionality
+
+let isRunning = true;
+
+process.on('SIGTERM', () => {
+	isRunning = false;
+	process.exit(0);
+});
+
+// Keep process alive
+const interval = setInterval(() => {
+	if (!isRunning) {
+		clearInterval(interval);
+	}
+}, 100);
+
+console.log('Child process started with PID:', process.pid);

package/core/unitTests/components/globalIsolation.test.js

@@ -2,10 +2,13 @@ const assert = require('node:assert/strict');
 const path = require('node:path');
 const { loadComponent, loadedPaths } = require('#src/components/componentLoader');
 const { PACKAGE_ROOT } = require('#js/utility/packageUtils');
+const fs = require('node:fs');
+const env = require('#src/utility/environment/environmentManager');
 const { ApplicationScope } = require('#js/components/ApplicationScope');
 
 describe('Global Variable Isolation in testJSWithDeps', function () {
 	let mockResources;
+	let pidsDir;
 
 	beforeEach(function () {
 		// Create mock resources
@@ -17,12 +20,24 @@ describe('Global Variable Isolation in testJSWithDeps', function () {
 		// Set a global variable in the parent context
 		global.globalVariableFromParent = 'parent-value';
 		loadedPaths.clear();
+
+		// Clean up pids directory
+		const basePath = env.getHdbBasePath();
+		pidsDir = path.join(basePath, 'pids');
+		if (fs.existsSync(pidsDir)) {
+			fs.rmSync(pidsDir, { recursive: true, force: true });
+		}
 	});
 
 	afterEach(function () {
 		// Clean up global variables
 		delete global.globalVariableFromParent;
 		delete global.globalVariableFromComponent;
+
+		// Clean up pids directory
+		if (fs.existsSync(pidsDir)) {
+			fs.rmSync(pidsDir, { recursive: true, force: true });
+		}
 	});
 	const componentDir = path.join(__dirname, 'fixtures', 'testJSWithDeps');
 
@@ -39,7 +54,7 @@ describe('Global Variable Isolation in testJSWithDeps', function () {
 
 		// The component's resources.js file asserts that globalVariableFromParent is undefined
 		// If the component loaded without throwing, it means global variables are properly isolated
-
+		assert.equal(mockResources.get('/'), undefined); // this will contain an error if it failed to load
 		// Verify the component's global variable didn't leak into our context
 		assert.equal(
 			typeof global.globalVariableFromComponent,
@@ -52,6 +67,7 @@ describe('Global Variable Isolation in testJSWithDeps', function () {
 
 		// verify the exported resource works
 		assert.equal(mockResources.get('/testExport').get(), 'hello world');
+		assert((await mockResources.get('/testExport').testLoadTypeScript()).isTyped, 'TypeScript exports');
 		assert.equal(typeof mockResources.get('/TestComponent').get, 'function');
 		assert.equal(typeof mockResources.get('/my-component').get, 'function');
 	});
@@ -102,4 +118,74 @@ describe('Global Variable Isolation in testJSWithDeps', function () {
 		// assert(typeof mockResources.get('/my-component').get === 'function'); // this syntax doesn't seem to work
 		// with SES Compartments
 	});
+
+	it('should enforce process spawning restrictions', async function () {
+		let applicationScope = new ApplicationScope('test', mockResources, server);
+		Object.assign(applicationScope, {
+			mode: 'vm',
+			dependencyContainment: false,
+			verifyPath: PACKAGE_ROOT,
+		});
+		await loadComponent(componentDir, mockResources, 'test-origin', {
+			applicationScope,
+		});
+
+		const processSpawnTest = mockResources.get('/processSpawnTest');
+
+		// Test that disallowed commands throw
+		processSpawnTest.testSpawnDisallowed();
+
+		// Test that spawn without name throws
+		processSpawnTest.testSpawnWithoutName();
+	});
+
+	it('should allow fork with allowed commands', async function () {
+		let applicationScope = new ApplicationScope('test', mockResources, server);
+		Object.assign(applicationScope, {
+			mode: 'vm',
+			dependencyContainment: false,
+			verifyPath: PACKAGE_ROOT,
+		});
+		await loadComponent(componentDir, mockResources, 'test-origin', {
+			applicationScope,
+		});
+
+		const processSpawnTest = mockResources.get('/processSpawnTest');
+
+		// Test that fork works
+		const child = processSpawnTest.testFork();
+		assert(child.pid, 'Should return a child process with PID');
+
+		// Clean up
+		child.kill();
+	});
+
+	it('should reuse existing processes with same name', async function () {
+		this.timeout(10000); // Increase timeout for process spawning
+
+		let applicationScope = new ApplicationScope('test', mockResources, server);
+		Object.assign(applicationScope, {
+			mode: 'vm',
+			dependencyContainment: false,
+			verifyPath: PACKAGE_ROOT,
+		});
+		await loadComponent(componentDir, mockResources, 'test-origin', {
+			applicationScope,
+		});
+
+		const processSpawnTest = mockResources.get('/processSpawnTest');
+		const childProcessPath = path.join(componentDir, 'test-child-process.js');
+
+		// Test process reuse
+		const { child1, child2 } = processSpawnTest.testProcessReuse(childProcessPath);
+
+		// Verify both have same PID
+		assert.equal(child1.pid, child2.pid, 'Should reuse existing process');
+
+		// Verify exit event is emitted on wrapper
+		await new Promise((resolve) => {
+			child2.on('exit', resolve);
+			child1.kill();
+		});
+	});
 });