@agimon-ai/doompi-computer-use 0.0.1-alpha.26 → 0.0.1-alpha.28

package/dist/extensionService-BJXeNc4R.mjs

@@ -0,0 +1,434 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { realpath } from "node:fs/promises";
+//#region src/constants/computerUse.ts
+const COMPUTER_USE_GUIDANCE = `[COMPUTER USE ACTIVE]
+Use computer_state before acting and after any action that may change the interface. Use only element refs and snapshot ids returned by computer_state. Use computer_action for one semantic press, focus, set_value, or scroll at a time. Use computer_exec only for a trusted, explicitly allowed local TypeScript script. Never infer coordinates, inspect another application, bypass secure elements, or retry an uncertain outcome. Stop computer use when the task is complete.`;
+const COMMAND_NAME = "computer-use";
+const COMMAND_DESCRIPTION = "Inspect or manage the session computer use mode";
+const COMPUTER_USE_TOOL_NAMES = [
+	"computer_state",
+	"computer_action",
+	"computer_exec"
+];
+//#endregion
+//#region src/services/computerScriptWorker/index.ts
+/** Source for an isolated child process. Restricted modules execute in QuickJS, not in Node's realm. */
+const COMPUTER_SCRIPT_WORKER_SOURCE = String.raw`
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { stripTypeScriptTypes } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+let nextRequestId = 0;
+let started = false;
+const pending = new Map();
+const controller = new AbortController();
+process.once('SIGTERM', () => controller.abort());
+const send = (message) => {
+  if (process.connected) process.send(message, () => {});
+};
+const call = (operation, payload) => new Promise((resolve, reject) => {
+  if (controller.signal.aborted) return reject(new Error('Computer script was cancelled.'));
+  if (pending.size >= 64) return reject(new Error('Too many outstanding program operations.'));
+  const id = String(++nextRequestId);
+  pending.set(id, { resolve, reject });
+  send({ type: 'program', id, operation, payload });
+});
+
+async function restricted(message) {
+  const { getQuickJS } = await import(pathToFileURL(message.quickjsPath).href);
+  const QuickJS = await getQuickJS();
+  const runtime = QuickJS.newRuntime();
+  runtime.setMemoryLimit(32 * 1024 * 1024);
+  runtime.setMaxStackSize(512 * 1024);
+  const deadline = Date.now() + message.timeoutMs;
+  runtime.setInterruptHandler(() => controller.signal.aborted || Date.now() >= deadline);
+  const root = realpathSync(message.scriptRoot);
+  const sources = new Map();
+  let sourceBytes = 0;
+  let moduleFailure;
+  const modulePath = (candidate) => {
+    const filename = realpathSync(candidate);
+    const relative = path.relative(root, filename);
+    if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {
+      throw new Error('Computer helper escapes the admitted script root.');
+    }
+    if (!/\.(ts|js|mjs)$/.test(filename)) throw new Error('Computer helpers must be JavaScript or erasable TypeScript.');
+    return filename;
+  };
+  const entry = modulePath(message.scriptPath);
+  runtime.setModuleLoader((filename) => {
+    // Preserve a rejected normalization even if the engine subsequently asks to load an empty name.
+    if (moduleFailure) throw moduleFailure;
+    if (sources.has(filename)) return sources.get(filename);
+    if (sources.size >= 32 || statSync(filename).size > 256 * 1024) throw new Error('Computer script module limit exceeded.');
+    const source = readFileSync(filename, 'utf8');
+    sourceBytes += Buffer.byteLength(source);
+    if (sourceBytes > 512 * 1024) throw new Error('Computer script source limit exceeded.');
+    const compiled = filename.endsWith('.ts') ? stripTypeScriptTypes(source, { mode: 'strip' }) : source;
+    sources.set(filename, compiled);
+    return compiled;
+  }, (base, name) => {
+    try {
+      if (name === '__entry__') return entry;
+      if (!name.startsWith('./') && !name.startsWith('../')) {
+        throw new Error('Restricted computer functions cannot import host or package modules.');
+      }
+      return modulePath(path.resolve(path.dirname(base), name));
+    } catch (error) {
+      moduleFailure = error;
+      throw error;
+    }
+  });
+  const vm = runtime.newContext();
+  let disposed = false;
+  const deferreds = new Set();
+  const pump = () => {
+    if (disposed) return;
+    const jobs = runtime.executePendingJobs();
+    if (jobs.error) {
+      const detail = vm.dump(jobs.error);
+      jobs.error.dispose();
+      throw new Error(detail?.message ?? String(detail));
+    }
+  };
+  const set = (name, value) => {
+    vm.setProp(vm.global, name, value);
+    value.dispose();
+  };
+  set('__input', vm.newString(JSON.stringify(message.input)));
+  set('__aborted', vm.newFunction('__aborted', () => controller.signal.aborted ? vm.true : vm.false));
+  set('__log', vm.newFunction('__log', (level, text) => {
+    send({ type: 'log', level: vm.getString(level), message: vm.getString(text) });
+  }));
+  set('__call', vm.newFunction('__call', (operationHandle, payloadHandle) => {
+    const operation = vm.getString(operationHandle);
+    const serialized = vm.getString(payloadHandle);
+    if (serialized.length > message.maxOutputBytes) throw new Error('Computer action exceeds the size limit.');
+    if (operation !== 'observe' && operation !== 'act') throw new Error('Unsupported program operation.');
+    const deferred = vm.newPromise();
+    deferreds.add(deferred);
+    call(operation, JSON.parse(serialized)).then((value) => {
+      if (disposed) return;
+      const handle = vm.newString(JSON.stringify(value));
+      deferred.resolve(handle);
+      handle.dispose();
+    }, (error) => {
+      if (disposed) return;
+      const handle = vm.newError(error.message);
+      deferred.reject(handle);
+      handle.dispose();
+    }).then(() => {
+      if (disposed) return;
+      deferred.dispose();
+      deferreds.delete(deferred);
+      pump();
+    }).catch((error) => send({ type: 'failed', error: error.message }));
+    return deferred.handle.dup();
+  }));
+  let evaluation;
+  try {
+    evaluation = vm.unwrapResult(vm.evalCode(
+      'import { run } from "__entry__";\n' +
+      'const invoke = __call; const log = __log; const isAborted = __aborted;\n' +
+      'const program = Object.freeze({\n' +
+      ' observe: async (options = {}) => JSON.parse(await invoke("observe", JSON.stringify(options))),\n' +
+      ' act: async (action) => JSON.parse(await invoke("act", JSON.stringify(action)))\n' +
+      '});\n' +
+      'const logger = Object.freeze(Object.fromEntries(["debug","info","warn","error"].map(level => [level, value => log(level, String(value))])));\n' +
+      'const signal = Object.freeze({ get aborted() { return isAborted(); }, throwIfAborted() { if (isAborted()) throw new Error("Computer script was cancelled."); } });\n' +
+      'const result = await run({ context: { program }, input: JSON.parse(__input), logger, signal });\n' +
+      'globalThis.__result = result === undefined ? undefined : JSON.stringify(result);',
+      path.join(root, '__computer_entry__.mjs'), { type: 'module' },
+    ));
+    const completion = vm.resolvePromise(evaluation);
+    pump();
+    const completed = vm.unwrapResult(await completion);
+    completed.dispose();
+    const result = vm.getProp(vm.global, '__result');
+    const resultJson = vm.dump(result);
+    result.dispose();
+    return resultJson;
+  } finally {
+    disposed = true;
+    for (const deferred of deferreds) deferred.dispose();
+    evaluation?.dispose();
+    vm.dispose();
+    runtime.dispose();
+  }
+}
+
+process.on('message', async (message) => {
+  if (message?.type === 'response') {
+    const request = pending.get(message.id);
+    if (!request) return;
+    pending.delete(message.id);
+    if (message.error) request.reject(new Error(message.error));
+    else request.resolve(message.value);
+    return;
+  }
+  if (message?.type !== 'start' || started) return;
+  started = true;
+  try {
+    let resultJson;
+    if (message.trusted) {
+      const loaded = await import(pathToFileURL(message.scriptPath).href);
+      if (typeof loaded.run !== 'function') throw new Error('Computer script must export a named run function.');
+      const program = {
+        observe: (options = {}) => call('observe', options),
+        act: (action) => call('act', action),
+      };
+      const logger = Object.fromEntries(['debug','info','warn','error'].map(level => [level, value => {
+        send({ type: 'log', level, message: String(value) });
+      }]));
+      const result = await loaded.run({ context: { program }, input: message.input, logger, signal: controller.signal });
+      resultJson = result === undefined ? undefined : JSON.stringify(result);
+    } else {
+      resultJson = await restricted(message);
+    }
+    if (typeof resultJson === 'string' && Buffer.byteLength(resultJson) > message.maxOutputBytes) {
+      throw new Error('Computer script result exceeded the size limit.');
+    }
+    send({ type: 'complete', resultJson });
+  } catch (error) {
+    send({ type: 'failed', error: String(error?.message ?? error).slice(0, 1024) });
+  }
+});
+`;
+//#endregion
+//#region src/services/computerScriptRunner/index.ts
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 262144;
+const MAX_IMAGE_BYTES = 6291456;
+const MAX_PENDING_OPERATIONS = 64;
+var ComputerScriptExecutionError = class extends Error {
+	completedActions;
+	outcomeUncertain;
+	constructor(message, completedActions, outcomeUncertain) {
+		super(message);
+		this.completedActions = completedActions;
+		this.outcomeUncertain = outcomeUncertain;
+		this.name = "ComputerScriptExecutionError";
+	}
+};
+var ComputerScriptRunner = class {
+	client;
+	allowedScriptPaths;
+	scriptRoot;
+	timeoutMs;
+	maxOutputBytes;
+	constructor(options) {
+		this.client = options.client;
+		this.allowedScriptPaths = options.allowedScriptPaths;
+		this.scriptRoot = options.scriptRoot;
+		this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+	}
+	async execute(scriptPath, input, signal, options = {}) {
+		signal?.throwIfAborted();
+		const resolvedPath = await realpath(path.resolve(this.scriptRoot ?? process.cwd(), scriptPath));
+		const allowedPaths = await Promise.all(this.allowedScriptPaths.map(async (candidate) => realpath(candidate).catch(() => "")));
+		const trusted = options.trusted === true;
+		if ((trusted || this.scriptRoot === void 0) && !allowedPaths.includes(resolvedPath)) throw new Error("Computer script path is not explicitly allowed.");
+		if (!/\.(ts|js|mjs)$/u.test(resolvedPath)) throw new Error("Computer scripts must be JavaScript or erasable TypeScript files.");
+		const root = await realpath(this.scriptRoot ?? path.dirname(resolvedPath));
+		const relative = path.relative(root, resolvedPath);
+		if (!trusted && (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) throw new Error("Computer script escapes the admitted script root.");
+		const serializedInput = JSON.stringify(input);
+		if (serializedInput === void 0) throw new Error("Computer script input must be JSON serializable.");
+		if (Buffer.byteLength(serializedInput) > this.maxOutputBytes) throw new Error("Computer script input exceeds the size limit.");
+		const quickjsPath = trusted ? void 0 : createRequire(import.meta.url).resolve("quickjs-emscripten");
+		signal?.throwIfAborted();
+		const started = performance.now();
+		return new Promise((resolve, reject) => {
+			const child = spawn(process.execPath, [
+				"--input-type=module",
+				"--eval",
+				COMPUTER_SCRIPT_WORKER_SOURCE
+			], {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe",
+					"ipc"
+				],
+				env: trusted ? process.env : { ELECTRON_RUN_AS_NODE: "1" }
+			});
+			const controller = new AbortController();
+			const logs = [];
+			let outputBytes = 0;
+			let completedActions = 0;
+			let observations = 0;
+			let actionInFlight = false;
+			let settled = false;
+			let completing = false;
+			let outstanding = 0;
+			let operation = Promise.resolve();
+			const finish = (error, value) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				signal?.removeEventListener("abort", onAbort);
+				controller.abort();
+				child.kill("SIGTERM");
+				setTimeout(() => child.kill("SIGKILL"), 250).unref();
+				if (error) reject(new ComputerScriptExecutionError(error.message, completedActions, actionInFlight));
+				else resolve(value);
+			};
+			const addOutput = (value) => {
+				outputBytes += Buffer.byteLength(value);
+				if (outputBytes <= this.maxOutputBytes) return true;
+				finish(/* @__PURE__ */ new Error("Computer script output exceeded the size limit."));
+				return false;
+			};
+			const send = (value) => {
+				if (settled || !child.connected) return;
+				child.send(value, (error) => {
+					if (error && !settled) finish(error);
+				});
+			};
+			const onAbort = () => finish(/* @__PURE__ */ new Error("Computer script execution was cancelled."));
+			const timeout = setTimeout(() => finish(/* @__PURE__ */ new Error("Computer script execution timed out.")), this.timeoutMs);
+			timeout.unref();
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted) return onAbort();
+			child.stdout?.on("data", (chunk) => addOutput(chunk.toString("utf8")));
+			child.stderr?.on("data", (chunk) => addOutput(chunk.toString("utf8")));
+			child.on("error", (error) => finish(error));
+			child.on("exit", (code, exitSignal) => {
+				if (!settled) finish(/* @__PURE__ */ new Error(`Computer script worker exited before completion (${exitSignal ?? code ?? "unknown"}).`));
+			});
+			const observe = async (includeScreenshot) => {
+				const value = await this.client.observe(controller.signal, { includeScreenshot });
+				observations += 1;
+				const { screenshot, ...semantic } = value;
+				if (Buffer.byteLength(JSON.stringify(semantic)) > this.maxOutputBytes) throw new Error("Computer observation exceeds the size limit.");
+				if (includeScreenshot && screenshot) {
+					if (screenshot.mimeType !== "image/png" || screenshot.data.length > Math.ceil(MAX_IMAGE_BYTES / 3) * 4) throw new Error("Computer screenshot exceeds the image limit.");
+					return {
+						...semantic,
+						screenshot
+					};
+				}
+				return semantic;
+			};
+			child.on("message", (raw) => {
+				if (settled) return;
+				if (!raw || typeof raw !== "object" || Buffer.byteLength(JSON.stringify(raw)) > this.maxOutputBytes + 4096) {
+					finish(/* @__PURE__ */ new Error("Computer worker message exceeds the size limit."));
+					return;
+				}
+				if (raw.type === "log" && typeof raw.message === "string") {
+					const line = `[${String(raw.level)}] ${raw.message}`;
+					if (addOutput(line)) logs.push(line);
+					return;
+				}
+				if (raw.type === "program") {
+					if (completing || typeof raw.id !== "string" || raw.id.length > 128 || raw.operation !== "observe" && raw.operation !== "act" || outstanding >= MAX_PENDING_OPERATIONS) {
+						finish(/* @__PURE__ */ new Error("Invalid or excessive computer program operations."));
+						return;
+					}
+					outstanding += 1;
+					operation = operation.then(async () => {
+						if (settled || controller.signal.aborted) return;
+						try {
+							let value;
+							if (raw.operation === "observe") {
+								const settings = raw.payload;
+								if (!settings || typeof settings !== "object" || Array.isArray(settings) || Object.keys(settings).some((key) => key !== "includeScreenshot") || "includeScreenshot" in settings && typeof settings.includeScreenshot !== "boolean") throw new Error("Invalid observation options.");
+								value = await observe("includeScreenshot" in settings && settings.includeScreenshot === true);
+							} else {
+								actionInFlight = true;
+								value = await this.client.act(raw.payload, controller.signal);
+								completedActions += 1;
+								actionInFlight = false;
+							}
+							send({
+								type: "response",
+								id: raw.id,
+								value
+							});
+						} catch (error) {
+							if (actionInFlight) finish(error instanceof Error ? error : new Error(String(error)));
+							else send({
+								type: "response",
+								id: raw.id,
+								error: error instanceof Error ? error.message : String(error)
+							});
+						} finally {
+							outstanding -= 1;
+						}
+					}).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+					return;
+				}
+				if (raw.type === "failed" && typeof raw.error === "string") {
+					finish(new Error(raw.error));
+					return;
+				}
+				if (raw.type === "complete") {
+					if (completing) {
+						finish(/* @__PURE__ */ new Error("Computer worker completed twice."));
+						return;
+					}
+					completing = true;
+					operation = operation.then(async () => {
+						if (settled) return;
+						const resultJson = raw.resultJson;
+						if (resultJson !== void 0 && typeof resultJson !== "string") throw new Error("Computer script returned an invalid result.");
+						if (typeof resultJson === "string" && !addOutput(resultJson)) return;
+						const observation = await observe(options.includeScreenshot === true);
+						if (settled || !addOutput(JSON.stringify({
+							...observation,
+							screenshot: void 0
+						}))) return;
+						finish(void 0, {
+							...typeof resultJson === "string" ? { result: JSON.parse(resultJson) } : {},
+							observation,
+							logs,
+							metrics: {
+								actions: completedActions,
+								observations,
+								durationMs: Math.round(performance.now() - started),
+								outputBytes
+							}
+						});
+					}).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+				}
+			});
+			send({
+				type: "start",
+				scriptPath: resolvedPath,
+				scriptRoot: root,
+				input: JSON.parse(serializedInput),
+				trusted,
+				quickjsPath,
+				timeoutMs: this.timeoutMs,
+				maxOutputBytes: this.maxOutputBytes
+			});
+		});
+	}
+};
+//#endregion
+//#region src/services/extensionService/index.ts
+var DefaultComputerUseExtensionService = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async execute() {
+		if (this.client === void 0) return {
+			message: "Computer use requires a DoomPi Desktop session.",
+			level: "error"
+		};
+		return {
+			message: `Computer use is ${(await this.client.state()).phase.replaceAll("_", " ")}.`,
+			level: "info"
+		};
+	}
+};
+//#endregion
+export { COMMAND_NAME as a, COMMAND_DESCRIPTION as i, ComputerScriptExecutionError as n, COMPUTER_USE_GUIDANCE as o, ComputerScriptRunner as r, COMPUTER_USE_TOOL_NAMES as s, DefaultComputerUseExtensionService as t };
+
+//# sourceMappingURL=extensionService-BJXeNc4R.mjs.map

package/dist/extensionService-BJXeNc4R.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionService-BJXeNc4R.mjs","names":[],"sources":["../src/constants/computerUse.ts","../src/services/computerScriptWorker/index.ts","../src/services/computerScriptRunner/index.ts","../src/services/extensionService/index.ts"],"sourcesContent":["export const COMPUTER_USE_GUIDANCE = `[COMPUTER USE ACTIVE]\nUse computer_state before acting and after any action that may change the interface. Use only element refs and snapshot ids returned by computer_state. Use computer_action for one semantic press, focus, set_value, or scroll at a time. Use computer_exec only for a trusted, explicitly allowed local TypeScript script. Never infer coordinates, inspect another application, bypass secure elements, or retry an uncertain outcome. Stop computer use when the task is complete.`;\nexport const COMMAND_NAME = 'computer-use';\nexport const COMMAND_DESCRIPTION = 'Inspect or manage the session computer use mode';\n\nexport const COMPUTER_USE_TOOL_NAMES = ['computer_state', 'computer_action', 'computer_exec'] as const;\n","/** Source for an isolated child process. Restricted modules execute in QuickJS, not in Node's realm. */\nexport const COMPUTER_SCRIPT_WORKER_SOURCE = String.raw`\nimport { readFileSync, realpathSync, statSync } from 'node:fs';\nimport path from 'node:path';\nimport { stripTypeScriptTypes } from 'node:module';\nimport { pathToFileURL } from 'node:url';\n\nlet nextRequestId = 0;\nlet started = false;\nconst pending = new Map();\nconst controller = new AbortController();\nprocess.once('SIGTERM', () => controller.abort());\nconst send = (message) => {\n  if (process.connected) process.send(message, () => {});\n};\nconst call = (operation, payload) => new Promise((resolve, reject) => {\n  if (controller.signal.aborted) return reject(new Error('Computer script was cancelled.'));\n  if (pending.size >= 64) return reject(new Error('Too many outstanding program operations.'));\n  const id = String(++nextRequestId);\n  pending.set(id, { resolve, reject });\n  send({ type: 'program', id, operation, payload });\n});\n\nasync function restricted(message) {\n  const { getQuickJS } = await import(pathToFileURL(message.quickjsPath).href);\n  const QuickJS = await getQuickJS();\n  const runtime = QuickJS.newRuntime();\n  runtime.setMemoryLimit(32 * 1024 * 1024);\n  runtime.setMaxStackSize(512 * 1024);\n  const deadline = Date.now() + message.timeoutMs;\n  runtime.setInterruptHandler(() => controller.signal.aborted || Date.now() >= deadline);\n  const root = realpathSync(message.scriptRoot);\n  const sources = new Map();\n  let sourceBytes = 0;\n  let moduleFailure;\n  const modulePath = (candidate) => {\n    const filename = realpathSync(candidate);\n    const relative = path.relative(root, filename);\n    if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {\n      throw new Error('Computer helper escapes the admitted script root.');\n    }\n    if (!/\\.(ts|js|mjs)$/.test(filename)) throw new Error('Computer helpers must be JavaScript or erasable TypeScript.');\n    return filename;\n  };\n  const entry = modulePath(message.scriptPath);\n  runtime.setModuleLoader((filename) => {\n    // Preserve a rejected normalization even if the engine subsequently asks to load an empty name.\n    if (moduleFailure) throw moduleFailure;\n    if (sources.has(filename)) return sources.get(filename);\n    if (sources.size >= 32 || statSync(filename).size > 256 * 1024) throw new Error('Computer script module limit exceeded.');\n    const source = readFileSync(filename, 'utf8');\n    sourceBytes += Buffer.byteLength(source);\n    if (sourceBytes > 512 * 1024) throw new Error('Computer script source limit exceeded.');\n    const compiled = filename.endsWith('.ts') ? stripTypeScriptTypes(source, { mode: 'strip' }) : source;\n    sources.set(filename, compiled);\n    return compiled;\n  }, (base, name) => {\n    try {\n      if (name === '__entry__') return entry;\n      if (!name.startsWith('./') && !name.startsWith('../')) {\n        throw new Error('Restricted computer functions cannot import host or package modules.');\n      }\n      return modulePath(path.resolve(path.dirname(base), name));\n    } catch (error) {\n      moduleFailure = error;\n      throw error;\n    }\n  });\n  const vm = runtime.newContext();\n  let disposed = false;\n  const deferreds = new Set();\n  const pump = () => {\n    if (disposed) return;\n    const jobs = runtime.executePendingJobs();\n    if (jobs.error) {\n      const detail = vm.dump(jobs.error);\n      jobs.error.dispose();\n      throw new Error(detail?.message ?? String(detail));\n    }\n  };\n  const set = (name, value) => {\n    vm.setProp(vm.global, name, value);\n    value.dispose();\n  };\n  set('__input', vm.newString(JSON.stringify(message.input)));\n  set('__aborted', vm.newFunction('__aborted', () => controller.signal.aborted ? vm.true : vm.false));\n  set('__log', vm.newFunction('__log', (level, text) => {\n    send({ type: 'log', level: vm.getString(level), message: vm.getString(text) });\n  }));\n  set('__call', vm.newFunction('__call', (operationHandle, payloadHandle) => {\n    const operation = vm.getString(operationHandle);\n    const serialized = vm.getString(payloadHandle);\n    if (serialized.length > message.maxOutputBytes) throw new Error('Computer action exceeds the size limit.');\n    if (operation !== 'observe' && operation !== 'act') throw new Error('Unsupported program operation.');\n    const deferred = vm.newPromise();\n    deferreds.add(deferred);\n    call(operation, JSON.parse(serialized)).then((value) => {\n      if (disposed) return;\n      const handle = vm.newString(JSON.stringify(value));\n      deferred.resolve(handle);\n      handle.dispose();\n    }, (error) => {\n      if (disposed) return;\n      const handle = vm.newError(error.message);\n      deferred.reject(handle);\n      handle.dispose();\n    }).then(() => {\n      if (disposed) return;\n      deferred.dispose();\n      deferreds.delete(deferred);\n      pump();\n    }).catch((error) => send({ type: 'failed', error: error.message }));\n    return deferred.handle.dup();\n  }));\n  let evaluation;\n  try {\n    evaluation = vm.unwrapResult(vm.evalCode(\n      'import { run } from \"__entry__\";\\n' +\n      'const invoke = __call; const log = __log; const isAborted = __aborted;\\n' +\n      'const program = Object.freeze({\\n' +\n      ' observe: async (options = {}) => JSON.parse(await invoke(\"observe\", JSON.stringify(options))),\\n' +\n      ' act: async (action) => JSON.parse(await invoke(\"act\", JSON.stringify(action)))\\n' +\n      '});\\n' +\n      'const logger = Object.freeze(Object.fromEntries([\"debug\",\"info\",\"warn\",\"error\"].map(level => [level, value => log(level, String(value))])));\\n' +\n      'const signal = Object.freeze({ get aborted() { return isAborted(); }, throwIfAborted() { if (isAborted()) throw new Error(\"Computer script was cancelled.\"); } });\\n' +\n      'const result = await run({ context: { program }, input: JSON.parse(__input), logger, signal });\\n' +\n      'globalThis.__result = result === undefined ? undefined : JSON.stringify(result);',\n      path.join(root, '__computer_entry__.mjs'), { type: 'module' },\n    ));\n    const completion = vm.resolvePromise(evaluation);\n    pump();\n    const completed = vm.unwrapResult(await completion);\n    completed.dispose();\n    const result = vm.getProp(vm.global, '__result');\n    const resultJson = vm.dump(result);\n    result.dispose();\n    return resultJson;\n  } finally {\n    disposed = true;\n    for (const deferred of deferreds) deferred.dispose();\n    evaluation?.dispose();\n    vm.dispose();\n    runtime.dispose();\n  }\n}\n\nprocess.on('message', async (message) => {\n  if (message?.type === 'response') {\n    const request = pending.get(message.id);\n    if (!request) return;\n    pending.delete(message.id);\n    if (message.error) request.reject(new Error(message.error));\n    else request.resolve(message.value);\n    return;\n  }\n  if (message?.type !== 'start' || started) return;\n  started = true;\n  try {\n    let resultJson;\n    if (message.trusted) {\n      const loaded = await import(pathToFileURL(message.scriptPath).href);\n      if (typeof loaded.run !== 'function') throw new Error('Computer script must export a named run function.');\n      const program = {\n        observe: (options = {}) => call('observe', options),\n        act: (action) => call('act', action),\n      };\n      const logger = Object.fromEntries(['debug','info','warn','error'].map(level => [level, value => {\n        send({ type: 'log', level, message: String(value) });\n      }]));\n      const result = await loaded.run({ context: { program }, input: message.input, logger, signal: controller.signal });\n      resultJson = result === undefined ? undefined : JSON.stringify(result);\n    } else {\n      resultJson = await restricted(message);\n    }\n    if (typeof resultJson === 'string' && Buffer.byteLength(resultJson) > message.maxOutputBytes) {\n      throw new Error('Computer script result exceeded the size limit.');\n    }\n    send({ type: 'complete', resultJson });\n  } catch (error) {\n    send({ type: 'failed', error: String(error?.message ?? error).slice(0, 1024) });\n  }\n});\n`;\n","import { spawn } from 'node:child_process';\nimport { realpath } from 'node:fs/promises';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\n\nimport type {\n  ComputerScriptExecutionOptions,\n  ComputerScriptExecutionResult,\n  ComputerScriptRunnerOptions,\n} from '../../types/computerScript';\nimport type { ComputerUseAction, ComputerUseObservation, ComputerUseSessionClient } from '../../types/computerUse';\nimport { COMPUTER_SCRIPT_WORKER_SOURCE } from '../computerScriptWorker';\n\nconst DEFAULT_TIMEOUT_MS = 30_000;\nconst DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;\nconst MAX_IMAGE_BYTES = 6 * 1024 * 1024;\nconst MAX_PENDING_OPERATIONS = 64;\n\nexport class ComputerScriptExecutionError extends Error {\n  constructor(\n    message: string,\n    readonly completedActions: number,\n    readonly outcomeUncertain: boolean,\n  ) {\n    super(message);\n    this.name = 'ComputerScriptExecutionError';\n  }\n}\n\ninterface WorkerMessage {\n  readonly type?: unknown;\n  readonly id?: unknown;\n  readonly operation?: unknown;\n  readonly payload?: unknown;\n  readonly level?: unknown;\n  readonly message?: unknown;\n  readonly resultJson?: unknown;\n  readonly error?: unknown;\n}\n\nexport class ComputerScriptRunner {\n  private readonly client: ComputerUseSessionClient;\n  private readonly allowedScriptPaths: readonly string[];\n  private readonly scriptRoot?: string;\n  private readonly timeoutMs: number;\n  private readonly maxOutputBytes: number;\n\n  constructor(options: ComputerScriptRunnerOptions) {\n    this.client = options.client;\n    this.allowedScriptPaths = options.allowedScriptPaths;\n    this.scriptRoot = options.scriptRoot;\n    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n    this.maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;\n  }\n\n  async execute(\n    scriptPath: string,\n    input: unknown,\n    signal?: AbortSignal,\n    options: ComputerScriptExecutionOptions = {},\n  ): Promise<ComputerScriptExecutionResult> {\n    signal?.throwIfAborted();\n    const resolvedPath = await realpath(path.resolve(this.scriptRoot ?? process.cwd(), scriptPath));\n    const allowedPaths = await Promise.all(\n      this.allowedScriptPaths.map(async (candidate) => realpath(candidate).catch(() => '')),\n    );\n    const trusted = options.trusted === true;\n    if ((trusted || this.scriptRoot === undefined) && !allowedPaths.includes(resolvedPath)) {\n      throw new Error('Computer script path is not explicitly allowed.');\n    }\n    if (!/\\.(ts|js|mjs)$/u.test(resolvedPath))\n      throw new Error('Computer scripts must be JavaScript or erasable TypeScript files.');\n    const root = await realpath(this.scriptRoot ?? path.dirname(resolvedPath));\n    const relative = path.relative(root, resolvedPath);\n    if (!trusted && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) {\n      throw new Error('Computer script escapes the admitted script root.');\n    }\n    const serializedInput = JSON.stringify(input);\n    if (serializedInput === undefined) throw new Error('Computer script input must be JSON serializable.');\n    if (Buffer.byteLength(serializedInput) > this.maxOutputBytes)\n      throw new Error('Computer script input exceeds the size limit.');\n    const quickjsPath = trusted ? undefined : createRequire(import.meta.url).resolve('quickjs-emscripten');\n    signal?.throwIfAborted();\n    const started = performance.now();\n\n    return new Promise((resolve, reject) => {\n      const child = spawn(process.execPath, ['--input-type=module', '--eval', COMPUTER_SCRIPT_WORKER_SOURCE], {\n        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],\n        // Preserve Electron's Node mode, but no host credentials, for restricted workers.\n        env: trusted ? process.env : { ELECTRON_RUN_AS_NODE: '1' },\n      });\n      const controller = new AbortController();\n      const logs: string[] = [];\n      let outputBytes = 0;\n      let completedActions = 0;\n      let observations = 0;\n      let actionInFlight = false;\n      let settled = false;\n      let completing = false;\n      let outstanding = 0;\n      let operation: Promise<void> = Promise.resolve();\n      const finish = (error?: Error, value?: ComputerScriptExecutionResult): void => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timeout);\n        signal?.removeEventListener('abort', onAbort);\n        controller.abort();\n        child.kill('SIGTERM');\n        const killTimer = setTimeout(() => child.kill('SIGKILL'), 250);\n        killTimer.unref();\n        if (error) reject(new ComputerScriptExecutionError(error.message, completedActions, actionInFlight));\n        else resolve(value!);\n      };\n      const addOutput = (value: string): boolean => {\n        outputBytes += Buffer.byteLength(value);\n        if (outputBytes <= this.maxOutputBytes) return true;\n        finish(new Error('Computer script output exceeded the size limit.'));\n        return false;\n      };\n      const send = (value: object): void => {\n        if (settled || !child.connected) return;\n        child.send(value, (error) => {\n          if (error && !settled) finish(error);\n        });\n      };\n      const onAbort = (): void => finish(new Error('Computer script execution was cancelled.'));\n      const timeout = setTimeout(() => finish(new Error('Computer script execution timed out.')), this.timeoutMs);\n      timeout.unref();\n      signal?.addEventListener('abort', onAbort, { once: true });\n      if (signal?.aborted) return onAbort();\n      child.stdout?.on('data', (chunk: Buffer) => addOutput(chunk.toString('utf8')));\n      child.stderr?.on('data', (chunk: Buffer) => addOutput(chunk.toString('utf8')));\n      child.on('error', (error) => finish(error));\n      child.on('exit', (code, exitSignal) => {\n        if (!settled)\n          finish(new Error(`Computer script worker exited before completion (${exitSignal ?? code ?? 'unknown'}).`));\n      });\n\n      const observe = async (includeScreenshot: boolean): Promise<ComputerUseObservation> => {\n        const value = await this.client.observe(controller.signal, { includeScreenshot });\n        observations += 1;\n        const { screenshot, ...semantic } = value;\n        if (Buffer.byteLength(JSON.stringify(semantic)) > this.maxOutputBytes)\n          throw new Error('Computer observation exceeds the size limit.');\n        if (includeScreenshot && screenshot) {\n          if (screenshot.mimeType !== 'image/png' || screenshot.data.length > Math.ceil(MAX_IMAGE_BYTES / 3) * 4) {\n            throw new Error('Computer screenshot exceeds the image limit.');\n          }\n          return { ...semantic, screenshot };\n        }\n        return semantic;\n      };\n\n      child.on('message', (raw: WorkerMessage) => {\n        if (settled) return;\n        if (!raw || typeof raw !== 'object' || Buffer.byteLength(JSON.stringify(raw)) > this.maxOutputBytes + 4096) {\n          finish(new Error('Computer worker message exceeds the size limit.'));\n          return;\n        }\n        if (raw.type === 'log' && typeof raw.message === 'string') {\n          const line = `[${String(raw.level)}] ${raw.message}`;\n          if (addOutput(line)) logs.push(line);\n          return;\n        }\n        if (raw.type === 'program') {\n          if (\n            completing ||\n            typeof raw.id !== 'string' ||\n            raw.id.length > 128 ||\n            (raw.operation !== 'observe' && raw.operation !== 'act') ||\n            outstanding >= MAX_PENDING_OPERATIONS\n          ) {\n            finish(new Error('Invalid or excessive computer program operations.'));\n            return;\n          }\n          outstanding += 1;\n          operation = operation\n            .then(async () => {\n              if (settled || controller.signal.aborted) return;\n              try {\n                let value: unknown;\n                if (raw.operation === 'observe') {\n                  const settings = raw.payload;\n                  if (\n                    !settings ||\n                    typeof settings !== 'object' ||\n                    Array.isArray(settings) ||\n                    Object.keys(settings).some((key) => key !== 'includeScreenshot') ||\n                    ('includeScreenshot' in settings && typeof settings.includeScreenshot !== 'boolean')\n                  ) {\n                    throw new Error('Invalid observation options.');\n                  }\n                  value = await observe('includeScreenshot' in settings && settings.includeScreenshot === true);\n                } else {\n                  actionInFlight = true;\n                  value = await this.client.act(raw.payload as ComputerUseAction, controller.signal);\n                  completedActions += 1;\n                  actionInFlight = false;\n                }\n                send({ type: 'response', id: raw.id, value });\n              } catch (error) {\n                // An action can have taken effect before its transport failed. Never run the remaining chain.\n                if (actionInFlight) finish(error instanceof Error ? error : new Error(String(error)));\n                else\n                  send({ type: 'response', id: raw.id, error: error instanceof Error ? error.message : String(error) });\n              } finally {\n                outstanding -= 1;\n              }\n            })\n            .catch((error: unknown) => finish(error instanceof Error ? error : new Error(String(error))));\n          return;\n        }\n        if (raw.type === 'failed' && typeof raw.error === 'string') {\n          finish(new Error(raw.error));\n          return;\n        }\n        if (raw.type === 'complete') {\n          if (completing) {\n            finish(new Error('Computer worker completed twice.'));\n            return;\n          }\n          completing = true;\n          operation = operation\n            .then(async () => {\n              if (settled) return;\n              const resultJson = raw.resultJson;\n              if (resultJson !== undefined && typeof resultJson !== 'string')\n                throw new Error('Computer script returned an invalid result.');\n              if (typeof resultJson === 'string' && !addOutput(resultJson)) return;\n              const observation = await observe(options.includeScreenshot === true);\n              if (settled || !addOutput(JSON.stringify({ ...observation, screenshot: undefined }))) return;\n              finish(undefined, {\n                ...(typeof resultJson === 'string' ? { result: JSON.parse(resultJson) as unknown } : {}),\n                observation,\n                logs,\n                metrics: {\n                  actions: completedActions,\n                  observations,\n                  durationMs: Math.round(performance.now() - started),\n                  outputBytes,\n                },\n              });\n            })\n            .catch((error: unknown) => finish(error instanceof Error ? error : new Error(String(error))));\n        }\n      });\n      send({\n        type: 'start',\n        scriptPath: resolvedPath,\n        scriptRoot: root,\n        input: JSON.parse(serializedInput) as unknown,\n        trusted,\n        quickjsPath,\n        timeoutMs: this.timeoutMs,\n        maxOutputBytes: this.maxOutputBytes,\n      });\n    });\n  }\n}\n","import type { ComputerUseExtensionResult, ComputerUseExtensionService } from '../../types/extension';\nimport type { ComputerUseSessionClient } from '../sessionApiClient';\n\nexport class DefaultComputerUseExtensionService implements ComputerUseExtensionService {\n  public constructor(private readonly client?: ComputerUseSessionClient) {}\n\n  public async execute(): Promise<ComputerUseExtensionResult> {\n    if (this.client === undefined)\n      return { message: 'Computer use requires a DoomPi Desktop session.', level: 'error' };\n    const state = await this.client.state();\n    return { message: `Computer use is ${state.phase.replaceAll('_', ' ')}.`, level: 'info' };\n  }\n}\n"],"mappings":"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"}