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

package/dist/extensions/server.mjs

@@ -0,0 +1,1388 @@
+import { a as COMMAND_NAME, i as COMMAND_DESCRIPTION, n as ComputerScriptExecutionError, r as ComputerScriptRunner, t as DefaultComputerUseExtensionService } from "../extensionService-DXvF7esO.mjs";
+import path from "node:path";
+import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineChannel, defineRoot, defineRoutedContribution } from "@agimon-ai/po-core/extensionFile";
+import { defineMinorMode, serverMinorModes } from "@agimon-ai/po-minor-mode";
+import { randomUUID } from "node:crypto";
+import { doomApiCallerFrom } from "@agimon-ai/po-core/packageApi";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-core/web";
+//#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 = "doom-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/services/mcpTools/index.ts
+const COMPUTER_USE_MCP_TOOLS_SERVICE = "doom/computer-use-mcp-tools";
+function mountMcpTools(tools) {
+	return (context) => {
+		context.plugin((providerContext) => {
+			providerContext.provide(COMPUTER_USE_MCP_TOOLS_SERVICE, {
+				get: (name) => tools.find((tool) => tool.name === name),
+				names: () => tools.map((tool) => tool.name)
+			});
+		});
+	};
+}
+//#endregion
+//#region src/models/computerUseMode.ts
+function modeState(state, enabled = false) {
+	const phase = state?.phase ?? "inactive";
+	const modeEnabled = enabled || phase !== "inactive" && phase !== "failed";
+	return {
+		activation: modeEnabled ? phase === "stopping" ? "deactivating" : phase === "awaiting_confirmation" || phase === "activating" ? "activating" : "active" : "inactive",
+		condition: phase === "awaiting_confirmation" ? "blocked" : phase === "failed" ? "failed" : phase === "activating" || phase === "stopping" ? "queued" : "ready",
+		...modeEnabled && phase === "inactive" ? { detail: "configure computer use in Activity" } : {},
+		...phase === "awaiting_confirmation" ? { detail: "awaiting confirmation in Activity" } : {},
+		actions: [
+			{
+				id: "activate",
+				enabled: !modeEnabled,
+				...!modeEnabled ? {} : { disabledReason: "Computer use is already enabled." }
+			},
+			{
+				id: "deactivate",
+				enabled: modeEnabled,
+				...modeEnabled ? {} : { disabledReason: "Computer use is not enabled." }
+			},
+			{
+				id: "doctor",
+				enabled: true
+			}
+		]
+	};
+}
+//#endregion
+//#region src/services/computerToolOutput/index.ts
+const MAX_TEXT_BYTES = 262144;
+const MAX_IMAGE_DATA_LENGTH = 8388608;
+function content(value, observation) {
+	const text = JSON.stringify(value);
+	if (Buffer.byteLength(text) > MAX_TEXT_BYTES) throw new Error("Computer-use text response exceeds the size limit.");
+	const screenshot = observation.screenshot;
+	if (screenshot && (screenshot.mimeType !== "image/png" || screenshot.data.length > MAX_IMAGE_DATA_LENGTH)) throw new Error("Computer-use screenshot exceeds the image limit.");
+	return [{
+		type: "text",
+		text
+	}, ...screenshot ? [{
+		type: "image",
+		mimeType: screenshot.mimeType,
+		data: screenshot.data
+	}] : []];
+}
+function computerObservationOutput(observation) {
+	return {
+		content: content({
+			...observation,
+			screenshot: void 0
+		}, observation),
+		details: observation
+	};
+}
+function computerScriptOutput(result) {
+	try {
+		return {
+			content: content({
+				...result,
+				observation: {
+					...result.observation,
+					screenshot: void 0
+				}
+			}, result.observation),
+			details: result
+		};
+	} catch (error) {
+		if (result.metrics === void 0) throw error;
+		throw new ComputerScriptExecutionError(error instanceof Error ? error.message : String(error), result.metrics.actions, false);
+	}
+}
+function computerScriptFailure(error) {
+	const details = {
+		error: (error instanceof Error ? error.message : String(error)).slice(0, 1024),
+		...error instanceof ComputerScriptExecutionError ? {
+			completedActions: error.completedActions,
+			outcomeUncertain: error.outcomeUncertain
+		} : {}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(details)
+		}],
+		details,
+		isError: true
+	};
+}
+//#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.
+*/
+var apiRoutes_default = defineApiRoutes({
+	artifact: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.artifact,
+		query: ["artifactId", "offset"],
+		raw: true
+	},
+	activationState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: apiResponse()
+	},
+	cancelActivation: {
+		method: "DELETE",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: apiResponse()
+	},
+	activate: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.activate,
+		response: apiResponse()
+	},
+	agentState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.agentState,
+		response: apiResponse()
+	},
+	/** Answers whatever the admitted Desktop provider returned, which is runtime-defined JSON. */
+	agentObserve: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentObserve,
+		response: apiResponse()
+	},
+	agentAction: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentAction,
+		response: apiResponse()
+	},
+	agentStop: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.agentStop,
+		response: apiResponse()
+	},
+	hubState: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubState,
+		response: apiResponse()
+	},
+	/** Null until a reader has confirmed one; reading it moves the session to `activating`. */
+	hubActivation: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubActivation,
+		response: apiResponse()
+	},
+	hubAuthorization: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubAuthorization,
+		response: apiResponse()
+	},
+	hubNext: {
+		method: "GET",
+		path: COMPUTER_USE_ROUTES.hubNext,
+		response: apiResponse()
+	},
+	hubComplete: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.hubComplete,
+		response: apiResponse()
+	},
+	hubStop: {
+		method: "POST",
+		path: COMPUTER_USE_ROUTES.hubStop,
+		response: apiResponse()
+	}
+});
+//#endregion
+//#region src/services/computerUseApi/index.ts
+function jsonError(message, status) {
+	return Response.json({ error: message }, { status });
+}
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+async function body(request) {
+	try {
+		return record$1(await request.json()) ?? {};
+	} catch {
+		return {};
+	}
+}
+function semanticAction(value) {
+	if (!(typeof value.snapshotId === "string" && value.snapshotId.length > 0 && typeof value.elementRef === "string" && value.elementRef.length > 0)) return false;
+	const allowed = (keys) => Object.keys(value).every((key) => keys.includes(key));
+	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"
+	]);
+	return false;
+}
+function artifactView(value) {
+	const input = record$1(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$1(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", 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 = doomApiCallerFrom(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$1(input.target);
+		const durationMs = input.durationMs;
+		if (target === void 0 && (input.target !== void 0 || caller.locality !== "remote") || target !== void 0 && (typeof target.windowId !== "string" || typeof target.bundleId !== "string")) return jsonError("A Desktop target 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: 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: 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 === apiRoutes_default.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 === apiRoutes_default.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 === apiRoutes_default.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 === apiRoutes_default.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 === apiRoutes_default.agentState.path || path === apiRoutes_default.hubState.path)) return Response.json(this.state());
+		if (request.method === "POST" && path === apiRoutes_default.agentObserve.path) return this.enqueue("observe", void 0, request.signal);
+		if (request.method === "POST" && path === apiRoutes_default.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 === apiRoutes_default.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 === apiRoutes_default.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 === apiRoutes_default.hubAuthorization.path) return Response.json(this.grantId === void 0 ? null : {
+			grantId: this.grantId,
+			expiresAt: this.expiresAt
+		});
+		if (request.method === "GET" && path === apiRoutes_default.hubNext.path) return Response.json(this.pending?.request ?? null);
+		if (request.method === "POST" && path === apiRoutes_default.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 === apiRoutes_default.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$1(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$1(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/computerUseServer/index.ts
+/** This package's identity for mode, activity and restriction ownership, not a status key. */
+const SOURCE = "@agimon-ai/po-computer-use";
+const SCRIPT_PATHS_ENV = "PO_COMPUTER_USE_SCRIPT_PATHS";
+const 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. Never infer coordinates or bypass secure elements.";
+function output(value, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		}],
+		details: value,
+		...isError ? { isError: true } : {}
+	};
+}
+function createComputerUseServer(host, apiContext) {
+	if (!apiContext?.computerUse?.available || !apiContext.directEvents) return {
+		tools: [],
+		commands: []
+	};
+	const desktop = apiContext.computerUse;
+	const broker = createComputerUseApi({
+		sessionId: host.context.sessionId,
+		internalToken: apiContext.internalToken,
+		hubToken: apiContext.hubToken,
+		directEvents: apiContext.directEvents,
+		desktop,
+		beforeActivate: async () => {
+			if (!modeSelected()) throw new Error("Enable computer use before authorizing an application.");
+			const activity = await host.context.session.activity();
+			if (!activity.isIdle || activity.hasPendingMessages) throw new Error("Wait for the agent and its queued prompts to finish before granting computer use.");
+		}
+	});
+	const client = broker.sessionClient();
+	const allowedScriptPaths = (host.context.environment[SCRIPT_PATHS_ENV] ?? "").split(path.delimiter).filter((entry) => entry.length > 0);
+	const dependencies = {
+		client,
+		scriptRunner: new ComputerScriptRunner({
+			client,
+			allowedScriptPaths,
+			scriptRoot: host.context.cwd
+		}),
+		service: new DefaultComputerUseExtensionService(client)
+	};
+	let state = broker.state();
+	const restrictionListeners = /* @__PURE__ */ new Set();
+	let stopActivity;
+	let modeOwner;
+	const modeSelected = () => (host.context.selection.state?.["minor-mode"] ?? []).includes(COMPUTER_USE_MODE_ID);
+	const publishMode = () => modeOwner?.publish();
+	const applyState = (next) => {
+		state = next;
+		host.context.client.setStatus(COMPUTER_USE_STATUS_KEY, next === void 0 || next.phase === "inactive" ? void 0 : `computer use: ${next.phase}`);
+		publishMode();
+		for (const listener of restrictionListeners) listener();
+	};
+	const selectMode = async (enabled) => {
+		const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== COMPUTER_USE_MODE_ID);
+		await host.changeSelection({
+			axis: "state",
+			key: "minor-mode",
+			values: enabled ? [...modes, COMPUTER_USE_MODE_ID] : modes
+		});
+		publishMode();
+	};
+	const refresh = async (signal) => {
+		if (!client) {
+			applyState(void 0);
+			return;
+		}
+		try {
+			applyState(await client.state(signal));
+		} catch {
+			applyState(void 0);
+		}
+	};
+	const requireActive = () => {
+		if (!desktop.available || desktop.enabled === false || !modeSelected() || state?.phase !== "active") throw new Error("Computer use is not active for this session.");
+		return client;
+	};
+	modeOwner = defineMinorMode({
+		descriptor: {
+			source: SOURCE,
+			id: COMPUTER_USE_MODE_ID,
+			label: "Computer Use",
+			description: "Session-scoped semantic control through Po Desktop.",
+			order: 450,
+			actions: [
+				{
+					id: "activate",
+					label: "Activate",
+					description: "Enable computer use for this session.",
+					contexts: ["headless"],
+					parameters: []
+				},
+				{
+					id: "deactivate",
+					label: "Deactivate",
+					description: "Stop this session computer-use run.",
+					contexts: ["headless"],
+					parameters: []
+				},
+				{
+					id: "doctor",
+					label: "Doctor",
+					description: "Report Desktop availability and session state.",
+					contexts: ["headless"],
+					parameters: []
+				}
+			]
+		},
+		state: () => {
+			const mode = modeState(state, modeSelected());
+			return desktop.enabled === false ? {
+				...mode,
+				condition: "blocked",
+				detail: "Enable computer use in global Desktop settings.",
+				actions: mode.actions.map((action) => ({
+					...action,
+					enabled: false,
+					disabledReason: "Enable computer use in global Desktop settings."
+				}))
+			} : mode;
+		},
+		async handleAction(_runtime, actionId, _argumentsValue, execution) {
+			execution.signal.throwIfAborted();
+			if (actionId === "activate") {
+				if (!desktop.available || desktop.enabled === false) throw new Error("Enable computer use in global Desktop settings first.");
+				await selectMode(true);
+				await refresh(execution.signal);
+				return { message: "Computer use is ready to configure in Activity." };
+			}
+			if (actionId === "doctor") {
+				await refresh(execution.signal);
+				return { message: client ? `Computer use is ${state?.phase ?? "unavailable"}.` : "Po Desktop session API is unavailable." };
+			}
+			if (actionId === "deactivate") {
+				if (client && state?.phase !== void 0 && state.phase !== "inactive" && state.phase !== "failed") await client.stop(execution.signal);
+				await selectMode(false);
+				await refresh(execution.signal);
+				return { message: "Computer use deactivated." };
+			}
+			throw new Error(`Unknown computer-use action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	const unsubscribeState = client.subscribeStatus?.(applyState);
+	return {
+		api: [{
+			basePath: API_BASE_PATH,
+			start: () => broker
+		}],
+		services: [(context) => {
+			const fiber = context.plugin(serverMinorModes([modeOwner]));
+			context.effect(() => desktop.subscribe(() => {
+				if (!desktop.available) fiber.dispose();
+			}));
+		}],
+		toolRestrictions: [{
+			source: SOURCE,
+			restrict: () => ({ excludedTools: desktop.available && desktop.enabled !== false && modeSelected() && state?.phase === "active" ? [] : [
+				"computer_state",
+				"computer_action",
+				"computer_exec"
+			] }),
+			subscribe: (listener) => {
+				restrictionListeners.add(listener);
+				return () => {
+					restrictionListeners.delete(listener);
+				};
+			}
+		}],
+		activities: [{
+			when: {
+				state: { "minor-mode": COMPUTER_USE_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: COMPUTER_USE_MODE_ID
+				}
+			},
+			name: SOURCE,
+			async start() {
+				await refresh();
+				stopActivity = () => {
+					client.stop();
+				};
+				return () => {
+					stopActivity?.();
+					stopActivity = void 0;
+				};
+			}
+		}],
+		tools: [
+			{
+				when: {
+					state: { "minor-mode": COMPUTER_USE_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: COMPUTER_USE_MODE_ID
+					}
+				},
+				name: "computer_state",
+				label: "Computer State",
+				description: "Observe the authorized application window and return semantic accessibility state.",
+				parameters: {
+					type: "object",
+					properties: { includeScreenshot: { type: "boolean" } },
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, _parameters, signal) {
+					try {
+						return computerObservationOutput(await requireActive().observe(signal, { includeScreenshot: _parameters.includeScreenshot !== false }));
+					} catch (error) {
+						return output(error instanceof Error ? error.message : String(error), true);
+					}
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": COMPUTER_USE_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: COMPUTER_USE_MODE_ID
+					}
+				},
+				name: "computer_action",
+				label: "Computer Action",
+				description: "Perform one constrained semantic action in the authorized application window.",
+				parameters: {
+					type: "object",
+					properties: {
+						kind: {
+							type: "string",
+							enum: [
+								"press",
+								"focus",
+								"set_value",
+								"scroll"
+							]
+						},
+						snapshotId: {
+							type: "string",
+							minLength: 1
+						},
+						elementRef: {
+							type: "string",
+							minLength: 1
+						},
+						value: { type: "string" },
+						direction: {
+							type: "string",
+							enum: [
+								"up",
+								"down",
+								"left",
+								"right"
+							]
+						},
+						amount: {
+							type: "string",
+							enum: ["line", "page"]
+						}
+					},
+					required: [
+						"kind",
+						"snapshotId",
+						"elementRef"
+					],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					try {
+						const result = await requireActive().act(parameters, signal);
+						await refresh(signal);
+						return output(result);
+					} catch (error) {
+						return output(error instanceof Error ? error.message : String(error), true);
+					}
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": COMPUTER_USE_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: COMPUTER_USE_MODE_ID
+					}
+				},
+				name: "computer_exec",
+				label: "Computer Script",
+				description: "Run a reusable function with only the authorized program API. Relative helpers are supported. Full Node requires trusted:true and an explicitly allowlisted path.",
+				parameters: {
+					type: "object",
+					properties: {
+						scriptPath: {
+							type: "string",
+							minLength: 1
+						},
+						input: {},
+						trusted: { type: "boolean" },
+						includeScreenshot: { type: "boolean" }
+					},
+					required: ["scriptPath", "input"],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					try {
+						requireActive();
+						if (!dependencies.scriptRunner) throw new Error("Computer script execution is unavailable.");
+						const input = parameters;
+						return computerScriptOutput(await dependencies.scriptRunner.execute(input.scriptPath, input.input, signal, input));
+					} catch (error) {
+						return computerScriptFailure(error);
+					}
+				}
+			}
+		],
+		commands: [{
+			name: COMMAND_NAME,
+			description: COMMAND_DESCRIPTION,
+			async execute(args, execution) {
+				const result = await dependencies.service.execute();
+				await execution.client.notify({
+					body: result.message,
+					level: result.level
+				});
+				if (args.trim() === "deactivate" && client && state?.phase !== "inactive" && state?.phase !== "failed") {
+					await client.stop();
+					await host.changeSelection({
+						axis: "state",
+						key: "minor-mode",
+						values: (execution.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== COMPUTER_USE_MODE_ID)
+					});
+					await refresh();
+				}
+			}
+		}],
+		hooks: [{
+			when: {
+				state: { "minor-mode": COMPUTER_USE_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: COMPUTER_USE_MODE_ID
+				}
+			},
+			event: "before_agent_start",
+			handle(event) {
+				if (state?.phase !== "active") return void 0;
+				return { systemPrompt: `${typeof event.systemPrompt === "string" ? event.systemPrompt : ""}\n\n${GUIDANCE}`.trim() };
+			}
+		}, {
+			when: {
+				state: { "minor-mode": COMPUTER_USE_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: COMPUTER_USE_MODE_ID
+				}
+			},
+			event: "session_shutdown",
+			handle: async () => {
+				stopActivity?.();
+				if (client && state?.phase !== "inactive" && state?.phase !== "failed") await client.stop();
+			}
+		}],
+		onDispose() {
+			stopActivity?.();
+			stopActivity = void 0;
+			unsubscribeState?.();
+			broker.close();
+			restrictionListeners.clear();
+			host.context.client.setStatus(COMPUTER_USE_STATUS_KEY, void 0);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_runtime/index.server.ts
+var index_server_default = (({ agent, host }) => agent ? createComputerUseServer(agent, host.context) : {
+	tools: [],
+	commands: []
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot((context) => {
+	const value = index_server_default(context);
+	return {
+		value,
+		services: [...value.services ?? [], ...value.tools?.length ? [mountMcpTools(value.tools)] : []],
+		activities: value.activities,
+		onStop: value.onStop,
+		onDispose: value.onDispose
+	};
+});
+//#endregion
+//#region src/services/webComputerUseAvailability/index.ts
+var MissingComputerUseApiError = class extends Error {};
+function computerUseSessionApiError(status, value) {
+	const error = typeof value === "object" && value !== null && !Array.isArray(value) ? value.error : void 0;
+	const message = typeof error === "string" ? error : `HTTP ${String(status)}`;
+	return status === 404 && message === `No API 'computer-use' in this session.` ? new MissingComputerUseApiError(message) : new Error(message);
+}
+//#endregion
+//#region src/services/webComputerUseChannel/index.ts
+/** Computer use runs on the Po Desktop host, so every other client declines it. */
+const DESKTOP_UNAVAILABLE = "Po Desktop computer use is unavailable.";
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function command(value) {
+	const input = record(value);
+	return input?.action === "status" || input?.action === "targets" || input?.action === "stop" || input?.action === "artifacts" ? { action: input.action } : void 0;
+}
+async function responseJson(response) {
+	const value = await response.json();
+	if (!response.ok) throw computerUseSessionApiError(response.status, value);
+	return value;
+}
+function sessionState(value) {
+	const input = record(value);
+	if (typeof input?.sessionId !== "string" || typeof input.revision !== "number" || typeof input.wake !== "number" || ![
+		"inactive",
+		"awaiting_confirmation",
+		"activating",
+		"active",
+		"stopping",
+		"failed"
+	].includes(input.phase)) return void 0;
+	return input;
+}
+function createComputerUseChannel() {
+	let receiveCommand;
+	return {
+		frameType: computerUseChannelType,
+		lifecycle: "hub",
+		start(host) {
+			const scopes = /* @__PURE__ */ new Map();
+			const latest = /* @__PURE__ */ new Map();
+			const targets = /* @__PURE__ */ new Map();
+			const grants = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			const processing = /* @__PURE__ */ new Set();
+			const rerun = /* @__PURE__ */ new Map();
+			const requests = /* @__PURE__ */ new Map();
+			let activeSessionId;
+			let closed = false;
+			const sessionRequest = async (scope, path, method = "GET", value) => host.requestSessionApi(scope, {
+				basePath: API_BASE_PATH,
+				path,
+				method,
+				...value === void 0 ? {} : { body: JSON.stringify(value) }
+			});
+			const publish = (scope, state) => {
+				if (state.phase === "active" || state.phase === "activating" || state.phase === "stopping") activeSessionId = scope.sessionId;
+				else if (activeSessionId === scope.sessionId) {
+					activeSessionId = void 0;
+					grants.delete(scope.sessionId);
+				}
+				const payload = {
+					state,
+					targets: targets.get(scope.sessionId) ?? [],
+					...activeSessionId !== void 0 && activeSessionId !== scope.sessionId ? { busy: true } : {}
+				};
+				latest.set(scope.sessionId, payload);
+				host.publish(scope.sessionId, payload);
+			};
+			const refresh = async (scope) => {
+				const state = sessionState(await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubState)));
+				if (state === void 0) throw new Error("Computer-use API returned an invalid session state.");
+				publish(scope, state);
+				return state;
+			};
+			const completePending = async (scope, pending) => {
+				if (!host.computerUse?.available) throw new Error(DESKTOP_UNAVAILABLE);
+				const controller = new AbortController();
+				requests.set(scope.sessionId, controller);
+				try {
+					const result = await host.computerUse.request(scope, {
+						operation: pending.operation,
+						signal: controller.signal,
+						payload: pending.operation === "act" ? {
+							grantId: pending.grantId,
+							sequence: pending.sequence,
+							action: pending.payload
+						} : {
+							grantId: pending.grantId,
+							includeScreenshot: record(pending.payload)?.includeScreenshot !== false
+						}
+					});
+					await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubComplete, "POST", {
+						id: pending.id,
+						result
+					}));
+				} catch (error) {
+					await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubComplete, "POST", {
+						id: pending.id,
+						error: error instanceof Error ? error.message : String(error)
+					}));
+				} finally {
+					if (requests.get(scope.sessionId) === controller) requests.delete(scope.sessionId);
+				}
+			};
+			const stopSession = async (scope) => {
+				requests.get(scope.sessionId)?.abort();
+				const authorization = await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubAuthorization));
+				let artifact;
+				if (authorization !== null && host.computerUse?.available) try {
+					artifact = record(await host.computerUse.request(scope, {
+						operation: "stop",
+						payload: { grantId: authorization.grantId }
+					}))?.artifact;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					artifact = {
+						artifactId: randomUUID(),
+						status: "failed",
+						failure: {
+							code: "recording_failed",
+							message: message.slice(0, 512)
+						}
+					};
+					host.onNotice(`computer-use Desktop stop was already unavailable (${message})`);
+				}
+				await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubStop, "POST", { artifact }));
+				grants.delete(scope.sessionId);
+				if (activeSessionId === scope.sessionId) activeSessionId = void 0;
+			};
+			const processScope = async (scope, announced) => {
+				if (closed || !scopes.has(scope.sessionId)) return;
+				if (processing.has(scope.sessionId)) {
+					rerun.set(scope.sessionId, announced);
+					return;
+				}
+				processing.add(scope.sessionId);
+				try {
+					const state = announced ?? await refresh(scope);
+					if (state.phase === "active") {
+						if (!grants.has(scope.sessionId)) {
+							const authorization = await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubAuthorization));
+							if (authorization !== null) grants.set(scope.sessionId, authorization.grantId);
+						}
+						const expired = typeof state.expiresAt === "number" && state.expiresAt <= Date.now();
+						let owned = false;
+						if (!expired && host.computerUse?.available) try {
+							owned = record(await host.computerUse.request(scope, { operation: "status" }))?.ownedBySession === true;
+						} catch {
+							owned = false;
+						}
+						if (expired || !owned) {
+							await stopSession(scope);
+							await refresh(scope);
+							return;
+						}
+					}
+					if (state.phase === "awaiting_confirmation" && (activeSessionId === void 0 || activeSessionId === scope.sessionId)) {
+						const activation = await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubActivation));
+						if (activation !== null && !host.computerUse?.available) {
+							await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubStop, "POST", { error: DESKTOP_UNAVAILABLE }));
+							await refresh(scope);
+							return;
+						}
+						if (activation !== null && host.computerUse?.available) {
+							activeSessionId = scope.sessionId;
+							const controller = new AbortController();
+							requests.set(scope.sessionId, controller);
+							try {
+								const hostResult = await host.computerUse.request(scope, {
+									operation: "activate",
+									payload: activation,
+									signal: controller.signal
+								});
+								await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubStop, "POST", { host: hostResult }));
+								const grantId = record(hostResult)?.grantId;
+								if (typeof grantId === "string") grants.set(scope.sessionId, grantId);
+							} catch (error) {
+								activeSessionId = void 0;
+								await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubStop, "POST", { error: error instanceof Error ? error.message : String(error) }));
+							} finally {
+								if (requests.get(scope.sessionId) === controller) requests.delete(scope.sessionId);
+							}
+							await refresh(scope);
+						}
+					}
+					if (state.phase === "stopping") {
+						await stopSession(scope);
+						await refresh(scope);
+					}
+					const pending = await responseJson(await sessionRequest(scope, COMPUTER_USE_ROUTES.hubNext));
+					if (pending !== null) await completePending(scope, pending);
+				} catch (error) {
+					if (error instanceof MissingComputerUseApiError) latest.delete(scope.sessionId);
+					else host.onNotice(`computer-use state handling failed for ${scope.sessionId} (${error instanceof Error ? error.message : String(error)})`);
+				} finally {
+					processing.delete(scope.sessionId);
+					if (!closed && scopes.has(scope.sessionId) && rerun.has(scope.sessionId)) {
+						const next = rerun.get(scope.sessionId);
+						rerun.delete(scope.sessionId);
+						queueMicrotask(() => {
+							processScope(scope, next);
+						});
+					}
+				}
+			};
+			const onState = (scope, payload) => {
+				const state = sessionState(payload);
+				if (state === void 0 || state.sessionId !== scope.sessionId) return;
+				if (state.phase === "stopping" || state.phase === "failed" || state.phase === "inactive") requests.get(scope.sessionId)?.abort();
+				publish(scope, state);
+				processScope(scope, state);
+			};
+			receiveCommand = (scope, payload) => {
+				const parsed = command(payload);
+				if (parsed === void 0) return;
+				(async () => {
+					try {
+						if (parsed.action === "targets") {
+							const result = host.computerUse?.available ? await host.computerUse.request(scope, { operation: "targets" }) : [];
+							targets.set(scope.sessionId, Array.isArray(result) ? result.filter((item) => record(item) !== void 0) : []);
+						} else if (parsed.action === "stop") await stopSession(scope);
+						await refresh(scope);
+						processScope(scope);
+					} catch (error) {
+						if (error instanceof MissingComputerUseApiError) latest.delete(scope.sessionId);
+						else host.onNotice(`computer-use command failed for ${scope.sessionId} (${error instanceof Error ? error.message : String(error)})`);
+					}
+				})();
+			};
+			return {
+				payloadFor: (scope) => latest.get(scope.sessionId),
+				sessionAdded(scope) {
+					scopes.set(scope.sessionId, scope);
+					const unsubscribe = host.directEvents.subscribe(computerUseChannelType, scope.sessionId, (payload) => onState(scope, payload), { replayLatest: true });
+					subscriptions.set(scope.sessionId, unsubscribe);
+					processScope(scope);
+				},
+				sessionRemoved(sessionId) {
+					requests.get(sessionId)?.abort();
+					requests.delete(sessionId);
+					rerun.delete(sessionId);
+					const scope = scopes.get(sessionId);
+					const grantId = grants.get(sessionId);
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					if (scope !== void 0 && grantId !== void 0 && host.computerUse?.available) host.computerUse.request(scope, {
+						operation: "stop",
+						payload: { grantId }
+					}).catch((error) => host.onNotice(`computer-use session cleanup failed (${error instanceof Error ? error.message : String(error)})`));
+					scopes.delete(sessionId);
+					latest.delete(sessionId);
+					targets.delete(sessionId);
+					grants.delete(sessionId);
+					processing.delete(sessionId);
+					if (activeSessionId === sessionId) activeSessionId = void 0;
+				},
+				close() {
+					closed = true;
+					for (const controller of requests.values()) controller.abort();
+					requests.clear();
+					rerun.clear();
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					if (host.computerUse?.available) for (const [sessionId, grantId] of grants) {
+						const scope = scopes.get(sessionId);
+						if (scope !== void 0) host.computerUse.request(scope, {
+							operation: "stop",
+							payload: { grantId }
+						}).catch(() => void 0);
+					}
+					scopes.clear();
+					latest.clear();
+					targets.clear();
+					grants.clear();
+				}
+			};
+		},
+		receive(scope, payload, connection) {
+			if (connection.desktopAuthorized !== true && connection.computerUseAuthorized !== true) return;
+			receiveCommand?.(scope, payload);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/computer-use.server.ts
+var computer_use_server_default$2 = defineChannel(createComputerUseChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/computer-use/route.server.ts
+var route_server_default = defineRoutedContribution((context) => context.root.api?.find((api) => api.basePath === "computer-use"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/computer-use.server.ts
+var computer_use_server_default$1 = defineRoutedContribution((context) => context.root.commands.find((command) => command.name === "computer-use"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/before-agent-start.server.ts
+var before_agent_start_server_default = defineRoutedContribution((context) => context.root.hooks?.find((hook) => hook.event === "before_agent_start"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineRoutedContribution((context) => context.root.hooks?.find((hook) => hook.event === "session_shutdown"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/computer-use.server.ts
+var computer_use_server_default = defineRoutedContribution((context) => context.root.toolRestrictions?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/00-computer-state.server.ts
+var _00_computer_state_server_default = defineRoutedContribution((context) => context.root.tools.find((tool) => tool.name === "computer_state"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/10-computer-action.server.ts
+var _10_computer_action_server_default = defineRoutedContribution((context) => context.root.tools.find((tool) => tool.name === "computer_action"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/20-computer-exec.server.ts
+var _20_computer_exec_server_default = defineRoutedContribution((context) => context.root.tools.find((tool) => tool.name === "computer_exec"), { cardinality: "optional" });
+//#endregion
+//#region generated/server.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 facet = defineServerPlugin({
+	name: "@agimon-ai/po-computer-use",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	global: () => ({ get channels() {
+		return [() => via({ frameType: "computer_use" }, computer_use_server_default$2())];
+	} }),
+	workspace: () => ({ get channels() {
+		return [() => via({ frameType: "computer_use" }, computer_use_server_default$2())];
+	} }),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return defined([at(route_server_default, contextSession)]);
+			},
+			get channels() {
+				return [() => via({ frameType: "computer_use" }, computer_use_server_default$2())];
+			},
+			get commands() {
+				return defined([via({ name: "computer-use" }, at(computer_use_server_default$1, contextSession))]);
+			},
+			get hooks() {
+				return defined([via({ event: "before_agent_start" }, at(before_agent_start_server_default, contextSession)), via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession))]);
+			},
+			get toolRestrictions() {
+				return defined([at(computer_use_server_default, contextSession)]);
+			},
+			get tools() {
+				return defined([
+					via({ name: "00_computer_state" }, at(_00_computer_state_server_default, contextSession)),
+					via({ name: "10_computer_action" }, at(_10_computer_action_server_default, contextSession)),
+					via({ name: "20_computer_exec" }, at(_20_computer_exec_server_default, contextSession))
+				]);
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map