@agimon-ai/po-computer-use 0.0.0-alpha.0

package/dist/extensionService-DXvF7esO.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 = {}, cwd) {
+		signal?.throwIfAborted();
+		const resolvedPath = await realpath(path.resolve(this.scriptRoot ?? cwd ?? 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 Po 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-DXvF7esO.mjs.map

package/dist/extensionService-DXvF7esO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionService-DXvF7esO.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    cwd?: string,\n  ): Promise<ComputerScriptExecutionResult> {\n    signal?.throwIfAborted();\n    const resolvedPath = await realpath(path.resolve(this.scriptRoot ?? cwd ?? 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) return { message: 'Computer use requires a Po 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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"}

package/dist/extensions/mcp-ui.mjs

@@ -0,0 +1,47 @@
+import { defineMcpWidget } from "@agimon-ai/po-core/web";
+import { McpToolFields, McpToolFrame, McpToolOutput } from "@agimon-ai/po-web-components";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer_action.mcp.tsx
+function ComputerActionMcpWidget(props) {
+	return /* @__PURE__ */ jsxs(McpToolFrame, {
+		...props,
+		title: "Interact with application",
+		children: [/* @__PURE__ */ jsx(McpToolFields, { fields: [
+			["Action", props.args.kind],
+			["Element", props.args.elementRef],
+			["Direction", props.args.direction],
+			["Amount", props.args.amount]
+		] }), /* @__PURE__ */ jsx(McpToolOutput, { result: props.result })]
+	});
+}
+var computer_action_mcp_default = defineMcpWidget(ComputerActionMcpWidget);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer_exec.mcp.tsx
+function ComputerExecMcpWidget(props) {
+	return /* @__PURE__ */ jsxs(McpToolFrame, {
+		...props,
+		title: "Run application script",
+		children: [/* @__PURE__ */ jsx(McpToolFields, { fields: [["Script", props.args.scriptPath]] }), /* @__PURE__ */ jsx(McpToolOutput, { result: props.result })]
+	});
+}
+var computer_exec_mcp_default = defineMcpWidget(ComputerExecMcpWidget);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer_state.mcp.tsx
+function ComputerStateMcpWidget(props) {
+	return /* @__PURE__ */ jsx(McpToolFrame, {
+		...props,
+		title: "Observe application",
+		children: /* @__PURE__ */ jsx(McpToolOutput, { result: props.result })
+	});
+}
+//#endregion
+//#region generated/mcp-ui.ts
+const widgets = {
+	"@agimon-ai/po-computer-use/computer_action": computer_action_mcp_default,
+	"@agimon-ai/po-computer-use/computer_exec": computer_exec_mcp_default,
+	"@agimon-ai/po-computer-use/computer_state": defineMcpWidget(ComputerStateMcpWidget)
+};
+//#endregion
+export { widgets };
+
+//# sourceMappingURL=mcp-ui.mjs.map

package/dist/extensions/mcp-ui.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-ui.mjs","names":["Widget0","Widget1","Widget2"],"sources":["../../src/extensions/workspaces/sessions/(frontend)/tool/computer_action.mcp.tsx","../../src/extensions/workspaces/sessions/(frontend)/tool/computer_exec.mcp.tsx","../../src/extensions/workspaces/sessions/(frontend)/tool/computer_state.mcp.tsx","../../generated/mcp-ui.ts"],"sourcesContent":["import { defineMcpWidget, type DoomMcpWidgetProps } from '@agimon-ai/po-core/web';\nimport { McpToolFrame, McpToolFields, McpToolOutput } from '@agimon-ai/po-web-components';\n\nfunction ComputerActionMcpWidget(props: DoomMcpWidgetProps) {\n  return (\n    <McpToolFrame {...props} title=\"Interact with application\">\n      <McpToolFields\n        fields={[\n          ['Action', props.args.kind],\n          ['Element', props.args.elementRef],\n          ['Direction', props.args.direction],\n          ['Amount', props.args.amount],\n        ]}\n      />\n      <McpToolOutput result={props.result} />\n    </McpToolFrame>\n  );\n}\n\nexport default defineMcpWidget(ComputerActionMcpWidget);\n","import { defineMcpWidget, type DoomMcpWidgetProps } from '@agimon-ai/po-core/web';\nimport { McpToolFrame, McpToolFields, McpToolOutput } from '@agimon-ai/po-web-components';\n\nfunction ComputerExecMcpWidget(props: DoomMcpWidgetProps) {\n  return (\n    <McpToolFrame {...props} title=\"Run application script\">\n      <McpToolFields fields={[['Script', props.args.scriptPath]]} />\n      <McpToolOutput result={props.result} />\n    </McpToolFrame>\n  );\n}\n\nexport default defineMcpWidget(ComputerExecMcpWidget);\n","import { defineMcpWidget, type DoomMcpWidgetProps } from '@agimon-ai/po-core/web';\nimport { McpToolFrame, McpToolOutput } from '@agimon-ai/po-web-components';\n\nfunction ComputerStateMcpWidget(props: DoomMcpWidgetProps) {\n  return (\n    <McpToolFrame {...props} title=\"Observe application\">\n      <McpToolOutput result={props.result} />\n    </McpToolFrame>\n  );\n}\n\nexport default defineMcpWidget(ComputerStateMcpWidget);\n","// Generated by @agimon-ai/po-build. Do not edit by hand.\nimport type { ComponentType } from 'react';\nimport type { DoomMcpWidgetProps } from '@agimon-ai/po-core/mcpWidget';\nimport Widget0 from \"../src/extensions/workspaces/sessions/(frontend)/tool/computer_action.mcp\";\nimport Widget1 from \"../src/extensions/workspaces/sessions/(frontend)/tool/computer_exec.mcp\";\nimport Widget2 from \"../src/extensions/workspaces/sessions/(frontend)/tool/computer_state.mcp\";\n\nexport const widgets: Readonly<Record<string, ComponentType<DoomMcpWidgetProps>>> = {\n  \"@agimon-ai/po-computer-use/computer_action\": Widget0,\n  \"@agimon-ai/po-computer-use/computer_exec\": Widget1,\n  \"@agimon-ai/po-computer-use/computer_state\": Widget2,\n};\n"],"mappings":";;;;AAGA,SAAS,wBAAwB,OAA2B;CAC1D,OACE,qBAAC,cAAD;EAAc,GAAI;EAAO,OAAM;EAA/B,UAAA,CACE,oBAAC,eAAD,EACE,QAAQ;GACN,CAAC,UAAU,MAAM,KAAK,IAAI;GAC1B,CAAC,WAAW,MAAM,KAAK,UAAU;GACjC,CAAC,aAAa,MAAM,KAAK,SAAS;GAClC,CAAC,UAAU,MAAM,KAAK,MAAM;EAC9B,EACD,CAAA,GACD,oBAAC,eAAD,EAAe,QAAQ,MAAM,OAAS,CAAA,CAC1B;;AAElB;AAEA,IAAA,8BAAe,gBAAgB,uBAAuB;;;AChBtD,SAAS,sBAAsB,OAA2B;CACxD,OACE,qBAAC,cAAD;EAAc,GAAI;EAAO,OAAM;EAA/B,UAAA,CACE,oBAAC,eAAD,EAAe,QAAQ,CAAC,CAAC,UAAU,MAAM,KAAK,UAAU,CAAC,EAAI,CAAA,GAC7D,oBAAC,eAAD,EAAe,QAAQ,MAAM,OAAS,CAAA,CAC1B;;AAElB;AAEA,IAAA,4BAAe,gBAAgB,qBAAqB;;;ACTpD,SAAS,uBAAuB,OAA2B;CACzD,OACE,oBAAC,cAAD;EAAc,GAAI;EAAO,OAAM;EAC7B,UAAA,oBAAC,eAAD,EAAe,QAAQ,MAAM,OAAS,CAAA;CAC1B,CAAA;AAElB;;;ACFA,MAAa,UAAuE;CAClF,8CAA8CA;CAC9C,4CAA4CC;CAC5C,6CDCa,gBAAgB,sBCDgBC;AAC/C"}

package/dist/extensions/mcp.cjs

@@ -0,0 +1,66 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _agimon_ai_po_core_mcpFacet = require("@agimon-ai/po-core/mcpFacet");
+let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
+//#endregion
+//#region src/services/mcpTools/index.ts
+const COMPUTER_USE_MCP_TOOLS_SERVICE = "doom/computer-use-mcp-tools";
+const MODE_LABEL = "Computer Use";
+function bindMcpTool(context, name) {
+	const catalog = context.services.get(COMPUTER_USE_MCP_TOOLS_SERVICE);
+	const tool = catalog?.get(name);
+	if (!tool || !catalog) return void 0;
+	return {
+		...tool,
+		execute(toolCallId, parameters, signal, onUpdate) {
+			if (!(context.selection.read().state?.["minor-mode"] ?? []).includes("computer-use")) {
+				const inactiveTools = [...catalog.names()].sort().join(", ");
+				throw new Error(`${MODE_LABEL} minor mode is inactive. Inactive ${MODE_LABEL} tools: ${inactiveTools}.`);
+			}
+			const executionSignal = AbortSignal.any([context.signal, signal ?? context.signal]);
+			return tool.execute(toolCallId, parameters, executionSignal, onUpdate, context.execution);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/computer_action.mcp.ts
+var computer_action_mcp_default = (0, _agimon_ai_po_core_extensionFile.defineRoutedContribution)((context) => bindMcpTool(context, "computer_action"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/computer_exec.mcp.ts
+var computer_exec_mcp_default = (0, _agimon_ai_po_core_extensionFile.defineRoutedContribution)((context) => bindMcpTool(context, "computer_exec"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/computer_state.mcp.ts
+var computer_state_mcp_default = (0, _agimon_ai_po_core_extensionFile.defineRoutedContribution)((context) => bindMcpTool(context, "computer_state"), { cardinality: "optional" });
+//#endregion
+//#region generated/mcp.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const withWidget = (key, value) => value === void 0 ? value : {
+	...value,
+	_meta: {
+		...value._meta,
+		["po/widget"]: key
+	}
+};
+const mcp = (0, _agimon_ai_po_core_mcpFacet.defineMcpPlugin)({
+	name: "@agimon-ai/po-computer-use",
+	session: (context) => ({ get tools() {
+		return defined([
+			withWidget("@agimon-ai/po-computer-use/computer_action", via({ name: "computer_action" }, at(computer_action_mcp_default, context))),
+			withWidget("@agimon-ai/po-computer-use/computer_exec", via({ name: "computer_exec" }, at(computer_exec_mcp_default, context))),
+			withWidget("@agimon-ai/po-computer-use/computer_state", via({ name: "computer_state" }, at(computer_state_mcp_default, context)))
+		]);
+	} })
+});
+//#endregion
+exports.default = mcp;
+exports.mcp = mcp;
+
+//# sourceMappingURL=mcp.cjs.map

package/dist/extensions/mcp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.cjs","names":["defineRoutedContribution","defineRoutedContribution","defineRoutedContribution","defineMcpPlugin","toolComputerAction","toolComputerExec","toolComputerState"],"sources":["../../src/types/computerUseApi.ts","../../src/services/mcpTools/index.ts","../../src/extensions/workspaces/sessions/(backend)/tool/computer_action.mcp.ts","../../src/extensions/workspaces/sessions/(backend)/tool/computer_exec.mcp.ts","../../src/extensions/workspaces/sessions/(backend)/tool/computer_state.mcp.ts","../../generated/mcp.ts"],"sourcesContent":["import type { DoomApiCaller } from '@agimon-ai/po-core/packageApi';\n\nexport const API_BASE_PATH = 'computer-use';\nexport const computerUseChannelType = 'computer_use_state';\nexport const COMPUTER_USE_MODE_ID = 'computer-use';\nexport const COMPUTER_USE_STATUS_KEY = 'doom-computer-use';\nexport const COMPUTER_USE_MODE_STATUS_KEY = 'doom-computer-use-mode';\nexport const COMPUTER_USE_MAX_DURATION_MS = 1_800 * 1_000;\nexport const COMPUTER_USE_DEFAULT_DURATION_MS = 300 * 1_000;\nexport const COMPUTER_USE_CONFIRMATION_WINDOW_MS = 2 * 60 * 1_000;\n\n/**\n * Every path this API answers on, below its mount.\n *\n * The typed route table in `./apiRoutes` is built from this, the dispatcher\n * reads that table, and the hub channel addresses the broker with these same\n * strings, so a route cannot move on one side alone.\n */\nexport const COMPUTER_USE_ROUTES = {\n  activate: '/activate',\n  artifact: '/artifact',\n  agentState: '/agent/state',\n  agentObserve: '/agent/observe',\n  agentAction: '/agent/action',\n  agentStop: '/agent/stop',\n  hubState: '/hub/state',\n  hubActivation: '/hub/activation',\n  hubAuthorization: '/hub/authorization',\n  hubNext: '/hub/next',\n  hubComplete: '/hub/complete',\n  hubStop: '/hub/stop',\n} as const;\n\nexport const COMPUTER_USE_WAKE_LIMIT = 1_000_000;\n\nexport interface ComputerUseArtifactView {\n  readonly artifactId: string;\n  readonly status: 'ready' | 'failed';\n  readonly sizeBytes?: number;\n  readonly downloadUrl?: string;\n  readonly previewUrl?: string;\n  readonly actionCount?: number;\n  readonly completedAt?: string;\n  readonly failure?: { readonly code: string; readonly message: string };\n}\n\nexport interface ComputerUseSessionView {\n  readonly sessionId: string;\n  readonly revision: number;\n  readonly wake: number;\n  readonly phase: 'inactive' | 'awaiting_confirmation' | 'activating' | 'active' | 'stopping' | 'failed';\n  readonly requestId?: string;\n  readonly target?: Record<string, unknown>;\n  readonly durationMs?: number;\n  readonly expiresAt?: number;\n  readonly failure?: { readonly code: string; readonly message: string };\n  readonly artifact?: ComputerUseArtifactView;\n}\n\nexport interface ComputerUseActivationRequest {\n  readonly requestId: string;\n  readonly target?: Record<string, unknown>;\n  readonly durationSeconds: number;\n  readonly createdAt: number;\n  readonly confirmationExpiresAt: number;\n  readonly caller: DoomApiCaller;\n}\n\nexport interface ComputerUseBrokerRequest {\n  readonly id: string;\n  readonly operation: 'observe' | 'act';\n  readonly payload?: unknown;\n  readonly grantId: string;\n  readonly sequence?: number;\n}\n\nexport interface ComputerUseChannelPayload {\n  readonly state: ComputerUseSessionView;\n  readonly targets: readonly Record<string, unknown>[];\n  readonly busy?: true;\n}\n\nexport type ComputerUseBrowserCommand = { readonly action: 'status' | 'targets' | 'stop' | 'artifacts' };\n","import type { DoomHeadlessTool } from '@agimon-ai/po-core/headless';\nimport type { DoomMcpPluginContext } from '@agimon-ai/po-core/mcpFacet';\nimport type { Context } from '@deepseek-ai/cordis';\n\nimport { COMPUTER_USE_MODE_ID } from '../../types/computerUseApi';\n\nexport const COMPUTER_USE_MCP_TOOLS_SERVICE = 'doom/computer-use-mcp-tools';\n\nconst MODE_LABEL = 'Computer Use';\n\nexport interface McpToolCatalog {\n  get(name: string): DoomHeadlessTool | undefined;\n  names(): readonly string[];\n}\n\nexport function mountMcpTools(tools: readonly DoomHeadlessTool[]) {\n  return (context: Context): void => {\n    context.plugin((providerContext) => {\n      providerContext.provide(COMPUTER_USE_MCP_TOOLS_SERVICE, {\n        get: (name) => tools.find((tool) => tool.name === name),\n        names: () => tools.map((tool) => tool.name),\n      } satisfies McpToolCatalog);\n    });\n  };\n}\n\nexport function bindMcpTool(context: DoomMcpPluginContext, name: string): DoomHeadlessTool | undefined {\n  const catalog = context.services.get<McpToolCatalog>(COMPUTER_USE_MCP_TOOLS_SERVICE);\n  const tool = catalog?.get(name);\n  if (!tool || !catalog) return undefined;\n  return {\n    ...tool,\n    execute(toolCallId, parameters, signal, onUpdate) {\n      const activeModes = context.selection.read().state?.['minor-mode'] ?? [];\n      if (!activeModes.includes(COMPUTER_USE_MODE_ID)) {\n        const inactiveTools = [...catalog.names()].sort().join(', ');\n        throw new Error(`${MODE_LABEL} minor mode is inactive. Inactive ${MODE_LABEL} tools: ${inactiveTools}.`);\n      }\n      const executionSignal = AbortSignal.any([context.signal, signal ?? context.signal]);\n      return tool.execute(toolCallId, parameters, executionSignal, onUpdate, context.execution);\n    },\n  };\n}\n","import { defineRoutedContribution } from '@agimon-ai/po-core/extensionFile';\nimport type { DoomMcpPluginContext } from '@agimon-ai/po-core/mcpFacet';\n\nimport { bindMcpTool } from '../../../../../services/mcpTools';\n\nexport default defineRoutedContribution((context: DoomMcpPluginContext) => bindMcpTool(context, 'computer_action'), {\n  cardinality: 'optional',\n});\n","import { defineRoutedContribution } from '@agimon-ai/po-core/extensionFile';\nimport type { DoomMcpPluginContext } from '@agimon-ai/po-core/mcpFacet';\n\nimport { bindMcpTool } from '../../../../../services/mcpTools';\n\nexport default defineRoutedContribution((context: DoomMcpPluginContext) => bindMcpTool(context, 'computer_exec'), {\n  cardinality: 'optional',\n});\n","import { defineRoutedContribution } from '@agimon-ai/po-core/extensionFile';\nimport type { DoomMcpPluginContext } from '@agimon-ai/po-core/mcpFacet';\n\nimport { bindMcpTool } from '../../../../../services/mcpTools';\n\nexport default defineRoutedContribution((context: DoomMcpPluginContext) => bindMcpTool(context, 'computer_state'), {\n  cardinality: 'optional',\n});\n","// Generated by @agimon-ai/po-build. Do not edit by hand.\nimport { defineMcpPlugin, type DoomMcpSessionPlugin } from '@agimon-ai/po-core/mcpFacet';\n\nimport toolComputerAction from '../src/extensions/workspaces/sessions/(backend)/tool/computer_action.mcp';\nimport toolComputerExec from '../src/extensions/workspaces/sessions/(backend)/tool/computer_exec.mcp';\nimport toolComputerState from '../src/extensions/workspaces/sessions/(backend)/tool/computer_state.mcp';\n\ntype Factory<T, C> = (context: C) => T;\nconst at = <T, C>(value: T | Factory<T, C>, context: C): T =>\n  typeof value === 'function' ? (value as Factory<T, C>)(context) : value;\n/* v8 ignore next -- generated normalization branch */\nconst defined = <T>(values: readonly (T | undefined)[]): T[] =>\n  values.filter((value): value is T => value !== undefined);\nconst via = <T>(identity: Record<string, unknown>, value: unknown): T =>\n  (value === undefined ? undefined : { ...identity, ...(value as object) }) as T;\n\nconst withWidget = <T>(key: string, value: T): T => value === undefined ? value : ({\n  ...value, _meta: { ...(value as { _meta?: object })._meta, [\"po/widget\"]: key },\n});\n\nexport const mcp = defineMcpPlugin({\n  name: '@agimon-ai/po-computer-use',\n  session: (context) => ({\n    get tools(): DoomMcpSessionPlugin['tools'] { return defined([withWidget(\"@agimon-ai/po-computer-use/computer_action\", via({ name: 'computer_action' }, at(toolComputerAction, context))), withWidget(\"@agimon-ai/po-computer-use/computer_exec\", via({ name: 'computer_exec' }, at(toolComputerExec, context))), withWidget(\"@agimon-ai/po-computer-use/computer_state\", via({ name: 'computer_state' }, at(toolComputerState, context)))]); },\n  }) satisfies DoomMcpSessionPlugin,\n});\n\nexport default mcp;\n"],"mappings":";;;;;;;;ACMA,MAAa,iCAAiC;AAE9C,MAAM,aAAa;AAkBnB,SAAgB,YAAY,SAA+B,MAA4C;CACrG,MAAM,UAAU,QAAQ,SAAS,IAAoB,8BAA8B;CACnF,MAAM,OAAO,SAAS,IAAI,IAAI;CAC9B,IAAI,CAAC,QAAQ,CAAC,SAAS,OAAO,KAAA;CAC9B,OAAO;EACL,GAAG;EACH,QAAQ,YAAY,YAAY,QAAQ,UAAU;GAEhD,IAAI,EADgB,QAAQ,UAAU,KAAK,CAAC,CAAC,QAAQ,iBAAiB,CAAC,EAAA,CACtD,SAAA,cAA6B,GAAG;IAC/C,MAAM,gBAAgB,CAAC,GAAG,QAAQ,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI;IAC3D,MAAM,IAAI,MAAM,GAAG,WAAW,oCAAoC,WAAW,UAAU,cAAc,EAAE;GACzG;GACA,MAAM,kBAAkB,YAAY,IAAI,CAAC,QAAQ,QAAQ,UAAU,QAAQ,MAAM,CAAC;GAClF,OAAO,KAAK,QAAQ,YAAY,YAAY,iBAAiB,UAAU,QAAQ,SAAS;EAC1F;CACF;AACF;;;ACrCA,IAAA,+BAAA,GAAeA,iCAAAA,yBAAAA,EAA0B,YAAkC,YAAY,SAAS,iBAAiB,GAAG,EAClH,aAAa,WACf,CAAC;;;ACFD,IAAA,6BAAA,GAAeC,iCAAAA,yBAAAA,EAA0B,YAAkC,YAAY,SAAS,eAAe,GAAG,EAChH,aAAa,WACf,CAAC;;;ACFD,IAAA,8BAAA,GAAeC,iCAAAA,yBAAAA,EAA0B,YAAkC,YAAY,SAAS,gBAAgB,GAAG,EACjH,aAAa,WACf,CAAC;;;ACCD,MAAM,MAAY,OAA0B,YAC1C,OAAO,UAAU,aAAc,MAAwB,OAAO,IAAI;;AAEpE,MAAM,WAAc,WAClB,OAAO,QAAQ,UAAsB,UAAU,KAAA,CAAS;AAC1D,MAAM,OAAU,UAAmC,UAChD,UAAU,KAAA,IAAY,KAAA,IAAY;CAAE,GAAG;CAAU,GAAI;AAAiB;AAEzE,MAAM,cAAiB,KAAa,UAAgB,UAAU,KAAA,IAAY,QAAS;CACjF,GAAG;CAAO,OAAO;EAAE,GAAI,MAA6B;GAAQ,cAAc;CAAI;AAChF;AAEA,MAAa,OAAA,GAAMC,4BAAAA,gBAAAA,CAAgB;CACjC,MAAM;CACN,UAAU,aAAa,EACrB,IAAI,QAAuC;EAAE,OAAO,QAAQ;GAAC,WAAW,8CAA8C,IAAI,EAAE,MAAM,kBAAkB,GAAG,GAAGC,6BAAoB,OAAO,CAAC,CAAC;GAAG,WAAW,4CAA4C,IAAI,EAAE,MAAM,gBAAgB,GAAG,GAAGC,2BAAkB,OAAO,CAAC,CAAC;GAAG,WAAW,6CAA6C,IAAI,EAAE,MAAM,iBAAiB,GAAG,GAAGC,4BAAmB,OAAO,CAAC,CAAC;EAAC,CAAC;CAAG,EAC/a;AACF,CAAC"}

package/dist/extensions/mcp.d.mts

@@ -0,0 +1,5 @@
+//#region generated/mcp.d.ts
+export declare const mcp: import("@agimon-ai/po-core/mcpFacet").DoomMcpPluginDefinition;
+//#endregion
+export { mcp as default };
+//# sourceMappingURL=mcp.d.mts.map