zidane-ui 0.0.0-stage → 9.0.2

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

@@ -0,0 +1,256 @@
+import { createStorageEditorPrefs } from "../files/headless/editor-prefs.js";
+import { droppedImportItems } from "../files/headless/entries.js";
+import { mediaTypeOfPath } from "../files/headless/media.js";
+import { importEntries } from "zidane/chat/pure";
+import { SERVER_MEDIA_PATH } from "zidane/ipc/browser";
+//#region src/adapters/server-files-host.ts
+/** FNV-1a over the text: the file's version, as the server has none. */
+function versionOf(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+const utf8Bytes = (text) => new TextEncoder().encode(text).length;
+/** Bytes as base64, in slices (`String.fromCharCode` takes so many arguments at once). */
+function toBase64(bytes) {
+	let binary = "";
+	for (let at = 0; at < bytes.length; at += 32768) binary += String.fromCharCode(...bytes.subarray(at, at + 32768));
+	return btoa(binary);
+}
+const ENTRY_METHODS = [
+	"sessions.workspaceCreate",
+	"sessions.workspaceMove",
+	"sessions.workspaceCopy",
+	"sessions.workspaceRemove"
+];
+/** The session's entry actions, over its `sessions.workspace*` calls. */
+function serverEntries(client, session) {
+	const noSession = (cwd) => ({
+		ok: false,
+		reason: "denied",
+		message: `No session holds ${cwd}.`
+	});
+	const create = (cwd, path, kind, content, freeName) => client.call("sessions.workspaceCreate", {
+		sessionId: session(cwd),
+		path,
+		kind,
+		...content ? { content: toBase64(content) } : {},
+		...freeName ? { freeName } : {}
+	});
+	const guarded = async (cwd, run) => {
+		try {
+			return await run();
+		} catch (error) {
+			return error instanceof Error && /no session holds/.test(error.message) ? noSession(cwd) : {
+				ok: false,
+				reason: "denied",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	return {
+		create: (cwd, path, kind) => guarded(cwd, () => create(cwd, path, kind)),
+		move: (cwd, from, to) => guarded(cwd, () => client.call("sessions.workspaceMove", {
+			sessionId: session(cwd),
+			from,
+			to
+		})),
+		copy: (cwd, from, toDir) => guarded(cwd, () => client.call("sessions.workspaceCopy", {
+			sessionId: session(cwd),
+			from,
+			toDir
+		})),
+		remove: (cwd, path) => guarded(cwd, () => client.call("sessions.workspaceRemove", {
+			sessionId: session(cwd),
+			path
+		})),
+		importFiles: async (cwd, dir, items) => importEntries((path, kind, options) => guarded(cwd, () => create(cwd, path, kind, options?.content, options?.freeName)), dir, await droppedImportItems(items)),
+		removal: () => "permanent"
+	};
+}
+/** A listed path relative to the folder: `./a`, `/cwd/a` and `a` all read `a`. */
+function relativePath(path, cwd) {
+	const base = cwd.replace(/\/+$/, "");
+	if (path.startsWith(`${base}/`)) return path.slice(base.length + 1);
+	return path.replace(/^\.\//, "");
+}
+/**
+* A media ticket, registered on every connection of `client` (the server
+* drops it with the connection); `null` when the server serves no media.
+*/
+function mediaTicket(client) {
+	if (!client.can("files.mediaTicket")) return null;
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32));
+	const ticket = btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	const register = () => void client.call("files.mediaTicket", { ticket }).catch(() => void 0);
+	register();
+	client.onOpen(register);
+	return ticket;
+}
+/** Where `source` plays from, under `ticket`. */
+function mediaAddress(ticket, source) {
+	const query = new URLSearchParams({
+		ticket,
+		cwd: source.cwd,
+		path: source.path
+	});
+	if (source.kind === "diff") query.set("side", source.side);
+	if (source.version !== void 0) query.set("v", String(source.version));
+	return `${SERVER_MEDIA_PATH}?${query}`;
+}
+/**
+* Creates a {@link FilesHost} on a running zidane-server.
+*
+* @param options - The shared client, the folder → session lookup and where editor preferences live.
+*/
+function createServerFilesHost(options) {
+	const { client, sessionOf } = options;
+	const ticket = mediaTicket(client);
+	const session = (cwd) => {
+		const id = sessionOf(cwd);
+		if (!id) throw new Error(`createServerFilesHost: no session holds ${cwd}`);
+		return id;
+	};
+	/** The file's text, or `null` when it does not exist. */
+	const readText = async (sessionId, path) => {
+		try {
+			return await client.call("sessions.workspaceReadFile", {
+				sessionId,
+				path
+			});
+		} catch (error) {
+			if (await client.call("sessions.workspaceFileSize", {
+				sessionId,
+				path
+			}).catch(() => void 0) === null) return null;
+			throw error;
+		}
+	};
+	return {
+		async list(cwd, opts) {
+			const sessionId = session(cwd);
+			const [entries, emptyDirs] = await Promise.all([client.call("sessions.workspaceListFiles", {
+				sessionId,
+				path: "**/*",
+				options: {
+					glob: true,
+					gitignore: !opts?.showIgnored
+				}
+			}), client.can("sessions.workspaceEmptyDirs") ? client.call("sessions.workspaceEmptyDirs", { sessionId }).catch(() => []) : []]);
+			const paths = /* @__PURE__ */ new Set();
+			for (const entry of entries) paths.add(relativePath(typeof entry === "string" ? entry : entry.path, cwd));
+			return [...[...paths].map((path) => ({
+				path,
+				kind: "file"
+			})), ...emptyDirs.map((path) => ({
+				path: `${path}/`,
+				kind: "dir"
+			}))].sort((a, b) => a.path.localeCompare(b.path));
+		},
+		async read(cwd, path) {
+			const sessionId = sessionOf(cwd);
+			if (!sessionId) return null;
+			const media = mediaTypeOfPath(path);
+			if (media && ticket) {
+				const size = await client.call("sessions.workspaceFileSize", {
+					sessionId,
+					path
+				}).catch(() => null);
+				return size === null ? null : {
+					path,
+					contents: "",
+					truncated: false,
+					size,
+					binary: true,
+					media,
+					mtimeMs: size
+				};
+			}
+			const text = await readText(sessionId, path).catch(() => null);
+			if (text === null) return null;
+			const binary = media !== null || text.includes("\0");
+			return {
+				path,
+				contents: binary ? "" : text,
+				truncated: false,
+				size: utf8Bytes(text),
+				binary,
+				mtimeMs: versionOf(text)
+			};
+		},
+		async write(cwd, path, contents, expectedMtimeMs) {
+			const sessionId = sessionOf(cwd);
+			if (!sessionId) return {
+				ok: false,
+				reason: "denied"
+			};
+			const current = await readText(sessionId, path).catch(() => void 0);
+			if (current === void 0) return {
+				ok: false,
+				reason: "denied"
+			};
+			if (current === null) return {
+				ok: false,
+				reason: "missing"
+			};
+			if (versionOf(current) !== expectedMtimeMs) return {
+				ok: false,
+				reason: "changed"
+			};
+			try {
+				await client.call("sessions.workspaceWriteFile", {
+					sessionId,
+					path,
+					content: contents
+				});
+			} catch {
+				return {
+					ok: false,
+					reason: "denied"
+				};
+			}
+			return {
+				ok: true,
+				mtimeMs: versionOf(contents)
+			};
+		},
+		...ENTRY_METHODS.every((method) => client.can(method)) ? { entries: serverEntries(client, session) } : {},
+		watch(scope, onChange) {
+			return client.onSignal((signal) => {
+				if (signal.kind !== "event" || signal.event.kind !== "tool-result") return;
+				const bound = scope.session ?? sessionOf(scope.workspace ?? scope.cwd);
+				if (signal.sessionId === bound) onChange("tool-result");
+			});
+		},
+		...client.can("files.search") ? { search: (cwd, query, { caseSensitive, searchId }) => client.call("files.search", {
+			cwd,
+			query,
+			caseSensitive,
+			searchId
+		}) } : {},
+		...client.can("git.fileStatus") ? { gitStatus: (cwd) => client.call("git.fileStatus", { cwd }) } : {},
+		...client.can("git.diff") ? { workingTreeDiff: (cwd, opts) => client.call("git.diff", {
+			cwd,
+			...opts?.path ? { path: opts.path } : {},
+			...opts?.context !== void 0 ? { context: Number.isFinite(opts.context) ? opts.context : null } : {}
+		}) } : {},
+		...client.can("files.diagnostics") && client.can("files.diagnosticsInvalidate") ? { diagnostics: {
+			run: (cwd, paths, { disabled, timeoutMs }) => client.call("files.diagnostics", {
+				cwd,
+				paths,
+				disabled,
+				timeoutMs
+			}),
+			invalidate: async (cwd) => {
+				await client.call("files.diagnosticsInvalidate", { cwd });
+			}
+		} } : {},
+		...options.storage ? { editorPrefs: createStorageEditorPrefs({ storage: options.storage }) } : {},
+		...ticket ? { mediaUrl: (source) => mediaAddress(ticket, source) } : {}
+	};
+}
+//#endregion
+export { createServerFilesHost };

package/dist/adapters/server-git-host.d.ts

@@ -0,0 +1,16 @@
+import { GitHost } from "../git/headless/host.js";
+import { ServerClient } from "zidane/ipc/browser";
+//#region src/adapters/server-git-host.d.ts
+/** Options for {@link createServerGitHost}. */
+interface ServerGitHostOptions {
+  /** The client to speak through, shared with the chat host. */
+  client: ServerClient;
+}
+/**
+ * Creates a {@link GitHost} over a zidane-server client.
+ *
+ * @param options - The client.
+ */
+declare function createServerGitHost(options: ServerGitHostOptions): GitHost;
+//#endregion
+export { ServerGitHostOptions, createServerGitHost };

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

@@ -0,0 +1,329 @@
+import { parseRepoInput } from "zidane/chat/pure";
+//#region src/adapters/server-git-host.ts
+/**
+* A `GitHost` on a running zidane-server, over the same client as the chat
+* host (`createServerClient`, or `createServerHost(...).client`).
+*
+* What it offers: the server's folders for a session's folder (`fs.listDirs`,
+* inside the server's workspace roots, with what the hello's `clone` and
+* `createFolders` allow there), creating and searching them (`fs.mkdir`,
+* `fs.searchDirs`), a shared machine's folders (`machines.listDirs`), the
+* environment kinds a new session can run in
+* (`environments.list`, read again on `settings:changed`, where environment
+* edits land, and after a reconnect), moving a session into a new worktree
+* or anywhere else the server runs, its machines included
+* (`sessions.moveEnvironment`), and the checkout in a folder of the
+* server's workspace roots: branches, pull requests, the git bar's status and
+* pull request (`git.branches`, `git.pullRequests`, `git.status`,
+* `git.branchPullRequest`), switching, starting branches, sync and the
+* repository import (`git.checkout`, `git.createBranch`, `git.sync`,
+* `git.clone` with `git:clone:progress`, `git.cloneCancel`; clones land in
+* the first workspace root by default). A session's tool results refresh the
+* git bar (`event` signals), and so do its refs moving (`subscribeRefs`:
+* `git.watch`, `git:refs`, watched again after a reconnect). Each git member
+* is offered when the connection may call its method (`client.can`): reads,
+* cloning and new folders need a `chat` token, the other writes an `admin`
+* one.
+*
+* Not offered: a native folder dialog, and clone on send (the browser has no
+* project on this computer to start from: `originUrl`, `cloneOnServer`).
+*/
+const failed = (error) => ({
+	code: "failed",
+	message: error instanceof Error ? error.message : String(error)
+});
+/** A server's switch answer, as the kit words it. */
+function readCheckout(result) {
+	if (result.ok) return { ok: true };
+	return {
+		ok: false,
+		error: {
+			code: "failed",
+			message: result.error
+		},
+		...result.worktree ? { worktree: {
+			path: result.worktree,
+			chats: result.chats ?? []
+		} } : {}
+	};
+}
+/** A server's sync answer, as the kit words it. */
+function readSync(result) {
+	if (result.ok) return result;
+	return {
+		ok: false,
+		error: {
+			code: "failed",
+			message: result.error
+		},
+		...result.conflicts ? { conflicts: result.conflicts } : {}
+	};
+}
+/**
+* What the server lets this connection do in its folders: the hello's flags, and the methods its token reaches. An
+* older server sends no flags: the methods its hello lists say it then. `undefined` when neither says.
+*/
+function folderAllows(client) {
+	const hello = client.hello();
+	const searchFolders = client.can("fs.searchDirs");
+	if (hello?.clone !== void 0 || hello?.createFolders !== void 0) return {
+		createFolders: hello.createFolders === true && client.can("fs.mkdir"),
+		clone: hello.clone === true && client.can("git.clone"),
+		searchFolders
+	};
+	if (!hello?.methods) return void 0;
+	return {
+		createFolders: client.can("fs.mkdir"),
+		clone: client.can("git.clone"),
+		searchFolders
+	};
+}
+/** The repository import over `git.clone`: one clone per connection, landing in the first workspace root by default. */
+function createClone(client) {
+	return {
+		parse: parseRepoInput,
+		async defaultParent() {
+			return (await client.call("fs.roots", {})).roots[0] ?? "";
+		},
+		async clone(input, parent) {
+			try {
+				const result = await client.call("git.clone", {
+					input,
+					parent
+				});
+				if (result.ok) return {
+					ok: true,
+					path: result.path,
+					existed: result.existed
+				};
+				return result.cancelled ? {
+					ok: false,
+					cancelled: true
+				} : {
+					ok: false,
+					error: {
+						code: "failed",
+						message: result.error
+					}
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: failed(error)
+				};
+			}
+		},
+		onProgress: (onProgress) => client.onSignal((signal) => {
+			if (signal.kind === "git:clone:progress") onProgress({
+				phase: signal.phase,
+				percent: signal.percent
+			});
+		}),
+		...client.can("git.cloneCancel") ? { cancel: async () => {
+			await client.call("git.cloneCancel", {});
+		} } : {}
+	};
+}
+/**
+* Creates a {@link GitHost} over a zidane-server client.
+*
+* @param options - The client.
+*/
+function createServerGitHost(options) {
+	const { client } = options;
+	const host = {
+		async startWorktree(sessionId, branch) {
+			try {
+				await client.call("sessions.moveEnvironment", {
+					sessionId,
+					environment: {
+						kind: "worktree",
+						...branch ? { branch } : {}
+					}
+				});
+				return { ok: true };
+			} catch (error) {
+				return {
+					ok: false,
+					error: failed(error)
+				};
+			}
+		},
+		async moveSession(sessionId, { kind, branch, cwd, removeOldWorktree }) {
+			try {
+				const result = await client.call("sessions.moveEnvironment", {
+					sessionId,
+					environment: {
+						kind,
+						...branch ? { branch } : {}
+					},
+					...cwd ? { cwd } : {},
+					...removeOldWorktree ? { removeOldWorktree: true } : {}
+				});
+				return {
+					ok: true,
+					...result?.oldWorktree ? { oldWorktree: result.oldWorktree } : {}
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: failed(error)
+				};
+			}
+		},
+		async environments({ cwd }) {
+			return client.call("environments.list", cwd ? { cwd } : {});
+		},
+		subscribeEnvironments(_query, onChange) {
+			const offSignal = client.onSignal((signal) => {
+				if (signal.kind === "settings:changed") onChange();
+			});
+			const offOpen = client.onOpen((_hello, reconnected) => {
+				if (reconnected) onChange();
+			});
+			return () => {
+				offSignal();
+				offOpen();
+			};
+		},
+		subscribeActivity: (sessionId, onChange) => client.onSignal((signal) => {
+			if (signal.kind === "event" && signal.sessionId === sessionId && signal.event.kind === "tool-result") onChange();
+		}),
+		async listFolders({ machineId, path }) {
+			try {
+				if (machineId) {
+					const listing = await client.call("machines.listDirs", {
+						machineId,
+						...path ? { path } : {}
+					});
+					const atRoot = listing.roots.includes(listing.path);
+					return {
+						ok: true,
+						listing: {
+							roots: listing.roots,
+							path: listing.path,
+							parent: atRoot ? null : listing.path.replace(/\/[^/]+\/?$/, "") || "/",
+							dirs: listing.dirs.map((dir) => ({
+								name: dir.slice(dir.lastIndexOf("/") + 1),
+								path: dir,
+								isGitRepo: false
+							}))
+						}
+					};
+				}
+				const listing = await client.call("fs.listDirs", path ? { path } : {});
+				const allows = folderAllows(client);
+				return {
+					ok: true,
+					listing: {
+						roots: listing.roots,
+						path: listing.path,
+						parent: listing.parent,
+						dirs: listing.entries.map((dir) => ({
+							name: dir.name,
+							path: dir.path,
+							isGitRepo: dir.isGitRepo
+						})),
+						...allows ? { allows } : {}
+					}
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: failed(error)
+				};
+			}
+		}
+	};
+	if (client.can("fs.mkdir")) host.createFolder = async ({ parent, name }) => {
+		try {
+			return {
+				ok: true,
+				folder: await client.call("fs.mkdir", {
+					parent,
+					name
+				})
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: failed(error)
+			};
+		}
+	};
+	if (client.can("fs.searchDirs")) host.searchFolders = async ({ query, path }) => {
+		try {
+			const found = await client.call("fs.searchDirs", {
+				query,
+				...path ? { path } : {}
+			});
+			return {
+				ok: true,
+				results: found.results,
+				truncated: found.truncated === true
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: failed(error)
+			};
+		}
+	};
+	if (client.can("git.branches")) host.branches = (cwd) => client.call("git.branches", { cwd });
+	if (client.can("git.pullRequests")) host.pullRequests = async ({ cwd, search, fresh }) => {
+		const result = await client.call("git.pullRequests", {
+			cwd,
+			...search ? { search } : {},
+			...fresh ? { fresh } : {}
+		});
+		if (result === null) return { kind: "unavailable" };
+		if (!Array.isArray(result)) return {
+			kind: "rate-limited",
+			retryAt: result.rateLimited.retryAt
+		};
+		return {
+			kind: "list",
+			items: result
+		};
+	};
+	if (client.can("git.checkout")) host.checkout = async (cwd, target, sessionId) => readCheckout(await client.call("git.checkout", {
+		cwd,
+		target: "branch" in target ? target.branch : { pr: target.pullRequest },
+		...sessionId ? { sessionId } : {}
+	}));
+	if (client.can("git.createBranch")) host.createBranch = async (cwd, name, sessionId) => readCheckout(await client.call("git.createBranch", {
+		cwd,
+		name,
+		...sessionId ? { sessionId } : {}
+	}));
+	if (client.can("git.status")) host.status = (cwd) => client.call("git.status", { cwd });
+	if (client.can("git.branchPullRequest")) host.branchPullRequest = (cwd, branch, fresh) => client.call("git.branchPullRequest", {
+		cwd,
+		branch,
+		...fresh ? { fresh } : {}
+	});
+	if (client.can("git.sync")) host.sync = async (cwd, sessionId) => readSync(await client.call("git.sync", {
+		cwd,
+		...sessionId ? { sessionId } : {}
+	}));
+	if (client.can("git.clone")) host.clone = createClone(client);
+	if (client.can("git.watch")) host.subscribeRefs = (cwd, onChange) => subscribeRefs(client, cwd, onChange);
+	return host;
+}
+/** Follows `cwd`'s refs: one `git.watch` per connection while subscribed (a closed connection's is released with it). */
+function subscribeRefs(client, cwd, onChange) {
+	const watch = () => void client.call("git.watch", { cwd }).catch(() => void 0);
+	if (client.hello()) watch();
+	const offs = [client.onSignal((signal) => {
+		if (signal.kind === "git:refs" && signal.cwd === cwd) onChange();
+	}), client.onOpen(() => {
+		watch();
+		onChange();
+	})];
+	return () => {
+		for (const off of offs) off();
+		client.call("git.unwatch", { cwd }).catch(() => void 0);
+	};
+}
+//#endregion
+export { createServerGitHost };

package/dist/adapters/server-host.d.ts

@@ -0,0 +1,58 @@
+import { Readable } from "../chat/headless/store.js";
+import { SidebarListSession } from "../chat/headless/sidebar/types.js";
+import { ChatHost, ChatModelProvider, ChatSession } from "../chat/headless/host.js";
+import { ServerClient, ServerClientOptions, ServerClientState } from "zidane/ipc/browser";
+import { HostModelProvider, SessionRow } from "zidane/ipc";
+//#region src/adapters/server-host.d.ts
+/** Options for {@link createServerHost}: a client to share, or what to create one with. */
+type ServerHostOptions = ({
+  /** A client already made with `createServerClient`, shared with other hosts (approvals, settings…). */
+  client: ServerClient;
+} | (Omit<ServerClientOptions, 'onState'> & {
+  client?: undefined;
+})) & {
+  /** Working directory for new sessions (default `''`: the server's first workspace root). */
+  cwd?: string;
+  /** Called with errors that no caller can receive, such as a failed background reload. Default: a console warning. */
+  onError?: (error: unknown) => void;
+};
+/** The {@link ChatHost} {@link createServerHost} returns, plus the connection. */
+interface ServerHost extends ChatHost {
+  /** The client it speaks through (for other areas' hosts on the same connection). */
+  client: ServerClient;
+  /** The connection's state, for a status line or a sign-in prompt. */
+  connection: Readable<ServerClientState>;
+  /** Resolves once the first handshake and session list completed; rejects when the client was refused. */
+  ready: Promise<void>;
+  /** Re-reads the session list. */
+  refresh(): Promise<void>;
+  /** Closes the connection and stops reconnecting (also closes a client it was given). */
+  close(): void;
+}
+/**
+ * Converts a zidane server's session row into a {@link ChatSession}. The project root becomes the group, the main session is pinned, and the model id gets its provider prefix.
+ *
+ * @param row - The session row from the server.
+ */
+declare function toChatSession(row: SessionRow): ChatSession;
+/**
+ * Converts a zidane server's session row into a {@link SidebarListSession}: the chat session plus its folder and space.
+ *
+ * @param row - The session row from the server.
+ */
+declare function toSidebarListSession(row: SessionRow): SidebarListSession;
+/**
+ * Converts the server's model list into the model picker's providers.
+ *
+ * @param providers - `models.list`'s providers.
+ */
+declare function toChatModelProviders(providers: readonly HostModelProvider[]): ChatModelProvider[];
+/**
+ * Creates a {@link ChatHost} on a running zidane-server. Pass a shared `client`, or the `url`
+ * and `token` (and client options) to create one.
+ *
+ * @param options - The client, or what to create one with, plus the working directory for new sessions.
+ */
+declare function createServerHost(options: ServerHostOptions): ServerHost;
+//#endregion
+export { ServerHost, ServerHostOptions, createServerHost, toChatModelProviders, toChatSession, toSidebarListSession };