@xopcai/xopc 0.0.254 → 0.0.256

package/dist/src/share/hosted-session-share.js

@@ -9,7 +9,7 @@ import { SessionShareSnapshotConflictError } from "./session-share-service.js";
 import { basename } from "node:path";
 import { createReadStream } from "node:fs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 //#region src/share/hosted-session-share.ts
 init_credentials();
 init_resolution();
@@ -82,6 +82,7 @@ var HostedSessionShareBuilder = class {
 			cutoffSeq: source.snapshot.lastSeq,
 			manifest: {
 				schemaVersion: 1,
+				kind: "session_document",
 				title: (source.metadata.name?.trim() || "Shared conversation").slice(0, 200),
 				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
 				...input.description?.trim() ? { description: input.description.trim().slice(0, 1e3) } : {},
@@ -105,7 +106,7 @@ var HostedSessionShareBuilder = class {
 		};
 	}
 };
-var HostedSessionSharePublisher = class {
+var HostedPublicationPublisher = class {
 	baseUrl;
 	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? resolveConnectedPlatformEndpoint("shareApi") ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
 		this.credentials = credentials;
@@ -113,23 +114,38 @@ var HostedSessionSharePublisher = class {
 		this.baseUrl = baseUrl.replace(/\/+$/, "");
 	}
 	async create(snapshot, lifecycle) {
+		return this.createPublication({
+			kind: "session_document",
+			manifest: snapshot.manifest,
+			assets: snapshot.assets
+		}, lifecycle);
+	}
+	async createPublication(snapshot, lifecycle) {
 		const publicToken = randomBytes(32).toString("base64url");
-		const draft = await this.request("/api/v1/session-shares", {
+		const draft = await this.request("/api/v1/publications", {
 			method: "POST",
 			headers: { "Idempotency-Key": `xopc-${randomUUID()}` },
 			body: JSON.stringify({
+				kind: snapshot.kind,
 				publicToken,
 				manifest: snapshot.manifest,
 				...lifecycle
 			})
 		});
 		await this.uploadAssets(draft, snapshot.assets);
-		const finalized = await this.request(`/api/v1/session-shares/${encodeURIComponent(draft.shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" });
+		const finalized = await this.request(`/api/v1/publications/${encodeURIComponent(draft.shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" });
 		if (!draft.publicUrl) throw new Error("Hosted Share did not return a public URL");
 		return toResult(finalized.item, draft.publicUrl);
 	}
 	async refresh(shareId, expectedRevision, publicUrl, snapshot) {
-		const draft = await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}/revisions`, {
+		return this.refreshPublication(shareId, expectedRevision, publicUrl, {
+			kind: "session_document",
+			manifest: snapshot.manifest,
+			assets: snapshot.assets
+		});
+	}
+	async refreshPublication(shareId, expectedRevision, publicUrl, snapshot) {
+		const draft = await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/revisions`, {
 			method: "POST",
 			headers: { "Idempotency-Key": `xopc-${randomUUID()}` },
 			body: JSON.stringify({
@@ -138,28 +154,47 @@ var HostedSessionSharePublisher = class {
 			})
 		});
 		await this.uploadAssets(draft, snapshot.assets);
-		return toResult((await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" })).item, publicUrl);
+		return toResult((await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" })).item, publicUrl);
 	}
-	async list() {
-		return (await this.request("/api/v1/session-shares")).items;
+	async listPublications() {
+		return (await this.request("/api/v1/publications")).items;
+	}
+	async capabilities() {
+		return this.request("/api/v1/publications/capabilities");
 	}
 	async revoke(shareId) {
-		await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}`, { method: "DELETE" });
+		await this.revokePublication(shareId);
+	}
+	async revokePublication(shareId) {
+		await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}`, { method: "DELETE" });
+	}
+	async listRevisions(shareId) {
+		return (await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/revisions`)).items;
+	}
+	async rollbackPublication(shareId, expectedRevision, targetRevision) {
+		return (await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/rollback`, {
+			method: "POST",
+			body: JSON.stringify({
+				expectedRevision,
+				targetRevision
+			})
+		})).item;
 	}
 	async uploadAssets(draft, assets) {
 		const uploads = new Map(draft.assetUploads.map((upload) => [upload.assetId, upload.uploadUrl]));
 		for (const asset of assets) {
 			const uploadUrl = uploads.get(asset.id);
 			if (!uploadUrl) throw new Error(`Hosted Share did not accept attachment: ${asset.id}`);
-			const bytes = await readFile(asset.path);
-			if (bytes.byteLength !== asset.size) throw new Error(`Attachment changed during upload: ${asset.id}`);
+			const current = await stat(asset.path);
+			if (!current.isFile() || current.size !== asset.size) throw new Error(`Attachment changed during upload: ${asset.id}`);
 			await this.request(uploadUrl, {
 				method: "PUT",
 				headers: {
-					"Content-Length": String(bytes.byteLength),
+					"Content-Length": String(asset.size),
 					"Content-Type": "application/octet-stream"
 				},
-				body: bytes
+				body: createReadStream(asset.path),
+				duplex: "half"
 			});
 		}
 	}
@@ -180,7 +215,7 @@ var HostedSessionSharePublisher = class {
 		});
 		const body = await response.json().catch(() => ({}));
 		if (response.status === 401) throw new HostedShareAuthorizationError();
-		if (!response.ok) throw new Error(body.error?.message || `Hosted Share request failed (${response.status})`);
+		if (!response.ok) throw new HostedShareRemoteError(body.error?.message || `Hosted Share request failed (${response.status})`, response.status, body.error?.code);
 		return body;
 	}
 };
@@ -190,14 +225,36 @@ var HostedShareAuthorizationError = class extends Error {
 		this.name = "HostedShareAuthorizationError";
 	}
 };
+var HostedShareRemoteError = class extends Error {
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "HostedShareRemoteError";
+	}
+};
 var HostedShareBindingStore = class {
 	state = new DurableState("hosted-share-bindings");
 	async list(sessionId) {
 		return this.state.values().filter((item) => item.sessionId === sessionId).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 	}
+	async listBySource(kind, id) {
+		return this.state.values().filter((item) => item.source.kind === kind && item.source.id === id).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	}
+	async listAll() {
+		return this.state.values().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	}
 	async upsert(binding) {
 		this.state.set(binding.id, binding);
 	}
+	async markRevoked(id) {
+		const binding = this.state.get(id);
+		if (binding) this.state.set(id, {
+			...binding,
+			revoked: true,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
 	async reconcile(remote) {
 		const byId = new Map(remote.map((item) => [item.id, item]));
 		requireXopcDatabase();
@@ -242,4 +299,4 @@ async function checksumFile(path) {
 	return hash.digest("hex");
 }
 //#endregion
-export { HostedSessionShareBuilder, HostedSessionSharePublisher, HostedShareAuthorizationError, HostedShareBindingStore };
+export { HostedPublicationPublisher, HostedSessionShareBuilder, HostedShareAuthorizationError, HostedShareBindingStore, HostedShareRemoteError };

package/dist/src/share/hosted-static-site-publication.d.ts

@@ -0,0 +1,16 @@
+import type { HostedPublicationSnapshot } from './hosted-session-share.js';
+export interface HostedStaticSitePublicationSnapshot extends HostedPublicationSnapshot {
+    kind: 'static_site';
+    rootDir: string;
+    title: string;
+    fileCount: number;
+    totalBytes: number;
+}
+export declare class HostedStaticSitePublicationBuilder {
+    build(workspaceRoot: string, input: {
+        path: string;
+        title?: string;
+        description?: string;
+        spaFallback?: boolean;
+    }): Promise<HostedStaticSitePublicationSnapshot>;
+}

package/dist/src/share/hosted-static-site-publication.js

@@ -0,0 +1,108 @@
+import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
+import { resolveMimeType } from "./share-store.js";
+import { basename, dirname, extname, posix, relative, resolve } from "node:path";
+import { createReadStream } from "node:fs";
+import { createHash } from "node:crypto";
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
+//#region src/share/hosted-static-site-publication.ts
+const MAX_FILES = 2e3;
+const MAX_FILE_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 512 * 1024 * 1024;
+var HostedStaticSitePublicationBuilder = class {
+	async build(workspaceRoot, input) {
+		const realSource = await realpath(resolve(workspaceRoot, normalizeInputPath(input.path)));
+		if (!isPathUnderWorkspace(workspaceRoot, realSource)) throw new Error("Static site path is outside the workspace");
+		const sourceStat = await stat(realSource);
+		const singleHtml = sourceStat.isFile();
+		if (singleHtml && resolveMimeType(realSource) !== "text/html") throw new Error("Static site file must be an HTML document");
+		if (!singleHtml && !sourceStat.isDirectory()) throw new Error("Static site source must be an HTML file or directory");
+		const rootDir = singleHtml ? dirname(realSource) : realSource;
+		const entries = singleHtml ? [{
+			path: "index.html",
+			absolutePath: realSource
+		}] : (await collectFiles(rootDir)).map((path) => ({
+			path,
+			absolutePath: resolve(rootDir, path)
+		}));
+		if (!singleHtml && !entries.some((entry) => entry.path === "index.html")) throw new Error("Static site must contain index.html");
+		const assets = [];
+		const files = [];
+		let totalBytes = 0;
+		for (const entry of entries) {
+			const filePath = entry.path;
+			const absolutePath = entry.absolutePath;
+			const fileStat = await stat(absolutePath);
+			if (fileStat.size > MAX_FILE_BYTES) throw new Error(`Static site file exceeds publishing limit: ${filePath}`);
+			totalBytes += fileStat.size;
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error("Static site exceeds total publishing limit");
+			const id = createHash("sha256").update(filePath).digest("hex").slice(0, 40);
+			assets.push({
+				id,
+				path: absolutePath,
+				size: fileStat.size
+			});
+			files.push({
+				id,
+				path: filePath,
+				mimeType: resolveMimeType(filePath),
+				size: fileStat.size,
+				sha256: await sha256File(absolutePath)
+			});
+		}
+		const defaultTitle = singleHtml ? basename(realSource, extname(realSource)) : basename(realSource);
+		const title = input.title?.trim() || defaultTitle || "Published site";
+		return {
+			kind: "static_site",
+			rootDir,
+			title,
+			fileCount: files.length,
+			totalBytes,
+			assets,
+			manifest: {
+				schemaVersion: 1,
+				kind: "static_site",
+				title,
+				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...input.description?.trim() ? { description: input.description.trim() } : {},
+				entrypoint: "index.html",
+				spaFallback: input.spaFallback ?? true,
+				files
+			}
+		};
+	}
+};
+async function collectFiles(rootDir) {
+	const files = [];
+	const visit = async (directory) => {
+		const entries = await readdir(directory, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const absolutePath = resolve(directory, entry.name);
+			const details = await lstat(absolutePath);
+			if (details.isSymbolicLink()) throw new Error(`Static site cannot contain symbolic links: ${entry.name}`);
+			if (details.isDirectory()) {
+				await visit(absolutePath);
+				continue;
+			}
+			if (!details.isFile()) throw new Error(`Unsupported static site entry: ${entry.name}`);
+			const filePath = relative(rootDir, absolutePath).split("\\").join("/");
+			if (filePath.split("/").some((part) => !part || part === "." || part === "..")) throw new Error("Invalid static site path");
+			files.push(posix.normalize(filePath));
+			if (files.length > MAX_FILES) throw new Error(`Static site has more than ${MAX_FILES} files`);
+		}
+	};
+	await visit(rootDir);
+	return files;
+}
+function normalizeInputPath(value) {
+	const normalized = value.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+	if (!normalized || normalized.includes("\0") || normalized.split("/").some((part) => part === "..")) throw new Error("Invalid static site path");
+	return normalized;
+}
+async function sha256File(filePath) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+	return hash.digest("hex");
+}
+//#endregion
+export { HostedStaticSitePublicationBuilder };

package/dist/src/share/hosted-static-site-publish.d.ts

@@ -0,0 +1,23 @@
+import { HostedPublicationPublisher, HostedShareBindingStore, type HostedShareBinding } from './hosted-session-share.js';
+import { HostedStaticSitePublicationBuilder, type HostedStaticSitePublicationSnapshot } from './hosted-static-site-publication.js';
+export interface PublishHostedStaticSiteInput {
+    workspaceRoot: string;
+    path: string;
+    title?: string;
+    description?: string;
+    spaFallback?: boolean;
+    ttlMs: number;
+    maxViews: number | null;
+    sessionKey?: string;
+    agentId?: string;
+}
+export interface PublishHostedStaticSiteResult {
+    binding: HostedShareBinding;
+    snapshot: HostedStaticSitePublicationSnapshot;
+}
+/** Build, upload, activate, and locally bind one immutable static-site snapshot. */
+export declare function publishHostedStaticSite(input: PublishHostedStaticSiteInput, deps?: {
+    builder?: HostedStaticSitePublicationBuilder;
+    publisher?: HostedPublicationPublisher;
+    bindings?: HostedShareBindingStore;
+}): Promise<PublishHostedStaticSiteResult>;

package/dist/src/share/hosted-static-site-publish.js

@@ -0,0 +1,53 @@
+import { HostedPublicationPublisher, HostedShareBindingStore } from "./hosted-session-share.js";
+import { HostedStaticSitePublicationBuilder } from "./hosted-static-site-publication.js";
+//#region src/share/hosted-static-site-publish.ts
+/** Build, upload, activate, and locally bind one immutable static-site snapshot. */
+async function publishHostedStaticSite(input, deps = {}) {
+	const builder = deps.builder ?? new HostedStaticSitePublicationBuilder();
+	const publisher = deps.publisher ?? new HostedPublicationPublisher();
+	const bindings = deps.bindings ?? new HostedShareBindingStore();
+	const snapshot = await builder.build(input.workspaceRoot, {
+		path: input.path,
+		title: input.title,
+		description: input.description,
+		spaFallback: input.spaFallback
+	});
+	const result = await publisher.createPublication(snapshot, {
+		ttlMs: input.ttlMs,
+		maxViews: input.maxViews
+	});
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const binding = {
+		...result,
+		kind: "static_site",
+		source: {
+			kind: "static_site",
+			id: input.path,
+			version: now
+		},
+		revisionSources: { [String(result.snapshotRevision)]: {
+			kind: "static_site",
+			id: input.path,
+			version: now
+		} },
+		workspaceContext: {
+			workspaceRoot: input.workspaceRoot,
+			...input.sessionKey ? { sessionKey: input.sessionKey } : {},
+			...input.agentId ? { agentId: input.agentId } : {}
+		},
+		title: snapshot.title,
+		description: input.description?.trim() || null,
+		attachmentCount: snapshot.fileCount,
+		attachmentIds: snapshot.assets.map((asset) => asset.id),
+		createdAt: now,
+		updatedAt: now,
+		revoked: false
+	};
+	await bindings.upsert(binding);
+	return {
+		binding,
+		snapshot
+	};
+}
+//#endregion
+export { publishHostedStaticSite };

package/dist/src/share/note-share-service.d.ts

@@ -65,3 +65,4 @@ export declare class NoteShareService {
     private artifactRelativePath;
     private artifactDir;
 }
+export declare function projectPublicNoteMarkdown(note: Note, selected: Set<string>): string;

package/dist/src/share/note-share-service.js

@@ -2,8 +2,8 @@ import { resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths } from "../config/paths.js";
-import { collectReferencedAttachmentIds } from "../notes/note-attachment-sync.js";
 import { issueShareAssetTicket, verifyShareAssetTicket } from "./share-asset-ticket.js";
+import { collectReferencedAttachmentIds } from "../notes/note-attachment-sync.js";
 import { dirname, join } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { copyFile, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -155,7 +155,7 @@ var NoteShareService = class {
 		for (const id of referenced) if (!known.has(id)) throw new Error(`Referenced attachment is missing: ${id}`);
 		const selected = requestedAttachmentIds === void 0 ? [...referenced] : Array.from(new Set(requestedAttachmentIds));
 		for (const id of selected) if (!referenced.has(id)) throw new Error(`Attachment is not referenced by this Note: ${id}`);
-		const projectedMarkdown = projectPublicMarkdown(note, new Set(selected));
+		const projectedMarkdown = projectPublicNoteMarkdown(note, new Set(selected));
 		const markdownBytes = Buffer.byteLength(projectedMarkdown, "utf8");
 		if (markdownBytes > cfg.maxMarkdownBytes) throw new Error("Note Markdown exceeds sharing limit");
 		if (selected.length > cfg.maxAttachmentCount) throw new Error("Note has too many attachments to share");
@@ -235,7 +235,7 @@ var NoteShareService = class {
 		return join(resolveStateDir(), this.artifactRelativePath(shareId));
 	}
 };
-function projectPublicMarkdown(note, selected) {
+function projectPublicNoteMarkdown(note, selected) {
 	const canonicalTarget = "xopc-attachment://notes/([^/\\s)]+)/([^\\s)]+)";
 	const assertOwned = new RegExp(canonicalTarget, "gi");
 	note.markdown.replace(assertOwned, (_match, rawNoteId) => {
@@ -260,4 +260,4 @@ function projectPublicMarkdown(note, selected) {
 	return markdown;
 }
 //#endregion
-export { NoteShareService, NoteShareVersionConflictError };
+export { NoteShareService, NoteShareVersionConflictError, projectPublicNoteMarkdown };

package/dist/src/share/share-url.d.ts

@@ -33,7 +33,7 @@ export interface ResolvedSiteShareUrl {
 }
 /**
  * Resolve the URL pair for a site share. Priority mirrors `resolveShareUrl`:
- *  1. FRP tunnel → wildcard subdomain on `<publicHostSuffix>`.
+ *  1. FRP tunnel → gateway `/site/<token>/` subpath.
  *  2. Reverse-proxy `publicUrl` → `<publicUrl>/site/<token>/` subpath.
  *  3. Direct gateway bind → `http://<host>:<port>/site/<token>/`.
  */

package/dist/src/share/share-url.js

@@ -1,12 +1,12 @@
 import { enumerateLanGatewayCandidates } from "../gateway/host.js";
-import { loadTunnelState } from "../tunnel/tunnel-state.js";
+import { getTunnelService } from "../tunnel/tunnel-service.js";
 //#region src/share/share-url.ts
 function resolveShareUrl(token, ctx) {
-	const tunnelState = loadTunnelState();
+	const tunnelPublicUrl = activeTunnelPublicUrl();
 	const { gatewayHost, gatewayPort, reverseProxyPublicUrl } = ctx;
 	const path = `/s/${token}`;
-	if (tunnelState?.publicUrl) return {
-		shareUrl: `${tunnelState.publicUrl.replace(/\/+$/, "")}${path}`,
+	if (tunnelPublicUrl) return {
+		shareUrl: `${tunnelPublicUrl.replace(/\/+$/, "")}${path}`,
 		lanUrl: buildLanUrl(gatewayHost, gatewayPort, path),
 		reachability: "public",
 		reachabilityHint: null
@@ -40,22 +40,23 @@ function isLoopbackHost(host) {
 	return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 function resolveReachabilityForList(ctx) {
-	if (loadTunnelState()?.publicUrl) return "public";
+	if (activeTunnelPublicUrl()) return "public";
 	if (ctx.reverseProxyPublicUrl?.trim()) return "public";
 	if (!isLoopbackHost(ctx.gatewayHost)) return "lan";
 	return "local-only";
 }
 /**
 * Resolve the URL pair for a site share. Priority mirrors `resolveShareUrl`:
-*  1. FRP tunnel → wildcard subdomain on `<publicHostSuffix>`.
+*  1. FRP tunnel → gateway `/site/<token>/` subpath.
 *  2. Reverse-proxy `publicUrl` → `<publicUrl>/site/<token>/` subpath.
 *  3. Direct gateway bind → `http://<host>:<port>/site/<token>/`.
 */
 function resolveSiteShareUrl(ctx) {
-	if (loadTunnelState()?.publicUrl) {
-		const root = `https://${ctx.subdomainLabel}.${ctx.publicHostSuffix}`;
+	const tunnelPublicUrl = activeTunnelPublicUrl();
+	if (tunnelPublicUrl) {
+		const root = tunnelPublicUrl.replace(/\/+$/, "");
 		return {
-			shareUrl: `${root}/`,
+			shareUrl: `${root}/site/${ctx.token}/`,
 			thumbnailUrl: `${root}/site/${ctx.token}/thumbnail`,
 			reachability: "public",
 			reachabilityHint: null
@@ -80,5 +81,9 @@ function resolveSiteShareUrl(ctx) {
 		reachabilityHint: loopback ? "当前仅本机可访问，开启远程隧道后对外可达" : "当前局域网内可访问，开启远程隧道后对外网可达"
 	};
 }
+function activeTunnelPublicUrl() {
+	const status = getTunnelService().getStatus();
+	return status.state === "connected" && status.publicUrl ? status.publicUrl : null;
+}
 //#endregion
 export { resolveReachabilityForList, resolveShareUrl, resolveSiteShareUrl };

package/dist/src/tui/backends/embedded-backend.js

@@ -12,11 +12,11 @@ import { effectiveWorkspacePathForSession } from "../../session/session-workspac
 import { ProjectService } from "../../projects/project-service.js";
 import { inferSuggestedProjectDefaultAgentId } from "../../projects/project-agent-suggestion.js";
 import "../../projects/index.js";
+import { buildSessionTimeline } from "../../session/transcript-outline.js";
+import { transcriptRowsToClientHistory } from "../../session/client-history.js";
 import { createCreateShareTool, isShareToolAvailable } from "../../agent/tools/create-share-tool.js";
 import { evictEmbeddedSessionRunner } from "../../agent/embedded/session-runner.js";
 import { setTuiDefaultAgentConfig } from "../../commands/agents.config.js";
-import { buildSessionTimeline } from "../../session/transcript-outline.js";
-import { transcriptRowsToClientHistory } from "../../session/client-history.js";
 import { SessionIndex } from "../../session/manager.js";
 import "../../session/index.js";
 import { parseModelRef } from "../../agent/models/selection.js";

package/dist/src/tui/tui-agent-events.js

@@ -1,5 +1,5 @@
-import { formatAgentRunErrorForDisplay } from "../agent/client-error-format.js";
 import { stripRuntimeContextFromUserContent } from "../session/user-message-display.js";
+import { formatAgentRunErrorForDisplay } from "../agent/client-error-format.js";
 import { createAssistantMessageFromText } from "./components/assistant-message.js";
 import { markRunEvent, markRunIdleAfterCompletion } from "./tui-run-state.js";
 //#region src/tui/tui-agent-events.ts

package/dist/src/tui/tui-workflow-slash.d.ts

@@ -11,17 +11,14 @@
  *   shortest reliable path is to turn `/audit_repo` into the same plain-text
  *   request the model already knows how to handle.
  *
- * Why catalog the workflow list at the TUI layer?
- *   The catalog reads `~/.xopc/workflows/` synchronously (single `readdir`),
- *   so the slash dispatch stays sync and the user sees no latency. The lookup
- *   only runs for inputs that started with `/` and didn't match any built-in
- *   or extension command, so the cost is negligible.
+ * The lookup only runs for inputs that started with `/` and did not match a
+ * built-in or extension command. A short cache keeps repeated dispatch cheap.
  *
  * Built-in TUI command names that overlap with a workflow file name keep their
  * existing TUI behaviour — the slash dispatcher matches the built-in switch
  * cases before this helper is consulted.
  */
-/** Reset the cache (for tests, or after a `/workflow save`). */
+/** Reset the cache after workflow changes and in tests. */
 export declare function resetWorkflowSlashCache(): void;
 /**
  * Returns a rewritten user message when `name` matches a known workflow,

package/dist/src/tui/tui-workflow-slash.js

@@ -13,11 +13,8 @@ import { createWorkflowCatalog } from "../agent/workflow/catalog.js";
 *   shortest reliable path is to turn `/audit_repo` into the same plain-text
 *   request the model already knows how to handle.
 *
-* Why catalog the workflow list at the TUI layer?
-*   The catalog reads `~/.xopc/workflows/` synchronously (single `readdir`),
-*   so the slash dispatch stays sync and the user sees no latency. The lookup
-*   only runs for inputs that started with `/` and didn't match any built-in
-*   or extension command, so the cost is negligible.
+* The lookup only runs for inputs that started with `/` and did not match a
+* built-in or extension command. A short cache keeps repeated dispatch cheap.
 *
 * Built-in TUI command names that overlap with a workflow file name keep their
 * existing TUI behaviour — the slash dispatcher matches the built-in switch
@@ -26,7 +23,7 @@ import { createWorkflowCatalog } from "../agent/workflow/catalog.js";
 let cachedNames = null;
 let cachedAt = 0;
 const CACHE_TTL_MS = 5e3;
-/** Reset the cache (for tests, or after a `/workflow save`). */
+/** Reset the cache after workflow changes and in tests. */
 function resetWorkflowSlashCache() {
 	cachedNames = null;
 	cachedAt = 0;

package/dist/src/tunnel/index.js

@@ -1,7 +1,7 @@
-import { loadTunnelState, resolveTunnelStatePath, saveTunnelState } from "./tunnel-state.js";
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
 import { FRPC_VERSION, clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
 import { TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TunnelRegistrationSecretError, getTunnelRegistrationSecretMeta, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, tunnelRegistrationSecretRequiredMessage } from "./env.js";
+import { loadTunnelState, resolveTunnelStatePath, saveTunnelState } from "./tunnel-state.js";
 import { logTunnelAudit } from "./tunnel-audit.js";
 import { TunnelService, getTunnelService, hashGatewayToken } from "./tunnel-service.js";
 import { CURRENT_TUNNEL_CONSENT_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelConsentError, assertTunnelMayStart, getTunnelConsentState, hasValidTunnelConsent } from "./consent.js";

package/dist/src/tunnel/tunnel-service.js

@@ -1,13 +1,13 @@
 import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { clearTunnelState, loadTunnelState, saveTunnelState, updateTunnelState } from "./tunnel-state.js";
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
 import { clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
 import { writeFrpcConfig } from "./frpc-config.js";
 import { spawnFrpcProcess } from "./frpc-process.js";
 import { TunnelRegistrationSecretError } from "./env.js";
 import { canResumePersistedTunnel, persistedFromRegistration, registrationFromPersisted } from "./tunnel-persist.js";
+import { clearTunnelState, loadTunnelState, saveTunnelState, updateTunnelState } from "./tunnel-state.js";
 import { logTunnelAudit } from "./tunnel-audit.js";
 import { createHash } from "node:crypto";
 import { EventEmitter } from "node:events";

package/dist/src/user-model/bootstrap.d.ts

@@ -0,0 +1,17 @@
+import { type UserProfilePatch } from './profile.js';
+export interface UserModelBootstrapInput {
+    profile: UserProfilePatch;
+    responsibilities?: string[];
+    goals?: string[];
+    communicationPreferences?: string[];
+    boundaries?: string[];
+    relationships?: string[];
+}
+export declare function bootstrapUserModel(input: UserModelBootstrapInput, now?: number): {
+    profile: Partial<Record<import("./profile.js").UserProfileField, string>>;
+    created: {
+        assertions: number;
+        goals: number;
+        rules: number;
+    };
+};