@mind-harness/mh-browser 0.2.3 → 0.2.5

package/THIRD-PARTY-NOTICES

@@ -0,0 +1,23 @@
+lib/client.cjs includes code from @deepseek-ai/dsh-typert-protocol, distributed under the following license.
+
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Mind Harness",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "permissions": ["tabGroups"],
   "background": { "service_worker": "sw.js" }
 }

package/lib/client.cjs

@@ -0,0 +1,446 @@
+window.__ModuleLoader__.load({
+	id: "@mind-harness/mh-browser",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let zod = require("zod");
+		let react = require("react");
+		//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-typert-protocol@0.2.2-rc.1_@deepseek-ai+cordis@4.1.0/node_modules/@deepseek-ai/dsh-typert-protocol/lib/types/remote-info.js
+		/** Lazy assembly of generated Remote definitions using caller-supplied Zod; no runtime imports. */
+		/**
+		* Retain one generated definition per endpoint without constructing parsers or projections.
+		* The class instance builds its shared descriptor/method index on first access;
+		* input schemas and JSON Schema projections are cached only when requested.
+		* @param spec - compiler-produced method facts and Zod factories.
+		* @param zod - the generated artifact's Zod runtime for named-input parsers.
+		* @returns a lazy, mountable info instance with no registration or transport effects.
+		*/
+		function createTypertRemoteInfo(spec, zod) {
+			return new RemoteInfo(spec, zod);
+		}
+		var RemoteInfo = class {
+			spec;
+			zod;
+			index;
+			constructor(spec, zod) {
+				this.spec = spec;
+				this.zod = zod;
+			}
+			get package() {
+				return this.spec.package;
+			}
+			get descriptors() {
+				return this.resolve().descriptors;
+			}
+			get methods() {
+				return this.resolve().methods;
+			}
+			resolve() {
+				if (this.index !== void 0) return this.index;
+				const zod = this.zod;
+				const descriptors = [];
+				const methods = Object.create(null);
+				for (const [endpoint, definition] of Object.entries(this.spec.methods)) {
+					const separator = endpoint.indexOf("/");
+					const namespace = endpoint.slice(0, separator);
+					const method = endpoint.slice(separator + 1);
+					const parameters = definition.parameters.map((parameter) => ({
+						...parameter,
+						wire: parameter.wire ?? parameter.name
+					}));
+					const descriptor = {
+						...definition,
+						id: `${this.spec.package}#${endpoint}`,
+						namespace,
+						method,
+						parameters,
+						result: definition.result.description === void 0 ? definition.result : new ResultValue(definition.result)
+					};
+					if (definition.invocation.kind === "direct") {
+						const inputs = [];
+						methods[endpoint] = Object.assign(descriptor, {
+							input(options) {
+								const strict = options?.strict === true;
+								return inputs[strict ? 1 : 0] ??= new NamedInput(parameters, strict, zod);
+							},
+							invoke(remote, input, signal) {
+								const named = input;
+								const values = parameters.map((parameter) => named[parameter.wire]);
+								if (definition.cancellation !== void 0) values.push(signal);
+								const receiver = Reflect.get(remote, namespace);
+								return Reflect.get(receiver, method).apply(receiver, values);
+							}
+						});
+					}
+					descriptors.push(descriptor);
+				}
+				return this.index = {
+					descriptors,
+					methods
+				};
+			}
+		};
+		function optional(parameter) {
+			return parameter.source === "json" && parameter.acceptsUndefined === true;
+		}
+		var NamedInput = class {
+			parameters;
+			strict;
+			zod;
+			schema;
+			projection;
+			constructor(parameters, strict, zod) {
+				this.parameters = parameters;
+				this.strict = strict;
+				this.zod = zod;
+			}
+			codec(parameter) {
+				return this.strict ? parameter.strictCodec : parameter.codec;
+			}
+			create = () => this.schema ??= this.zod.strictObject(Object.fromEntries(this.parameters.map((parameter) => {
+				const value = this.codec(parameter).create();
+				return [parameter.wire, optional(parameter) ? value.optional() : value.nonoptional()];
+			})));
+			get jsonSchema() {
+				return this.project().jsonSchema;
+			}
+			get jsonSchemaError() {
+				return this.project().jsonSchemaError;
+			}
+			project() {
+				if (this.projection !== void 0) return this.projection;
+				const unavailable = this.parameters.find((parameter) => this.codec(parameter).jsonSchema === void 0);
+				if (unavailable !== void 0) return this.projection = { jsonSchemaError: this.codec(unavailable).jsonSchemaError ?? `No JSON Schema for parameter ${unavailable.wire}` };
+				return this.projection = { jsonSchema: {
+					type: "object",
+					properties: Object.fromEntries(this.parameters.map((parameter) => [parameter.wire, {
+						...this.codec(parameter).jsonSchema,
+						...parameter.description === void 0 ? {} : { description: parameter.description }
+					}])),
+					required: this.parameters.filter((parameter) => !optional(parameter)).map((parameter) => parameter.wire),
+					additionalProperties: false
+				} };
+			}
+		};
+		var ResultValue = class {
+			spec;
+			projection;
+			constructor(spec) {
+				this.spec = spec;
+			}
+			get mode() {
+				return this.spec.mode;
+			}
+			get typeSymbol() {
+				return this.spec.typeSymbol;
+			}
+			get create() {
+				return this.spec.create;
+			}
+			get decode() {
+				return this.spec.decode;
+			}
+			get encode() {
+				return this.spec.encode;
+			}
+			get description() {
+				return this.spec.description;
+			}
+			get jsonSchemaError() {
+				return this.spec.jsonSchemaError;
+			}
+			get jsonSchema() {
+				if (this.projection === void 0) {
+					const schema = this.spec.jsonSchema;
+					this.projection = { value: schema === void 0 ? void 0 : {
+						...schema,
+						description: this.spec.description
+					} };
+				}
+				return this.projection.value;
+			}
+		};
+		//#endregion
+		//#region lib/typert.remote-client.js
+		let _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0$schema$value;
+		const _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0$schema = () => _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0$schema$value ??= zod.z.string();
+		let _mind_harness_mh_browser_mhBrowser_revealHandover_result$schema$value;
+		const _mind_harness_mh_browser_mhBrowser_revealHandover_result$schema = () => _mind_harness_mh_browser_mhBrowser_revealHandover_result$schema$value ??= zod.z.object({ "status": zod.z.union([
+			zod.z.literal("revealed"),
+			zod.z.literal("not-handing-over"),
+			zod.z.literal("no-tab")
+		]) });
+		let _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0_strict$schema$value;
+		const _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0_strict$schema = () => _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0_strict$schema$value ??= zod.z.string();
+		const TYPERT_REMOTE = createTypertRemoteInfo({
+			package: "@mind-harness/mh-browser",
+			methods: { "mhBrowser/revealHandover": {
+				service: "mhBrowser",
+				description: "The person asked to see the page this Session handed over.",
+				invocation: { kind: "direct" },
+				parameters: [{
+					name: "sessionId",
+					source: "json",
+					codec: {
+						mode: "strict",
+						typeSymbol: "@mind-harness/mh-browser#mhBrowser/revealHandover:sessionId",
+						create: _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0$schema,
+						jsonSchema: { "type": "string" }
+					},
+					strictCodec: {
+						mode: "strict",
+						typeSymbol: "@mind-harness/mh-browser#mhBrowser/revealHandover:sessionId",
+						create: _mind_harness_mh_browser_mhBrowser_revealHandover_parameter_0_strict$schema,
+						jsonSchema: { "type": "string" }
+					}
+				}],
+				cancellation: { parameter: "signal" },
+				result: {
+					mode: "strict",
+					typeSymbol: "@mind-harness/mh-browser#mhBrowser/revealHandover:result",
+					create: _mind_harness_mh_browser_mhBrowser_revealHandover_result$schema,
+					jsonSchema: {
+						"type": "object",
+						"properties": { "status": {
+							"type": "string",
+							"enum": [
+								"revealed",
+								"not-handing-over",
+								"no-tab"
+							]
+						} },
+						"required": ["status"],
+						"additionalProperties": true
+					}
+				},
+				sourceLocation: {
+					"file": "packages/mh-browser/src/service/service.ts",
+					"line": 684,
+					"column": 9
+				}
+			} }
+		}, zod.z);
+		//#endregion
+		//#region src/client/card.ts
+		/** Host theme tokens only; the rules unmount with the row. */
+		const STYLE = `
+.mh-br { display: flex; flex-direction: column; align-items: flex-start; gap: 8px; color: var(--dsw-alias-label-primary); font-size: 14px; line-height: 20px; }
+.mh-br-line { margin: 0; }
+.mh-br-status { margin: 0; color: var(--dsw-alias-label-secondary); }
+.mh-br-button { padding: 4px 10px; border: 0.5px solid var(--dsw-alias-border-l3); border-radius: var(--dsw-radius-md); background: transparent; color: var(--dsw-alias-label-primary); font: inherit; cursor: pointer; }
+`;
+		/** The open handover: the reason and the button that raises its window. */
+		function HandoverRow(props) {
+			const [note, setNote] = (0, react.useState)(void 0);
+			return (0, react.createElement)("section", { className: "mh-br" }, (0, react.createElement)("style", null, STYLE), (0, react.createElement)("p", { className: "mh-br-line" }, props.t("waiting", { reason: props.reason })), (0, react.createElement)("button", {
+				type: "button",
+				className: "mh-br-button",
+				onClick: () => {
+					props.reveal(props.sessionId, new AbortController().signal).then((result) => {
+						setNote(noteFor(result, props.t));
+					}).catch(() => {
+						setNote(props.t("failed"));
+					});
+				}
+			}, props.t("reveal")), note !== void 0 ? (0, react.createElement)("p", { className: "mh-br-status" }, note) : null);
+		}
+		/** `revealed` adds no status line. */
+		function noteFor(result, t) {
+			if (!result.ok) return t("failed");
+			if (result.value.status === "not-handing-over") return t("notHandingOver");
+			if (result.value.status === "no-tab") return t("noTab");
+		}
+		//#endregion
+		//#region src/client/locales.ts
+		/** Dictionary namespace for the handover row. */
+		const NS = "mh-browser";
+		const zh = {
+			waiting: "浏览器交给你了：{reason}",
+			reveal: "去浏览器",
+			notHandingOver: "这次交接已经结束",
+			noTab: "没有可以去的页面",
+			failed: "没能切到浏览器"
+		};
+		const en = {
+			waiting: "The browser is yours: {reason}",
+			reveal: "Go to the browser",
+			notHandingOver: "This handover has already ended",
+			noTab: "There is no page to open",
+			failed: "Could not switch to the browser"
+		};
+		//#endregion
+		//#region src/client/row.ts
+		/**
+		* One chat row for the open `browser_handover` in a turn.
+		* `groupTree: 'turn'` stands outside the process group. A settled call keeps
+		* the same key and hides the row; a hidden row is omitted from group order.
+		*/
+		const HANDOVER_KIND = "browser-handover";
+		const HANDOVER_TOOL = "browser_handover";
+		function isRecord(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		}
+		function turnOf(data) {
+			if (!isRecord(data) || typeof data.turn !== "number") return void 0;
+			return data.turn;
+		}
+		function reasonOf(value) {
+			if (typeof value !== "string") return "";
+			try {
+				const parsed = JSON.parse(value);
+				if (!isRecord(parsed) || typeof parsed.reason !== "string") return "";
+				return parsed.reason;
+			} catch {
+				return "";
+			}
+		}
+		function callOf(data) {
+			if (!isRecord(data) || typeof data.callId !== "string" || typeof data.name !== "string") return void 0;
+			return {
+				callId: data.callId,
+				name: data.name,
+				arguments: data.arguments
+			};
+		}
+		/** A result names its call on `message.source` and again on `message.toolCallId`. */
+		function callIdOf(data) {
+			if (!isRecord(data) || !isRecord(data.message)) return void 0;
+			const message = data.message;
+			if (isRecord(message.source) && typeof message.source.callId === "string" && message.source.callId !== "") return message.source.callId;
+			if (typeof message.toolCallId === "string" && message.toolCallId !== "") return message.toolCallId;
+		}
+		function hidden(current) {
+			return {
+				...current,
+				visibility: "hidden",
+				data: { reason: "" }
+			};
+		}
+		/**
+		* The row for one turn. Absent until a handover in that turn has been seen;
+		* hidden, with the same key, once the open call settles.
+		*/
+		function buildHandoverView(context) {
+			const current = context.current.get("chat") ?? null;
+			const anchorSeq = context.state?.anchorSeq;
+			if (anchorSeq === void 0) return current === null ? null : hidden(current);
+			const open = context.state?.open;
+			return {
+				key: context.key,
+				kind: HANDOVER_KIND,
+				id: context.id,
+				target: "chat",
+				anchorSeq,
+				location: context.start?.location ?? { kind: "unresolved" },
+				visibility: open === void 0 ? "hidden" : "visible",
+				groupTree: "turn",
+				data: { reason: open?.reason ?? "" }
+			};
+		}
+		const handoverRowDefinition = {
+			kind: HANDOVER_KIND,
+			target: "chat",
+			match(event) {
+				const turn = turnOf(event.data);
+				if (turn === void 0) return null;
+				const id = String(turn);
+				if (event.type === "turn/start") return {
+					id,
+					role: "start"
+				};
+				if (event.type === "tool/call") return callOf(event.data)?.name === HANDOVER_TOOL ? {
+					id,
+					role: "update"
+				} : null;
+				if (event.type === "tool/result" && callIdOf(event.data) !== void 0) return {
+					id,
+					role: "update"
+				};
+				return null;
+			},
+			start() {
+				return {
+					open: void 0,
+					anchorSeq: void 0
+				};
+			},
+			update(context, match) {
+				const event = match.event;
+				if (event.type === "tool/call") {
+					const call = callOf(event.data);
+					if (call === void 0 || call.name !== HANDOVER_TOOL) return context.state;
+					return {
+						open: {
+							callId: call.callId,
+							reason: reasonOf(call.arguments),
+							seq: event.seq
+						},
+						anchorSeq: event.seq
+					};
+				}
+				if (event.type === "tool/result") {
+					const callId = callIdOf(event.data);
+					if (context.state.open === void 0 || callId !== context.state.open.callId) return context.state;
+					return {
+						open: void 0,
+						anchorSeq: context.state.anchorSeq
+					};
+				}
+				return context.state;
+			},
+			buildViewNode(context) {
+				return buildHandoverView(context);
+			}
+		};
+		//#endregion
+		//#region src/client/client.ts
+		/**
+		* Cordis services this client reads. `dsh.client.inject` is package load
+		* order, not this list. `remote.mhBrowser` is absent until `$mount`.
+		*/
+		const inject = [
+			"slots",
+			"locale",
+			"remote",
+			"uiConversation"
+		];
+		const namespaceInject = [...inject, "remote.mhBrowser"];
+		async function apply(ctx) {
+			const unmount = await ctx.remote.$mount(TYPERT_REMOTE);
+			let release = () => void 0;
+			await ctx.inject(namespaceInject, (inner) => {
+				release = start(inner);
+			});
+			return async () => {
+				release();
+				await unmount();
+			};
+		}
+		/** Register the handover row. The tool call itself keeps the generic tool row. */
+		function start(ctx) {
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}));
+			ctx.effect(() => ctx.uiConversation.events.register(handoverRowDefinition));
+			const remote = ctx.remote.mhBrowser;
+			ctx.slots.inject("conversation.chat.node", () => ctx.slots.register({
+				name: "conversation.chat.node",
+				key: HANDOVER_KIND,
+				locale: NS
+			}, (props) => (0, react.createElement)(HandoverRow, {
+				sessionId: props.sessionId,
+				reason: props.node.data.reason,
+				t: props.t,
+				reveal: (sessionId, signal) => remote.revealHandover(sessionId, signal)
+			})));
+			return () => void 0;
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		exports.start = start;
+		return module.exports;
+	}
+});