pi-roundtable 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -5,6 +5,13 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.12.1] - 2026-10-13
+
+### Fixed
+
+- Expired card copy texts leave `card-copies.json`, not only memory. They are dropped from the file when the host starts, when a copy button finds one past `keepDays`, and on an hourly sweep (an unref'd timer that the Discord plugin starts and stops with the host), without waiting for a new card.
+- Downloading the files of an owner or agent channel message has an overall 20 second deadline for the message and its reference together, and takes an `AbortSignal`: `attachmentsOf(message, dir, logger, fetchImpl?, limits?)` gains `limits: { deadlineMs?: number; signal?: AbortSignal }`. Files still to come when it passes, a body that stalls, and a directory that cannot be created are recorded as `download failed` failures instead of holding the turn or throwing.
+
 ## [0.12.0] - 2026-10-13
 
 ### Added

package/docs/plugins.md

@@ -553,6 +553,7 @@ A key the contract does not have stops the start and names the closest one.
 ### `context.attachments`: files from outside a turn
 
 A surface that takes a file as it arrives, such as Discord, hands the core a link, and the core downloads it into the conversation's attachment directory.
+The downloads of one message and of the message it replies to share a 20 second deadline; a file still to come when it passes, or whose directory cannot be made, is reported as `download failed` and the turn goes on without it.
 A plugin whose clients upload a file themselves, over HTTP for instance, has the file before any turn exists.
 `context.attachments` keeps such a file for the conversation until a turn uses it:
 
@@ -2563,7 +2564,7 @@ A surface or a `Prompts` of your own may ignore it: nothing requires reading it.
 
 `details.copy` (`{ label?, text }`) is a text the approval offers to copy, such as a command or a message the call would send; whoever builds `details` for a `confirm` of their own sets it.
 It is informational and never an answer: using it does not approve, decline or otherwise settle the prompt, and a surface that cannot show it ignores it, as the web chat's own client does (the frame carries it as `approval.copy`, left out when it would not fit beside the call's `input` in the frame's 256 KiB: the input is never cut for it).
-On Discord the card gets a third button (`label`, default "Copy", or its Traditional Chinese equivalent on a host in that language) that any member who can see the card may press, any number of times, also after the card has ended; it replies ephemerally with the text in a code block, or as a `copy.txt` file when the text does not fit a message (2,000 characters) or holds a code fence. The button's custom id holds the card's id, never the text: the text is kept under that id in `card-copies.json` in the host's `dataDir`, in plain text and readable by the host's user only, so the button works after a restart even though the card itself no longer answers; a card whose text is gone says so. `discord.cardCopies` (`{ keepDays?, keep? }`, default the newest 100 cards for 30 days) sets how long and how many; `false` keeps the texts in memory only, with the same limits, so they are gone at a restart. The file is written in the background, one write at a time, so a card is not held up by it. The attachments' `retention` and discarding a conversation do not remove the texts: they age out, or set `cardCopies` to `false` on a host that wants none on disk: the host then deletes an existing `card-copies.json` when it starts. A text over 20,000 characters gets no button, and a warning is logged.
+On Discord the card gets a third button (`label`, default "Copy", or its Traditional Chinese equivalent on a host in that language) that any member who can see the card may press, any number of times, also after the card has ended; it replies ephemerally with the text in a code block, or as a `copy.txt` file when the text does not fit a message (2,000 characters) or holds a code fence. The button's custom id holds the card's id, never the text: the text is kept under that id in `card-copies.json` in the host's `dataDir`, in plain text and readable by the host's user only, so the button works after a restart even though the card itself no longer answers; a card whose text is gone says so. `discord.cardCopies` (`{ keepDays?, keep? }`, default the newest 100 cards for 30 days) sets how long and how many; `false` keeps the texts in memory only, with the same limits, so they are gone at a restart. The file is written in the background, one write at a time, so a card is not held up by it. A text past `keepDays` leaves the file too, not only memory: when the host starts or a button finds one expired, and on an hourly sweep that does not keep the process alive. The attachments' `retention` and discarding a conversation do not remove the texts: they age out, or set `cardCopies` to `false` on a host that wants none on disk: the host then deletes an existing `card-copies.json` when it starts. A text over 20,000 characters gets no button, and a warning is logged.
 Because anyone who can see the card can copy the text, it holds nothing they may not read.
 `confirm` resolves `approved`, `declined`, `expired` (a card was shown and went unanswered), `unavailable` (no card could be shown: no one may approve the call, the speaker is below its tier, or the card could not be posted), `cancelled` (the turn stopped), or `pending` (with a `wait`). Both `expired` and `unavailable` leave the call held for the owner's next message; the turn's progress reports them as `refused: "expired"` and `refused: "held"`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.12.0",
+	"version": "0.12.1",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/attachments/attachment-fetcher.ts

@@ -16,6 +16,8 @@ export interface FetchRequest {
 	/** Prefix that keeps files of different messages apart, such as the message ID. */
 	prefix: string;
 	fromReference: boolean;
+	/** Aborts the download of the files still to come, and the one in flight. */
+	signal?: AbortSignal;
 }
 
 export interface FetchResult {
@@ -63,25 +65,33 @@ export async function fetchAttachments(
 ): Promise<FetchResult> {
 	const files: StoredAttachment[] = [];
 	const failures: AttachmentFailure[] = [];
-	const { refs, dir, prefix, fromReference } = request;
+	const { refs, dir, prefix, fromReference, signal } = request;
 	if (refs.length === 0) return { files, failures };
-	mkdirSync(dir, { recursive: true, mode: 0o700 });
 
 	for (const [index, ref] of refs.entries()) {
 		const fail = (reason: string) =>
 			failures.push({ name: ref.name, reason, fromReference });
+		if (signal?.aborted) {
+			fail("download failed: deadline passed or download aborted");
+			continue;
+		}
 		if (ref.size > MAX_ATTACHMENT_BYTES) {
 			fail(`larger than 25 MB (${ref.size} bytes)`);
 			continue;
 		}
 		try {
-			const response = await fetchImpl(ref.url);
+			// A directory that cannot be made fails the file, not the turn.
+			mkdirSync(dir, { recursive: true, mode: 0o700 });
+			const response = await fetchImpl(
+				ref.url,
+				signal ? { signal } : undefined,
+			);
 			if (!response.ok) {
 				await response.body?.cancel();
 				fail(`download failed with HTTP ${response.status}`);
 				continue;
 			}
-			const data = await readAttachmentBody(response);
+			const data = await readAttachmentBody(response, signal);
 			if (typeof data === "number") {
 				fail(`larger than 25 MB (${data} bytes)`);
 				continue;
@@ -110,12 +120,17 @@ export async function fetchAttachments(
 /** Returns the bytes, or the observed size once the stream exceeds the limit. */
 async function readAttachmentBody(
 	response: Response,
+	signal?: AbortSignal,
 ): Promise<Uint8Array | number> {
 	if (!response.body) return new Uint8Array();
 	const reader = response.body.getReader();
 	const chunks: Uint8Array[] = [];
 	let size = 0;
+	// A body that stalls ends with the signal, also when the fetch itself ignores it.
+	const stop = () => void reader.cancel(signal?.reason).catch(() => {});
+	signal?.addEventListener("abort", stop, { once: true });
 	try {
+		if (signal?.aborted) throw signal.reason ?? new Error("aborted");
 		for (;;) {
 			const { done, value } = await reader.read();
 			if (done) break;
@@ -126,7 +141,10 @@ async function readAttachmentBody(
 			}
 			chunks.push(value);
 		}
+		// A cancelled reader reads as the end of the body, so a cut-short body is not a whole file.
+		if (signal?.aborted) throw signal.reason ?? new Error("aborted");
 	} finally {
+		signal?.removeEventListener("abort", stop);
 		reader.releaseLock();
 	}
 	const data = new Uint8Array(size);

package/src/core/attachments/turn-attachments.ts

@@ -4,19 +4,34 @@ import type { Logger } from "../log.ts";
 import { fetchAttachments } from "./attachment-fetcher.ts";
 import { modelImagesOf } from "./model-images.ts";
 
+/** The most milliseconds all of a message's downloads take together by default. */
+const DEADLINE_MS = 20_000;
+
 /** Saves the message's and its reference's files, and turns up to four images into model images. */
 export async function collectAttachments(
 	message: InboundMessage,
 	dir: string,
-	options: { logger: Logger; fetchImpl?: typeof fetch },
+	options: {
+		logger: Logger;
+		fetchImpl?: typeof fetch;
+		/** One deadline for the message's and its reference's files together; default 20 s. */
+		deadlineMs?: number;
+		/** Aborts the downloads, as the deadline does. */
+		signal?: AbortSignal;
+	},
 ): Promise<TurnAttachments> {
 	const { fetchImpl, logger } = options;
+	const deadline = AbortSignal.timeout(options.deadlineMs ?? DEADLINE_MS);
+	const signal = options.signal
+		? AbortSignal.any([deadline, options.signal])
+		: deadline;
 	const own = await fetchAttachments(
 		{
 			refs: message.attachments,
 			dir,
 			prefix: message.messageId,
 			fromReference: false,
+			signal,
 		},
 		fetchImpl,
 	);
@@ -26,6 +41,7 @@ export async function collectAttachments(
 			dir,
 			prefix: `${message.messageId}-ref`,
 			fromReference: true,
+			signal,
 		},
 		fetchImpl,
 	);
@@ -54,9 +70,11 @@ export function attachmentsOf(
 	dir: string,
 	logger: Logger,
 	fetchImpl?: typeof fetch,
+	limits: { deadlineMs?: number; signal?: AbortSignal } = {},
 ): Promise<TurnAttachments> {
 	return collectAttachments(message, dir, {
 		logger,
+		...limits,
 		...(fetchImpl ? { fetchImpl } : {}),
 	});
 }

package/src/core/builtin/discord.ts

@@ -202,7 +202,11 @@ export function discordPlugin(options: DiscordOptions): RoundtablePlugin {
 					// The sweep reads threads through the connection, so it follows the surface's start.
 					{ name: "threads", start: () => void threads.sweep() },
 					// The copy texts of the last cards are on disk before the host exits.
-					{ name: "card-copies", stop: () => cards.flushCopies() },
+					{
+						name: "card-copies",
+						start: () => cards.startCopies(),
+						stop: () => cards.stopCopies(),
+					},
 				],
 			};
 		},

package/src/core/discord/card-copies.ts

@@ -11,6 +11,8 @@ export const COPY_TEXT_LIMIT = 20_000;
 const COPY_KEEP = 100;
 /** How many days a copy text is kept by default. */
 const COPY_KEEP_DAYS = 30;
+/** How often expired texts are dropped from the file, an hour. */
+const SWEEP_MS = 60 * 60_000;
 
 interface Entry {
 	text: string;
@@ -27,6 +29,12 @@ export interface CardCopiesOptions {
 	logger: Logger;
 	/** Replaceable in tests. */
 	now?: () => number;
+	/** How often expired texts are dropped from the file; default `SWEEP_MS`. */
+	sweepMs?: number;
+	/** Replaceable in tests. */
+	setInterval?: typeof setInterval;
+	/** Replaceable in tests, with `setInterval`. */
+	clearInterval?: typeof clearInterval;
 }
 
 /**
@@ -42,6 +50,7 @@ export class CardCopies {
 	readonly #entries = new Map<string, Entry>();
 	#writing: Promise<void> | undefined;
 	#dirty = false;
+	#timer: ReturnType<typeof setInterval> | undefined;
 
 	constructor(options: CardCopiesOptions) {
 		this.#options = options;
@@ -56,7 +65,7 @@ export class CardCopies {
 				if (typeof text === "string" && typeof at === "number")
 					this.#entries.set(id, { text, at });
 			}
-			this.#prune();
+			if (this.#prune()) this.#schedule();
 		} catch (error) {
 			logger.warn(
 				{ path, err: error },
@@ -77,12 +86,31 @@ export class CardCopies {
 		const entry = this.#entries.get(id);
 		if (!entry) return undefined;
 		if (this.#now() - entry.at > this.#keepMs()) {
-			this.#entries.delete(id);
+			this.#prune();
+			this.#schedule();
 			return undefined;
 		}
 		return entry.text;
 	}
 
+	/** Starts the hourly sweep that drops expired texts from the file too; the timer does not hold the process. */
+	start(): void {
+		if (this.#timer || !this.#options.path) return;
+		const every = this.#options.setInterval ?? setInterval;
+		this.#timer = every(() => {
+			if (this.#prune()) this.#schedule();
+		}, this.#options.sweepMs ?? SWEEP_MS);
+		this.#timer.unref?.();
+	}
+
+	/** Stops the sweep and resolves once what was remembered so far is on disk; for a host that stops and for tests. */
+	async stop(): Promise<void> {
+		if (this.#timer)
+			(this.#options.clearInterval ?? clearInterval)(this.#timer);
+		this.#timer = undefined;
+		await this.flush();
+	}
+
 	/** Resolves once what was remembered so far is on disk; for a host that stops and for tests. */
 	async flush(): Promise<void> {
 		while (this.#writing) await this.#writing;
@@ -96,15 +124,18 @@ export class CardCopies {
 		return (this.#options.keepDays ?? COPY_KEEP_DAYS) * 24 * 60 * 60_000;
 	}
 
-	#prune(): void {
+	/** Drops expired and surplus entries; true when any went. */
+	#prune(): boolean {
+		const before = this.#entries.size;
 		const now = this.#now();
 		const keep = this.#options.keep ?? COPY_KEEP;
 		for (const [id, entry] of this.#entries)
 			if (now - entry.at > this.#keepMs()) this.#entries.delete(id);
 		for (const id of this.#entries.keys()) {
-			if (this.#entries.size <= keep) return;
+			if (this.#entries.size <= keep) break;
 			this.#entries.delete(id);
 		}
+		return this.#entries.size < before;
 	}
 
 	/** Writes the file after the call that asked, once at a time; asks made meanwhile share the next write. */

package/src/core/discord/owner-cards.ts

@@ -111,6 +111,8 @@ export class OwnerCards implements InteractionModule {
 	}
 	/** Resolves once the remembered copy texts are on disk. */
 	flushCopies = (): Promise<void> => this.#copies.flush();
+	startCopies = (): void => this.#copies.start();
+	stopCopies = (): Promise<void> => this.#copies.stop();
 
 	commands() {
 		return [];