emdash 0.37.0 → 0.39.0

package/src/plugins/http-wire.ts

@@ -0,0 +1,180 @@
+export const PLUGIN_HTTP_MAX_REQUEST_BYTES = 8 * 1024 * 1024;
+export const PLUGIN_HTTP_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+const REDIRECT_BODY_HEADERS = [
+	"content-encoding",
+	"content-language",
+	"content-location",
+	"content-type",
+	"content-length",
+	"transfer-encoding",
+];
+const PLUGIN_HTTP_REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+
+export type PluginHttpRedirectAction = "return" | "follow" | "error";
+
+export interface PluginHttpResponseWire {
+	status: number;
+	statusText: string;
+	headers: Array<[string, string]>;
+	finalUrl: string;
+	redirected: boolean;
+	body: Uint8Array;
+}
+
+function createPluginHttpWireRuntime(maxRequestBytes: number) {
+	// oxlint-disable-next-line unicorn/consistent-function-scoping -- local declaration keeps the generated factory dependency-free
+	async function readPluginHttpBytes(
+		stream: ReadableStream<Uint8Array> | null,
+		limit: number,
+		label: "request" | "response",
+	): Promise<Uint8Array> {
+		if (!stream) return new Uint8Array();
+		const reader = stream.getReader();
+		const chunks: Uint8Array[] = [];
+		let total = 0;
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				total += value.byteLength;
+				if (total > limit) {
+					try {
+						await reader.cancel();
+					} catch {
+						// The byte limit remains the caller-visible failure.
+					}
+					throw new Error(`Plugin HTTP ${label} body exceeds the ${limit} byte limit`);
+				}
+				chunks.push(value);
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		const bytes = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return bytes;
+	}
+
+	async function bufferPluginHttpRequest(
+		init: RequestInit | undefined,
+	): Promise<RequestInit | undefined> {
+		if (init?.body === undefined || init.body === null) return init;
+		const encoded = new Response(init.body);
+		const body = await readPluginHttpBytes(encoded.body, maxRequestBytes, "request");
+		const headers = new Headers(init.headers);
+		if (!headers.has("content-type")) {
+			const contentType = encoded.headers.get("content-type");
+			if (contentType) headers.set("content-type", contentType);
+		}
+		const bufferedInit = { ...init };
+		Reflect.deleteProperty(bufferedInit, "duplex");
+		return { ...bufferedInit, headers, body: new Uint8Array(body).buffer };
+	}
+
+	// oxlint-disable-next-line unicorn/consistent-function-scoping -- local declaration keeps the generated factory dependency-free
+	function decoratePluginHttpResponse(
+		response: Response,
+		finalUrl: string,
+		redirected: boolean,
+	): Response {
+		const clone = response.clone.bind(response);
+		Object.defineProperties(response, {
+			url: { configurable: true, value: finalUrl },
+			redirected: { configurable: true, value: redirected },
+			clone: {
+				configurable: true,
+				value: () => decoratePluginHttpResponse(clone(), finalUrl, redirected),
+			},
+		});
+		return response;
+	}
+
+	function pluginHttpResponseFromWire(wire: PluginHttpResponseWire): Response {
+		const nullBodyStatus =
+			wire.status === 101 || wire.status === 204 || wire.status === 205 || wire.status === 304;
+		const response = new Response(nullBodyStatus ? null : new Uint8Array(wire.body).buffer, {
+			status: wire.status,
+			statusText: wire.statusText,
+			headers: wire.headers,
+		});
+		return decoratePluginHttpResponse(response, wire.finalUrl, wire.redirected);
+	}
+
+	return [
+		readPluginHttpBytes,
+		bufferPluginHttpRequest,
+		decoratePluginHttpResponse,
+		pluginHttpResponseFromWire,
+	] as const;
+}
+
+export const [
+	readPluginHttpBytes,
+	bufferPluginHttpRequest,
+	decoratePluginHttpResponse,
+	pluginHttpResponseFromWire,
+] = createPluginHttpWireRuntime(PLUGIN_HTTP_MAX_REQUEST_BYTES);
+
+export function rewritePluginHttpRedirect(
+	status: number,
+	init: RequestInit | undefined,
+): RequestInit | undefined {
+	if (!init) return init;
+	const method = (init.method ?? "GET").toUpperCase();
+	const rewriteToGet =
+		((status === 301 || status === 302) && method === "POST") ||
+		(status === 303 && method !== "GET" && method !== "HEAD");
+	if (!rewriteToGet) return init;
+
+	const headers = new Headers(init.headers);
+	for (const name of REDIRECT_BODY_HEADERS) headers.delete(name);
+	return { ...init, method: "GET", headers, body: undefined };
+}
+
+export function pluginHttpRedirectAction(
+	status: number,
+	hasLocation: boolean,
+	init: RequestInit | undefined,
+): PluginHttpRedirectAction {
+	if (!PLUGIN_HTTP_REDIRECT_STATUSES.has(status) || !hasLocation) return "return";
+	const mode = init?.redirect ?? "follow";
+	if (mode === "manual") return "return";
+	if (mode === "error") return "error";
+	return "follow";
+}
+
+export async function pluginHttpResponseToWire(
+	response: Response,
+	finalUrl: string,
+	redirected: boolean,
+): Promise<PluginHttpResponseWire> {
+	const headers: Array<[string, string]> = [];
+	response.headers.forEach((value, key) => headers.push([key, value]));
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+		finalUrl: response.url || finalUrl,
+		redirected: response.redirected || redirected,
+		body: await readPluginHttpBytes(response.body, PLUGIN_HTTP_MAX_RESPONSE_BYTES, "response"),
+	};
+}
+
+/**
+ * Generate the dependency-free helper module injected into sandbox wrappers.
+ * Generated isolates cannot resolve host package imports, so both runners embed
+ * the runtime forms of these canonical functions instead.
+ */
+export function generatePluginHttpWireRuntimeSource(): string {
+	return `const [
+	readPluginHttpBytes,
+	bufferPluginHttpRequest,
+	decoratePluginHttpResponse,
+	pluginHttpResponseFromWire,
+] = (${createPluginHttpWireRuntime.toString()})(${PLUGIN_HTTP_MAX_REQUEST_BYTES});`;
+}

package/src/plugins/index.ts

@@ -9,7 +9,7 @@
  */
 
 // definePlugin
-export { definePlugin } from "./define-plugin.js";
+export { definePlugin, definePluginRoute } from "./define-plugin.js";
 
 // Standard plugin adapter
 export { adaptSandboxEntry } from "./adapt-sandbox-entry.js";
@@ -27,8 +27,11 @@ export {
 	createPluginContext,
 	createKVAccess,
 	createStorageAccess,
-	createContentAccess,
 	createContentAccessWithWrite,
+	createCommentAccess,
+	createRedirectAccess,
+	RedirectAccessError,
+	createSchemaAccess,
 	createMediaAccess,
 	createMediaAccessWithWrite,
 	createHttpAccess,
@@ -39,12 +42,43 @@ export {
 	createUrlHelper,
 	createSiteInfo,
 } from "./context.js";
-export type { PluginContextFactoryOptions } from "./context.js";
+export { createContentAccess } from "./content-access.js";
+export type { ContentActionCallbacks, PluginContextFactoryOptions } from "./context.js";
+export {
+	PLUGIN_HTTP_MAX_REQUEST_BYTES,
+	PLUGIN_HTTP_MAX_RESPONSE_BYTES,
+	bufferPluginHttpRequest,
+	pluginHttpRedirectAction,
+	pluginHttpResponseFromWire,
+	pluginHttpResponseToWire,
+	readPluginHttpBytes,
+	rewritePluginHttpRedirect,
+} from "./http-wire.js";
+export type { PluginHttpResponseWire } from "./http-wire.js";
+export type { PluginHttpRedirectAction } from "./http-wire.js";
+export { CronAccessImpl } from "./cron.js";
+export {
+	DEFAULT_PLUGIN_MEDIA_READ_BYTES,
+	MAX_PLUGIN_MEDIA_READ_BYTES,
+	parsePluginMediaMetadataPatch,
+	readPluginMediaBytes,
+	toPluginMediaItem,
+	updatePluginMediaMetadata,
+} from "./media.js";
 
 // Hooks
 export { HookPipeline, createHookPipeline } from "./hooks.js";
 export type { HookResult } from "./hooks.js";
 export { ContentSaveRejectedError, isContentSaveRejection } from "./save-rejection.js";
+export {
+	SCHEDULED_POLICY_REJECTION_PREFIX,
+	isScheduledPolicyRejection,
+	scheduledPolicyRejectionKey,
+} from "./content-policy.js";
+export type {
+	ScheduledPolicyRejection,
+	VersionedScheduledPolicyRejection,
+} from "./content-policy.js";
 
 // Email pipeline
 export { EmailPipeline, EmailNotConfiguredError, EmailRecursionError } from "./email.js";
@@ -86,10 +120,14 @@ export {
 export type {
 	SandboxRunner,
 	SandboxedPluginInstance,
+	SandboxInvocationOptions,
 	SandboxRunnerFactory,
 	SandboxOptions,
 	SandboxEmailMessage,
 	SandboxEmailSendCallback,
+	SandboxCommentModerateCallback,
+	SandboxContentCreateCallback,
+	SandboxHttpFetchCallback,
 	ResourceLimits,
 	PluginCodeStorage,
 	SerializedRequest,
@@ -101,6 +139,17 @@ export type {
 	SandboxSaveRejectedError,
 } from "./sandbox/index.js";
 
+export { StorageSerializationError } from "./storage-query.js";
+export {
+	PluginSettingEncryptionError,
+	createPluginSecretRedactor,
+	createSettingsAccess,
+	decodePluginSettingValue,
+	encryptPluginSetting,
+	isEncryptedPluginSetting,
+} from "./settings.js";
+export type { EncryptedPluginSetting, PluginSecretRedactor } from "./settings.js";
+
 // Types
 export type {
 	// Core types
@@ -118,26 +167,54 @@ export type {
 	// Context APIs
 	PluginContext,
 	StorageCollection,
+	NumericDelta,
+	UpdateIfArgs,
+	UpdateIfResult,
+	VersionedValue,
+	ConditionalWriteResult,
+	ConditionalDeleteResult,
 	KVAccess,
+	SettingsAccess,
 	ContentAccess,
 	ContentAccessWithWrite,
+	ContentPublicationAccess,
+	ContentRestoreAccess,
+	VersionedContentItem,
 	MediaAccess,
 	MediaAccessWithWrite,
+	MediaBytes,
+	MediaMetadataPatch,
 	HttpAccess,
 	LogAccess,
 	SiteInfo,
 	UserInfo,
 	UserAccess,
 	ContentItem,
+	ContentTranslationSummary,
+	ContentRevisionInfo,
+	SchemaAccess,
+	CollectionSchemaInfo,
+	FieldSchemaInfo,
 	ContentCreateOptions,
 	ContentWriteInput,
+	CronTaskInfo,
 	MediaItem,
 	ContentListOptions,
 	MediaListOptions,
 	TaxonomyAccess,
+	TaxonomyAccessWithWrite,
 	TaxonomyDefInfo,
 	TaxonomyTermInfo,
+	TaxonomyTermCreateInput,
 	TaxonomyReadOptions,
+	RedirectAccess,
+	RedirectAccessWithWrite,
+	RedirectCreateInput,
+	RedirectInfo,
+	RedirectListOptions,
+	RedirectStatus,
+	RedirectUpdateInput,
+	VersionedRedirect,
 
 	// Hook types
 	PluginHooks,
@@ -145,7 +222,12 @@ export type {
 	HookName,
 	ResolvedHook,
 	ResolvedPluginHooks,
+	ActorInfo,
+	ContentActionOrigin,
 	ContentHookEvent,
+	ContentPolicyDecision,
+	ContentPolicyEvent,
+	ContentSchedulePolicyEvent,
 	ContentDeleteEvent,
 	ContentPublishStateChangeEvent,
 	ContentRestoreStateChangeEvent,
@@ -171,6 +253,9 @@ export type {
 	ContentAfterSaveHandler,
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
+	ContentBeforePublishHandler,
+	ContentBeforeScheduleHandler,
+	ContentBeforeUnpublishHandler,
 	ContentAfterRestoreHandler,
 	ContentAfterScheduleHandler,
 	ContentAfterUnscheduleHandler,
@@ -191,6 +276,11 @@ export type {
 	ModerationDecision,
 	CollectionCommentSettings,
 	StoredComment,
+	PluginComment,
+	PluginCommentStatus,
+	CommentAccess,
+	CommentListOptions,
+	CommentCountOptions,
 
 	// Request metadata types
 	RequestMeta,
@@ -198,12 +288,15 @@ export type {
 
 	// Route types
 	PluginRoute,
+	PluginRouteDefinition,
 	RouteContext,
 
 	// Admin types
 	PluginAdminConfig,
 	PluginAdminPage,
 	PluginDashboardWidget,
+	PluginEditorPanel,
+	PluginEditorAction,
 	PluginAdminExports,
 	FieldWidgetConfig,
 	PortableTextBlockConfig,
@@ -223,5 +316,6 @@ export {
 	isDeprecatedCapability,
 	normalizeCapability,
 	normalizeCapabilities,
+	normalizePluginCapabilities,
 } from "./types.js";
 export type { CurrentPluginCapability, DeprecatedPluginCapability } from "./types.js";

package/src/plugins/install-finalization.ts

@@ -0,0 +1,77 @@
+import type { ApiResult } from "../api/types.js";
+
+export interface PluginInstallFinalizationOptions {
+	pluginId: string;
+	syncRuntime(): Promise<void>;
+	runLifecycle(): Promise<void>;
+	rollback(): Promise<ApiResult<unknown>>;
+}
+
+export interface PluginUpdateFinalizationOptions extends PluginInstallFinalizationOptions {
+	runRollbackLifecycle(): Promise<void>;
+}
+
+export async function finalizePluginInstall(
+	options: PluginInstallFinalizationOptions,
+): Promise<void> {
+	try {
+		await options.syncRuntime();
+		await options.runLifecycle();
+	} catch (installError) {
+		const failures: unknown[] = [installError];
+		try {
+			const rollback = await options.rollback();
+			if (!rollback.success) failures.push(new Error(rollback.error.message));
+		} catch (rollbackError) {
+			failures.push(rollbackError);
+		}
+		try {
+			await options.syncRuntime();
+		} catch (syncError) {
+			failures.push(syncError);
+		}
+		if (failures.length > 1) {
+			const rollbackError = new Error(
+				`Plugin ${options.pluginId} installation failed and rollback did not complete`,
+				{ cause: installError },
+			);
+			Object.defineProperty(rollbackError, "errors", { value: failures });
+			throw rollbackError;
+		}
+		throw installError;
+	}
+}
+
+export async function finalizePluginUpdate(
+	options: PluginUpdateFinalizationOptions,
+): Promise<void> {
+	try {
+		await options.syncRuntime();
+		await options.runLifecycle();
+	} catch (updateError) {
+		const failures: unknown[] = [updateError];
+		let rollbackSucceeded = false;
+		try {
+			const rollback = await options.rollback();
+			rollbackSucceeded = rollback.success;
+			if (!rollback.success) failures.push(new Error(rollback.error.message));
+		} catch (rollbackError) {
+			failures.push(rollbackError);
+		}
+		try {
+			await options.syncRuntime();
+			if (rollbackSucceeded) await options.runRollbackLifecycle();
+		} catch (syncError) {
+			failures.push(syncError);
+		}
+		if (failures.length > 1) {
+			const rollbackError = new Error(
+				`Plugin ${options.pluginId} update failed and rollback did not complete`,
+				{ cause: updateError },
+			);
+			Object.defineProperty(rollbackError, "errors", { value: failures });
+			throw rollbackError;
+		}
+		throw updateError;
+	}
+}

package/src/plugins/lifecycle.ts

@@ -0,0 +1,47 @@
+import type { Kysely } from "kysely";
+
+import { handlePluginDisable, handlePluginEnable } from "../api/handlers/plugins.js";
+import type { Database } from "../database/types.js";
+import type { SandboxedPluginEntry } from "../emdash-runtime.js";
+import { setCronTasksEnabled } from "./cron.js";
+import type { ResolvedPlugin } from "./types.js";
+
+export interface PluginLifecycleRuntime {
+	db: Kysely<Database>;
+	configuredPlugins: ResolvedPlugin[];
+	sandboxedPluginEntries: SandboxedPluginEntry[];
+	setPluginStatus(pluginId: string, status: "active" | "inactive"): Promise<void>;
+	syncMarketplacePlugins(): Promise<void>;
+	syncRegistryPlugins(): Promise<void>;
+}
+
+export async function enableRuntimePlugin(runtime: PluginLifecycleRuntime, pluginId: string) {
+	const result = await handlePluginEnable(
+		runtime.db,
+		runtime.configuredPlugins,
+		runtime.sandboxedPluginEntries,
+		pluginId,
+	);
+	if (!result.success) return result;
+
+	const source = result.data.item.source;
+	if (source === "registry") await runtime.syncRegistryPlugins();
+	else if (source === "marketplace") await runtime.syncMarketplacePlugins();
+	await runtime.setPluginStatus(pluginId, "active");
+	await setCronTasksEnabled(runtime.db, pluginId, true);
+	return result;
+}
+
+export async function disableRuntimePlugin(runtime: PluginLifecycleRuntime, pluginId: string) {
+	const result = await handlePluginDisable(
+		runtime.db,
+		runtime.configuredPlugins,
+		runtime.sandboxedPluginEntries,
+		pluginId,
+	);
+	if (!result.success) return result;
+
+	await runtime.setPluginStatus(pluginId, "inactive");
+	await setCronTasksEnabled(runtime.db, pluginId, false);
+	return result;
+}

package/src/plugins/manager.ts

@@ -26,6 +26,7 @@ import {
 } from "./hooks.js";
 import { PluginRouteRegistry, type RouteResult, type InvokeRouteOptions } from "./routes.js";
 import type {
+	ActorInfo,
 	PluginDefinition,
 	ResolvedPlugin,
 	PluginStorageConfig,
@@ -306,12 +307,13 @@ export class PluginManager {
 		collection: string,
 		isNew: boolean,
 		id?: string,
+		actor?: ActorInfo,
 	): Promise<{
 		content: Record<string, unknown>;
 		results: HookResult<Record<string, unknown>>[];
 	}> {
 		this.ensureInitialized();
-		return this.hookPipeline!.runContentBeforeSave(content, collection, isNew, id);
+		return this.hookPipeline!.runContentBeforeSave(content, collection, isNew, id, actor);
 	}
 
 	/**
@@ -321,9 +323,10 @@ export class PluginManager {
 		content: Record<string, unknown>,
 		collection: string,
 		isNew: boolean,
+		actor?: ActorInfo,
 	): Promise<HookResult<void>[]> {
 		this.ensureInitialized();
-		return this.hookPipeline!.runContentAfterSave(content, collection, isNew);
+		return this.hookPipeline!.runContentAfterSave(content, collection, isNew, actor);
 	}
 
 	/**