@mind-harness/mh-workspace 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,783 @@
+import { basename, dirname, join, sep } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { mkdir, realpath } from "node:fs/promises";
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { AGENT_VIEW_ACCEPT, readAgentView } from "@mind-harness/mh-browser/agent-view";
+import { z as z$1 } from "zod";
+import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
+//#region lib/types/config.js
+const DEFAULT_HOME = "https://mindharness.com/";
+const workspaceConfig = z.object({
+	memory: z.object({ home: z.string().default(DEFAULT_HOME).volatile().description("Memory home page address. A new value is read on the next request, without restarting.") }).default({ home: DEFAULT_HOME }).description("The Memory this Harness lists Projects from."),
+	projectsDir: z.string().description("Where each Project gets its workspace directory. Defaults to mh/projects under the dsh home.")
+});
+function projectsDirOf(config) {
+	return config.projectsDir ?? join(resolveDshHome(), "mh", "projects");
+}
+//#endregion
+//#region lib/types/codes.js
+function unauthenticated(title, status) {
+	return new RemoteError("mh-workspace/unauthenticated", title || "Authentication required", {
+		title,
+		status
+	});
+}
+function unreadable(reason, extra) {
+	return new RemoteError("mh-workspace/unreadable", reason, {
+		reason,
+		...extra?.status !== void 0 ? { status: extra.status } : {},
+		...extra?.finalUrl !== void 0 ? { finalUrl: extra.finalUrl } : {}
+	});
+}
+function unlisted(url) {
+	return new RemoteError("mh-workspace/unlisted", "url is not in the project list", { url });
+}
+function cancelled() {
+	return new RemoteError("gateway/cancelled", "cancelled", {});
+}
+//#endregion
+//#region lib/types/required.js
+/** What these Agent Views list in `requires`, in order, without repeats. */
+function requiredUrls(views) {
+	const urls = [];
+	for (const doc of docsOf(views)) for (const url of doc.requires) if (url !== "" && !urls.includes(url)) urls.push(url);
+	return urls;
+}
+function docsOf(views) {
+	return views.flatMap((view) => {
+		const representation = view.representation;
+		if (representation?.kind !== "agent-view" || representation.text === void 0) return [];
+		const read = readAgentView(representation.text, view.url);
+		return read.ok ? [read.doc] : [];
+	});
+}
+function sameUrl(left, right) {
+	try {
+		const a = new URL(left);
+		const b = new URL(right);
+		a.hash = "";
+		b.hash = "";
+		return a.href === b.href;
+	} catch {
+		return left === right;
+	}
+}
+//#endregion
+//#region lib/types/cwd-pages.js
+const RULES_PATH = "AGENTS.md";
+/** One root-level page of a Project; undefined when it is not a readable Agent View. */
+function rootLevel(text, url) {
+	const read = readAgentView(text, url);
+	if (!read.ok) return void 0;
+	const { links, items } = read.doc;
+	const readme = links.find((link) => link.rel === "describedby")?.href;
+	const next = links.find((link) => link.rel === "next")?.href;
+	const rules = items.find((item) => item.path === RULES_PATH)?.id;
+	return {
+		...readme !== void 0 && readme !== "" ? { readme } : {},
+		...typeof rules === "string" && rules !== "" ? { rules } : {},
+		...next !== void 0 && next !== "" ? { next } : {}
+	};
+}
+/** The Project's own cwd pages, broad to specific: root README, then root AGENTS.md. */
+function projectPages(levels) {
+	const readme = levels[0]?.readme;
+	const rules = levels.find((level) => level.rules !== void 0)?.rules;
+	return distinct([readme, rules]);
+}
+/** Placing order: what those pages require first, then the pages themselves. */
+function placingOrder(required, own) {
+	return distinct([...required, ...own]);
+}
+function distinct(urls) {
+	const out = [];
+	for (const url of urls) if (url !== void 0 && !out.some((known) => sameUrl(known, url))) out.push(url);
+	return out;
+}
+//#endregion
+//#region lib/types/domain.js
+const projectRecord = z$1.object({
+	projectId: z$1.string(),
+	url: z$1.string(),
+	workspaceId: z$1.string(),
+	path: z$1.string(),
+	/** Title last written to the Workspace. Absent on records from before it was stored. */
+	title: z$1.string().optional(),
+	/** The person removed this Workspace. Sync does not register it again. */
+	removed: z$1.boolean().optional()
+});
+const mhWorkspaceDomain = defineDomain({
+	name: "mh_workspace",
+	version: 1,
+	tables: { projects: { valueSchema: projectRecord } }
+});
+//#endregion
+//#region lib/types/json.js
+/** Href values for one rel. Array links use `rel`; an object uses the rel as a key. */
+function linkHrefs(page, rel) {
+	if (!page || typeof page !== "object") return [];
+	const links = page.links;
+	if (Array.isArray(links)) {
+		const hrefs = [];
+		for (const link of links) {
+			if (!link || typeof link !== "object") continue;
+			const row = link;
+			if (row.rel === rel && typeof row.href === "string" && row.href !== "") hrefs.push(row.href);
+		}
+		return hrefs;
+	}
+	if (links && typeof links === "object") {
+		const value = links[rel];
+		if (typeof value === "string" && value !== "") return [value];
+		if (value && typeof value === "object") {
+			const href = value.href;
+			if (typeof href === "string" && href !== "") return [href];
+		}
+	}
+	return [];
+}
+/** Project rows. The address is `items[].id`. `project_id` comes from `fields`. */
+function projectItems(page) {
+	if (!page || typeof page !== "object") return [];
+	const items = page.items;
+	if (!Array.isArray(items)) return [];
+	const projects = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		const row = item;
+		if (typeof row.id !== "string" || row.id === "") continue;
+		const projectId = (row.fields && typeof row.fields === "object" ? row.fields : void 0)?.project_id;
+		if (typeof projectId !== "string" || projectId === "") continue;
+		projects.push({
+			url: row.id,
+			name: typeof row.title === "string" && row.title !== "" ? row.title : projectId,
+			projectId
+		});
+	}
+	return projects;
+}
+/** Home viewer is present: the browser is signed in. Memory answers 200 either way. */
+function signedInOf(page) {
+	if (!page || typeof page !== "object") return false;
+	const viewer = page.viewer;
+	return typeof viewer === "string" ? viewer !== "" : viewer != null && viewer !== false;
+}
+/** Home viewer is present and `act` is absent or empty. */
+function selfLoginOf(page) {
+	if (!signedInOf(page)) return false;
+	const act = page.act;
+	return act == null || act === "" || Array.isArray(act) && act.length === 0;
+}
+function titleOf(page) {
+	if (!page || typeof page !== "object") return "";
+	const title = page.title;
+	return typeof title === "string" ? title : "";
+}
+function parseJson(bytes) {
+	return JSON.parse(new TextDecoder().decode(bytes));
+}
+//#endregion
+//#region lib/types/notice.js
+function projectContextText(context, home) {
+	const lines = [projectSentence(context)];
+	if (context.gap !== void 0) lines.push(signInSentence(home, context.gap));
+	else if (context.unread === true) lines.push(UNREAD_SENTENCE);
+	lines.push(workingCopySentence(context.url));
+	return lines.join("\n\n");
+}
+function projectSentence(context) {
+	return context.name === void 0 || context.name === "" ? `Current Project: ${context.url}.` : `Current Project: ${JSON.stringify(context.name)} at ${context.url}.`;
+}
+/** What the working directory of a Project's Workspace is. */
+function workingCopySentence(project) {
+	return `The working directory is a local working copy for the Project ${project}, not the Project itself: it starts empty and does not mirror the Project. Read the Project by opening its pages and change it through the actions they declare. Keep files on their way in or out here, such as downloads and files to upload; a file edited here is not in the Project until you upload it.`;
+}
+function signInSentence(home, gap) {
+	return `Memory at ${home} cannot show this Project to the browser (${gap}). Its README and AGENTS.md were not opened. Tell the person to sign in to Memory in their browser, then continue; Memory pages read before that show only what is public.`;
+}
+const UNREAD_SENTENCE = "The Project page could not be read, so its README and AGENTS.md were not opened; open the Project page to read them.";
+//#endregion
+//#region lib/types/service.js
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/**
+* Host half. Lists Memory projects through the browser request channel,
+* registers one Workspace directory per project, and places the cwd pages
+* on the first step.
+*/
+let MhWorkspaceService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _syncProjects_decorators;
+	let _ensureWorkspace_decorators;
+	let _openPersonWindow_decorators;
+	return class MhWorkspaceService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_syncProjects_decorators = [Remote];
+			_ensureWorkspace_decorators = [Remote];
+			_openPersonWindow_decorators = [Remote];
+			__esDecorate(this, null, _syncProjects_decorators, {
+				kind: "method",
+				name: "syncProjects",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "syncProjects" in obj,
+					get: (obj) => obj.syncProjects
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _ensureWorkspace_decorators, {
+				kind: "method",
+				name: "ensureWorkspace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "ensureWorkspace" in obj,
+					get: (obj) => obj.ensureWorkspace
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _openPersonWindow_decorators, {
+				kind: "method",
+				name: "openPersonWindow",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "openPersonWindow" in obj,
+					get: (obj) => obj.openPersonWindow
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = [
+			"mhBrowser",
+			"workspaceRegistry",
+			"storageDomain",
+			"sessionProjections",
+			"systemPrompt"
+		];
+		home = __runInitializers(this, _instanceExtraInitializers);
+		projectsDir;
+		ready;
+		table;
+		listed = /* @__PURE__ */ new Map();
+		/** One sync at a time. A second call waits on this instead of listing again. */
+		syncing;
+		contexts = /* @__PURE__ */ new Map();
+		constructor(ctx, config) {
+			super(ctx, "mhWorkspace");
+			this.home = config.memory.home;
+			this.projectsDir = projectsDirOf(config);
+			this.ready = this.mount();
+			Object.getPrototypeOf(ctx).on("loader/volatile-update", () => {
+				this.listed.clear();
+			});
+			const prompt = ctx.systemPrompt;
+			prompt.context({
+				name: "mh-workspace:project",
+				order: prompt.getContextOrder("WORKING_DIRECTORY") + 1,
+				required: true,
+				interpolate: false,
+				text: (context) => {
+					const session = context.agent?.session;
+					const project = session === void 0 ? void 0 : this.contexts.get(session.id);
+					return project === void 0 || project === null ? "" : projectContextText(project, this.home.get());
+				}
+			});
+			const listen = ctx.on;
+			listen("agent/pre-step", async (payload, next) => {
+				await this.ready;
+				await this.prepareStep(payload);
+				return next();
+			});
+		}
+		/**
+		* List every reachable Project and register a Workspace for each one that
+		* the person has not removed. New Workspaces are registered from the end of
+		* the list, so the first Project ends up first: the registry prepends.
+		*/
+		async syncProjects(signal) {
+			await this.ready;
+			if (signal.aborted) throw cancelled();
+			const current = this.syncing;
+			if (current !== void 0) return current;
+			const run = this.doSync(signal).finally(() => {
+				if (this.syncing === run) this.syncing = void 0;
+			});
+			this.syncing = run;
+			return run;
+		}
+		/** Put a listed Project back in the sidebar after the person removed it. */
+		async ensureWorkspace(projectUrl, signal) {
+			await this.ready;
+			if (signal.aborted) throw cancelled();
+			const known = this.listed.get(projectUrl);
+			if (known === void 0) throw unlisted(projectUrl);
+			return { workspaceId: await this.register(known) };
+		}
+		async openPersonWindow(url, signal) {
+			await this.ready;
+			if (signal?.aborted === true) throw cancelled();
+			const home = this.memoryHome();
+			const target = url === void 0 || url === "" ? home : url;
+			if (target !== home && !this.listed.has(target)) throw unlisted(target);
+			if (!isWebUrl(target)) throw unreadable("address is not http or https");
+			await this.browser().open("person", [{ url: target }], signal);
+			await this.browser().bringToFront("person");
+		}
+		/**
+		* Keep the Session's Project context current and, on the first step of its
+		* first turn, place the cwd pages. Later steps read Memory only while a
+		* sign-in gap is open, to notice when it closes.
+		*/
+		async prepareStep(payload) {
+			await this.ready;
+			const id = payload.agent.session.id;
+			const first = this.isFirstStep(payload);
+			let context = this.contexts.get(id);
+			if (context === void 0) {
+				context = await this.contextFor(payload.agent.session, first, payload.signal);
+				this.contexts.set(id, context);
+			}
+			if (context === null) return;
+			if (!first && context.gap === void 0) return;
+			const gap = await this.signInGap(payload.signal);
+			if (gap !== void 0) {
+				if (first) this.ctx.logger.warn("mh-workspace: cwd pages not placed: %s", gap);
+				this.contexts.set(id, {
+					...context,
+					gap
+				});
+				return;
+			}
+			const open = withoutGap(context);
+			if (!first) {
+				this.contexts.set(id, open);
+				return;
+			}
+			const placed = await this.placePages(id, open.url, payload.signal);
+			this.contexts.set(id, placed ? open : {
+				...open,
+				unread: true
+			});
+		}
+		/** The first step of the Session's first turn. Later turns do not place pages. */
+		isFirstStep(payload) {
+			if (payload.step !== 1 || payload.messages.length === 0) return false;
+			const boundary = this.turns().stateOf(payload.agent.session, "turnBoundary");
+			if (boundary === void 0) {
+				this.ctx.logger.warn("mh-workspace: turnBoundary projection is not registered; cwd pages not placed");
+				return false;
+			}
+			return boundary.lastTurn === 1;
+		}
+		/**
+		* The Project this Session's cwd is a working copy of. Only the first step
+		* may ask Memory, to find a Project by directory name; a resumed or forked
+		* Session is matched from storage alone.
+		*/
+		async contextFor(session, first, signal) {
+			const cwd = session.header.cwd;
+			if (cwd === void 0 || cwd === "") return null;
+			const project = first ? await this.projectForCwd(cwd, signal) : await this.storedProject(cwd);
+			if (project === void 0) return null;
+			return {
+				url: project.url,
+				...project.name !== void 0 ? { name: project.name } : {}
+			};
+		}
+		async storedProject(cwd) {
+			let canonical;
+			try {
+				canonical = await realpath(cwd);
+			} catch {
+				return;
+			}
+			const record = this.recordForPath(canonical);
+			return record === void 0 ? void 0 : named(record.url, record.title);
+		}
+		/**
+		* Place the cwd pages, broad to specific: what the Project page, the root
+		* README and AGENTS.md require (the Memory home), the README, then
+		* AGENTS.md. The Project page itself is not placed. False when the Project
+		* page could not be read.
+		*/
+		async placePages(owner, project, signal) {
+			const [view] = await this.openQuietly(owner, [project], signal);
+			const first = view === void 0 ? void 0 : levelOf(view);
+			if (view === void 0 || first === void 0) {
+				this.ctx.logger.warn("mh-workspace: project page has no readable Agent View; cwd pages not placed");
+				return false;
+			}
+			const own = projectPages([first, ...await this.laterLevels(first, signal)]);
+			const required = requiredUrls([view, ...own.length === 0 ? [] : await this.openQuietly(owner, own, signal)]);
+			const held = this.browser().presenceList(owner);
+			const isNew = (url) => !sameUrl(url, project) && !held.some((page) => sameUrl(page.url, url));
+			const toOpen = required.filter((url) => isNew(url) && !own.some((page) => sameUrl(page, url)));
+			if (toOpen.length > 0) await this.openQuietly(owner, toOpen, signal);
+			const urls = placingOrder(required, own).filter(isNew);
+			if (urls.length > 0) this.browser().presencePut(owner, urls, "cwd reference");
+			return true;
+		}
+		/** Follow `next` from the first root level until a level names AGENTS.md or none is left. */
+		async laterLevels(first, signal) {
+			const levels = [];
+			const seen = /* @__PURE__ */ new Set();
+			let current = first;
+			while (current.rules === void 0 && current.next !== void 0 && !seen.has(current.next)) {
+				seen.add(current.next);
+				const level = await this.readLevel(current.next, signal);
+				if (level === void 0) break;
+				levels.push(level);
+				current = level;
+			}
+			return levels;
+		}
+		async readLevel(url, signal) {
+			if (signal.aborted) throw cancelled();
+			const response = await this.browser().fetch(url, { accept: AGENT_VIEW_ACCEPT });
+			if (response.kind === "error" || response.status !== 200) {
+				this.ctx.logger.warn("mh-workspace: project level not read: %s", url);
+				return;
+			}
+			return rootLevel(new TextDecoder().decode(response.body), response.finalUrl);
+		}
+		/** Why the browser cannot read the person's Projects now; undefined when it can. */
+		async signInGap(signal) {
+			try {
+				return signedInOf((await this.readJson(this.memoryHome(), signal)).page) ? void 0 : "not signed in";
+			} catch (error) {
+				if (signal.aborted) throw error;
+				return errorText(error);
+			}
+		}
+		async openQuietly(owner, urls, signal) {
+			try {
+				return await this.browser().open(owner, urls.map((url) => ({ url })), signal);
+			} catch (error) {
+				this.ctx.logger.warn("mh-workspace open failed: %s", errorText(error));
+				return [];
+			}
+		}
+		turns() {
+			return this.ctx.sessionProjections;
+		}
+		browser() {
+			return this.ctx.mhBrowser;
+		}
+		async mount() {
+			const domain = await this.ctx.storageDomain.open(mhWorkspaceDomain);
+			this.table = domain.table("projects");
+			this.ctx.effect(() => async () => {
+				try {
+					await domain.close();
+				} catch (error) {
+					this.ctx.logger.warn("mh-workspace storage close failed: %s", errorText(error));
+				}
+			});
+		}
+		projects() {
+			if (this.table === void 0) throw new Error("mh-workspace storage is not open");
+			return this.table;
+		}
+		byUrl() {
+			return new Map(this.projects().entries());
+		}
+		async doSync(signal) {
+			const { found, signedIn, selfLogin } = await this.readProjects(signal);
+			this.listed = new Map(found.map((item) => [item.url, item]));
+			const reg = registry(this.ctx);
+			const live = new Set(reg.list().map((workspace) => String(workspace.id)));
+			for (const item of [...found].reverse()) try {
+				await this.reconcile(item, this.byUrl().get(item.url), live, reg);
+			} catch (error) {
+				this.ctx.logger.warn("mh-workspace register failed: %s", errorText(error));
+			}
+			const stored = this.byUrl();
+			return {
+				signedIn,
+				selfLogin,
+				projects: found.map((item) => projectView(item, stored.get(item.url)))
+			};
+		}
+		/**
+		* Bring one listed Project in line with its Workspace. A failure here is
+		* the caller's to skip; the rest of the list still registers.
+		*/
+		async reconcile(item, record, live, reg) {
+			if (record?.removed === true) return;
+			if (record !== void 0 && !live.has(record.workspaceId)) {
+				await this.projects().put(item.url, {
+					...record,
+					removed: true
+				});
+				return;
+			}
+			if (record === void 0) {
+				await this.register(item);
+				return;
+			}
+			const workspace = reg.get(record.workspaceId);
+			if (workspace === void 0) {
+				await this.projects().put(item.url, {
+					...record,
+					removed: true
+				});
+				return;
+			}
+			if (record.title === void 0) {
+				if (workspace.title === item.name) await this.projects().put(item.url, {
+					...record,
+					title: item.name
+				});
+				return;
+			}
+			if (workspace.title === item.name) {
+				if (record.title !== item.name) await this.projects().put(item.url, {
+					...record,
+					title: item.name
+				});
+				return;
+			}
+			if (workspace.title === record.title) {
+				await workspace.setTitle(item.name);
+				await this.projects().put(item.url, {
+					...record,
+					title: item.name
+				});
+			}
+		}
+		/** Create or reuse the Workspace directory and remember it. Clears `removed`. */
+		async register(item) {
+			const dir = join(this.projectsDir, hostDir(this.memoryHome()), directoryName(item.projectId));
+			await mkdir(dir, { recursive: true });
+			const workspace = await registry(this.ctx).create(dir, item.name);
+			const path = await realpath(dir);
+			const record = {
+				projectId: item.projectId,
+				url: item.url,
+				workspaceId: String(workspace.id),
+				path,
+				title: item.name
+			};
+			await this.projects().put(item.url, record);
+			return record.workspaceId;
+		}
+		async projectForCwd(cwd, signal) {
+			let canonical;
+			try {
+				canonical = await realpath(cwd);
+			} catch {
+				return;
+			}
+			const stored = this.recordForPath(canonical);
+			if (stored !== void 0) return named(stored.url, stored.title);
+			let root;
+			try {
+				root = await realpath(join(this.projectsDir, hostDir(this.memoryHome())));
+			} catch {
+				return;
+			}
+			if (dirname(canonical) !== root) return void 0;
+			try {
+				const { found } = await this.readProjects(signal);
+				const item = found.find((candidate) => candidate.projectId === basename(canonical));
+				return item === void 0 ? void 0 : named(item.url, item.name);
+			} catch (error) {
+				this.ctx.logger.warn("mh-workspace list failed: %s", errorText(error));
+				return;
+			}
+		}
+		async readProjects(signal) {
+			if (signal.aborted) throw cancelled();
+			const home = await this.readJson(this.memoryHome(), signal);
+			const signedIn = signedInOf(home.page);
+			const selfLogin = selfLoginOf(home.page);
+			const projectsHref = linkHrefs(home.page, "projects")[0];
+			const found = [];
+			const seen = /* @__PURE__ */ new Set();
+			let next = projectsHref;
+			while (next !== void 0 && !seen.has(next)) {
+				seen.add(next);
+				const page = await this.readJson(next, signal);
+				found.push(...projectItems(page.page));
+				next = linkHrefs(page.page, "next")[0];
+			}
+			return {
+				found,
+				signedIn,
+				selfLogin
+			};
+		}
+		recordForPath(canonical) {
+			let best;
+			for (const record of this.byUrl().values()) {
+				if (canonical !== record.path && !canonical.startsWith(record.path + sep)) continue;
+				if (best === void 0 || record.path.length > best.path.length) best = record;
+			}
+			return best;
+		}
+		/** The configured home. Not http(s) fails closed, before any request. */
+		memoryHome() {
+			const home = this.home.get();
+			if (!isWebUrl(home)) throw unreadable("address is not http or https");
+			return home;
+		}
+		async readJson(url, signal) {
+			if (signal.aborted) throw cancelled();
+			let response;
+			try {
+				response = await this.browser().fetch(url, { accept: "application/json" });
+			} catch (error) {
+				throw unreadable(errorText(error));
+			}
+			if (response.kind === "error") throw unreadable(response.reason);
+			const mediaType = response.mediaType?.split(";")[0]?.trim().toLowerCase();
+			if (response.status === 401) throw unauthenticated(mediaType === "application/json" ? jsonTitle(response.body) : "", response.status);
+			if (mediaType !== "application/json") throw unreadable("response is not JSON", {
+				status: response.status,
+				finalUrl: response.finalUrl
+			});
+			try {
+				return {
+					page: parseJson(response.body),
+					status: response.status,
+					finalUrl: response.finalUrl
+				};
+			} catch (error) {
+				throw unreadable(errorText(error), {
+					status: response.status,
+					finalUrl: response.finalUrl
+				});
+			}
+		}
+	};
+})();
+function projectView(item, record) {
+	return {
+		url: item.url,
+		name: item.name,
+		projectId: item.projectId,
+		...record !== void 0 ? { workspaceId: record.workspaceId } : {},
+		...record?.removed === true ? { removed: true } : {}
+	};
+}
+function registry(ctx) {
+	return ctx.workspaceRegistry;
+}
+/** Directory segment for one Memory: its host, with `:` written as `_`. */
+function hostDir(home) {
+	let host;
+	try {
+		host = new URL(home).host;
+	} catch {
+		throw unreadable("address is not http or https");
+	}
+	const name = host.replaceAll(":", "_");
+	if (name === "" || name.includes("/") || name.includes("\\") || name === "." || name === "..") throw unreadable("address is not http or https");
+	return name;
+}
+function directoryName(projectId) {
+	if (projectId.includes("/") || projectId.includes("\\") || projectId === "." || projectId === "..") throw unreadable("project_id is not a directory name");
+	return projectId;
+}
+function isWebUrl(url) {
+	try {
+		const { protocol } = new URL(url);
+		return protocol === "http:" || protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function jsonTitle(body) {
+	try {
+		return titleOf(parseJson(body));
+	} catch {
+		return "";
+	}
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function named(url, name) {
+	return name === void 0 || name === "" ? { url } : {
+		url,
+		name
+	};
+}
+function withoutGap(context) {
+	const open = { ...context };
+	delete open.gap;
+	return open;
+}
+function levelOf(view) {
+	const representation = view.representation;
+	if (representation?.kind !== "agent-view" || representation.text === void 0) return void 0;
+	return rootLevel(representation.text, view.url);
+}
+//#endregion
+//#region lib/types/index.js
+const name = "mh-workspace";
+const inject = [
+	"mhBrowser",
+	"workspaceRegistry",
+	"storageDomain",
+	"sessionProjections",
+	"systemPrompt"
+];
+const Config = workspaceConfig;
+function apply(ctx, config) {
+	ctx.plugin(MhWorkspaceService, {
+		memory: config.memory,
+		projectsDir: projectsDirOf(config)
+	});
+}
+//#endregion
+export { Config, DEFAULT_HOME, MhWorkspaceService, apply, inject, name };