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

package/dist/extensions/web.mjs

@@ -0,0 +1,771 @@
+import { apiResponse, createApiClient, defineActivityGroup, defineApiRoutes, defineChannelFile, defineFill, defineMinorModeFile, defineSessionStore, defineSettingsSection, defineToolRenderer, defineWebPlugin, sessionApiAddress, toolResultTextLines } from "@agimon-ai/po-core/web";
+import { Button, MessageItem, MessageItemBody, MessageItemHeader, MessageItemStatus, MessageLines, collapseLines, toolTone } from "@agimon-ai/po-web-components";
+import { useStore } from "@tanstack/react-store";
+import { useEffect, useState } from "react";
+import { sealedTransport } from "@agimon-ai/po-web-security/browser";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/extensions/(frontend)/_lib/computerUseSettings.ts
+const computerUseSettingsSection = {
+	id: "computer-use",
+	desktopOnly: true,
+	label: "computer use",
+	detail: "control whether Po Desktop may expose session-scoped computer control",
+	order: 45,
+	fields: [{
+		id: "enabled",
+		label: "enable computer use",
+		kind: "toggle",
+		keyPath: ["computerUse", "enabled"],
+		detail: "Makes the computer-use minor mode available. Each control session still requires native confirmation."
+	}]
+};
+//#endregion
+//#region src/extensions/(frontend)/setting/computer-use.web.ts
+var computer_use_web_default$3 = defineSettingsSection({ settingsSections: [computerUseSettingsSection] }.settingsSections[0]);
+//#endregion
+//#region src/extensions/workspaces/(frontend)/setting/computer-use.web.ts
+var computer_use_web_default$2 = defineSettingsSection({ settingsSections: [computerUseSettingsSection] }.settingsSections[0]);
+//#endregion
+//#region src/types/computerUseApi.ts
+const computerUseChannelType = "computer_use_state";
+const COMPUTER_USE_MODE_ID = "computer-use";
+const COMPUTER_USE_STATUS_KEY = "doom-computer-use";
+const COMPUTER_USE_MODE_STATUS_KEY = "doom-computer-use-mode";
+const COMPUTER_USE_DEFAULT_DURATION_MS = 3e5;
+/**
+* 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 computerUse = defineSessionStore({
+	state: {
+		sessionId: "",
+		revision: 0,
+		wake: 0,
+		phase: "inactive"
+	},
+	targets: []
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const computerUseChannel = computerUse.channel({
+	channel: computerUseChannelType,
+	parse(input) {
+		if (!isRecord(input) || !isRecord(input.state) || !Array.isArray(input.targets)) return null;
+		if (typeof input.state.phase !== "string" || typeof input.state.revision !== "number") return null;
+		return input;
+	},
+	reduce: (_current, payload) => payload
+});
+//#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()
+	}
+});
+const api = createApiClient(apiRoutes_default, {
+	scopes: ["session"],
+	basePath: "computer-use",
+	transport: (input, init) => sealedTransport.fetch(input, init),
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/computerUseRecording.ts
+const MAX_RECORDING_BYTES = 134217728;
+const CHUNK_BYTES = 1048576;
+/** Owns only a bounded sealed download and its disposable browser URL. */
+async function loadComputerUseRecording(sessionId, artifactId, sizeBytes, signal) {
+	if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 1 || sizeBytes > MAX_RECORDING_BYTES) throw new Error("Recording exceeds the permitted size.");
+	const parts = [];
+	for (let offset = 0; offset < sizeBytes; offset += CHUNK_BYTES) {
+		signal.throwIfAborted();
+		const result = await api.session(sessionId).artifact({
+			query: {
+				artifactId,
+				offset
+			},
+			signal
+		});
+		if (!result.ok || result.status !== 206) throw new Error("The recording is unavailable or access was revoked.");
+		const end = Math.min(offset + CHUNK_BYTES, sizeBytes) - 1;
+		if (result.response.headers.get("content-range") !== `bytes ${offset}-${end}/${sizeBytes}`) throw new Error("The recording response is invalid.");
+		const bytes = await result.response.arrayBuffer();
+		signal.throwIfAborted();
+		if (bytes.byteLength !== end - offset + 1) throw new Error("The recording response is incomplete.");
+		parts.push(bytes);
+	}
+	signal.throwIfAborted();
+	const url = URL.createObjectURL(new Blob(parts, { type: "video/mp4" }));
+	let disposed = false;
+	return {
+		url,
+		dispose() {
+			if (!disposed) {
+				disposed = true;
+				URL.revokeObjectURL(url);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/ComputerUsePanel.tsx
+function text(value, fallback) {
+	return typeof value === "string" || typeof value === "number" ? String(value) : fallback;
+}
+function ComputerUsePanel({ sessionId, sendSessionFrame }) {
+	const session = useStore(computerUse.store, (state) => computerUse.select(state, sessionId));
+	const [selected, setSelected] = useState(0);
+	const [confirmationTarget, setConfirmationTarget] = useState();
+	const [error, setError] = useState();
+	const [recordingUrl, setRecordingUrl] = useState();
+	const [recordingAccessDenied, setRecordingAccessDenied] = useState(false);
+	const send = (payload) => {
+		if (sessionId !== null) sendSessionFrame(sessionId, {
+			type: computerUseChannelType,
+			payload
+		});
+	};
+	useEffect(() => {
+		if (sessionId === null) return;
+		sendSessionFrame(sessionId, {
+			type: computerUseChannelType,
+			payload: { action: "status" }
+		});
+		sendSessionFrame(sessionId, {
+			type: computerUseChannelType,
+			payload: { action: "targets" }
+		});
+	}, [sendSessionFrame, sessionId]);
+	useEffect(() => {
+		if (sessionId === null) return;
+		const controller = new AbortController();
+		let timer;
+		const poll = async () => {
+			try {
+				const result = await api.session(sessionId).activationState({ signal: controller.signal });
+				if (controller.signal.aborted) return;
+				setRecordingAccessDenied(!result.ok);
+				if (result.ok) computerUse.update(sessionId, (current) => result.data.revision >= current.state.revision ? {
+					...current,
+					state: result.data
+				} : current);
+			} catch {
+				if (!controller.signal.aborted) setRecordingAccessDenied(true);
+			}
+			if (!controller.signal.aborted) timer = setTimeout(() => void poll(), 2e3);
+		};
+		poll();
+		return () => {
+			controller.abort();
+			clearTimeout(timer);
+		};
+	}, [sessionId]);
+	const artifactId = session.state.artifact?.artifactId;
+	const artifactSize = session.state.artifact?.sizeBytes;
+	const artifactStatus = session.state.artifact?.status;
+	useEffect(() => {
+		setRecordingUrl(void 0);
+		if (recordingAccessDenied || sessionId === null || artifactId === void 0 || artifactSize === void 0 || artifactStatus !== "ready") return;
+		const controller = new AbortController();
+		let asset;
+		loadComputerUseRecording(sessionId, artifactId, artifactSize, controller.signal).then((loaded) => {
+			if (controller.signal.aborted) loaded.dispose();
+			else {
+				asset = loaded;
+				setRecordingUrl(loaded.url);
+			}
+		}).catch(() => {
+			if (!controller.signal.aborted) setError("The recording is unavailable or access was revoked.");
+		});
+		return () => {
+			controller.abort();
+			asset?.dispose();
+		};
+	}, [
+		sessionId,
+		artifactId,
+		artifactSize,
+		artifactStatus,
+		recordingAccessDenied
+	]);
+	if (sessionId === null) return /* @__PURE__ */ jsx("p", {
+		className: "px-1 text-sm text-doom-dim",
+		children: "Select a session."
+	});
+	const state = session.state;
+	const target = session.targets[selected];
+	const artifact = state.artifact;
+	const confirm = async (chosenTarget = confirmationTarget) => {
+		setError(void 0);
+		try {
+			const result = await api.session(sessionId).activate({ body: {
+				...chosenTarget === void 0 ? {} : { target: chosenTarget },
+				durationMs: COMPUTER_USE_DEFAULT_DURATION_MS
+			} });
+			if (!result.ok) {
+				if (result.status === 0) setError("The session is unreachable.");
+				else setError(result.error === "" ? `Activation failed with HTTP ${result.status}.` : result.error);
+				return;
+			}
+			setConfirmationTarget(void 0);
+			computerUse.update(sessionId, (current) => ({
+				...current,
+				state: result.data
+			}));
+			send({ action: "status" });
+		} catch {
+			setError("The activation request is unavailable.");
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "computer-use-panel",
+		className: "flex flex-col gap-2 text-base text-doom-text",
+		children: [
+			/* @__PURE__ */ jsxs("header", {
+				className: "flex items-center justify-between gap-2",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "text-doom-dim",
+					children: state.phase.replaceAll("_", " ")
+				}), /* @__PURE__ */ jsx(Button, {
+					size: "sm",
+					type: "button",
+					className: "min-h-7 rounded border border-doom-border bg-doom-panel px-2 py-1",
+					onClick: () => send({ action: "targets" }),
+					children: "Refresh targets"
+				})]
+			}),
+			session.busy ? /* @__PURE__ */ jsx("p", {
+				className: "rounded border border-doom-yellow px-2 py-1",
+				children: "Computer use is busy in another session"
+			}) : null,
+			state.failure ? /* @__PURE__ */ jsx("p", {
+				className: "text-doom-red",
+				children: state.failure.message
+			}) : null,
+			error ? /* @__PURE__ */ jsx("p", {
+				className: "text-doom-red",
+				children: error
+			}) : null,
+			(state.phase === "inactive" || state.phase === "failed") && confirmationTarget === void 0 ? /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col gap-2",
+				children: [
+					/* @__PURE__ */ jsx("label", {
+						htmlFor: "computer-use-target",
+						children: "Application window"
+					}),
+					/* @__PURE__ */ jsx("select", {
+						id: "computer-use-target",
+						value: selected,
+						onChange: (event) => setSelected(Number(event.target.value)),
+						className: "min-h-7 rounded border border-doom-border bg-doom-panel px-2 py-1",
+						children: session.targets.map((item, index) => /* @__PURE__ */ jsx("option", {
+							value: index,
+							children: text(item.applicationName, text(item.windowTitle, text(item.windowId, "Window")))
+						}, text(item.windowId, String(index))))
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						size: "sm",
+						type: "button",
+						disabled: Boolean(session.busy),
+						variant: "primary",
+						onClick: () => {
+							if (target === void 0) confirm();
+							else setConfirmationTarget(Object.freeze({ ...target }));
+						},
+						children: target === void 0 ? "Choose window on Mac" : "Request activation"
+					})
+				]
+			}) : null,
+			confirmationTarget !== void 0 ? /* @__PURE__ */ jsxs("div", {
+				className: "rounded border border-doom-blue p-3",
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: "Confirm computer control" }),
+					/* @__PURE__ */ jsxs("p", {
+						className: "my-2 text-doom-text",
+						children: [
+							text(confirmationTarget.applicationName, "Application"),
+							":",
+							" ",
+							text(confirmationTarget.windowTitle, text(confirmationTarget.windowId, "Window"))
+						]
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "my-2 text-doom-dim",
+						children: "Confirm a 5 minute session for this exact application window."
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						className: "flex gap-2",
+						children: [/* @__PURE__ */ jsx(Button, {
+							size: "sm",
+							type: "button",
+							variant: "primary",
+							onClick: () => void confirm(),
+							children: "Confirm"
+						}), /* @__PURE__ */ jsx(Button, {
+							size: "sm",
+							type: "button",
+							className: "min-h-7 rounded border border-doom-border bg-doom-panel px-2 py-1",
+							onClick: () => setConfirmationTarget(void 0),
+							children: "Cancel"
+						})]
+					})
+				]
+			}) : null,
+			state.phase === "awaiting_confirmation" || state.phase === "activating" ? /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", { children: "Desktop activation is pending." }), /* @__PURE__ */ jsx(Button, {
+				size: "sm",
+				type: "button",
+				onClick: () => {
+					(async () => {
+						try {
+							const result = await api.session(sessionId).cancelActivation();
+							if (!result.ok) setError("The activation could not be cancelled.");
+							else computerUse.update(sessionId, (current) => ({
+								...current,
+								state: result.data
+							}));
+						} catch {
+							setError("The activation could not be cancelled.");
+						}
+					})();
+				},
+				children: "Cancel activation"
+			})] }) : null,
+			state.phase === "active" || state.phase === "stopping" ? /* @__PURE__ */ jsx(Button, {
+				size: "sm",
+				type: "button",
+				disabled: state.phase === "stopping",
+				className: "min-h-7 rounded border border-doom-border bg-doom-panel px-2 py-1",
+				onClick: () => send({ action: "stop" }),
+				children: "Stop computer use"
+			}) : null,
+			artifact ? /* @__PURE__ */ jsxs("div", {
+				"data-testid": "computer-use-artifact",
+				className: "rounded bg-doom-panel p-2",
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: artifact.status === "ready" ? "Completed recording" : "Recording unavailable" }),
+					/* @__PURE__ */ jsxs("p", { children: ["ID: ", artifact.artifactId] }),
+					/* @__PURE__ */ jsxs("p", { children: ["Status: ", artifact.status] }),
+					artifact.failure ? /* @__PURE__ */ jsx("p", {
+						className: "text-doom-red",
+						children: artifact.failure.message
+					}) : null,
+					artifact.completedAt ? /* @__PURE__ */ jsxs("p", { children: ["Completed: ", artifact.completedAt] }) : null,
+					artifact.actionCount !== void 0 ? /* @__PURE__ */ jsxs("p", { children: ["Actions: ", artifact.actionCount] }) : null,
+					artifact.status === "ready" && artifact.sizeBytes && !recordingUrl ? /* @__PURE__ */ jsx("p", { children: "Loading recording through the secure channel." }) : null,
+					artifact.status === "ready" && recordingUrl ? /* @__PURE__ */ jsx("video", {
+						className: "mt-2 w-full",
+						controls: true,
+						preload: "metadata",
+						src: recordingUrl,
+						children: /* @__PURE__ */ jsx("track", { kind: "captions" })
+					}) : null,
+					artifact.status === "ready" && recordingUrl ? /* @__PURE__ */ jsx("a", {
+						className: "mt-2 inline-block text-doom-blue",
+						href: recordingUrl,
+						download: "Po-recording.mp4",
+						children: "Download recording"
+					}) : null
+				]
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/computerActionToolRender.ts
+const computerActionToolName = "computer_action";
+function computerActionCallSummary(args) {
+	return [typeof args.kind === "string" ? args.kind : "", typeof args.elementRef === "string" ? args.elementRef : ""].filter(Boolean).join(" ");
+}
+/**
+* The body as toned lines: what the result's details say, or its text. Pure,
+* so a unit test can pin it without a DOM; the item decides how many to show.
+*/
+function computerActionResultLines(result) {
+	if (result === null) return [];
+	return toolResultTextLines(result.content).map((text) => ({
+		text,
+		tone: "dim"
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/ComputerActionToolCard.tsx
+/**
+* The computer_action tool's timeline item: Perform one constrained semantic action in the authorized application window. The shell owns
+* the frame, the outcome tone, the status badge, and the expand toggle; this
+* card supplies the header summary and the body lines, and says whether it
+* hides any so the toggle appears only when it reveals something.
+*/
+function ComputerActionToolCard({ toolName, args, result, running, isError }) {
+	const lines = computerActionResultLines(result);
+	const collapsed = collapseLines(lines, 8, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, 8, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: /* @__PURE__ */ jsx("span", {
+					"data-testid": `tool-call-${toolName}`,
+					className: "min-w-0 flex-1 truncate text-doom-text",
+					children: computerActionCallSummary(args)
+				})
+			}), view.shown.length > 0 || running || isError ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": `tool-result-${toolName}`,
+				className: "flex flex-col gap-1",
+				children: [
+					view.shown.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: view.shown }) : null,
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					running ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "running",
+						children: "running"
+					}) : null,
+					isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "error",
+						children: "failed"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/computerExecToolRender.ts
+const computerExecToolName = "computer_exec";
+function computerExecCallSummary(args) {
+	return typeof args.scriptPath === "string" ? args.scriptPath : "";
+}
+function computerExecResultLines(result) {
+	if (result === null) return [];
+	return toolResultTextLines(result.content).map((text) => ({
+		text,
+		tone: "dim"
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/ComputerExecToolCard.tsx
+function ComputerExecToolCard({ toolName, args, result, running, isError }) {
+	const lines = computerExecResultLines(result);
+	const collapsed = collapseLines(lines, 8, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, 8, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: /* @__PURE__ */ jsx("span", {
+					"data-testid": `tool-call-${toolName}`,
+					className: "min-w-0 flex-1 truncate text-doom-text",
+					children: computerExecCallSummary(args)
+				})
+			}), view.shown.length > 0 || running || isError ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": `tool-result-${toolName}`,
+				className: "flex flex-col gap-1",
+				children: [
+					view.shown.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: view.shown }) : null,
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					running ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "running",
+						children: "running"
+					}) : null,
+					isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "error",
+						children: "failed"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/computerStateToolRender.ts
+const computerStateToolName = "computer_state";
+function computerStateCallSummary(_args) {
+	return "authorized window";
+}
+/**
+* The body as toned lines: what the result's details say, or its text. Pure,
+* so a unit test can pin it without a DOM; the item decides how many to show.
+*/
+function computerStateResultLines(result) {
+	if (result === null) return [];
+	return toolResultTextLines(result.content).map((text) => ({
+		text,
+		tone: "dim"
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/ComputerStateToolCard.tsx
+/**
+* The computer_state tool's timeline item: Observe the authorized application window and semantic accessibility state. The shell owns
+* the frame, the outcome tone, the status badge, and the expand toggle; this
+* card supplies the header summary and the body lines, and says whether it
+* hides any so the toggle appears only when it reveals something.
+*/
+function ComputerStateToolCard({ toolName, args, result, running, isError }) {
+	const lines = computerStateResultLines(result);
+	const collapsed = collapseLines(lines, 8, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, 8, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: /* @__PURE__ */ jsx("span", {
+					"data-testid": `tool-call-${toolName}`,
+					className: "min-w-0 flex-1 truncate text-doom-text",
+					children: computerStateCallSummary(args)
+				})
+			}), view.shown.length > 0 || running || isError ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": `tool-result-${toolName}`,
+				className: "flex flex-col gap-1",
+				children: [
+					view.shown.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: view.shown }) : null,
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					running ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "running",
+						children: "running"
+					}) : null,
+					isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "error",
+						children: "failed"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_legacy/index.ts
+var _legacy_default = {
+	minorModes: [{
+		name: "computer use",
+		modeId: COMPUTER_USE_MODE_ID,
+		keys: "c e",
+		statusKey: COMPUTER_USE_MODE_STATUS_KEY,
+		hideWhenMissing: true,
+		desktopOnly: true,
+		order: 70
+	}],
+	activityGroups: [{
+		name: "computer-use",
+		keys: "c e",
+		order: 70,
+		statusKey: COMPUTER_USE_STATUS_KEY,
+		hideWhenEmpty: true,
+		desktopOnly: true,
+		marksBackgroundWork: false
+	}],
+	activitySections: [{
+		id: "computer-use",
+		component: ComputerUsePanel
+	}],
+	channels: [computerUseChannel],
+	toolRenderers: [
+		{
+			tools: [computerStateToolName],
+			message: ComputerStateToolCard
+		},
+		{
+			tools: [computerActionToolName],
+			message: ComputerActionToolCard
+		},
+		{
+			tools: [computerExecToolName],
+			message: ComputerExecToolCard
+		}
+	]
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/computer-use.web.ts
+var computer_use_web_default$1 = defineActivityGroup(_legacy_default.activityGroups[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/computer-use.web.ts
+var computer_use_web_default = defineChannelFile(_legacy_default.channels[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/ComputerUse.activity.computer-use.web.tsx
+var ComputerUse_activity_computer_use_web_default = defineFill({
+	slot: "activity.computer-use",
+	..._legacy_default.activitySections[0]
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/mode/computer-use/mode.web.ts
+var mode_web_default = defineMinorModeFile(_legacy_default.minorModes[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer-action.web.tsx
+var computer_action_web_default = defineToolRenderer(_legacy_default.toolRenderers[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer-exec.web.tsx
+var computer_exec_web_default = defineToolRenderer(_legacy_default.toolRenderers[2]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/computer-state.web.tsx
+var computer_state_web_default = defineToolRenderer(_legacy_default.toolRenderers[0]);
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const webPlugin = defineWebPlugin({
+	id: "computer-use",
+	global: { get settingsSections() {
+		return [via({ id: "computer-use" }, computer_use_web_default$3)];
+	} },
+	workspace: { get settingsSections() {
+		return [via({ id: "computer-use" }, computer_use_web_default$2)];
+	} },
+	session: {
+		get activityGroups() {
+			return [via({ name: "computer-use" }, computer_use_web_default$1)];
+		},
+		get channels() {
+			return [via({ channel: "computer_use" }, computer_use_web_default)];
+		},
+		get fills() {
+			return [via({
+				slot: "activity.computer-use",
+				id: "computer-use"
+			}, ComputerUse_activity_computer_use_web_default)];
+		},
+		get minorModes() {
+			return [via({ name: "computer-use" }, mode_web_default)];
+		},
+		get toolRenderers() {
+			return [
+				via({ tools: ["computer_action"] }, computer_action_web_default),
+				via({ tools: ["computer_exec"] }, computer_exec_web_default),
+				via({ tools: ["computer_state"] }, computer_state_web_default)
+			];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map