@xopcai/xopc 0.0.254 → 0.0.255

package/dist/src/share/hosted-note-publication.d.ts

@@ -0,0 +1,22 @@
+import type { HostedPublicationSnapshot } from './hosted-session-share.js';
+import { type NoteShareSource } from './note-share-service.js';
+export interface HostedNotePublicationSnapshot extends HostedPublicationSnapshot {
+    kind: 'note_document';
+    sourceNoteId: string;
+    sourceVersion: number;
+    title: string;
+    attachmentCount: number;
+}
+export declare class HostedNotePublicationBuilder {
+    private readonly notes;
+    constructor(notes: NoteShareSource);
+    build(noteId: string, input: {
+        expectedNoteVersion?: number;
+        attachmentIds?: string[];
+        description?: string;
+    }): Promise<HostedNotePublicationSnapshot>;
+}
+export declare class HostedNoteVersionConflictError extends Error {
+    readonly currentVersion: number;
+    constructor(currentVersion: number);
+}

package/dist/src/share/hosted-note-publication.js

@@ -0,0 +1,96 @@
+import { collectReferencedAttachmentIds } from "../notes/note-attachment-sync.js";
+import { projectPublicNoteMarkdown } from "./note-share-service.js";
+import { createReadStream } from "node:fs";
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+//#region src/share/hosted-note-publication.ts
+const MAX_ATTACHMENTS = 20;
+const MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+const MAX_MARKDOWN_BYTES = 5 * 1024 * 1024;
+var HostedNotePublicationBuilder = class {
+	constructor(notes) {
+		this.notes = notes;
+	}
+	async build(noteId, input) {
+		const note = await this.notes.getNote(noteId);
+		if (!note) throw new Error("Note not found");
+		if (input.expectedNoteVersion !== void 0 && note.updatedAt !== input.expectedNoteVersion) throw new HostedNoteVersionConflictError(note.updatedAt);
+		const referenced = collectReferencedAttachmentIds(note);
+		const attachments = new Map((note.attachments ?? []).map((attachment) => [attachment.id, attachment]));
+		for (const id of referenced) if (!attachments.has(id)) throw new Error(`Referenced attachment is missing: ${id}`);
+		const selected = input.attachmentIds === void 0 ? [...referenced] : [...new Set(input.attachmentIds)];
+		if (selected.length > MAX_ATTACHMENTS) throw new Error("Note has too many attachments to publish");
+		for (const id of selected) if (!referenced.has(id)) throw new Error(`Attachment is not referenced by this Note: ${id}`);
+		const selectedSet = new Set(selected);
+		const markdown = rewritePublicationAssets(projectPublicNoteMarkdown(note, selectedSet), note, selectedSet);
+		if (Buffer.byteLength(markdown, "utf8") > MAX_MARKDOWN_BYTES) throw new Error("Note Markdown exceeds publishing limit");
+		const assets = [];
+		const manifestAttachments = [];
+		let totalBytes = Buffer.byteLength(markdown, "utf8");
+		for (const id of selected) {
+			const attachment = attachments.get(id);
+			if (attachment.size > MAX_ATTACHMENT_BYTES) throw new Error(`Attachment exceeds publishing limit: ${attachment.fileName}`);
+			totalBytes += attachment.size;
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error("Note publication exceeds total size limit");
+			const resolved = await this.notes.getAttachmentPath(note.id, id);
+			if (!resolved) throw new Error(`Attachment is missing: ${attachment.fileName}`);
+			const current = await stat(resolved.filePath);
+			if (!current.isFile() || current.size !== attachment.size) throw new Error(`Attachment changed or is missing: ${attachment.fileName}`);
+			assets.push({
+				id,
+				path: resolved.filePath,
+				size: attachment.size
+			});
+			manifestAttachments.push({
+				id,
+				fileName: attachment.fileName,
+				mimeType: attachment.mimeType,
+				size: attachment.size,
+				sha256: await sha256File(resolved.filePath)
+			});
+		}
+		return {
+			kind: "note_document",
+			sourceNoteId: note.id,
+			sourceVersion: note.updatedAt,
+			title: note.title?.trim() || "Untitled Note",
+			attachmentCount: assets.length,
+			assets,
+			manifest: {
+				schemaVersion: 1,
+				kind: "note_document",
+				title: note.title?.trim() || "Untitled Note",
+				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...input.description?.trim() ? { description: input.description.trim() } : {},
+				markdown,
+				attachments: manifestAttachments
+			}
+		};
+	}
+};
+var HostedNoteVersionConflictError = class extends Error {
+	constructor(currentVersion) {
+		super("Note changed after the publication preview was reviewed");
+		this.currentVersion = currentVersion;
+		this.name = "HostedNoteVersionConflictError";
+	}
+};
+function rewritePublicationAssets(markdown, note, selected) {
+	return markdown.replace(/xopc-attachment:\/\/notes\/([^/\s)]+)\/([^\s)]+)/gi, (match, rawNoteId, rawAttachmentId) => {
+		try {
+			const noteId = decodeURIComponent(rawNoteId);
+			const attachmentId = decodeURIComponent(rawAttachmentId);
+			return noteId === note.id && selected.has(attachmentId) ? `xopc-publication-asset://${attachmentId}` : match;
+		} catch {
+			return match;
+		}
+	});
+}
+async function sha256File(filePath) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+	return hash.digest("hex");
+}
+//#endregion
+export { HostedNotePublicationBuilder, HostedNoteVersionConflictError };

package/dist/src/share/hosted-session-share.d.ts

@@ -3,6 +3,7 @@ import { type SessionShareMessage, type SessionShareToolActivity } from './sessi
 import { type SessionShareSource } from './session-share-service.js';
 export interface HostedSessionShareManifest {
     schemaVersion: 1;
+    kind: 'session_document';
     title: string;
     snapshotAt: string;
     description?: string;
@@ -49,7 +50,17 @@ export interface HostedShareResult {
     viewCount: number;
     snapshotRevision: number;
 }
-type OwnerShare = {
+export type HostedPublicationKind = 'session_document' | 'note_document' | 'static_site';
+export interface HostedPublicationSnapshot {
+    kind: HostedPublicationKind;
+    manifest: unknown;
+    assets: Array<{
+        id: string;
+        path: string;
+        size: number;
+    }>;
+}
+export type HostedPublicationSummary = {
     id: string;
     title: string;
     description: string | null;
@@ -60,8 +71,42 @@ type OwnerShare = {
     viewCount: number;
     createdAt: string;
     updatedAt: string;
+    kind: HostedPublicationKind;
+    deliveryMode: 'hosted_snapshot';
+    owner: {
+        type: 'user' | 'workspace';
+        id: string;
+    };
+    workspaceId: string;
+    createdByPrincipalId: string;
 };
-export declare class HostedSessionSharePublisher {
+type OwnerShare = HostedPublicationSummary;
+export interface HostedPublicationCapabilities {
+    protocolVersion: string;
+    kinds: string[];
+    deliveryModes: string[];
+    accessModes: string[];
+    upload: {
+        direct: boolean;
+        multipart: boolean;
+        resumable: boolean;
+        streaming: boolean;
+    };
+    security?: {
+        contentScanning: boolean;
+        quarantineBeforeActivation: boolean;
+    };
+    lifecycle: {
+        revisions: boolean;
+        revoke: boolean;
+        asynchronousDeletion: boolean;
+    };
+    publishing: {
+        allowed: boolean;
+        managedBy: 'platform_admin';
+    };
+}
+export declare class HostedPublicationPublisher {
     private readonly credentials;
     private readonly fetchImpl;
     private readonly baseUrl;
@@ -70,23 +115,54 @@ export declare class HostedSessionSharePublisher {
         ttlMs: number;
         maxViews: number | null;
     }): Promise<HostedShareResult>;
+    createPublication(snapshot: HostedPublicationSnapshot, lifecycle: {
+        ttlMs: number;
+        maxViews: number | null;
+    }): Promise<HostedShareResult>;
     refresh(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedSessionShareSnapshot): Promise<HostedShareResult>;
-    list(): Promise<OwnerShare[]>;
+    refreshPublication(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedPublicationSnapshot): Promise<HostedShareResult>;
+    listPublications(): Promise<HostedPublicationSummary[]>;
+    capabilities(): Promise<HostedPublicationCapabilities>;
     revoke(shareId: string): Promise<void>;
+    revokePublication(shareId: string): Promise<void>;
+    listRevisions(shareId: string): Promise<Array<{
+        revision: number;
+        createdAt: string;
+        current: boolean;
+    }>>;
+    rollbackPublication(shareId: string, expectedRevision: number, targetRevision: number): Promise<HostedPublicationSummary>;
     private uploadAssets;
     private request;
 }
 export declare class HostedShareAuthorizationError extends Error {
     constructor();
 }
+export declare class HostedShareRemoteError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export type HostedPublicationSource = {
+    kind: 'session' | 'note' | 'static_site';
+    id: string;
+    version: string;
+};
 export interface HostedShareBinding extends HostedShareResult {
-    sessionId: string;
-    cutoffSeq: number;
+    kind: HostedPublicationKind;
+    source: HostedPublicationSource;
+    revisionSources: Record<string, HostedPublicationSource>;
+    workspaceContext?: {
+        workspaceRoot?: string;
+        sessionKey?: string;
+        agentId?: string;
+    };
+    sessionId?: string;
+    cutoffSeq?: number;
     title: string;
     description: string | null;
-    messageCount: number;
+    messageCount?: number;
     attachmentCount: number;
-    includeToolActivities: boolean;
+    includeToolActivities?: boolean;
     attachmentIds: string[];
     createdAt: string;
     updatedAt: string;
@@ -95,7 +171,10 @@ export interface HostedShareBinding extends HostedShareResult {
 export declare class HostedShareBindingStore {
     private readonly state;
     list(sessionId: string): Promise<HostedShareBinding[]>;
+    listBySource(kind: HostedPublicationSource['kind'], id: string): Promise<HostedShareBinding[]>;
+    listAll(): Promise<HostedShareBinding[]>;
     upsert(binding: HostedShareBinding): Promise<void>;
+    markRevoked(id: string): Promise<void>;
     reconcile(remote: OwnerShare[]): Promise<void>;
 }
 export {};

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 };