@agimon-ai/po-computer-use 0.0.0-alpha.55 → 0.0.0-alpha.57

package/dist/extensionService-CC9-p-Av.cjs

@@ -0,0 +1,1145 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_child_process = require("node:child_process");
+let node_fs_promises = require("node:fs/promises");
+let node_module = require("node:module");
+let node_crypto = require("node:crypto");
+let _agimon_ai_po_core_packageApi = require("@agimon-ai/po-core/packageApi");
+//#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"
+];
+/** The session artifact storage service and the folder computer-use evidence lands in. */
+const COMPUTER_USE_ARTIFACTS_SERVICE = "po/artifacts";
+const COMPUTER_USE_ARTIFACT_DIRECTORY = "computer-use";
+/** The host recording store's own bounds: its largest recording and its range size. */
+const COMPUTER_USE_RECORDING_MAX_BYTES = 134217728;
+const COMPUTER_USE_RECORDING_CHUNK_BYTES = 1048576;
+const COMPUTER_USE_CODEMODE_GUIDANCE = "[COMPUTER USE ACTIVE]\nUse computer.state() in exec before acting and after any action that may change the interface. Use only element refs and snapshot ids returned by computer.state(). Never infer coordinates or bypass secure elements. Call computer.stop() when the task is complete. Load codemode-how-to-computer-use for details.";
+//#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 { realpath } = await import('node:fs/promises');
+  const root = await realpath(message.scriptRoot);
+  const sources = new Map();
+  let sourceBytes = 0;
+  let moduleFailure;
+  // sync: QuickJS invokes module normalization and loading synchronously and cannot await filesystem reads.
+  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/types/computerUseApi.ts
+const API_BASE_PATH = "computer-use";
+const computerUseChannelType = "computer_use_state";
+const COMPUTER_USE_MODE_ID = "computer-use";
+const COMPUTER_USE_STATUS_KEY = "po-computer-use";
+const COMPUTER_USE_CONFIRMATION_WINDOW_MS = 12e4;
+/**
+* Every path this API answers on, below its mount.
+*
+* The typed route table in `./apiRoutes` is built from this, the dispatcher
+* reads that table, and the hub channel addresses the broker with these same
+* strings, so a route cannot move on one side alone.
+*/
+const COMPUTER_USE_ROUTES = {
+	activate: "/activate",
+	artifact: "/artifact",
+	agentState: "/agent/state",
+	agentObserve: "/agent/observe",
+	agentAction: "/agent/action",
+	agentStop: "/agent/stop",
+	hubState: "/hub/state",
+	hubActivation: "/hub/activation",
+	hubAuthorization: "/hub/authorization",
+	hubNext: "/hub/next",
+	hubComplete: "/hub/complete",
+	hubStop: "/hub/stop"
+};
+const COMPUTER_USE_WAKE_LIMIT = 1e6;
+//#endregion
+//#region src/types/desktopPermissions.ts
+/** The macOS privacy permissions Desktop reports, in the order the settings page shows them. */
+const DESKTOP_PERMISSIONS = [
+	"accessibility",
+	"screen-recording",
+	"microphone",
+	"automation",
+	"full-disk-access"
+];
+function isDesktopPermission(value) {
+	return typeof value === "string" && DESKTOP_PERMISSIONS.includes(value);
+}
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path: the build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/computer-use/`, so the
+* mount is stated once, by the folder that creates it.
+*
+* The paths come from `COMPUTER_USE_ROUTES` rather than being written out
+* again. That table already addressed the broker from the hub channel and from
+* the broker's own dispatcher, and a second copy here is exactly the
+* disagreement this file exists to prevent. The dispatcher now reads this
+* table, so the page, the broker and the hub all resolve one set of strings.
+*
+* Activation, status, cancellation and recording reads are reachable from a browser. The `/agent/` and `/hub/` routes
+* each demand a host-issued bearer token and answer 404 without one; they are
+* declared here because they are this API's surface, not because a page calls
+* them.
+*/
+const routes = {
+	artifact: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.artifact,
+		query: ["artifactId", "offset"],
+		raw: true
+	},
+	activationState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: void 0
+	},
+	cancelActivation: {
+		method: "DELETE",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: void 0
+	},
+	activate: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: void 0
+	},
+	agentState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.agentState,
+		response: void 0
+	},
+	/** Answers whatever the admitted Desktop provider returned, which is runtime-defined JSON. */
+	agentObserve: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentObserve,
+		response: void 0
+	},
+	agentAction: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentAction,
+		response: void 0
+	},
+	agentStop: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentStop,
+		response: void 0
+	},
+	hubState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubState,
+		response: void 0
+	},
+	/** Null until a reader has confirmed one; reading it moves the session to `activating`. */
+	hubActivation: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubActivation,
+		response: void 0
+	},
+	hubAuthorization: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubAuthorization,
+		response: void 0
+	},
+	hubNext: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubNext,
+		response: void 0
+	},
+	hubComplete: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.hubComplete,
+		response: void 0
+	},
+	hubStop: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.hubStop,
+		response: void 0
+	},
+	/** Desktop's macOS permission states, served by the hub's `desktop-permissions` mount. */
+	desktopPermissions: {
+		method: "GET",
+		path: "/",
+		response: void 0
+	},
+	/** Asks macOS for the body's permission on the Mac running Desktop; answers the states after. */
+	requestDesktopPermission: {
+		method: "POST",
+		path: "/",
+		response: void 0
+	}
+};
+//#endregion
+//#region src/services/computerUseApi/index.ts
+function jsonError(message, status) {
+	return Response.json({ error: message }, { status });
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+async function body(request) {
+	try {
+		return record(await request.json()) ?? {};
+	} catch {
+		return {};
+	}
+}
+function semanticAction(value) {
+	const allowed = (keys) => Object.keys(value).every((key) => keys.includes(key));
+	if (value.kind === "launch") return typeof value.app === "string" && value.app.length > 0 && allowed(["kind", "app"]);
+	if (!(typeof value.snapshotId === "string" && value.snapshotId.length > 0 && typeof value.elementRef === "string" && value.elementRef.length > 0)) return false;
+	if (value.kind === "press" || value.kind === "focus") return allowed([
+		"kind",
+		"snapshotId",
+		"elementRef"
+	]);
+	if (value.kind === "set_value") return typeof value.value === "string" && allowed([
+		"kind",
+		"snapshotId",
+		"elementRef",
+		"value"
+	]);
+	if (value.kind === "scroll") return [
+		"up",
+		"down",
+		"left",
+		"right"
+	].includes(value.direction) && (value.amount === "line" || value.amount === "page") && allowed([
+		"kind",
+		"snapshotId",
+		"elementRef",
+		"direction",
+		"amount"
+	]);
+	if (value.kind === "perform") return typeof value.action === "string" && /^AX[A-Za-z]{1,62}$/u.test(value.action) && allowed([
+		"kind",
+		"snapshotId",
+		"elementRef",
+		"action"
+	]);
+	return false;
+}
+/** Throws on anything but the documented observation options, so every caller shares one check. */
+function observationOptions(value) {
+	const options = record(value);
+	if (options === void 0) throw new TypeError("Observation options must be an object.");
+	for (const [key, entry] of Object.entries(options)) if (!(key === "includeScreenshot" ? typeof entry === "boolean" : key === "root" || key === "label" || key === "role" ? typeof entry === "string" && entry.length > 0 && entry.length <= 256 : key === "offset" ? Number.isInteger(entry) && entry >= 0 && entry <= 2e3 : key === "limit" && Number.isInteger(entry) && entry >= 1 && entry <= 500)) throw new TypeError(`Invalid observation option "${key}".`);
+	return options;
+}
+function artifactView(value) {
+	const input = record(value);
+	if (typeof input?.artifactId !== "string" || input.status !== "ready" && input.status !== "failed") return void 0;
+	const safeUrl = (candidate) => typeof candidate === "string" && candidate.startsWith("/api/") ? candidate : void 0;
+	const downloadUrl = safeUrl(input.downloadUrl);
+	const previewUrl = safeUrl(input.previewUrl);
+	const artifactFailure = record(input.failure);
+	const safeFailure = typeof artifactFailure?.code === "string" && typeof artifactFailure.message === "string" ? {
+		code: artifactFailure.code.slice(0, 128),
+		message: artifactFailure.message.slice(0, 512)
+	} : void 0;
+	return {
+		artifactId: input.artifactId,
+		status: input.status,
+		...typeof input.sizeBytes === "number" && Number.isSafeInteger(input.sizeBytes) && input.sizeBytes > 0 ? { sizeBytes: input.sizeBytes } : {},
+		...downloadUrl === void 0 ? {} : { downloadUrl },
+		...previewUrl === void 0 ? {} : { previewUrl },
+		...typeof input.actionCount === "number" ? { actionCount: input.actionCount } : {},
+		...typeof input.completedAt === "string" ? { completedAt: input.completedAt } : {},
+		...safeFailure === void 0 ? {} : { failure: safeFailure }
+	};
+}
+var ComputerUseRequestBroker = class ComputerUseRequestBroker {
+	sessionId;
+	internalToken;
+	hubToken;
+	directEvents;
+	requestTimeoutMs;
+	revision = 0;
+	wake = 0;
+	phase = "inactive";
+	activation;
+	grantId;
+	expiresAt;
+	actionSequence = 0;
+	expiryTimer;
+	failure;
+	artifact;
+	pending;
+	closed = false;
+	desktop;
+	beforeActivate;
+	listeners = /* @__PURE__ */ new Set();
+	unsubscribeDesktop;
+	static DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+	constructor(options) {
+		this.sessionId = options.sessionId ?? "unknown";
+		this.internalToken = options.internalToken;
+		this.hubToken = options.hubToken;
+		this.directEvents = options.directEvents;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? ComputerUseRequestBroker.DEFAULT_REQUEST_TIMEOUT_MS;
+		this.desktop = options.desktop;
+		this.beforeActivate = options.beforeActivate;
+		this.unsubscribeDesktop = options.desktop?.subscribe(() => {
+			clearTimeout(this.expiryTimer);
+			if (!options.desktop?.available) {
+				this.rejectPending("Desktop disconnected.");
+				this.phase = "failed";
+				this.grantId = void 0;
+				this.failure = {
+					code: "desktop_unavailable",
+					message: "Desktop disconnected."
+				};
+			} else if (this.phase !== "inactive" && this.phase !== "failed") {
+				this.phase = "stopping";
+				this.rejectPending("Control was stopped by Desktop.");
+			}
+			this.changed();
+		});
+	}
+	state() {
+		return Object.freeze({
+			sessionId: this.sessionId,
+			revision: this.revision,
+			wake: this.wake,
+			phase: this.phase,
+			...this.activation === void 0 ? {} : {
+				requestId: this.activation.requestId,
+				target: this.activation.target,
+				durationMs: this.activation.durationSeconds * 1e3
+			},
+			...this.expiresAt === void 0 ? {} : { expiresAt: this.expiresAt },
+			...this.failure === void 0 ? {} : { failure: this.failure },
+			...this.artifact === void 0 ? {} : { artifact: this.artifact }
+		});
+	}
+	/** Tools and the API share this broker. No socket, credential discovery, or second state store. */
+	sessionClient() {
+		const result = async (response) => {
+			const value = await response.json();
+			if (!response.ok) throw new Error(value.error ?? `Computer-use request failed (${response.status}).`);
+			return value;
+		};
+		const requireDesktop = () => {
+			if (this.closed || !this.desktop?.available || this.desktop.enabled === false) throw new Error("Desktop computer use is unavailable.");
+		};
+		return {
+			state: async () => this.state(),
+			subscribeStatus: (listener) => {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			},
+			observe: async (signal, options = {}) => {
+				requireDesktop();
+				return result(await this.enqueue("observe", observationOptions(options), signal));
+			},
+			act: async (action, signal) => {
+				requireDesktop();
+				if (!semanticAction(action)) throw new Error("A valid semantic action is required.");
+				return result(await this.enqueue("act", action, signal));
+			},
+			stop: async (signal) => {
+				signal?.throwIfAborted();
+				if (this.phase !== "inactive" && this.phase !== "failed") {
+					this.phase = "stopping";
+					this.rejectPending("Computer use was stopped.");
+					this.changed();
+				}
+				return this.state();
+			}
+		};
+	}
+	changed() {
+		this.revision += 1;
+		this.wake = (this.wake + 1) % COMPUTER_USE_WAKE_LIMIT;
+		const state = this.state();
+		for (const listener of this.listeners) listener(state);
+		this.directEvents.publish(computerUseChannelType, this.sessionId, state);
+	}
+	authorized(request, token) {
+		return token !== void 0 && request.headers.get("authorization") === `Bearer ${token}`;
+	}
+	async requestActivation(request) {
+		if (!this.desktop?.available || !(this.desktop.authorizeActivation?.(request.headers) ?? this.desktop.authorize(request.headers))) return jsonError("Not found.", 404);
+		if (this.desktop.enabled === false) return jsonError("Enable computer use in global Desktop settings first.", 409);
+		const stamped = (0, _agimon_ai_po_core_packageApi.poApiCallerFrom)(request.headers);
+		const caller = stamped?.locality === "remote" ? stamped : {
+			locality: "local",
+			stepUp: "not-required"
+		};
+		if (this.phase !== "inactive" && this.phase !== "failed") return jsonError("Computer use is already busy.", 409);
+		const input = await body(request);
+		const target = record(input.target);
+		const durationMs = input.durationMs;
+		const desktopTarget = target?.scope === "desktop" && Object.keys(target).length === 1;
+		if (target === void 0 && (input.target !== void 0 || caller.locality !== "remote") || target !== void 0 && !desktopTarget && (typeof target.windowId !== "string" || typeof target.bundleId !== "string")) return jsonError("A Desktop window or the whole desktop is required, or a remote request must leave selection to the Mac.", 400);
+		if (typeof durationMs !== "number" || !Number.isInteger(durationMs) || durationMs < 1e3 || durationMs > 18e5) return jsonError("The requested duration is invalid.", 400);
+		try {
+			this.desktop.claim(request.headers);
+			await this.beforeActivate?.();
+		} catch (error) {
+			return jsonError(error instanceof Error ? error.message : String(error), 409);
+		}
+		if (this.closed || !this.desktop.available || this.phase !== "inactive" && this.phase !== "failed") return jsonError("Computer use is unavailable or already busy.", 409);
+		const createdAt = Date.now();
+		this.activation = Object.freeze({
+			requestId: (0, node_crypto.randomUUID)(),
+			...target === void 0 ? {} : { target: Object.freeze({ ...target }) },
+			durationSeconds: durationMs / 1e3,
+			createdAt,
+			confirmationExpiresAt: createdAt + COMPUTER_USE_CONFIRMATION_WINDOW_MS,
+			caller: Object.freeze({ ...caller })
+		});
+		this.phase = "awaiting_confirmation";
+		this.failure = void 0;
+		this.artifact = void 0;
+		this.changed();
+		return Response.json(this.state(), { status: 202 });
+	}
+	rejectPending(message) {
+		const pending = this.pending;
+		if (pending === void 0) return;
+		this.pending = void 0;
+		pending.dispose();
+		pending.reject(new Error(message));
+	}
+	stopAfterUncertainRequest(message) {
+		if (this.phase === "active") {
+			this.phase = "stopping";
+			this.changed();
+		}
+		this.rejectPending(message);
+	}
+	async enqueue(operation, payload, signal) {
+		if (this.phase !== "active" || this.grantId === void 0) return jsonError("Computer use is not active.", 409);
+		if (this.pending !== void 0) return jsonError("Another computer-use request is live.", 409);
+		if (signal?.aborted === true) return jsonError("The computer-use request was cancelled.", 499);
+		const sequence = operation === "act" ? ++this.actionSequence : void 0;
+		const request = {
+			id: (0, node_crypto.randomUUID)(),
+			operation,
+			grantId: this.grantId,
+			...sequence === void 0 ? {} : { sequence },
+			...payload === void 0 ? {} : { payload }
+		};
+		const completion = new Promise((resolve, reject) => {
+			const onAbort = () => this.stopAfterUncertainRequest("The computer-use request was cancelled.");
+			const timer = setTimeout(() => this.stopAfterUncertainRequest("The computer-use request timed out."), this.requestTimeoutMs);
+			timer.unref?.();
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.pending = {
+				request,
+				resolve,
+				reject,
+				dispose: () => {
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", onAbort);
+				}
+			};
+		});
+		this.changed();
+		try {
+			return Response.json(await completion);
+		} catch (error) {
+			return jsonError(error instanceof Error ? error.message : String(error), 502);
+		}
+	}
+	async fetch(request) {
+		if (this.closed) return jsonError("Computer-use broker is closed.", 503);
+		const url = new URL(request.url);
+		const path = url.pathname;
+		if (request.method === "GET" && path === routes.artifact.path) {
+			if (!(this.desktop?.authorizeRecording?.(request.headers) ?? this.desktop?.authorize(request.headers)) || !this.desktop?.fetchRecording) return jsonError("Not found.", 404);
+			const artifactId = url.searchParams.get("artifactId") ?? "";
+			const offsetText = url.searchParams.get("offset") ?? "";
+			const offset = Number(offsetText);
+			if (!/^[0-9]+$/u.test(offsetText) || !Number.isSafeInteger(offset) || offset < 0 || offset > 134217728) return jsonError("Invalid recording offset.", 400);
+			return this.desktop.fetchRecording(artifactId, `bytes=${offset}-${offset + 1048576 - 1}`);
+		}
+		if (path === routes.activate.path && request.method === "GET") {
+			if (!this.desktop?.authorizePending?.(request.headers) && !(this.desktop?.authorizeRecording?.(request.headers) ?? this.desktop?.authorize(request.headers))) return jsonError("Not found.", 404);
+			return Response.json(this.state());
+		}
+		if (path === routes.activate.path && request.method === "DELETE") {
+			if (!this.desktop?.authorizePending?.(request.headers)) return jsonError("Not found.", 404);
+			if (this.phase !== "awaiting_confirmation" && this.phase !== "activating") return jsonError("No activation is pending.", 409);
+			this.phase = "stopping";
+			this.rejectPending("The activation was cancelled.");
+			this.changed();
+			return Response.json(this.state(), { status: 202 });
+		}
+		if (request.method === "POST" && path === routes.activate.path) return this.requestActivation(request);
+		const agent = path.startsWith("/agent/");
+		const hub = path.startsWith("/hub/");
+		if (agent && !this.authorized(request, this.internalToken) || hub && !this.authorized(request, this.hubToken)) return jsonError("Not found.", 404);
+		if (request.method === "GET" && (path === routes.agentState.path || path === routes.hubState.path)) return Response.json(this.state());
+		if (request.method === "POST" && path === routes.agentObserve.path) return this.enqueue("observe", void 0, request.signal);
+		if (request.method === "POST" && path === routes.agentAction.path) {
+			const action = await body(request);
+			if (!semanticAction(action)) return jsonError("A valid semantic action is required.", 400);
+			return this.enqueue("act", action, request.signal);
+		}
+		if (request.method === "POST" && path === routes.agentStop.path) {
+			if (this.phase !== "active") return jsonError("Computer use is not active.", 409);
+			this.phase = "stopping";
+			this.rejectPending("The computer-use request was stopped.");
+			this.changed();
+			return Response.json(this.state(), { status: 202 });
+		}
+		if (request.method === "GET" && path === routes.hubActivation.path) {
+			if (this.activation === void 0 || this.phase !== "awaiting_confirmation") return Response.json(null);
+			this.phase = "activating";
+			this.changed();
+			return Response.json(this.activation);
+		}
+		if (request.method === "GET" && path === routes.hubAuthorization.path) return Response.json(this.grantId === void 0 ? null : {
+			grantId: this.grantId,
+			expiresAt: this.expiresAt
+		});
+		if (request.method === "GET" && path === routes.hubNext.path) return Response.json(this.pending?.request ?? null);
+		if (request.method === "POST" && path === routes.hubComplete.path) {
+			const input = await body(request);
+			const id = typeof input.id === "string" ? input.id : void 0;
+			if (this.pending === void 0 || this.pending.request.id !== id) return jsonError("The request is stale.", 409);
+			const pending = this.pending;
+			this.pending = void 0;
+			pending.dispose();
+			if (typeof input.error === "string") {
+				this.phase = "stopping";
+				pending.reject(new Error(input.error));
+			} else pending.resolve(input.result);
+			this.changed();
+			return Response.json(this.state());
+		}
+		if (request.method === "POST" && path === routes.hubStop.path) {
+			const input = await body(request);
+			if (this.phase === "activating") {
+				if (typeof input.error === "string") {
+					this.phase = "failed";
+					this.failure = {
+						code: "desktop_unavailable",
+						message: input.error.slice(0, 512)
+					};
+					this.activation = void 0;
+				} else {
+					const host = record(input.host);
+					if (typeof host?.grantId !== "string" || !Number.isFinite(host.expiresAt) || host.expiresAt <= Date.now()) return jsonError("Desktop did not issue a complete grant.", 502);
+					const selectedTarget = record(host.target);
+					if (this.activation !== void 0 && selectedTarget !== void 0) this.activation = Object.freeze({
+						...this.activation,
+						target: Object.freeze({ ...selectedTarget })
+					});
+					this.grantId = host.grantId;
+					this.expiresAt = host.expiresAt;
+					this.actionSequence = 0;
+					this.phase = "active";
+					clearTimeout(this.expiryTimer);
+					this.expiryTimer = setTimeout(() => {
+						if (this.closed || this.phase !== "active") return;
+						this.phase = "stopping";
+						this.rejectPending("The computer-use grant expired.");
+						this.changed();
+					}, Math.max(0, this.expiresAt - Date.now()));
+					this.expiryTimer.unref?.();
+				}
+			} else {
+				clearTimeout(this.expiryTimer);
+				this.rejectPending("The computer-use session stopped.");
+				this.phase = "inactive";
+				this.grantId = void 0;
+				this.expiresAt = void 0;
+				this.activation = void 0;
+				this.artifact = artifactView(input.artifact) ?? this.artifact;
+			}
+			this.changed();
+			return Response.json(this.state());
+		}
+		return jsonError("Not found.", 404);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		clearTimeout(this.expiryTimer);
+		this.unsubscribeDesktop?.();
+		this.listeners.clear();
+		this.rejectPending("Computer-use broker closed.");
+		this.grantId = void 0;
+		this.expiresAt = void 0;
+	}
+};
+function createComputerUseApi(options) {
+	return new ComputerUseRequestBroker(options);
+}
+//#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 (0, node_fs_promises.realpath)(node_path.default.resolve(this.scriptRoot ?? cwd ?? process.cwd(), scriptPath));
+		const allowedPaths = await Promise.all(this.allowedScriptPaths.map(async (candidate) => (0, node_fs_promises.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 (0, node_fs_promises.realpath)(this.scriptRoot ?? node_path.default.dirname(resolvedPath));
+		const relative = node_path.default.relative(root, resolvedPath);
+		if (!trusted && (relative === ".." || relative.startsWith(`..${node_path.default.sep}`) || node_path.default.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 : (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve("quickjs-emscripten");
+		signal?.throwIfAborted();
+		const started = performance.now();
+		return new Promise((resolve, reject) => {
+			const child = (0, node_child_process.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 (options) => {
+				const includeScreenshot = options.includeScreenshot === true;
+				const value = await this.client.observe(controller.signal, {
+					...options,
+					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") value = await observe(observationOptions(raw.payload));
+							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({ includeScreenshot: 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
+Object.defineProperty(exports, "API_BASE_PATH", {
+	enumerable: true,
+	get: function() {
+		return API_BASE_PATH;
+	}
+});
+Object.defineProperty(exports, "COMMAND_DESCRIPTION", {
+	enumerable: true,
+	get: function() {
+		return COMMAND_DESCRIPTION;
+	}
+});
+Object.defineProperty(exports, "COMMAND_NAME", {
+	enumerable: true,
+	get: function() {
+		return COMMAND_NAME;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_ARTIFACTS_SERVICE", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_ARTIFACTS_SERVICE;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_ARTIFACT_DIRECTORY", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_ARTIFACT_DIRECTORY;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_CODEMODE_GUIDANCE", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_CODEMODE_GUIDANCE;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_GUIDANCE", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_GUIDANCE;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_MODE_ID", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_MODE_ID;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_RECORDING_CHUNK_BYTES", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_RECORDING_CHUNK_BYTES;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_RECORDING_MAX_BYTES", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_RECORDING_MAX_BYTES;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_ROUTES", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_ROUTES;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_STATUS_KEY", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_STATUS_KEY;
+	}
+});
+Object.defineProperty(exports, "COMPUTER_USE_TOOL_NAMES", {
+	enumerable: true,
+	get: function() {
+		return COMPUTER_USE_TOOL_NAMES;
+	}
+});
+Object.defineProperty(exports, "ComputerScriptExecutionError", {
+	enumerable: true,
+	get: function() {
+		return ComputerScriptExecutionError;
+	}
+});
+Object.defineProperty(exports, "ComputerScriptRunner", {
+	enumerable: true,
+	get: function() {
+		return ComputerScriptRunner;
+	}
+});
+Object.defineProperty(exports, "DefaultComputerUseExtensionService", {
+	enumerable: true,
+	get: function() {
+		return DefaultComputerUseExtensionService;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "computerUseChannelType", {
+	enumerable: true,
+	get: function() {
+		return computerUseChannelType;
+	}
+});
+Object.defineProperty(exports, "createComputerUseApi", {
+	enumerable: true,
+	get: function() {
+		return createComputerUseApi;
+	}
+});
+Object.defineProperty(exports, "isDesktopPermission", {
+	enumerable: true,
+	get: function() {
+		return isDesktopPermission;
+	}
+});
+Object.defineProperty(exports, "routes", {
+	enumerable: true,
+	get: function() {
+		return routes;
+	}
+});
+
+//# sourceMappingURL=extensionService-CC9-p-Av.cjs.map