@clinebot/core 0.0.27 → 0.0.29

package/src/{agents → extensions/plugin}/plugin-sandbox-bootstrap.ts

@@ -1,6 +1,3 @@
-import { existsSync } from "node:fs";
-import { builtinModules, createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
 /**
  * Bootstrap script for the plugin sandbox subprocess.
  *
@@ -9,12 +6,11 @@ import { dirname, resolve } from "node:path";
  * imports plugin modules, wiring up their contributions (tools, commands,
  * shortcuts, flags, renderers, providers) and lifecycle hooks.
  *
- * Because it executes in a separate process it must be self-contained — no
- * imports from the rest of the codebase are allowed.
+ * Because it executes in a separate process it must stay bundle-safe and only
+ * depend on local helpers that can be inlined into the sandbox build.
  */
 
-import { fileURLToPath } from "node:url";
-import createJiti from "jiti";
+import { importPluginModule } from "./plugin-module-import";
 
 // ---------------------------------------------------------------------------
 // Types (intentionally minimal – mirrors only what the RPC protocol needs)
@@ -47,9 +43,9 @@ interface PluginFlag {
 	defaultValue?: boolean | string | number;
 }
 
-interface PluginMessageRenderer {
+interface PluginMessageBuilder {
 	name: string;
-	render: (message: unknown) => string;
+	build: (message: unknown[]) => unknown[]; // Message[]
 }
 
 interface PluginProvider {
@@ -63,7 +59,7 @@ interface PluginApi {
 	registerCommand(command: PluginCommand): void;
 	registerShortcut(shortcut: PluginShortcut): void;
 	registerFlag(flag: PluginFlag): void;
-	registerMessageRenderer(renderer: PluginMessageRenderer): void;
+	registerMessageBuilder(builder: PluginMessageBuilder): void;
 	registerProvider(provider: PluginProvider): void;
 }
 
@@ -95,7 +91,7 @@ interface PluginDescriptor {
 		commands: ContributionDescriptor[];
 		shortcuts: ContributionDescriptor[];
 		flags: ContributionDescriptor[];
-		messageRenderers: ContributionDescriptor[];
+		messageBuilders: ContributionDescriptor[];
 		providers: ContributionDescriptor[];
 	};
 }
@@ -105,7 +101,7 @@ interface PluginState {
 	handlers: {
 		tools: Map<string, PluginTool["execute"]>;
 		commands: Map<string, NonNullable<PluginCommand["handler"]>>;
-		messageRenderers: Map<string, PluginMessageRenderer["render"]>;
+		messageBuilders: Map<string, PluginMessageBuilder["build"]>;
 	};
 }
 
@@ -134,11 +130,7 @@ function assertValidPluginModule(
 
 let pluginCounter = 0;
 const pluginState = new Map<string, PluginState>();
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const WORKSPACE_ALIASES = collectWorkspaceAliases(MODULE_DIR);
-const BUILTIN_MODULES = new Set(
-	builtinModules.flatMap((id) => [id, id.replace(/^node:/, "")]),
-);
+const contributionCounters = new Map<string, number>();
 
 // ---------------------------------------------------------------------------
 // IPC helpers
@@ -178,7 +170,10 @@ function sanitizeObject(value: unknown): Record<string, unknown> {
 }
 
 function makeId(pluginId: string, prefix: string): string {
-	return `${pluginId}_${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+	const key = `${pluginId}:${prefix}`;
+	const next = (contributionCounters.get(key) ?? 0) + 1;
+	contributionCounters.set(key, next);
+	return `${pluginId}_${prefix}_${next}`;
 }
 
 function getPlugin(pluginId: string): PluginState {
@@ -189,67 +184,6 @@ function getPlugin(pluginId: string): PluginState {
 	return state;
 }
 
-function collectWorkspaceAliases(startDir: string): Record<string, string> {
-	const root = resolve(startDir, "..", "..", "..", "..");
-	const aliases: Record<string, string> = {};
-	const candidates: Record<string, string> = {
-		"@clinebot/agents": resolve(root, "packages/agents/src/index.ts"),
-		"@clinebot/core": resolve(root, "packages/core/src/index.ts"),
-		"@clinebot/llms": resolve(root, "packages/llms/src/index.ts"),
-		"@clinebot/llms/models": resolve(root, "packages/llms/src/models.ts"),
-		"@clinebot/llms/providers": resolve(root, "packages/llms/src/providers.ts"),
-		"@clinebot/llms/runtime": resolve(root, "packages/llms/src/runtime.ts"),
-		"@clinebot/rpc": resolve(root, "packages/rpc/src/index.ts"),
-		"@clinebot/scheduler": resolve(root, "packages/scheduler/src/index.ts"),
-		"@clinebot/shared": resolve(root, "packages/shared/src/index.ts"),
-		"@clinebot/shared/storage": resolve(
-			root,
-			"packages/shared/src/storage/index.ts",
-		),
-		"@clinebot/shared/db": resolve(root, "packages/shared/src/db/index.ts"),
-	};
-	for (const [key, value] of Object.entries(candidates)) {
-		if (existsSync(value)) {
-			aliases[key] = value;
-		}
-	}
-	return aliases;
-}
-
-function collectPluginImportAliases(
-	pluginPath: string,
-): Record<string, string> {
-	const pluginRequire = createRequire(pluginPath);
-	const aliases: Record<string, string> = {};
-	for (const [specifier, sourcePath] of Object.entries(WORKSPACE_ALIASES)) {
-		try {
-			pluginRequire.resolve(specifier);
-			continue;
-		} catch {
-			// Use the workspace source only when the plugin package does not provide
-			// its own installed SDK dependency.
-		}
-		aliases[specifier] = sourcePath;
-	}
-	return aliases;
-}
-
-async function importPluginModule(
-	pluginPath: string,
-): Promise<Record<string, unknown>> {
-	const aliases = collectPluginImportAliases(pluginPath);
-	const jiti = createJiti(pluginPath, {
-		alias: aliases,
-		cache: false,
-		requireCache: false,
-		esmResolve: true,
-		interopDefault: false,
-		nativeModules: [...BUILTIN_MODULES],
-		transformModules: Object.keys(aliases),
-	});
-	return (await jiti.import(pluginPath, {})) as Record<string, unknown>;
-}
-
 // ---------------------------------------------------------------------------
 // RPC methods
 // ---------------------------------------------------------------------------
@@ -258,6 +192,10 @@ async function initialize(args: {
 	pluginPaths?: string[];
 	exportName?: string;
 }): Promise<PluginDescriptor[]> {
+	pluginState.clear();
+	pluginCounter = 0;
+	contributionCounters.clear();
+
 	const descriptors: PluginDescriptor[] = [];
 	const exportName = args.exportName || "plugin";
 
@@ -273,13 +211,13 @@ async function initialize(args: {
 			commands: [],
 			shortcuts: [],
 			flags: [],
-			messageRenderers: [],
+			messageBuilders: [],
 			providers: [],
 		};
 		const handlers: PluginState["handlers"] = {
 			tools: new Map(),
 			commands: new Map(),
-			messageRenderers: new Map(),
+			messageBuilders: new Map(),
 		};
 
 		const api: PluginApi = {
@@ -322,10 +260,10 @@ async function initialize(args: {
 					defaultValue: flag.defaultValue,
 				});
 			},
-			registerMessageRenderer: (renderer) => {
-				const id = makeId(pluginId, "renderer");
-				handlers.messageRenderers.set(id, renderer.render);
-				contributions.messageRenderers.push({ id, name: renderer.name });
+			registerMessageBuilder: (builder) => {
+				const id = makeId(pluginId, "builder");
+				handlers.messageBuilders.set(id, builder.build);
+				contributions.messageBuilders.push({ id, name: builder.name });
 			},
 			registerProvider: (provider) => {
 				contributions.providers.push({
@@ -395,17 +333,17 @@ async function executeCommand(args: {
 	return await handler(args.input);
 }
 
-async function renderMessage(args: {
+async function buildMessages(args: {
 	pluginId: string;
 	contributionId: string;
-	message: unknown;
-}): Promise<string> {
+	messages: unknown[];
+}): Promise<unknown[]> {
 	const state = getPlugin(args.pluginId);
-	const handler = state.handlers.messageRenderers.get(args.contributionId);
+	const handler = state.handlers.messageBuilders.get(args.contributionId);
 	if (typeof handler !== "function") {
-		return "";
+		return [];
 	}
-	return await handler(args.message);
+	return await handler(args.messages);
 }
 
 // ---------------------------------------------------------------------------
@@ -417,7 +355,7 @@ const methods: Record<string, (args: never) => Promise<unknown>> = {
 	invokeHook,
 	executeTool,
 	executeCommand,
-	renderMessage,
+	buildMessages,
 };
 
 process.on(

package/src/{agents → extensions/plugin}/plugin-sandbox.test.ts

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { AgentConfig, Tool, ToolContext } from "@clinebot/agents";
+import type { AgentConfig, Tool, ToolContext } from "@clinebot/shared";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { loadSandboxedPlugins } from "./plugin-sandbox";
 
@@ -12,7 +12,7 @@ function createApiCapture() {
 		registerCommand: () => {},
 		registerShortcut: () => {},
 		registerFlag: () => {},
-		registerMessageRenderer: () => {},
+		registerMessageBuilder: () => {},
 		registerProvider: () => {},
 	};
 	return { tools, api };
@@ -29,6 +29,7 @@ describe("plugin-sandbox", () => {
 	>();
 	const forwardedEvents: Array<{ name: string; payload?: unknown }> = [];
 
+	// Allow generous time for jiti transpilation of multiple TS plugins in CI.
 	beforeAll(async () => {
 		dir = await mkdtemp(join(tmpdir(), "core-plugin-sandbox-"));
 
@@ -150,6 +151,39 @@ describe("plugin-sandbox", () => {
 			"utf8",
 		);
 
+		await writeFile(
+			join(dir, "plugin-host-dep.ts"),
+			[
+				"import { resolveClineDataDir } from '@clinebot/shared/storage';",
+				"import YAML from 'yaml';",
+				"export default {",
+				"  name: YAML.stringify({ host: !!resolveClineDataDir() }).trim(),",
+				"  manifest: { capabilities: ['tools'] },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-create-tool.ts"),
+			[
+				"import { createTool } from '@clinebot/agents';",
+				"export default {",
+				"  name: 'sandbox-create-tool',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  setup(api) {",
+				"    api.registerTool(createTool({",
+				"      name: 'created_tool',",
+				"      description: 'created via agents export',",
+				"      inputSchema: { type: 'object', properties: { value: { type: 'string' } }, required: ['value'] },",
+				"      execute: async (input) => ({ echoed: input.value }),",
+				"    }));",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
 		sharedSandbox = await loadSandboxedPlugins({
 			pluginPaths: [
 				join(dir, "plugin.mjs"),
@@ -157,7 +191,12 @@ describe("plugin-sandbox", () => {
 				join(dir, "plugin-ts.ts"),
 				join(dir, "plugin-dep.ts"),
 				join(dir, "plugin-sdk.ts"),
+				join(dir, "plugin-host-dep.ts"),
+				join(dir, "plugin-create-tool.ts"),
 			],
+			// CI environments are significantly slower for jiti transpilation;
+			// the default 4 000 ms is too tight for 7 plugins.
+			importTimeoutMs: 30_000,
 			onEvent: (event) => {
 				forwardedEvents.push(event);
 			},
@@ -168,7 +207,7 @@ describe("plugin-sandbox", () => {
 				extension,
 			]),
 		);
-	});
+	}, 60_000);
 
 	beforeEach(() => {
 		forwardedEvents.length = 0;
@@ -293,4 +332,22 @@ describe("plugin-sandbox", () => {
 			"sandbox-plugin-installed-sdk",
 		);
 	});
+
+	it("allows standalone file plugins to use host runtime dependencies in the sandbox", async () => {
+		expect(sharedExtensions.get("host: true")?.name).toBe("host: true");
+	});
+
+	it("supports createTool through the agents package export in the sandbox", async () => {
+		const extension = sharedExtensions.get("sandbox-create-tool");
+		const { tools, api } = createApiCapture();
+		await extension?.setup?.(api);
+		const tool = tools.find((entry) => entry.name === "created_tool");
+		expect(tool).toBeDefined();
+		const result = await tool?.execute({ value: "ok" }, {
+			agentId: "agent-1",
+			conversationId: "conv-1",
+			iteration: 1,
+		} as ToolContext);
+		expect(result).toEqual({ echoed: "ok" });
+	});
 });

package/src/{agents → extensions/plugin}/plugin-sandbox.ts

@@ -1,8 +1,9 @@
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AgentConfig, Tool } from "@clinebot/agents";
-import { SubprocessSandbox } from "../runtime/sandbox/subprocess-sandbox";
+import type { AgentConfig, HookStage, Tool } from "@clinebot/shared";
+import { SubprocessSandbox } from "../../runtime/subprocess-sandbox";
 
 export interface PluginSandboxOptions {
 	pluginPaths: string[];
@@ -15,16 +16,6 @@ export interface PluginSandboxOptions {
 
 type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
 type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
-type HookStage =
-	| "input"
-	| "runtime_event"
-	| "session_start"
-	| "before_agent_start"
-	| "tool_call_before"
-	| "tool_call_after"
-	| "turn_end"
-	| "session_shutdown"
-	| "error";
 
 type SandboxedContributionDescriptor = {
 	id: string;
@@ -47,11 +38,16 @@ type SandboxedPluginDescriptor = {
 		commands: SandboxedContributionDescriptor[];
 		shortcuts: SandboxedContributionDescriptor[];
 		flags: SandboxedContributionDescriptor[];
-		messageRenderers: SandboxedContributionDescriptor[];
+		messageBuilders: SandboxedContributionDescriptor[];
 		providers: SandboxedContributionDescriptor[];
 	};
 };
 
+function isUnknownPluginIdError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("Unknown sandbox plugin id:");
+}
+
 /**
  * Resolve the bootstrap for the sandbox subprocess.
  *
@@ -62,19 +58,29 @@ type SandboxedPluginDescriptor = {
  */
 function resolveBootstrap(): { file: string } | { script: string } {
 	const dir = dirname(fileURLToPath(import.meta.url));
-	// In dev, the bootstrap sits next to this file in src/agents/.
-	// In production, the main bundle is at dist/ but bootstrap is at dist/agents/.
+	const requireFromHere = createRequire(import.meta.url);
+	// In dev, the bootstrap sits next to this file in src/extensions/.
+	// In production, the main bundle is at dist/ and the bootstrap is emitted
+	// under dist/extensions/. Keep the older dist/agents/ fallback for
+	// compatibility with previously built layouts.
 	const candidates = [
 		join(dir, "plugin-sandbox-bootstrap.js"),
+		join(dir, "extensions", "plugin-sandbox-bootstrap.js"),
 		join(dir, "agents", "plugin-sandbox-bootstrap.js"),
 	];
 	for (const candidate of candidates) {
 		if (existsSync(candidate)) return { file: candidate };
 	}
 	const tsPath = join(dir, "plugin-sandbox-bootstrap.ts");
+	let jitiSpecifier = "jiti";
+	try {
+		jitiSpecifier = requireFromHere.resolve("jiti");
+	} catch {
+		// Fall back to bare specifier and let runtime resolution handle it.
+	}
 	return {
 		script: [
-			"const createJiti = require('jiti');",
+			`const createJiti = require(${JSON.stringify(jitiSpecifier)});`,
 			`const jiti = createJiti(${JSON.stringify(tsPath)}, { cache: false, requireCache: false, esmResolve: true, interopDefault: false });`,
 			`Promise.resolve(jiti.import(${JSON.stringify(tsPath)}, {})).catch((error) => {`,
 			"  console.error(error);",
@@ -118,8 +124,8 @@ const HOOK_BINDINGS: Array<{
 	},
 	{
 		stage: "turn_end",
-		extensionKey: "onAgentEnd",
-		sandboxHookName: "onAgentEnd",
+		extensionKey: "onTurnEnd",
+		sandboxHookName: "onTurnEnd",
 	},
 	{
 		stage: "session_shutdown",
@@ -162,17 +168,30 @@ export async function loadSandboxedPlugins(
 	const hookTimeoutMs = withTimeoutFallback(options.hookTimeoutMs, 3000);
 	const contributionTimeoutMs = withTimeoutFallback(
 		options.contributionTimeoutMs,
-		5000,
+		60_000,
 	);
+	const initArgs = {
+		pluginPaths: options.pluginPaths,
+		exportName: options.exportName,
+	};
+
+	// Guard against concurrent re-initialization when multiple tools/hooks
+	// fail simultaneously with "Unknown sandbox plugin id:".
+	let reinitPromise: Promise<void> | undefined;
+	const reinitialize = (): Promise<void> => {
+		reinitPromise ??= sandbox
+			.call<void>("initialize", initArgs, { timeoutMs: importTimeoutMs })
+			.finally(() => {
+				reinitPromise = undefined;
+			});
+		return reinitPromise;
+	};
 
 	let descriptors: SandboxedPluginDescriptor[];
 	try {
 		descriptors = await sandbox.call<SandboxedPluginDescriptor[]>(
 			"initialize",
-			{
-				pluginPaths: options.pluginPaths,
-				exportName: options.exportName,
-			},
+			initArgs,
 			{ timeoutMs: importTimeoutMs },
 		);
 	} catch (error) {
@@ -188,13 +207,31 @@ export async function loadSandboxedPlugins(
 				name: descriptor.name,
 				manifest: descriptor.manifest,
 				setup: (api: AgentExtensionApi) => {
-					registerTools(api, sandbox, descriptor, contributionTimeoutMs);
-					registerCommands(api, sandbox, descriptor, contributionTimeoutMs);
+					registerTools(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
+					registerCommands(
+						api,
+						sandbox,
+						descriptor,
+						contributionTimeoutMs,
+						reinitialize,
+					);
 					registerSimpleContributions(api, descriptor);
 				},
 			};
 
-			bindHooks(extension, sandbox, descriptor.pluginId, hookTimeoutMs);
+			bindHooks(
+				extension,
+				sandbox,
+				descriptor.pluginId,
+				hookTimeoutMs,
+				reinitialize,
+			);
 
 			return extension;
 		},
@@ -217,6 +254,7 @@ function registerTools(
 	sandbox: SubprocessSandbox,
 	descriptor: SandboxedPluginDescriptor,
 	timeoutMs: number,
+	reinitialize: () => Promise<void>,
 ): void {
 	for (const td of descriptor.contributions.tools) {
 		const tool: Tool = {
@@ -228,17 +266,35 @@ function registerTools(
 			}) as Tool["inputSchema"],
 			timeoutMs: td.timeoutMs,
 			retryable: td.retryable,
-			execute: async (input: unknown, context: unknown) =>
-				await sandbox.call(
-					"executeTool",
-					{
-						pluginId: descriptor.pluginId,
-						contributionId: td.id,
-						input,
-						context,
-					},
-					{ timeoutMs },
-				),
+			execute: async (input: unknown, context: unknown) => {
+				try {
+					return await sandbox.call(
+						"executeTool",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: td.id,
+							input,
+							context,
+						},
+						{ timeoutMs },
+					);
+				} catch (error) {
+					if (!isUnknownPluginIdError(error)) {
+						throw error;
+					}
+					await reinitialize();
+					return await sandbox.call(
+						"executeTool",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: td.id,
+							input,
+							context,
+						},
+						{ timeoutMs },
+					);
+				}
+			},
 		};
 		api.registerTool(tool);
 	}
@@ -249,21 +305,39 @@ function registerCommands(
 	sandbox: SubprocessSandbox,
 	descriptor: SandboxedPluginDescriptor,
 	timeoutMs: number,
+	reinitialize: () => Promise<void>,
 ): void {
 	for (const cd of descriptor.contributions.commands) {
 		api.registerCommand({
 			name: cd.name,
 			description: cd.description,
-			handler: async (input: string) =>
-				await sandbox.call<string>(
-					"executeCommand",
-					{
-						pluginId: descriptor.pluginId,
-						contributionId: cd.id,
-						input,
-					},
-					{ timeoutMs },
-				),
+			handler: async (input: string) => {
+				try {
+					return await sandbox.call<string>(
+						"executeCommand",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: cd.id,
+							input,
+						},
+						{ timeoutMs },
+					);
+				} catch (error) {
+					if (!isUnknownPluginIdError(error)) {
+						throw error;
+					}
+					await reinitialize();
+					return await sandbox.call<string>(
+						"executeCommand",
+						{
+							pluginId: descriptor.pluginId,
+							contributionId: cd.id,
+							input,
+						},
+						{ timeoutMs },
+					);
+				}
+			},
 		});
 	}
 }
@@ -288,10 +362,10 @@ function registerSimpleContributions(
 		});
 	}
 
-	for (const rd of descriptor.contributions.messageRenderers) {
-		api.registerMessageRenderer({
+	for (const rd of descriptor.contributions.messageBuilders) {
+		api.registerMessageBuilder({
 			name: rd.name,
-			render: () => `[sandbox renderer ${rd.name} requires async bridge]`,
+			build: (m) => m,
 		});
 	}
 
@@ -309,13 +383,27 @@ function makeHookHandler(
 	pluginId: string,
 	hookName: string,
 	timeoutMs: number,
+	reinitialize: () => Promise<void>,
 ): (payload: unknown) => Promise<unknown> {
-	return async (payload: unknown) =>
-		await sandbox.call(
-			"invokeHook",
-			{ pluginId, hookName, payload },
-			{ timeoutMs },
-		);
+	return async (payload: unknown) => {
+		try {
+			return await sandbox.call(
+				"invokeHook",
+				{ pluginId, hookName, payload },
+				{ timeoutMs },
+			);
+		} catch (error) {
+			if (!isUnknownPluginIdError(error)) {
+				throw error;
+			}
+			await reinitialize();
+			return await sandbox.call(
+				"invokeHook",
+				{ pluginId, hookName, payload },
+				{ timeoutMs },
+			);
+		}
+	};
 }
 
 function bindHooks(
@@ -323,6 +411,7 @@ function bindHooks(
 	sandbox: SubprocessSandbox,
 	pluginId: string,
 	hookTimeoutMs: number,
+	reinitialize: () => Promise<void>,
 ): void {
 	for (const { stage, extensionKey, sandboxHookName } of HOOK_BINDINGS) {
 		if (hasHookStage(extension, stage)) {
@@ -331,6 +420,7 @@ function bindHooks(
 				pluginId,
 				sandboxHookName,
 				hookTimeoutMs,
+				reinitialize,
 			);
 			// Each hook property on AgentExtension accepts (payload: unknown) => Promise<unknown>.
 			// TypeScript cannot narrow a union of optional callback keys via computed access,

package/src/hooks/index.ts

@@ -0,0 +1,25 @@
+export {
+	createPersistentSubprocessHooks,
+	PersistentHookClient,
+	type PersistentHookClientOptions,
+	type PersistentSubprocessHookControl,
+	type PersistentSubprocessHooksOptions,
+} from "./persistent";
+export {
+	createSubprocessHooks,
+	type HookEventName,
+	HookEventNameSchema,
+	type HookEventPayload,
+	HookEventPayloadSchema,
+	parseHookEventPayload,
+	type RunHookOptions,
+	type RunHookResult,
+	runHook,
+	type SubprocessHookControl,
+	type SubprocessHooksOptions,
+} from "./subprocess";
+export {
+	type RunSubprocessEventOptions,
+	type RunSubprocessEventResult,
+	runSubprocessEvent,
+} from "./subprocess-runner";