pi-roundtable 0.22.5 → 0.23.1

package/src/core/modes/conversation-modes.ts

@@ -0,0 +1,213 @@
+import type { SQL } from "bun";
+import type { Migration } from "../db/migrations.ts";
+import { PluginError } from "../errors.ts";
+import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
+import type { Logger } from "../log.ts";
+import type { ChannelKey } from "../sessions.ts";
+import type { Speaker } from "../speakers.ts";
+
+/** What a conversation is set to run unattended: both off until an owner switches them on. */
+export interface ConversationMode {
+	/** Held calls that are safe enough are approved by the server instead of asked on a card. */
+	yolo: boolean;
+	/** A turn that reaches its time limit goes on by itself, up to `autonomy.longRunning.maxSeconds`. */
+	longRunning: boolean;
+	/** The principal who last changed it; absent for a conversation never changed. */
+	changedBy?: string;
+	changedAt?: Date;
+}
+
+/** Which modes a change sets; a mode left out stays as it is. */
+export interface ModeChange {
+	yolo?: boolean;
+	longRunning?: boolean;
+}
+
+/** A held call the server approved in yolo mode, for the room's log and the people watching it. */
+export interface AutoApproval {
+	channel: ChannelKey;
+	tool: string;
+	/** What the call would do, as the card would have said. */
+	action: string;
+	/** The hold classes that were all inside what yolo may approve. */
+	classes: readonly string[];
+	/** The owner whose message started the turn. */
+	principalId: string;
+	at: Date;
+}
+
+/**
+ * The per-conversation modes, provided as `MODES`. They are stored per conversation key, so they
+ * work for any surface; a surface decides who may toggle them. Every mode survives a restart.
+ */
+export interface ConversationModes {
+	/** A conversation's modes from memory, both off by default; never waits on the database. */
+	peek(channel: ChannelKey): ConversationMode;
+	/**
+	 * Sets the modes `change` names and stores them before they take effect; resolves with the
+	 * result. Throws `PluginError` unless `by` is an owner other than the system principal, so the
+	 * host's own turns and webhook-borne speakers cannot switch a conversation to run unattended.
+	 */
+	set(
+		channel: ChannelKey,
+		change: ModeChange,
+		by: Speaker,
+	): Promise<ConversationMode>;
+	/** Called after each change. Returns the function that stops it. A throwing listener is logged. */
+	onChange(
+		listener: (channel: ChannelKey, mode: ConversationMode) => void,
+	): () => void;
+	/** Records that yolo mode approved a held call: logs it and tells `onAutoApproved` listeners. */
+	autoApproved(entry: AutoApproval): void;
+	onAutoApproved(listener: (entry: AutoApproval) => void): () => void;
+}
+
+interface Row {
+	channel: string;
+	yolo: boolean;
+	long_running: boolean;
+	changed_by: string | null;
+	changed_at: Date;
+}
+
+const OFF: ConversationMode = Object.freeze({
+	yolo: false,
+	longRunning: false,
+});
+
+function modeOf(row: Row): ConversationMode {
+	return Object.freeze({
+		yolo: row.yolo,
+		longRunning: row.long_running,
+		...(row.changed_by === null ? {} : { changedBy: row.changed_by }),
+		changedAt: row.changed_at,
+	});
+}
+
+/** The conversation modes in the `conversation_modes` table, cached in memory after one load. */
+export class PgConversationModes implements ConversationModes {
+	readonly #sql: SQL;
+	readonly #logger: Logger;
+	readonly #modes = new Map<ChannelKey, ConversationMode>();
+	readonly #changed = new Set<
+		(channel: ChannelKey, mode: ConversationMode) => void
+	>();
+	readonly #approved = new Set<(entry: AutoApproval) => void>();
+
+	private constructor(sql: SQL, logger: Logger) {
+		this.#sql = sql;
+		this.#logger = logger;
+	}
+
+	/** The modes' table; the host runs this before the modes attach. */
+	static readonly migration: Migration = {
+		name: "conversation-modes",
+		up: async (sql) => {
+			await sql`
+				CREATE TABLE IF NOT EXISTS conversation_modes (
+					channel text PRIMARY KEY,
+					yolo boolean NOT NULL DEFAULT false,
+					long_running boolean NOT NULL DEFAULT false,
+					changed_by text,
+					changed_at timestamptz NOT NULL DEFAULT now()
+				)`;
+		},
+	};
+
+	/**
+	 * The modes over the host's migrated pool, with none loaded: `Roundtable.check()` opens no
+	 * connection, so the rows are read by `load`, from the plugin's service start.
+	 */
+	static attach(sql: SQL, logger: Logger): PgConversationModes {
+		return new PgConversationModes(sql, logger);
+	}
+
+	/** Reads every stored row into memory; until then every conversation reads as both modes off. */
+	async load(): Promise<void> {
+		const rows: Row[] = await this.#sql`SELECT * FROM conversation_modes`;
+		// A mode `set` wrote while the rows were read is newer than its row here.
+		for (const row of rows)
+			if (!this.#modes.has(row.channel as ChannelKey))
+				this.#modes.set(row.channel as ChannelKey, modeOf(row));
+	}
+
+	peek(channel: ChannelKey): ConversationMode {
+		return this.#modes.get(channel) ?? OFF;
+	}
+
+	async set(
+		channel: ChannelKey,
+		change: ModeChange,
+		by: Speaker,
+	): Promise<ConversationMode> {
+		if (by.tier !== "owner" || by.principalId === SYSTEM_PRINCIPAL)
+			throw new PluginError(
+				"only an owner sets a conversation's modes, and not the host's own turns",
+			);
+		const yolo = change.yolo ?? null;
+		const longRunning = change.longRunning ?? null;
+		// One statement, so two changes that name different modes cannot undo each other.
+		const rows: Row[] = await this.#sql`
+			INSERT INTO conversation_modes (channel, yolo, long_running, changed_by, changed_at)
+			VALUES (${channel}, COALESCE(${yolo}::boolean, false),
+				COALESCE(${longRunning}::boolean, false), ${by.principalId}, now())
+			ON CONFLICT (channel) DO UPDATE SET
+				yolo = COALESCE(${yolo}::boolean, conversation_modes.yolo),
+				long_running = COALESCE(${longRunning}::boolean, conversation_modes.long_running),
+				changed_by = ${by.principalId},
+				changed_at = now()
+			RETURNING *`;
+		const [row] = rows;
+		if (!row)
+			throw new Error(`conversation modes of ${channel} were not stored`);
+		const mode = modeOf(row);
+		this.#modes.set(channel, mode);
+		this.#logger.info(
+			{
+				channel,
+				yolo: mode.yolo,
+				longRunning: mode.longRunning,
+				by: by.principalId,
+			},
+			"conversation modes changed",
+		);
+		this.#tell(this.#changed, "change", (listener) => listener(channel, mode));
+		return mode;
+	}
+
+	onChange(
+		listener: (channel: ChannelKey, mode: ConversationMode) => void,
+	): () => void {
+		this.#changed.add(listener);
+		return () => void this.#changed.delete(listener);
+	}
+
+	autoApproved(entry: AutoApproval): void {
+		this.#logger.info(
+			{
+				channel: entry.channel,
+				tool: entry.tool,
+				classes: entry.classes,
+				principalId: entry.principalId,
+			},
+			"held call approved by yolo mode",
+		);
+		this.#tell(this.#approved, "auto-approval", (listener) => listener(entry));
+	}
+
+	onAutoApproved(listener: (entry: AutoApproval) => void): () => void {
+		this.#approved.add(listener);
+		return () => void this.#approved.delete(listener);
+	}
+
+	/** Runs each listener; one that throws is logged and the rest still hear it. */
+	#tell<L>(listeners: Set<L>, what: string, call: (listener: L) => void): void {
+		for (const listener of [...listeners]) {
+			try {
+				call(listener);
+			} catch (error) {
+				this.#logger.error({ err: error }, `a ${what} listener threw`);
+			}
+		}
+	}
+}

package/src/core/modes/modes-plugin.ts

@@ -0,0 +1,24 @@
+import type { RoundtablePlugin } from "../plugin.ts";
+import { MODES } from "../services.ts";
+import { PgConversationModes } from "./conversation-modes.ts";
+
+/** The name of the modes' plugin, as the migration ledger names it. */
+export const MODES_PLUGIN = "modes";
+
+/**
+ * The per-conversation modes (yolo and long-running), provided as `MODES`. They live in their own
+ * table, so they survive a restart: the service loads them when the host starts, before it
+ * serves a turn, and until then every conversation reads as both modes off.
+ */
+export function modesPlugin(): RoundtablePlugin {
+	return {
+		name: MODES_PLUGIN,
+		migrations: [PgConversationModes.migration],
+		provides: [MODES],
+		setup: ({ database, logger, services }) => {
+			const modes = PgConversationModes.attach(database(), logger);
+			services.provide(MODES, modes);
+			return { services: [{ name: "modes", start: () => modes.load() }] };
+		},
+	};
+}

package/src/core/modules/delegation/delegator.ts

@@ -1,14 +1,14 @@
 import type { BackgroundTarget } from "../../contract/channels.ts";
-import type {
-	DispatchThread,
-	DispatchThreads,
-} from "../../discord/dispatch-threads.ts";
 import type { ChannelKey } from "../../domain/conversation.ts";
 import { DelegationError } from "../../domain/errors.ts";
 import { messages } from "../../i18n/index.ts";
 import type { Logger } from "../../log.ts";
 import type { Delegator } from "../../services.ts";
 import type { Tier } from "../../speakers.ts";
+import type {
+	DispatchThread,
+	DispatchThreads,
+} from "../../threads/dispatch-threads.ts";
 import { timeZone } from "../../time.ts";
 
 export interface DelegationJob {

package/src/core/modules/host-shell/shell-arithmetic.ts

@@ -0,0 +1,81 @@
+/**
+ * The `((` groups of one list the lexer reads. Words in arithmetic are no commands, but `((a); (b))`
+ * is two subshells, so the commands read inside an open group are kept apart and dropped only once
+ * the group closes as `))`; any group left open or closed otherwise passes them on.
+ */
+
+/** A `((` that may be arithmetic: where it opened and how many commands were read before it. */
+interface Group {
+	depth: number;
+	pos: number;
+	start: number;
+	/** Set when the `)` behind its closing one proved the group arithmetic. */
+	confirmed: boolean;
+}
+
+export class ArithGroups {
+	readonly #groups: Group[] = [];
+	readonly #held: string[][] = [];
+
+	/**
+	 * @param out where commands go when they are not in arithmetic
+	 * @param lone whether the list starts inside `$(`, so its first `(` is the second of `$((`
+	 * @param listStart where the list starts
+	 */
+	constructor(
+		readonly out: string[][],
+		readonly src: string,
+		readonly listStart: number,
+		readonly lone: boolean,
+	) {}
+
+	/** Whether a command read now is inside a `((` group. */
+	get open(): boolean {
+		return this.#groups.length > 0;
+	}
+
+	/** A finished simple command: held while a group is open, else passed on. */
+	add(words: string[]) {
+		(this.open ? this.#held : this.out).push(words);
+	}
+
+	/** The `(` at `pos`, at paren depth `depth`, opens a group. */
+	push(depth: number, pos: number) {
+		this.#groups.push({
+			depth,
+			pos,
+			start: this.#held.length,
+			confirmed: false,
+		});
+	}
+
+	/** Passes on every command held. */
+	flush() {
+		for (const command of this.#held.splice(0)) this.out.push(command);
+	}
+
+	/**
+	 * The `)` before `pos` closes paren depth `depth`. Returns whether it closed a group that is
+	 * arithmetic, whose commands are dropped. `))` closes arithmetic: the `)` right behind this one
+	 * proves the group below it (`((`) or the `$(` that started the list (`$((`).
+	 */
+	close(depth: number, pos: number): boolean {
+		const top = this.#groups[this.#groups.length - 1];
+		if (!top || top.depth !== depth) return false;
+		this.#groups.pop();
+		if (this.src[pos] === ")") {
+			const below = this.#groups[this.#groups.length - 1];
+			if (below && below.depth === depth - 1) below.confirmed = true;
+			else if (
+				!below &&
+				this.lone &&
+				top.pos === this.listStart &&
+				this.src[this.listStart - 1] === "("
+			)
+				top.confirmed = true;
+		}
+		if (top.confirmed) this.#held.length = top.start;
+		else if (!this.open) this.flush();
+		return top.confirmed;
+	}
+}

package/src/core/modules/host-shell/shell-lexer-types.ts

@@ -0,0 +1,53 @@
+/** The words, marks and records the shell lexer shares with the hold rule. */
+
+/** Words that can start a command line before the command itself: `then sudo ls` runs `sudo`. */
+export const COMMAND_PREFIX_WORDS: ReadonlySet<string> = new Set([
+	"if",
+	"then",
+	"elif",
+	"else",
+	"do",
+	"while",
+	"until",
+	"!",
+	"coproc",
+	"function",
+]);
+
+/** Words that can come before `case` or `esac` in a command that is still at its start. */
+export const KEYWORDS_BEFORE_CASE: ReadonlySet<string> = new Set([
+	...COMMAND_PREFIX_WORDS,
+	"time",
+]);
+
+/**
+ * Follows the `$(` or backtick a word keeps in place of a substitution that the shell running the
+ * line expands, so a `bash -c` script holding it is built at run time; a `$(` that came from single
+ * quotes or an escape has no mark, and the inner shell is the one that runs it.
+ */
+export const EXPANDED = "\uE000";
+
+/** The commands of a line, or `unreadable` when the lexer could not tell what bash would run. */
+export interface Lexed {
+	commands: string[][];
+	unreadable: boolean;
+	/** Whether the line evaluates arithmetic (`(( ))`, `$(( ))`, `$[ ]`), which runs a `$(` held in a variable's value. */
+	arithmetic: boolean;
+	/** Whether a `$(` or a backtick stands as text where no shell expands it (single quotes, an escape), which a value can carry into arithmetic. */
+	literalSubstitution: boolean;
+}
+
+/** A here-document waiting for the end of its line. */
+export interface Pending {
+	owner: number;
+	delimiter: string;
+	quoted: boolean;
+	stripTabs: boolean;
+}
+
+/** What every lexer of one line shares: how deep the substitutions go, and what the line turned out to hold. */
+export interface Shared {
+	depth: number;
+	arithmetic: boolean;
+	literalSubstitution: boolean;
+}