@vercel/board 0.0.0-stage → 0.15.0

package/dist/chat-provider-XCnQlxq6.d.mts

@@ -0,0 +1,140 @@
+import { _ as ExternalFile, h as ExternalAuthor, t as Actor, v as ExternalLink } from "./reducers-B_vUGQRp.mjs";
+import { Pt as SourceRead, a as ProviderFile, b as ProviderEvent, c as Receive, d as ResolvedTarget, h as SyncProvider, i as ProviderDelivery, l as ReceivedEvent, n as FetchedLink, o as ProviderOptions, r as FileDelivery, s as ProviderPost, w as SyncRoot } from "./provider-BGjz-mDa.mjs";
+import { Adapter, Author, FileUpload, Message, ReactionEvent } from "chat";
+//#region src/sync/types.d.ts
+declare function externalAuthor(platform: string, author: Author): ExternalAuthor;
+//#endregion
+//#region src/sync/chat-provider.d.ts
+type ChatInput = {
+  kind: 'message' | 'edited';
+  message: Message;
+} | {
+  kind: 'deleted';
+  thread: string;
+  message: string;
+  raw: unknown;
+} | {
+  kind: 'reaction';
+  reaction: ReactionEvent;
+};
+type ChatTransport = Omit<ProviderOptions, 'uploadsFiles'> & {
+  adapter: Adapter;
+  findByEmail?(email: string): Promise<ExternalAuthor | null>;
+  mention?(actor: Actor): string | null;
+  author?(author: Author, raw: unknown): ExternalAuthor;
+  resolveChannel(key: string): Promise<string>;
+  resolveTarget(target: string): Promise<ResolvedTarget>;
+  groupThread?(thread: string): string;
+  channelOf?(thread: string): string;
+  isRoot?(thread: string, message: string): boolean;
+  fromChatId?(id: string): string;
+  toChatId?(id: string): string;
+  context?(message: Message): string | null;
+  markdown?(message: Message): string;
+  /** Platform messages a message links to, located under sync key `key`. */
+  links?(key: string, message: Message): ExternalLink[];
+  fetchLink?(link: ExternalLink): Promise<FetchedLink>;
+  /** A channel or thread, read on demand without syncing it. */
+  read?(target: string, options: {
+    limit: number;
+  }): Promise<SourceRead>;
+  avatar?(message: Message): Promise<string | null>;
+  fetchRoot?(thread: string): Promise<Omit<SyncRoot, 'raw'> & {
+    raw?: unknown;
+  }>;
+  intercept?(key: string, headers: Headers, body: string): ReceivedEvent[];
+  /** Edits and deletes in a webhook that the adapter doesn't emit itself, as the adapter would have. */
+  missed?(headers: Headers, body: string): ChatInput[];
+  uploadFiles?(thread: string, files: FileUpload[]): Promise<FileDelivery>;
+  /** The name a file is uploaded under, when the platform reads more into a name than the board does. */
+  uploadName?(file: ProviderFile): string;
+  fileIds?(raw: unknown): string[];
+  refusesFiles?(error: unknown): boolean;
+  deleteFiles?(ids: string[]): Promise<void>;
+  /** What the adapter needs to fetch a file again, if not everything the event carried. */
+  fileToFetch?(file: ExternalFile): ExternalFile;
+  startTyping?(thread: string, latest: string | null, status?: string): Promise<void>;
+  /** Runs adapter calls with a person's token instead of the bot's: how a message posts as them. */
+  runAs?<T>(token: string, fn: () => Promise<T>): Promise<T>;
+  /** The platform account a person's token belongs to. */
+  whoAmI?(token: string): Promise<ExternalAuthor>;
+};
+declare abstract class ChatSyncProvider<E extends ProviderEvent = ProviderEvent> extends SyncProvider<E> {
+  protected readonly transport: ChatTransport;
+  private readonly chat;
+  private readonly receiving;
+  private initialized;
+  constructor(transport: ChatTransport);
+  protected toNative(id: string): string;
+  protected toChat(id: string): string;
+  protected locate(key: string, chatThread: string): {
+    channel: string;
+    thread: string;
+    subthread: string | null;
+  };
+  inboxChannel(key: string, thread: string): string;
+  eventId(key: string, input: ChatInput): string;
+  protected author(author: Author, raw: unknown): {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  protected authorOf(message: Message): Promise<{
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  }>;
+  protected normalize(key: string, input: ChatInput): Promise<ReceivedEvent>;
+  private emit;
+  receive(key: string, request: Request, emit: Receive): Promise<Response>;
+  private receiveRequest;
+  protected ready(): Promise<Adapter<unknown, unknown>>;
+  resolveChannel(key: string): Promise<string>;
+  resolveTarget(target: string): Promise<{
+    target: string;
+    channel: string;
+    kind: "channel" | "thread";
+  }>;
+  findByEmail(email: string): Promise<{
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  } | null>;
+  mention(actor: Actor): string | null;
+  fetchRoot(thread: string): Promise<SyncRoot | null>;
+  fetchLink(link: ExternalLink): Promise<FetchedLink>;
+  read(target: string, options: {
+    limit: number;
+  }): Promise<SourceRead>;
+  fetchFile(file: ExternalFile): Promise<Uint8Array | null>;
+  post(target: string, kind: ResolvedTarget['kind'], { as: _sender, files, ...body }: ProviderPost): Promise<ProviderDelivery>;
+  whoAmI(token: string): Promise<{
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  }>;
+  /** As the person: ready first, so the adapter learns its own identity with the bot's token, never theirs. */
+  private as;
+  postAs(token: string, target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
+  editAs(token: string, thread: string, message: string, body: ProviderPost): Promise<void>;
+  deleteAs(token: string, thread: string, message: string): Promise<void>;
+  edit(thread: string, message: string, { as: _sender, files, ...body }: ProviderPost): Promise<void>;
+  delete(thread: string, message: string): Promise<void>;
+  react(thread: string, message: string, emoji: string, added: boolean): Promise<void>;
+  startTyping(thread: string, latest: string | null, status?: string): Promise<void>;
+  uploadFiles(thread: string, files: ProviderFile[]): Promise<FileDelivery>;
+  /** Files as the Chat SDK takes them: Buffers, named as the platform wants. */
+  private named;
+  refusesFiles(error: unknown): boolean;
+  deleteFiles(ids: string[]): Promise<void>;
+}
+//#endregion
+export { externalAuthor as i, ChatSyncProvider as n, ChatTransport as r, ChatInput as t };

package/dist/chat-provider-jFSeyNmB.mjs

@@ -0,0 +1,389 @@
+import "./contract-CuJmlrhw.mjs";
+import { n as ResolvedTarget, r as SyncProvider } from "./provider-CuewcDNZ.mjs";
+import { n as userTokensOf } from "./users-Dls7_ANV.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Chat, stringifyMarkdown } from "chat";
+//#region src/sync/state.ts
+/**
+* Chat SDK state for sync. Correctness comes from the board log (deterministic
+* inbox IDs, the `sync` reducer), and Chat SDK runs with `concurrency:
+* 'concurrent'` and no subscriptions, so this only holds best-effort caches.
+*/
+function ephemeralState() {
+	const values = /* @__PURE__ */ new Map();
+	const lists = /* @__PURE__ */ new Map();
+	const queues = /* @__PURE__ */ new Map();
+	const locks = /* @__PURE__ */ new Map();
+	const subscriptions = /* @__PURE__ */ new Set();
+	const live = (key) => {
+		const entry = values.get(key);
+		if (entry && entry.expiresAt <= Date.now()) values.delete(key);
+		return values.get(key);
+	};
+	const expiry = (ttlMs) => ttlMs ? Date.now() + ttlMs : Number.POSITIVE_INFINITY;
+	return {
+		connect: async () => {},
+		disconnect: async () => {},
+		subscribe: async (threadId) => void subscriptions.add(threadId),
+		unsubscribe: async (threadId) => void subscriptions.delete(threadId),
+		isSubscribed: async (threadId) => subscriptions.has(threadId),
+		acquireLock: async (threadId, ttlMs) => {
+			const held = locks.get(threadId);
+			if (held && held.expiresAt > Date.now()) return null;
+			const lock = {
+				threadId,
+				token: crypto.randomUUID(),
+				expiresAt: Date.now() + ttlMs
+			};
+			locks.set(threadId, lock);
+			return lock;
+		},
+		extendLock: async (lock, ttlMs) => {
+			const held = locks.get(lock.threadId);
+			if (held?.token !== lock.token) return false;
+			held.expiresAt = Date.now() + ttlMs;
+			return true;
+		},
+		releaseLock: async (lock) => {
+			if (locks.get(lock.threadId)?.token === lock.token) locks.delete(lock.threadId);
+		},
+		forceReleaseLock: async (threadId) => void locks.delete(threadId),
+		get: async (key) => live(key)?.value ?? null,
+		set: async (key, value, ttlMs) => void values.set(key, {
+			value,
+			expiresAt: expiry(ttlMs)
+		}),
+		setIfNotExists: async (key, value, ttlMs) => {
+			if (live(key)) return false;
+			values.set(key, {
+				value,
+				expiresAt: expiry(ttlMs)
+			});
+			return true;
+		},
+		delete: async (key) => void values.delete(key),
+		appendToList: async (key, value, options) => {
+			const list = lists.get(key) ?? [];
+			list.push(value);
+			if (options?.maxLength && list.length > options.maxLength) list.splice(0, list.length - options.maxLength);
+			lists.set(key, list);
+		},
+		getList: async (key) => lists.get(key) ?? [],
+		enqueue: async (threadId, entry, maxSize) => {
+			const queue = queues.get(threadId) ?? [];
+			queue.push(entry);
+			if (queue.length > maxSize) queue.splice(0, queue.length - maxSize);
+			queues.set(threadId, queue);
+			return queue.length;
+		},
+		dequeue: async (threadId) => queues.get(threadId)?.shift() ?? null,
+		queueDepth: async (threadId) => queues.get(threadId)?.length ?? 0
+	};
+}
+//#endregion
+//#region src/sync/chat.ts
+/**
+* One Chat SDK instance per sync entry. Platform modules call this, so
+* the board (`@vercel/board`) never loads Chat SDK unless sync is configured.
+*/
+const createChat = (adapter) => new Chat({
+	userName: "board",
+	adapters: { [adapter.name]: adapter },
+	state: ephemeralState(),
+	concurrency: "concurrent",
+	logger: "warn"
+});
+/** A message as markdown, the board's text format: Chat SDK parses every platform's own. */
+function markdownOf(message) {
+	try {
+		return stringifyMarkdown(message.formatted).trim() || message.text;
+	} catch {
+		return message.text;
+	}
+}
+//#endregion
+//#region src/sync/types.ts
+function externalAuthor(platform, author) {
+	const handle = author.userName || author.userId;
+	return {
+		id: `${platform}:user:${author.userId}`,
+		handle,
+		name: author.fullName || handle,
+		avatar: null,
+		isBot: author.isBot === true
+	};
+}
+//#endregion
+//#region src/sync/chat-provider.ts
+const externalFile = (file) => ({
+	type: file.type,
+	...file.name ? { name: file.name.slice(0, 1e3) } : {},
+	...file.mimeType ? { mimeType: file.mimeType.slice(0, 255) } : {},
+	...typeof file.size === "number" && Number.isInteger(file.size) && file.size >= 0 ? { size: file.size } : {},
+	...file.url && file.url.length <= 4e3 ? { url: file.url } : {},
+	...file.fetchMetadata ? { fetchMetadata: file.fetchMetadata } : {}
+});
+var ChatSyncProvider = class extends SyncProvider {
+	transport;
+	chat;
+	receiving = new AsyncLocalStorage();
+	initialized;
+	constructor(transport) {
+		super({
+			...transport,
+			users: transport.users ?? userTokensOf(transport.adapter),
+			uploadsFiles: !!transport.uploadFiles
+		});
+		this.transport = transport;
+		this.chat = createChat(transport.adapter);
+		const onMessage = async (_thread, message) => this.emit({
+			kind: "message",
+			message
+		});
+		this.chat.onNewMessage(/[\s\S]*/, onMessage);
+		this.chat.onNewMention(onMessage);
+		this.chat.onMessageUpdated(async (_thread, message) => this.emit({
+			kind: "edited",
+			message
+		}));
+		this.chat.onMessageDeleted(async (event) => this.emit({
+			kind: "deleted",
+			thread: event.threadId,
+			message: event.messageId,
+			raw: event.raw
+		}));
+		this.chat.onReaction(async (reaction) => this.emit({
+			kind: "reaction",
+			reaction
+		}));
+	}
+	toNative(id) {
+		const native = id.slice(id.indexOf(":") + 1);
+		return this.transport.fromChatId?.(native) ?? native;
+	}
+	toChat(id) {
+		return `${this.transport.adapter.name}:${this.transport.toChatId?.(id) ?? id}`;
+	}
+	locate(key, chatThread) {
+		const native = this.toNative(chatThread);
+		const precise = `${key}:${native}`;
+		const thread = `${key}:${this.transport.groupThread?.(native) ?? native}`;
+		return {
+			channel: `${key}:${this.transport.channelOf?.(native) ?? this.toNative(this.transport.adapter.channelIdFromThreadId(chatThread))}`,
+			thread,
+			subthread: precise === thread ? null : precise
+		};
+	}
+	inboxChannel(key, thread) {
+		const native = thread.slice(key.length + 1);
+		return `${key}:${this.transport.channelOf?.(native) ?? this.toNative(this.transport.adapter.channelIdFromThreadId(this.toChat(native)))}`;
+	}
+	eventId(key, input) {
+		if (input.kind === "reaction") throw new Error(`${this.platform} must supply a stable reaction occurrence ID`);
+		if (input.kind === "deleted") return `deleted:${key}:${this.toNative(input.thread)}|${input.message}`;
+		const message = input.message;
+		const location = `${key}:${this.toNative(message.threadId)}|${message.id}`;
+		return input.kind === "message" ? `message:${location}` : `edited:${location}|${message.text}`;
+	}
+	author(author, raw) {
+		return this.transport.author?.(author, raw) ?? externalAuthor(this.platform, author);
+	}
+	async authorOf(message) {
+		const author = this.author(message.author, message.raw);
+		const avatar = await this.transport.avatar?.(message).catch(() => null);
+		return avatar ? {
+			...author,
+			avatar
+		} : author;
+	}
+	async normalize(key, input) {
+		const dedupe = this.eventId(key, input);
+		if (input.kind === "deleted") return {
+			dedupe,
+			raw: input.raw,
+			event: {
+				kind: "deleted",
+				...this.locate(key, input.thread),
+				message: input.message
+			}
+		};
+		if (input.kind === "reaction") {
+			const event = input.reaction;
+			const emoji = (event.emoji?.name ?? event.rawEmoji).toLowerCase().replace(/[^a-z0-9_+-]/g, "_").slice(0, 64) || "unknown";
+			return {
+				dedupe,
+				raw: event.raw,
+				event: {
+					kind: "reaction",
+					...this.locate(key, event.threadId),
+					message: event.messageId,
+					emoji,
+					added: event.added,
+					author: this.author(event.user, event.raw)
+				}
+			};
+		}
+		const message = input.message;
+		const found = this.transport.links?.(key, message) ?? [];
+		const links = found.length ? { links: found.slice(0, 10) } : {};
+		const common = {
+			...this.locate(key, message.threadId),
+			message: message.id,
+			text: this.transport.markdown?.(message) ?? markdownOf(message),
+			author: await this.authorOf(message),
+			...links
+		};
+		return {
+			dedupe,
+			raw: message.raw,
+			event: input.kind === "edited" ? {
+				kind: "edited",
+				...common
+			} : {
+				kind: "message",
+				...common,
+				isRoot: this.transport.isRoot?.(this.toNative(message.threadId), message.id) ?? false,
+				context: this.transport.context?.(message) ?? null,
+				...message.attachments?.length ? { files: message.attachments.slice(0, 20).map(externalFile) } : {}
+			}
+		};
+	}
+	async emit(input) {
+		const context = this.receiving.getStore();
+		if (!context) throw new Error("Chat SDK emitted an event outside a verified request");
+		await context.emit(await this.normalize(context.key, input));
+	}
+	receive(key, request, emit) {
+		return this.receiving.run({
+			key,
+			emit
+		}, () => this.receiveRequest(key, request, emit));
+	}
+	async receiveRequest(key, request, emit) {
+		const body = this.transport.intercept || this.transport.missed ? await request.clone().text() : null;
+		const tasks = [];
+		const response = await this.chat.webhooks[this.transport.adapter.name](request, { waitUntil: (task) => void tasks.push(task) });
+		const results = [];
+		while (tasks.length) results.push(...await Promise.allSettled(tasks.splice(0)));
+		const failed = results.find((result) => result.status === "rejected");
+		if (failed) throw failed.reason;
+		if (response.ok && body !== null) {
+			for (const input of this.transport.missed?.(request.headers, body) ?? []) await emit(await this.normalize(key, input));
+			for (const received of this.transport.intercept?.(key, request.headers, body) ?? []) await emit(received);
+		}
+		return response;
+	}
+	async ready() {
+		this.initialized ??= this.chat.initialize().catch((error) => {
+			this.initialized = void 0;
+			throw error;
+		});
+		await this.initialized;
+		return this.transport.adapter;
+	}
+	resolveChannel(key) {
+		return this.transport.resolveChannel(key);
+	}
+	async resolveTarget(target) {
+		return ResolvedTarget.parse(await this.transport.resolveTarget.call(this, target));
+	}
+	async findByEmail(email) {
+		return this.transport.findByEmail?.(email) ?? null;
+	}
+	mention(actor) {
+		return this.transport.mention?.(actor) ?? null;
+	}
+	async fetchRoot(thread) {
+		const root = await this.transport.fetchRoot?.(thread);
+		return root ? {
+			...root,
+			raw: root.raw ?? null
+		} : null;
+	}
+	async fetchLink(link) {
+		return this.transport.fetchLink ? this.transport.fetchLink(link) : super.fetchLink(link);
+	}
+	async read(target, options) {
+		return this.transport.read ? this.transport.read(target, options) : super.read(target, options);
+	}
+	async fetchFile(file) {
+		const fetch = (await this.ready()).rehydrateAttachment?.({ ...this.transport.fileToFetch?.(file) ?? file }).fetchData;
+		if (!fetch) return null;
+		const data = await fetch();
+		return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	}
+	async post(target, kind, { as: _sender, files, ...body }) {
+		if (kind === "channel" && !this.canStartThreads) throw new Error(`${this.platform} cannot start threads`);
+		await this.ready();
+		const sent = await (kind === "channel" ? this.chat.channel(this.toChat(target)) : this.chat.thread(this.toChat(target))).post(files?.length ? {
+			...body,
+			files: this.named(files)
+		} : body);
+		return {
+			thread: this.toNative(sent.threadId),
+			message: sent.id,
+			...files?.length ? { files: this.transport.fileIds?.(sent.raw) ?? [] } : {}
+		};
+	}
+	async whoAmI(token) {
+		if (!this.transport.whoAmI) return super.whoAmI(token);
+		await this.ready();
+		return this.transport.whoAmI(token);
+	}
+	/** As the person: ready first, so the adapter learns its own identity with the bot's token, never theirs. */
+	async as(token, fn) {
+		if (!this.transport.runAs) throw new Error(`${this.platform} can't post as a person`);
+		await this.ready();
+		return this.transport.runAs(token, fn);
+	}
+	async postAs(token, target, kind, body) {
+		return this.as(token, () => this.post(target, kind, body));
+	}
+	async editAs(token, thread, message, body) {
+		await this.as(token, () => this.edit(thread, message, body));
+	}
+	async deleteAs(token, thread, message) {
+		await this.as(token, () => this.delete(thread, message));
+	}
+	async edit(thread, message, { as: _sender, files, ...body }) {
+		await (await this.ready()).editMessage(this.toChat(thread), message, files ? {
+			...body,
+			files: this.named(files)
+		} : body);
+	}
+	async delete(thread, message) {
+		await (await this.ready()).deleteMessage(this.toChat(thread), message);
+	}
+	async react(thread, message, emoji, added) {
+		const adapter = await this.ready();
+		if (added) await adapter.addReaction(this.toChat(thread), message, emoji);
+		else await adapter.removeReaction(this.toChat(thread), message, emoji);
+	}
+	async startTyping(thread, latest, status) {
+		const adapter = await this.ready();
+		if (this.transport.startTyping) await this.transport.startTyping(this.toChat(thread), latest, status);
+		else await adapter.startTyping(this.toChat(thread), status);
+	}
+	async uploadFiles(thread, files) {
+		await this.ready();
+		if (!this.transport.uploadFiles) return super.uploadFiles(thread, files);
+		return this.transport.uploadFiles(this.toChat(thread), this.named(files));
+	}
+	/** Files as the Chat SDK takes them: Buffers, named as the platform wants. */
+	named(files) {
+		const name = this.transport.uploadName;
+		return files.map((file) => ({
+			...file,
+			data: Buffer.isBuffer(file.data) ? file.data : Buffer.from(file.data.buffer, file.data.byteOffset, file.data.byteLength),
+			...name ? { filename: name(file) } : {}
+		}));
+	}
+	refusesFiles(error) {
+		return this.transport.refusesFiles?.(error) ?? false;
+	}
+	async deleteFiles(ids) {
+		await this.transport.deleteFiles?.(ids);
+	}
+};
+//#endregion
+export { externalAuthor as n, markdownOf as r, ChatSyncProvider as t };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}