zidane-ui 9.0.4 → 9.1.3

package/dist/adapters/server-extensions-host.js

@@ -0,0 +1,829 @@
+import { writable } from "../chat/headless/store.js";
+import { ExtensionsHostError } from "../extensions/headless/host.js";
+import { createServerWebviewSources } from "./extension-modules.js";
+import { createDialogQueue } from "../extensions/headless/dialog-queue.js";
+import { createUiEffectChannel } from "../extensions/headless/effect-channel.js";
+import { EXTENSION_TOKENS } from "../extensions/headless/wire.js";
+import { IpcErrorCode, ServerCallError, ServerConnectionError, createExtensionsClient } from "zidane/ipc/browser";
+//#region src/adapters/server-extensions-host.ts
+/**
+* An `ExtensionsHost` on a running zidane-server, over the same client as the chat host
+* (`createServerClient`, or `createServerHost(...).client`), spoken through zidane's typed extensions client
+* (`createExtensionsClient` from `zidane/ipc/browser`): what the extensions of one folder
+* contribute to the UI, and the way back to them.
+*
+*   - items and `ui` bundles: `extensions.ui.list`, kept current by `extensions:ui` (listed again on
+*     `reset`, a reconnect and a folder change)
+*   - callbacks: `extensions.ui.invoke` (panel load and actions, references, badge menus, settings
+*     actions)
+*   - dialogs and toasts routed to this window into a `createDialogQueue`, answered with
+*     `ui.dialog.answer`, withdrawn on `ui:dialog:close`. A form's fields are checked with
+*     `ui.dialog.validate` (`dialogs.validate`), and a form is answered only once every field passes
+*   - `ctx.ui` panels, navigation, composer edits, notifications and `ctx.keymap.dispatch` chords into a
+*     `createUiEffectChannel`, answered with `ui.client.reply`
+*   - links: `openLink` offers a link to the folder's link handlers (`extensions.links.open`)
+*   - the token's scope (`scope`, from the handshake): action settings above it show disabled
+*   - RPC: `rpc.call` (aborts send `rpc.cancel`); the server checks each method's `scope` against
+*     this window's token (`rpc.forbidden` below it)
+*   - stores: `extensions.storage.load` / `.set`, kept current by `extensions:storage`; a write shows at
+*     once and settles to what the server holds (a refused one is put back)
+*   - settings (`extensions.settings`, the catalog provenance), integrations, commands (with their
+*     key scope, `editable` flag and mode, and the keymap mode on top)
+*   - webviews (with `assets`): a `file` source's URL minted by the server, minted again after a
+*     reconnect, a rebuild or a folder change
+*
+* The host announces the window on every connect (`ui.client.announce`): the server routes
+* dialogs only to windows that did. Call `announce` again when the shown session changes or the
+* user acts in the window. Sign-in steps of an OAuth or command integration go to `onFlowStep`;
+* by default a link opens in a new tab and a question shows as one of this host's dialogs.
+*
+* A reconnect may be a restarted server, whose bundle URLs and webview tickets are gone: the host
+* lists everything again and tells `onReset` listeners, as after a rebuild.
+*
+* `invoke` takes each callback's folder; the items, settings, commands and integrations are the
+* folder given by `cwd` / `setFolder`.
+*/
+const CATALOG_KINDS = [
+	"tools",
+	"agents",
+	"subagents",
+	"models",
+	"providers",
+	"mcp",
+	"skills"
+];
+/** Any rejection as the host's typed error. */
+function hostError(err) {
+	if (err instanceof ExtensionsHostError) return err;
+	if (err instanceof ServerConnectionError) return new ExtensionsHostError({ code: "unavailable" });
+	if (err instanceof ServerCallError && err.code === IpcErrorCode.Forbidden) return new ExtensionsHostError({
+		code: "refused",
+		reason: "not-allowed",
+		message: err.message
+	});
+	if (err instanceof Error && err.name === "RpcCallError" && typeof err.type === "string") {
+		const { type, data } = err;
+		return new ExtensionsHostError({
+			code: "rpc",
+			type,
+			message: err.message,
+			...data !== void 0 ? { data } : {}
+		});
+	}
+	return new ExtensionsHostError({
+		code: "failed",
+		message: err instanceof Error ? err.message : String(err)
+	});
+}
+const rethrow = (err) => {
+	throw hostError(err);
+};
+/** A refusal for invalid params as `refused` / `invalid`, anything else as {@link hostError}. */
+const rethrowInvalid = (err) => {
+	if (err instanceof ServerCallError && err.code === -32602) throw new ExtensionsHostError({
+		code: "refused",
+		reason: "invalid",
+		message: err.message
+	});
+	return rethrow(err);
+};
+/** The invoke request a callback travels as. */
+function invokeRequest(id, args) {
+	const a = args;
+	switch (id) {
+		case "panel.load": return {
+			op: id,
+			panelId: a.panelId,
+			...a.context !== void 0 ? { ctx: a.context } : {}
+		};
+		case "panel.action": return {
+			op: id,
+			panelId: a.panelId,
+			actionId: a.actionId,
+			...a.payload !== void 0 ? { payload: a.payload } : {},
+			...a.context !== void 0 ? { ctx: a.context } : {}
+		};
+		case "badge.run": return {
+			op: id,
+			source: a.source,
+			actionId: a.actionId,
+			target: a.target,
+			...a.sessionId ? { sessionId: a.sessionId } : {}
+		};
+		default: {
+			const { cwd: _cwd, ...rest } = a;
+			return {
+				op: id,
+				...rest
+			};
+		}
+	}
+}
+/** `ui:client`'s request as the effect the app applies. */
+function effectOf(request) {
+	switch (request.op) {
+		case "keymap.dispatch": return {
+			kind: "keymap",
+			chord: request.chord,
+			...request.sessionId ? { sessionId: request.sessionId } : {}
+		};
+		case "panel": return {
+			kind: "panel",
+			action: request.action,
+			panelId: request.panelId,
+			...request.sessionId ? { sessionId: request.sessionId } : {},
+			...request.focus ? { focus: request.focus } : {}
+		};
+		case "panelState": return {
+			kind: "panel-state",
+			...request.sessionId ? { sessionId: request.sessionId } : {}
+		};
+		case "navigate": return {
+			kind: "navigate",
+			to: request.to
+		};
+		case "composer": return {
+			kind: "composer",
+			op: request.edit,
+			...request.sessionId ? { sessionId: request.sessionId } : {}
+		};
+		case "notify": {
+			const { op: _op, ...rest } = request;
+			return {
+				kind: "notify",
+				...rest
+			};
+		}
+	}
+}
+const TEXT_TYPES = {
+	md: "text/markdown",
+	json: "application/json",
+	html: "text/html",
+	css: "text/css",
+	csv: "text/csv",
+	xml: "application/xml",
+	svg: "image/svg+xml",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	ts: "text/typescript",
+	tsx: "text/typescript",
+	yaml: "application/yaml",
+	yml: "application/yaml"
+};
+/** UTF-8 text as base64. */
+function base64Text(text) {
+	const bytes = new TextEncoder().encode(text);
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(binary);
+}
+/**
+* The files of a `ctx.composer.attach` with each server path read into bytes through the session's
+* workspace (`sessions.workspaceReadFile`): a browser can't read a server path itself. Text only (the
+* read answers text); a path that doesn't read, or reads as binary, stays a path, which the composer
+* does not stage.
+*/
+async function readAttachPaths(client, files, sessionId) {
+	if (!sessionId || !client.can("sessions.workspaceReadFile")) return [...files];
+	return Promise.all(files.map(async (file) => {
+		if (!("path" in file)) return file;
+		try {
+			const text = await client.call("sessions.workspaceReadFile", {
+				sessionId,
+				path: file.path
+			});
+			if (typeof text !== "string" || /[\u0000\uFFFD]/.test(text)) return file;
+			const name = file.path.split(/[\\/]/).pop() || file.path;
+			const ext = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
+			return {
+				name,
+				mimeType: TEXT_TYPES[ext] ?? "text/plain",
+				data: base64Text(text)
+			};
+		} catch {
+			return file;
+		}
+	}));
+}
+function integrationOf(wire) {
+	const raw = wire.connections ?? (wire.connection ? [wire.connection] : []);
+	const defaultAccount = wire.connection?.account ?? raw.find((c) => c.isDefault)?.account ?? raw[0]?.account;
+	const connections = raw.map((c) => connectionOf(c, c.account === defaultAccount));
+	const connection = connections.find((c) => c.isDefault);
+	return {
+		id: wire.id,
+		name: wire.name,
+		...wire.description ? { description: wire.description } : {},
+		extensionId: wire.extensionId,
+		methods: wire.methods.map((m) => {
+			const extra = m;
+			return {
+				type: m.type,
+				id: m.id,
+				label: m.label,
+				...extra.placeholder ? { placeholder: extra.placeholder } : {},
+				...extra.help ? { help: extra.help } : {}
+			};
+		}),
+		...connection ? { connection } : {},
+		...connections.length > 0 ? { connections } : {}
+	};
+}
+function connectionOf(wire, isDefault) {
+	return {
+		methodId: wire.methodId,
+		account: wire.account || "default",
+		...wire.label ? { label: wire.label } : {},
+		...isDefault ? { isDefault: true } : {},
+		connectedAt: wire.connectedAt
+	};
+}
+const EMPTY_SETTINGS = {
+	schema: {
+		categories: [],
+		items: []
+	},
+	actions: [],
+	values: {},
+	locked: []
+};
+/** A form dialog's request with what the user entered as its values and each field's error as its description. */
+function formWithErrors(request, extensionId, entered, errors) {
+	const settings = request.settings;
+	return {
+		...request,
+		settings: {
+			...settings,
+			schema: {
+				...settings.schema,
+				items: settings.schema.items.map((item) => errors[item.key] !== void 0 ? {
+					...item,
+					description: errors[item.key]
+				} : item)
+			},
+			values: {
+				...settings.values,
+				[extensionId]: {
+					...settings.values[extensionId],
+					...entered
+				}
+			}
+		}
+	};
+}
+/**
+* Creates an {@link ExtensionsHost} over a zidane-server client.
+*
+* @param options - The client, the folder, the sign-in step handler, the error sink and where assets are.
+*/
+function createServerExtensionsHost(options) {
+	const { client, onError = (error) => console.warn("[zidane-ui] extensions host:", error) } = options;
+	const ext = createExtensionsClient({
+		request: client.call,
+		onSignal: (listener) => client.onSignal(listener)
+	});
+	let cwd = options.cwd ?? null;
+	let announced = {};
+	const offs = [];
+	const on = (kind, fn) => {
+		offs.push(client.onSignal((signal) => {
+			if (signal.kind === kind) fn(signal);
+		}));
+	};
+	const panelListeners = /* @__PURE__ */ new Set();
+	const resetListeners = /* @__PURE__ */ new Set();
+	const webviews = options.assets ? createServerWebviewSources({
+		...options.assets,
+		cwd: () => cwd,
+		onError
+	}) : void 0;
+	const stores = Object.fromEntries(EXTENSION_TOKENS.map((token) => [token, writable([])]));
+	const items = stores;
+	let listSeq = 0;
+	let listing = Promise.resolve(null);
+	const listItems = () => {
+		const mine = ++listSeq;
+		const folder = cwd;
+		if (!folder) {
+			for (const token of EXTENSION_TOKENS) stores[token].set([]);
+			listing = Promise.resolve(null);
+			return Promise.resolve();
+		}
+		const snapshot = ext.ui.list(folder);
+		listing = snapshot.then((s) => ({
+			cwd: folder,
+			bundles: s.bundles ?? {}
+		}), () => null);
+		return snapshot.then((s) => {
+			if (mine !== listSeq) return;
+			const byToken = s;
+			for (const token of EXTENSION_TOKENS) stores[token].set(byToken[token] ?? []);
+		}, onError);
+	};
+	const upsert = (entry) => {
+		const store = stores[entry.token];
+		if (!store) return;
+		store.set((prev) => {
+			const index = prev.findIndex((e) => e.key === entry.key);
+			return index < 0 ? [...prev, entry] : prev.map((e, i) => i === index ? entry : e);
+		});
+	};
+	const remove = (key, token) => {
+		stores[token]?.set((prev) => prev.some((e) => e.key === key) ? prev.filter((e) => e.key !== key) : prev);
+	};
+	const reset = () => {
+		webviews?.reset();
+		refreshAll();
+		for (const listener of [...resetListeners]) listener();
+	};
+	offs.push(ext.ui.onChange((signalCwd, change) => {
+		if (change.type === "reset") {
+			reset();
+			return;
+		}
+		if (signalCwd !== cwd) {
+			if (change.type === "upsert" || change.type === "remove") listItems();
+			return;
+		}
+		if (change.type === "upsert") upsert(change.entry);
+		else if (change.type === "remove") remove(change.key, change.token);
+		if ((change.type === "upsert" ? change.entry.token : change.type === "remove" ? change.token : null) === "settings-page") settings.refresh();
+	}), ext.ui.onPanelChanged(({ cwd: signalCwd, ...change }) => {
+		if (signalCwd !== cwd) return;
+		for (const listener of [...panelListeners]) listener(change);
+	}));
+	const bundle = async (extensionId, opts = {}) => {
+		if (opts.fresh) await listItems();
+		const listed = await listing;
+		const found = listed?.bundles[extensionId];
+		if (found) return {
+			hash: found.hash,
+			url: found.url
+		};
+		if (!listed) return void 0;
+		const entry = (await ext.entries.list(listed.cwd).catch(() => [])).find((e) => e.id === extensionId);
+		return entry?.uiErrors?.length ? { errors: entry.uiErrors } : void 0;
+	};
+	const invoke = (id, args) => {
+		const folder = args.cwd ?? cwd;
+		if (!folder) return Promise.reject(new ExtensionsHostError({ code: "unavailable" }));
+		return ext.ui.invoke(folder, invokeRequest(id, args)).then((result) => result ?? void 0, rethrow);
+	};
+	const queue = createDialogQueue();
+	const validators = /* @__PURE__ */ new Map();
+	const channel = createUiEffectChannel();
+	offs.push(ext.serve({
+		async dialog(request, ctx) {
+			const show = (req) => queue.show(req, {
+				id: ctx.dialogId,
+				extensionId: ctx.extensionId,
+				...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+				signal: ctx.signal
+			});
+			validators.set(ctx.dialogId, ctx.validate);
+			try {
+				const original = request;
+				let answer = await show(original);
+				while (original.kind === "form" && answer !== null && typeof answer === "object") {
+					const entered = answer;
+					const keys = /* @__PURE__ */ new Set([...original.settings.schema.items.map((item) => item.key), ...Object.keys(entered)]);
+					const checked = await Promise.all([...keys].map(async (key) => [key, await ctx.validate(key, entered[key])]));
+					const errors = Object.fromEntries(checked.filter(([, error]) => error !== null));
+					if (Object.keys(errors).length === 0) break;
+					answer = await show(formWithErrors(original, ctx.extensionId, entered, errors));
+				}
+				return answer;
+			} finally {
+				validators.delete(ctx.dialogId);
+			}
+		},
+		async client(request) {
+			let effect = effectOf(request);
+			if (effect.kind === "composer" && effect.op.op === "attach") {
+				const files = await readAttachPaths(client, effect.op.files, effect.sessionId ?? announced.viewing?.[0]);
+				effect = {
+					...effect,
+					op: {
+						op: "attach",
+						files
+					}
+				};
+			}
+			return channel.apply(effect);
+		}
+	}));
+	const dialogs = {
+		...queue.dialogs,
+		validate(dialogId, key, value) {
+			const validate = validators.get(dialogId);
+			return validate ? validate(key, value).catch(() => null) : Promise.resolve(null);
+		}
+	};
+	const storage = serverStorage(ext, () => cwd, onError);
+	offs.push(storage.off);
+	const settings = serverSettings(client, () => cwd, onError);
+	const integrations = serverIntegrations(client, () => cwd, onError, options.onFlowStep ?? defaultFlowStep(queue.show));
+	const commands = serverCommands(ext, () => cwd, () => announced.viewing?.[0], onError);
+	on("extensions:integrations", () => integrations.refresh());
+	offs.push(ext.commands.onChange(() => commands.refresh()));
+	on("settings:changed", () => settings.refresh());
+	const refreshAll = () => {
+		storage.reload();
+		return Promise.all([
+			listItems(),
+			settings.refresh(),
+			integrations.refresh(),
+			commands.refresh()
+		]).then(() => void 0);
+	};
+	const sendAnnounce = () => ext.announce({
+		...announced,
+		dialogs: true,
+		ui: true
+	});
+	offs.push(client.onOpen((_hello, reconnected) => {
+		sendAnnounce().catch(onError);
+		if (reconnected) reset();
+	}));
+	if (client.hello()) sendAnnounce().catch(onError);
+	const ready = refreshAll();
+	const scope = writable(client.hello()?.scope ?? null);
+	offs.push(client.onOpen((hello) => scope.set(hello.scope ?? null)));
+	return {
+		ready,
+		items,
+		invoke,
+		dialogs,
+		effects: channel.effects,
+		async rpc(contract, method, input, opts = {}) {
+			return ext.rpc(contract, method, input, {
+				...cwd ? { cwd } : {},
+				...opts.signal ? { signal: opts.signal } : {}
+			}).catch(rethrow);
+		},
+		async openLink(link) {
+			if (!cwd || !client.can("extensions.links.open")) return false;
+			const { handled } = await ext.links.open(cwd, link).catch(rethrow);
+			return handled;
+		},
+		scope,
+		storage: storage.storage,
+		settings: settings.settings,
+		integrations: integrations.integrations,
+		commands: commands.commands,
+		...webviews ? { webviews } : {},
+		bundle,
+		setFolder(next) {
+			if (next === cwd) return;
+			cwd = next;
+			webviews?.reset();
+			refreshAll();
+		},
+		folder: () => cwd,
+		announce(info) {
+			const session = announced.viewing?.[0];
+			announced = info;
+			if (info.viewing?.[0] !== session) commands.refresh();
+			return sendAnnounce().catch(rethrow);
+		},
+		panelChanged(listener) {
+			panelListeners.add(listener);
+			return () => panelListeners.delete(listener);
+		},
+		onReset(listener) {
+			resetListeners.add(listener);
+			return () => resetListeners.delete(listener);
+		},
+		close() {
+			for (const off of offs.splice(0)) off();
+			queue.clear();
+		}
+	};
+}
+const storeKey = (ref) => [
+	ref.extensionId,
+	ref.scope,
+	ref.sessionId ?? "",
+	ref.name
+].join("\0");
+/**
+* The typed stores: loaded per ref, written as store records, followed through `extensions:storage`.
+* A write shows at once and settles to what the server answers it holds; a refused one is put back.
+*/
+function serverStorage(ext, folder, onError) {
+	const slots = /* @__PURE__ */ new Map();
+	const location = (ref) => ({
+		extensionId: ref.extensionId,
+		scope: ref.scope,
+		...ref.sessionId ? { sessionId: ref.sessionId } : {}
+	});
+	const hold = (slot, record) => {
+		if (typeof record?.v === "number") slot.schema = record.v;
+		slot.value.set(record && typeof record === "object" && "value" in record ? record.value : void 0);
+	};
+	const load = (slot) => {
+		const cwd = folder();
+		if (!cwd) return;
+		ext.storage.load(cwd, location(slot.ref)).then((snapshot) => {
+			slot.projectRoot = snapshot.projectRoot;
+			hold(slot, snapshot.stores[slot.ref.name]);
+		}, onError);
+	};
+	const off = ext.storage.onChange((signal) => {
+		if (signal.area !== "stores") return;
+		const slot = slots.get(storeKey({
+			extensionId: signal.extensionId,
+			scope: signal.scope,
+			name: signal.key,
+			...signal.sessionId ? { sessionId: signal.sessionId } : {}
+		}));
+		if (!slot) return;
+		if (signal.scope !== "user" && slot.projectRoot !== signal.projectRoot) return;
+		if (typeof signal.version === "number") {
+			if (signal.version < slot.version) return;
+			slot.version = signal.version;
+		}
+		hold(slot, signal.value);
+	});
+	const slotOf = (ref) => {
+		const key = storeKey(ref);
+		let slot = slots.get(key);
+		if (!slot) {
+			slot = {
+				ref,
+				value: writable(void 0),
+				version: 0
+			};
+			slots.set(key, slot);
+			load(slot);
+		}
+		return slot;
+	};
+	return {
+		storage: {
+			store: (ref) => slotOf(ref).value,
+			async set(ref, value) {
+				const cwd = folder();
+				if (!cwd) throw new ExtensionsHostError({ code: "unavailable" });
+				const slot = slotOf(ref);
+				const before = slot.value.get();
+				slot.value.set(value);
+				const record = {
+					v: slot.schema ?? 1,
+					value
+				};
+				const result = await ext.storage.set(cwd, location(ref), "stores", ref.name, record).catch((err) => {
+					slot.value.set(before);
+					return rethrowInvalid(err);
+				});
+				if (result.version >= slot.version) {
+					slot.version = result.version;
+					if (result.accepted) {
+						if (typeof result.value?.v === "number") slot.schema = result.value.v;
+					} else hold(slot, result.value);
+				} else if (!result.accepted) slot.value.set(before);
+				if (!result.accepted) throw new ExtensionsHostError({
+					code: "refused",
+					reason: "invalid",
+					message: result.reason
+				});
+			}
+		},
+		reload: () => slots.forEach(load),
+		off
+	};
+}
+/** Every extension's settings, with the catalog items extensions changed. */
+function serverSettings(client, folder, onError) {
+	const wire = writable(EMPTY_SETTINGS);
+	let seq = 0;
+	let loading = Promise.resolve();
+	const refresh = () => {
+		loading = load();
+		return loading;
+	};
+	const load = () => {
+		const mine = ++seq;
+		const cwd = folder();
+		if (!cwd) return Promise.resolve(wire.set(EMPTY_SETTINGS));
+		const provenance = Promise.all(CATALOG_KINDS.map((kind) => client.call("extensions.catalogs.provenance", {
+			cwd,
+			kind
+		}).then((items) => items.map((item) => ({
+			...item,
+			kind
+		})), () => []))).then((lists) => lists.flat());
+		return Promise.all([client.call("extensions.settings", { cwd }), provenance]).then(([settings, changed]) => {
+			if (mine !== seq) return;
+			const { sources: _sources, ...rest } = settings;
+			wire.set({
+				...rest,
+				provenance: changed
+			});
+		}, onError);
+	};
+	return {
+		settings: {
+			wire,
+			async set(extensionId, key, value) {
+				const cwd = folder();
+				if (!cwd) throw new ExtensionsHostError({ code: "unavailable" });
+				await loading;
+				if (wire.get().locked.includes(`${extensionId}:${key}`)) throw new ExtensionsHostError({
+					code: "refused",
+					reason: "locked"
+				});
+				await client.call("extensions.settings.set", {
+					cwd,
+					extension: extensionId,
+					key,
+					value,
+					scope: "user"
+				}).catch((err) => {
+					if (err instanceof ServerCallError && err.code === -32602) throw new ExtensionsHostError({
+						code: "refused",
+						reason: "invalid",
+						message: err.message
+					});
+					return rethrow(err);
+				});
+				wire.set((prev) => ({
+					...prev,
+					values: {
+						...prev.values,
+						[extensionId]: {
+							...prev.values[extensionId],
+							[key]: value
+						}
+					}
+				}));
+				refresh();
+			}
+		},
+		refresh
+	};
+}
+/** Steps shown the default way: a link in a new tab, a question as a dialog of this host. */
+function defaultFlowStep(show) {
+	const ask = (request, reply, pick) => void show(request, { extensionId: "zidane" }).then((answer) => reply(pick ? pick(answer) : typeof answer === "string" ? answer : void 0), () => reply(void 0));
+	return (step, reply) => {
+		switch (step.type) {
+			case "auth":
+				globalThis.open?.(step.url, "_blank", "noopener");
+				return;
+			case "device":
+				show({
+					kind: "toast",
+					text: `${step.userCode} · ${step.verificationUri}`,
+					tone: "info"
+				}, { extensionId: "zidane" });
+				return;
+			case "prompt": return ask({
+				kind: "prompt",
+				title: step.message,
+				...step.placeholder ? { placeholder: step.placeholder } : {}
+			}, reply);
+			case "manual-code": return ask({
+				kind: "prompt",
+				title: "Paste the address the browser ended on"
+			}, reply);
+			case "select": return ask({
+				kind: "select",
+				title: step.message,
+				options: step.options
+			}, reply, (answer) => answer?.ids?.[0]);
+			default: return;
+		}
+	};
+}
+/** Integrations: Connect (a key, or a sign-in flow whose steps `onStep` shows) and Disconnect. */
+function serverIntegrations(client, folder, onError, onStep) {
+	const list = writable([]);
+	let seq = 0;
+	const refresh = () => {
+		const mine = ++seq;
+		const cwd = folder();
+		if (!cwd) return Promise.resolve(list.set([]));
+		return client.call("extensions.integrations.list", { cwd }).then((wires) => {
+			if (mine === seq) list.set(wires.map(integrationOf));
+		}, onError);
+	};
+	const need = () => {
+		const cwd = folder();
+		if (!cwd) throw new ExtensionsHostError({ code: "unavailable" });
+		return cwd;
+	};
+	return {
+		integrations: {
+			list,
+			async connect(integrationId, { methodId, key }) {
+				const cwd = need();
+				const method = list.get().find((i) => i.id === integrationId)?.methods.find((m) => m.id === methodId);
+				if (key !== void 0 || method?.type === "apiKey") await client.call("extensions.integrations.connectKey", {
+					cwd,
+					integrationId,
+					key: key ?? "",
+					methodId
+				}).catch((err) => {
+					if (err instanceof ServerCallError && err.code !== IpcErrorCode.Forbidden) throw new ExtensionsHostError({
+						code: "refused",
+						reason: "invalid",
+						message: err.message
+					});
+					return rethrow(err);
+				});
+				else {
+					const flowId = `flow-ui-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+					const off = client.onSignal((signal) => {
+						if (signal.kind !== "extensions:integration-flow" || signal.flowId !== flowId) return;
+						const step = signal.step;
+						onStep(step, (value) => {
+							if ("inputId" in step) client.call("extensions.integrations.flowInput", {
+								flowId,
+								inputId: step.inputId,
+								...value !== void 0 ? { value } : {}
+							}).catch(onError);
+						});
+					});
+					try {
+						await client.call("extensions.integrations.start", {
+							cwd,
+							integrationId,
+							methodId,
+							flowId
+						}).catch(rethrow);
+					} finally {
+						off();
+					}
+				}
+				await refresh();
+			},
+			async disconnect(integrationId, opts) {
+				await client.call("extensions.integrations.disconnect", {
+					cwd: need(),
+					integrationId,
+					...opts?.account !== void 0 ? { account: opts.account } : {}
+				}).catch(rethrow);
+				await refresh();
+			},
+			async setDefault(integrationId, account) {
+				await client.call("extensions.integrations.setDefault", {
+					cwd: need(),
+					integrationId,
+					account
+				}).catch(rethrow);
+				await refresh();
+			}
+		},
+		refresh
+	};
+}
+/** The unified commands of the folder, and the keymap mode on top for the session on screen. */
+function serverCommands(ext, folder, session, onError) {
+	const list = writable([]);
+	const mode = writable(void 0);
+	let seq = 0;
+	const commandOf = (c) => ({
+		id: c.id,
+		title: c.title,
+		...c.description ? { description: c.description } : {},
+		...c.slash ? { slash: c.slash.name } : {},
+		...c.bind.length > 0 ? { bind: c.bind } : {},
+		...c.extensionId ? { extensionId: c.extensionId } : {},
+		scope: c.scope ?? "global",
+		editable: c.editable === true,
+		...c.mode ? { mode: c.mode } : {},
+		hint: c.hint === true,
+		when: c.when ?? "always",
+		enabled: c.enabled !== false
+	});
+	const refresh = () => {
+		const mine = ++seq;
+		const cwd = folder();
+		if (!cwd) {
+			list.set([]);
+			mode.set(void 0);
+			return Promise.resolve();
+		}
+		return ext.commands.list(cwd, session()).then((result) => {
+			if (mine !== seq) return;
+			list.set(result.commands.map(commandOf));
+			if (mode.get() !== result.mode) mode.set(result.mode);
+		}, onError);
+	};
+	return {
+		commands: {
+			list,
+			mode,
+			async run(id, opts = {}) {
+				const cwd = folder();
+				if (!cwd) throw new ExtensionsHostError({ code: "unavailable" });
+				return ext.commands.run(cwd, id, opts).catch(rethrow);
+			}
+		},
+		refresh
+	};
+}
+//#endregion
+export { createServerExtensionsHost };