@jmfederico/pi-web 1.202610.3 → 1.202610.5

package/dist/pi-packages/workflows/server-plugin.js

@@ -0,0 +1,579 @@
+//#region src/shared/pluginCatalogTypes.ts
+var PI_WEB_HOST_CATALOG_CAPABILITY = Object.freeze({
+	pluginId: "pi-web.host",
+	id: "catalog",
+	version: 1,
+	parse: snapshotCatalog
+});
+function snapshotCatalog(value) {
+	const catalog = record(value);
+	if (catalog["version"] !== 1) throw invalid();
+	const projects = methods(catalog["projects"]);
+	const workspaces = methods(catalog["workspaces"]);
+	const sessions = methods(catalog["sessions"]);
+	return Object.freeze({
+		version: 1,
+		projects: Object.freeze({
+			list: async (options) => array(await projects.list(options), snapshotProject),
+			get: async (projectId, options) => {
+				const id = text(projectId);
+				const result = snapshotProject(await projects.get(id, options));
+				if (result.id !== id) throw invalid();
+				return result;
+			}
+		}),
+		workspaces: Object.freeze({
+			list: async (projectId, options) => {
+				const id = text(projectId);
+				return array(await workspaces.list(id, options), (row) => workspaceFor(row, id));
+			},
+			get: async (selection, options) => {
+				const requested = snapshotSelection(selection);
+				const result = workspaceFor(await workspaces.get(requested, options), requested.projectId);
+				if (result.id !== requested.workspaceId) throw invalid();
+				return result;
+			}
+		}),
+		sessions: Object.freeze({
+			list: async (selection, options) => array(await sessions.list(snapshotSelection(selection), options), snapshotSession),
+			get: async (selection, options) => {
+				const requested = snapshotSelection(selection, true);
+				const result = snapshotSession(await sessions.get(requested, options));
+				if (result.id !== requested.sessionId) throw invalid();
+				return result;
+			}
+		})
+	});
+}
+function methods(value) {
+	const owner = record(value);
+	const list = owner["list"];
+	const get = owner["get"];
+	if (typeof list !== "function" || typeof get !== "function") throw invalid();
+	return {
+		list: (...args) => Promise.resolve(Reflect.apply(list, owner, args)),
+		get: (...args) => Promise.resolve(Reflect.apply(get, owner, args))
+	};
+}
+function snapshotProject(value) {
+	const row = record(value);
+	return Object.freeze({
+		id: text(row["id"]),
+		name: text(row["name"]),
+		path: text(row["path"])
+	});
+}
+function workspaceFor(value, projectId) {
+	const row = record(value);
+	if (row["projectId"] !== projectId || typeof row["isMain"] !== "boolean") throw invalid();
+	let provider;
+	if (row["provider"] !== void 0) {
+		const source = record(row["provider"]);
+		const capabilities = record(source["capabilities"]);
+		if (typeof capabilities["remove"] !== "boolean") throw invalid();
+		provider = Object.freeze({
+			pluginId: text(source["pluginId"]),
+			capabilities: Object.freeze({ remove: capabilities["remove"] }),
+			...source["metadata"] === void 0 ? {} : { metadata: jsonObject(source["metadata"]) }
+		});
+	}
+	const removal = row["removal"] === void 0 ? void 0 : record(row["removal"]);
+	return Object.freeze({
+		id: text(row["id"]),
+		projectId,
+		path: text(row["path"]),
+		label: text(row["label"]),
+		isMain: row["isMain"],
+		...provider === void 0 ? {} : { provider },
+		...removal === void 0 ? {} : { removal: Object.freeze({
+			actionLabel: text(removal["actionLabel"]),
+			confirmation: text(removal["confirmation"])
+		}) }
+	});
+}
+function snapshotSession(value) {
+	const row = record(value);
+	const runtime = row["runtime"];
+	if (typeof row["archived"] !== "boolean" || runtime !== "not-hosted" && runtime !== "idle" && runtime !== "busy") throw invalid();
+	let metadata;
+	if (row["metadata"] !== void 0) metadata = Object.freeze(Object.fromEntries(Object.entries(record(row["metadata"])).map(([key, data]) => [key, jsonObject(data)])));
+	if (row["name"] !== void 0 && typeof row["name"] !== "string") throw invalid();
+	return Object.freeze({
+		id: text(row["id"]),
+		cwd: text(row["cwd"]),
+		archived: row["archived"],
+		runtime,
+		...row["name"] === void 0 ? {} : { name: row["name"] },
+		...metadata === void 0 ? {} : { metadata }
+	});
+}
+function snapshotSelection(value, session = false) {
+	const row = record(value);
+	const keys = session ? [
+		"projectId",
+		"workspaceId",
+		"sessionId"
+	] : ["projectId", "workspaceId"];
+	if (Reflect.ownKeys(row).some((key) => typeof key !== "string" || !keys.includes(key))) throw invalid();
+	return Object.freeze({
+		projectId: text(row["projectId"]),
+		workspaceId: text(row["workspaceId"]),
+		...session ? { sessionId: text(row["sessionId"]) } : {}
+	});
+}
+function array(value, snapshot) {
+	if (!Array.isArray(value)) throw invalid();
+	return Object.freeze(value.map(snapshot));
+}
+function record(value) {
+	if (!isRecord(value)) throw invalid();
+	return value;
+}
+function isRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function text(value) {
+	if (typeof value !== "string" || value.trim() === "") throw invalid();
+	return value;
+}
+function jsonObject(value, ancestors = /* @__PURE__ */ new Set()) {
+	const source = record(value);
+	if (ancestors.has(source)) throw invalid();
+	ancestors.add(source);
+	const result = Object.freeze(Object.fromEntries(Object.entries(source).map(([key, data]) => [key, json(data, ancestors)])));
+	ancestors.delete(source);
+	return result;
+}
+function json(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw invalid();
+		ancestors.add(value);
+		const result = Object.freeze(value.map((item) => json(item, ancestors)));
+		ancestors.delete(value);
+		return result;
+	}
+	return jsonObject(value, ancestors);
+}
+function invalid() {
+	return /* @__PURE__ */ new Error("Invalid PI WEB host catalog capability v1 data");
+}
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "workspaces",
+	version: 1,
+	parse: snapshotPiWebHostWorkspacesV1
+});
+/** Exact PI sessions v1 capability supplied separately for each declaring server plugin. */
+var PI_WEB_HOST_PI_SESSIONS_CAPABILITY = Object.freeze({
+	pluginId: "pi-web.host",
+	id: "pi-sessions",
+	version: 1,
+	parse: snapshotPiWebHostPiSessionsV1
+});
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "pi-session-events",
+	version: 1,
+	parse: snapshotPiWebHostPiSessionEventsV1
+});
+function snapshotPiWebHostWorkspacesV1(value) {
+	if (typeof value !== "object" || value === null) throw invalidPiWebHostWorkspaces();
+	const version = Reflect.get(value, "version");
+	const resolve = Reflect.get(value, "resolve");
+	if (version !== 1 || typeof resolve !== "function") throw invalidPiWebHostWorkspaces();
+	return Object.freeze({
+		version: 1,
+		resolve: async (selection) => {
+			const requested = snapshotPiWebHostWorkspaceSelection(selection);
+			return snapshotPiWebHostWorkspaceAuthority(await Reflect.apply(resolve, value, [requested]), requested);
+		}
+	});
+}
+function snapshotPiWebHostPiSessionEventsV1(value) {
+	if (typeof value !== "object" || value === null) throw new Error("Invalid PI session events capability");
+	const connect = Reflect.get(value, "connect");
+	if (Reflect.get(value, "version") !== 1 || typeof connect !== "function") throw new Error("Invalid PI session events capability");
+	return Object.freeze({
+		version: 1,
+		connect: async (selection) => {
+			const workspace = snapshotPiWebHostWorkspaceSelection({
+				projectId: selection.projectId,
+				workspaceId: selection.workspaceId
+			});
+			const sessionId = selection.sessionId;
+			if (typeof sessionId !== "string" || sessionId.trim() === "" || sessionId.length > 512) throw new Error("Invalid hosted session id");
+			const connection = await Reflect.apply(connect, value, [{
+				...workspace,
+				sessionId
+			}]);
+			if (typeof connection !== "object" || connection === null) throw new Error("Invalid PI session events connection");
+			const signal = Reflect.get(connection, "signal");
+			const on = Reflect.get(connection, "on");
+			const emit = Reflect.get(connection, "emit");
+			const close = Reflect.get(connection, "close");
+			if (!(signal instanceof AbortSignal) || typeof on !== "function" || typeof emit !== "function" || typeof close !== "function") throw new Error("Invalid PI session events connection");
+			return Object.freeze({
+				signal,
+				on: (channel, handler) => {
+					const unsubscribe = Reflect.apply(on, connection, [channel, handler]);
+					if (typeof unsubscribe !== "function") throw new Error("Invalid PI event unsubscribe function");
+					return () => {
+						Reflect.apply(unsubscribe, void 0, []);
+					};
+				},
+				emit: (channel, data) => {
+					Reflect.apply(emit, connection, [channel, data]);
+				},
+				close: () => {
+					Reflect.apply(close, connection, []);
+				}
+			});
+		}
+	});
+}
+function snapshotPiWebHostPiSessionsV1(value) {
+	if (typeof value !== "object" || value === null) throw invalidPiWebHostPiSessions();
+	const version = Reflect.get(value, "version");
+	const run = Reflect.get(value, "run");
+	const create = Reflect.get(value, "create");
+	if (version !== 1 || typeof run !== "function" || typeof create !== "function") throw invalidPiWebHostPiSessions();
+	return Object.freeze({
+		version: 1,
+		create: async (input) => {
+			const requested = snapshotPiWebHostWorkspaceSelection(input);
+			const result = await Reflect.apply(create, value, [requested]);
+			if (!isPublicJsonObject(result)) throw new Error("PI WEB host PI sessions capability v1 must return a created session object");
+			const sessionId = requiredBoundedPiSessionString(Reflect.get(result, "sessionId"), "returned sessionId", 512);
+			return Object.freeze({ sessionId });
+		},
+		run: async (input) => {
+			const requested = snapshotPiWebHostPiSessionRunInput(input);
+			return snapshotPiWebHostPiSessionRun(await Reflect.apply(run, value, [requested]));
+		}
+	});
+}
+function snapshotPiWebHostPiSessionRunInput(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 run input must be an object");
+	const supportedKeys = /* @__PURE__ */ new Set([
+		"projectId",
+		"workspaceId",
+		"prompt"
+	]);
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !supportedKeys.has(key)) throw new Error(`Unsupported PI WEB host PI sessions capability v1 run input field: ${String(key)}`);
+	if (!Object.hasOwn(value, "projectId") || !Object.hasOwn(value, "workspaceId") || !Object.hasOwn(value, "prompt")) throw new Error("PI WEB host PI sessions capability v1 run input must contain projectId, workspaceId, and prompt");
+	const projectId = requiredBoundedPiSessionString(Reflect.get(value, "projectId"), "projectId", 512);
+	const workspaceId = requiredBoundedPiSessionString(Reflect.get(value, "workspaceId"), "workspaceId", 512);
+	const prompt = requiredBoundedPiSessionUtf8String(Reflect.get(value, "prompt"), "prompt", 65536);
+	return Object.freeze({
+		projectId,
+		workspaceId,
+		prompt
+	});
+}
+function snapshotPiWebHostPiSessionRun(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 must return a run object");
+	const sessionId = requiredBoundedPiSessionString(Reflect.get(value, "sessionId"), "returned sessionId", 512);
+	const completionValue = Reflect.get(value, "completion");
+	if (!isPromiseLike(completionValue)) throw new Error("PI WEB host PI sessions capability v1 run must expose completion");
+	const completion = Promise.resolve(completionValue).then(snapshotPiWebHostPiSessionRunCompletion);
+	return Object.freeze({
+		sessionId,
+		completion
+	});
+}
+function snapshotPiWebHostPiSessionRunCompletion(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 completion must be an object");
+	const status = Reflect.get(value, "status");
+	if (status === "completed" || status === "cancelled") return Object.freeze({ status });
+	if (status !== "failed") throw new Error("PI WEB host PI sessions capability v1 completion status is invalid");
+	const error = requiredBoundedPiSessionUtf8String(Reflect.get(value, "error"), "completion error", 4096);
+	return Object.freeze({
+		status,
+		error
+	});
+}
+function snapshotPiWebHostWorkspaceSelection(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 selection must be an object");
+	const supportedKeys = /* @__PURE__ */ new Set(["projectId", "workspaceId"]);
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !supportedKeys.has(key)) throw new Error(`Unsupported PI WEB host workspaces capability v1 selection field: ${String(key)}`);
+	if (!Object.hasOwn(value, "projectId") || !Object.hasOwn(value, "workspaceId")) throw new Error("PI WEB host workspaces capability v1 selection must contain projectId and workspaceId");
+	const projectId = requiredPublicString(Reflect.get(value, "projectId"), "selection projectId");
+	const workspaceId = requiredPublicString(Reflect.get(value, "workspaceId"), "selection workspaceId");
+	return Object.freeze({
+		projectId,
+		workspaceId
+	});
+}
+function snapshotPiWebHostWorkspaceAuthority(value, requested) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 must return an authority object");
+	const project = snapshotPiWebHostProject(Reflect.get(value, "project"));
+	const workspace = snapshotPiWebHostWorkspace(Reflect.get(value, "workspace"));
+	if (workspace.projectId !== project.id) throw new Error("PI WEB host workspaces capability v1 returned mismatched project and workspace scopes");
+	if (project.id !== requested.projectId || workspace.id !== requested.workspaceId) throw new Error("PI WEB host workspaces capability v1 returned authority outside the requested selection");
+	return Object.freeze({
+		project,
+		workspace
+	});
+}
+function snapshotPiWebHostProject(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 project must be an object");
+	const id = requiredPublicString(Reflect.get(value, "id"), "project id");
+	const name = requiredPublicString(Reflect.get(value, "name"), "project name");
+	const path = requiredPublicString(Reflect.get(value, "path"), "project path");
+	return Object.freeze({
+		id,
+		name,
+		path
+	});
+}
+function snapshotPiWebHostWorkspace(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 workspace must be an object");
+	const id = requiredPublicString(Reflect.get(value, "id"), "workspace id");
+	const projectId = requiredPublicString(Reflect.get(value, "projectId"), "workspace projectId");
+	const path = requiredPublicString(Reflect.get(value, "path"), "workspace path");
+	const label = requiredPublicString(Reflect.get(value, "label"), "workspace label");
+	const isMain = Reflect.get(value, "isMain");
+	if (typeof isMain !== "boolean") throw new Error("PI WEB host workspaces capability v1 workspace isMain must be a boolean");
+	const providerValue = Reflect.get(value, "provider");
+	const provider = providerValue === void 0 ? void 0 : snapshotPiWebHostWorkspaceProvider(providerValue);
+	return Object.freeze({
+		id,
+		projectId,
+		path,
+		label,
+		isMain,
+		...provider === void 0 ? {} : { provider }
+	});
+}
+function snapshotPiWebHostWorkspaceProvider(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 workspace provider must be an object");
+	const pluginId = requiredPublicString(Reflect.get(value, "pluginId"), "workspace provider pluginId");
+	const capabilitiesValue = Reflect.get(value, "capabilities");
+	if (!isPublicJsonObject(capabilitiesValue)) throw new Error("PI WEB host workspaces capability v1 workspace provider capabilities are invalid");
+	const remove = Reflect.get(capabilitiesValue, "remove");
+	if (typeof remove !== "boolean") throw new Error("PI WEB host workspaces capability v1 workspace provider capabilities are invalid");
+	const capabilities = Object.freeze({ remove });
+	const metadataValue = Reflect.get(value, "metadata");
+	const metadata = metadataValue === void 0 ? void 0 : clonePublicJsonObject(metadataValue, "workspace provider metadata");
+	return Object.freeze({
+		pluginId,
+		capabilities,
+		...metadata === void 0 ? {} : { metadata }
+	});
+}
+function clonePublicJsonObject(value, label) {
+	if (!isPublicJsonObject(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must be a JSON object`);
+	return clonePublicJsonRecord(value, /* @__PURE__ */ new Set(), label);
+}
+function clonePublicJsonRecord(value, ancestors, label) {
+	if (ancestors.has(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain cycles`);
+	ancestors.add(value);
+	try {
+		const output = {};
+		for (const key of Object.keys(value)) Object.defineProperty(output, key, {
+			value: clonePublicJsonValue(value[key], ancestors, label),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		return Object.freeze(output);
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function clonePublicJsonValue(value, ancestors, label) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must contain only finite JSON numbers`);
+		return value;
+	}
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain cycles`);
+		ancestors.add(value);
+		try {
+			const output = [];
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain sparse arrays`);
+				output.push(clonePublicJsonValue(value[index], ancestors, label));
+			}
+			return Object.freeze(output);
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	if (isPublicJsonObject(value)) return clonePublicJsonRecord(value, ancestors, label);
+	throw new Error(`PI WEB host workspaces capability v1 ${label} must contain only JSON values`);
+}
+function requiredPublicString(value, label) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host workspaces capability v1 ${label} must be a non-empty string`);
+	return value;
+}
+function requiredBoundedPiSessionString(value, label, maxLength) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host PI sessions capability v1 ${label} must be a non-empty string`);
+	if (value.length > maxLength) throw new Error(`PI WEB host PI sessions capability v1 ${label} must be at most ${String(maxLength)} characters`);
+	return value;
+}
+function requiredBoundedPiSessionUtf8String(value, label, maxBytes) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host PI sessions capability v1 ${label} must be a non-empty string`);
+	if (publicStringExceedsUtf8ByteLimit(value, maxBytes)) throw new Error(`PI WEB host PI sessions capability v1 ${label} must be at most ${String(maxBytes)} UTF-8 bytes`);
+	return value;
+}
+function publicStringExceedsUtf8ByteLimit(value, maxBytes) {
+	let bytes = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint === void 0) break;
+		if (codePoint > 65535) index += 1;
+		bytes += codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+		if (bytes > maxBytes) return true;
+	}
+	return false;
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null || typeof value === "function" ? typeof Reflect.get(value, "then") === "function" : false;
+}
+function isPublicJsonObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function invalidPiWebHostWorkspaces() {
+	return /* @__PURE__ */ new Error("PI WEB host workspaces capability v1 must expose resolve");
+}
+function invalidPiWebHostPiSessions() {
+	return /* @__PURE__ */ new Error("PI WEB host PI sessions capability v1 must expose create and run");
+}
+//#endregion
+//#region pi-packages/workflows/server-plugin.ts
+var GIT_LOCAL_ENV_VARS = Object.freeze([
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_COMMON_DIR",
+	"GIT_CONFIG",
+	"GIT_CONFIG_COUNT",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_DIR",
+	"GIT_GRAFT_FILE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+	"GIT_QUARANTINE_PATH",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_SHALLOW_FILE",
+	"GIT_WORK_TREE"
+]);
+var plugin = {
+	apiVersion: 5,
+	name: "Workflows",
+	requires: [PI_WEB_HOST_CATALOG_CAPABILITY, PI_WEB_HOST_PI_SESSIONS_CAPABILITY],
+	activate(context) {
+		let catalog;
+		let sessions;
+		return {
+			start({ capabilities }) {
+				catalog = capabilities.resolve(PI_WEB_HOST_CATALOG_CAPABILITY);
+				sessions = capabilities.resolve(PI_WEB_HOST_PI_SESSIONS_CAPABILITY);
+			},
+			peer: { async request({ scope, operation, input, signal }) {
+				if (scope.kind !== "project") throw new Error("Workflows requires project scope");
+				if (operation !== "prepare" && operation !== "dispatch") throw new Error("Unknown Workflows operation");
+				const details = operation === "dispatch" ? dispatchInput(input) : void 0;
+				if (catalog === void 0 || sessions === void 0) throw new Error("Workflows has not started");
+				const workspaces = await catalog.workspaces.list(scope.project.id, { signal });
+				if (workspaces.some((workspace) => workspace.projectId !== scope.project.id)) throw new Error("Catalog workspace is outside the scoped project");
+				const mains = workspaces.filter((workspace) => workspace.isMain);
+				const main = mains[0];
+				if (mains.length !== 1 || main === void 0) throw new Error("Project must have exactly one main workspace");
+				const git = (args) => runGit(context, main.path, args, signal);
+				if ((await git(["rev-parse", "--is-inside-work-tree"])).trim() !== "true" || (await git(["rev-parse", "--is-bare-repository"])).trim() !== "false") throw new Error("Main workspace must be a non-bare Git worktree");
+				if (details === void 0) {
+					const refs = await git([
+						"for-each-ref",
+						"--format=%(refname)",
+						"refs/heads/",
+						"refs/remotes/"
+					]);
+					const branches = [...new Set(refs.split(/\r?\n/u).filter(Boolean).map((ref) => ref.replace(/^refs\/(?:heads|remotes)\//u, "")))].sort();
+					const current = (await git([
+						"rev-parse",
+						"--abbrev-ref",
+						"HEAD"
+					])).trim();
+					if (current === "") throw new Error("Git returned an empty current branch");
+					return {
+						workspaceId: main.id,
+						workspacePath: main.path,
+						branches,
+						defaultBase: current
+					};
+				}
+				await git([
+					"rev-parse",
+					"--verify",
+					"--end-of-options",
+					`${details.base}^{commit}`
+				]);
+				signal.throwIfAborted();
+				const run = await sessions.run({
+					projectId: scope.project.id,
+					workspaceId: main.id,
+					prompt: worktreeCommand(details.base, details.description)
+				});
+				const logDetails = {
+					projectId: scope.project.id,
+					workspaceId: main.id,
+					sessionId: run.sessionId
+				};
+				run.completion.then((completion) => {
+					if (completion.status === "failed") context.logger.error("Workflows initial worktree task failed", {
+						...logDetails,
+						error: completion.error
+					});
+					else if (completion.status === "cancelled") context.logger.warn("Workflows initial worktree task cancelled", logDetails);
+				}, (error) => {
+					context.logger.error("Workflows initial worktree task completion rejected", {
+						...logDetails,
+						error: error instanceof Error ? error.message : String(error)
+					});
+				});
+				return {
+					workspaceId: main.id,
+					sessionId: run.sessionId
+				};
+			} }
+		};
+	}
+};
+function dispatchInput(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input) || Object.keys(input).some((key) => key !== "base" && key !== "description")) throw new Error("Dispatch input must contain only base and description");
+	return {
+		base: boundedString(Reflect.get(input, "base"), "base", 1024),
+		description: boundedString(Reflect.get(input, "description"), "description", 16384)
+	};
+}
+function boundedString(value, name, maxBytes) {
+	if (typeof value !== "string" || value.trim() === "" || value.includes("\0") || Buffer.byteLength(value, "utf8") > maxBytes) throw new Error(`Invalid ${name}: expected non-empty text of at most ${String(maxBytes)} UTF-8 bytes without NUL`);
+	return value;
+}
+function worktreeCommand(base, description) {
+	return `/worktree '${`base: ${base}\n\ndescription:\n${description}`.replaceAll("'", "'\"'\"'")}'`;
+}
+async function runGit(context, cwd, args, signal) {
+	const result = await context.execFile({
+		file: "git",
+		cwd,
+		args,
+		unsetEnv: GIT_LOCAL_ENV_VARS,
+		timeoutMs: 1e4,
+		signal
+	});
+	if (result.stdoutTruncated || result.stderrTruncated) throw new Error("Git output exceeded the host limit");
+	if (result.exitCode !== 0 || result.signal !== null) throw new Error(`Git command failed (${result.signal ?? String(result.exitCode)}): ${result.stderr.trim()}`);
+	return result.stdout;
+}
+//#endregion
+export { plugin as default };

package/dist/pi-packages/workflows/vite.config.mjs

@@ -0,0 +1,17 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+// Bundle the public host capability tokens so the shipped package does not
+// require a second installed copy of PI WEB at runtime.
+export default defineConfig({
+  build: {
+    emptyOutDir: false,
+    lib: {
+      entry: fileURLToPath(new URL("./server-plugin.ts", import.meta.url)),
+      formats: ["es"],
+      fileName: () => "server-plugin.js",
+    },
+    target: "node22",
+    minify: false,
+  },
+});