Moduletrace/cobble
2
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases 11 Wiki Activity

Let bots manage their hooks, with the user confirming what widens them

Browse Source 
Bots get list_hooks, pause_hook and delete_hook, which act directly since
they only take away. A new hook, or a new name, brief or filter, or
switching a paused one back on, goes through propose_hook: it stores a
hook_proposals row and puts a [hook-proposal:ID] card in the reply, which
the user it was proposed to confirms or rejects. The card is read from
what Confirm saves, with the bot's reason labelled as its own; confirming
checks everything again and saves through the Hooks modal's helpers. A
new hook's URL is shown on the card once, to the user only, never in the
outcome the bot is told. What calls a hook, its computers and its signing
are never proposed. Only chat replies propose, and a hook call's own run
gets no hook tools, so a caller's payload can't reach them.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
tben
2026-10-25 15:18:54 +01:00
co-authored by Claude Opus 5.5
parent 045167715d
commit 380d3ebb2f
54 changed files with 1983 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/functions/backend/db/bot-hooks/assert-hook-computers.ts
+52
View File
@@ -0,0 +1,52 @@
import type { BotHookSource } from "@/src/dict/bot-hook-dict";
import AppError from "@/src/utils/app-error";
import grabBotComputers from "../computers/grab-bot-computers";
import grabUserComputer from "../computers/grab-user-computer";
type Params = {
user_id: number | string;
bot_id: number | string;
workspace_id?: number | string | null;
source: BotHookSource;
computer_id?: number | string | null;
watch_computer_id?: number | string | null;
};
/**
* Checks the computers a new hook would use: its runs' one must be one of
* the bot's there, and a browser-notification hook needs a computer to
* watch that both the bot and the user reach. Returns the computer its
* runs use (a notification hook's defaults to the watched one), or null
* for the bot's current one. Throws why when it can't.
*/
export default async function assertHookComputers({
user_id,
bot_id,
workspace_id,
source,
computer_id,
watch_computer_id,
}: Params) {
const watching = source == "browser_notifications";
const run_computer_id = computer_id || (watching ? watch_computer_id : null) || null;
if (watching && !watch_computer_id) {
throw new AppError(`Pick the computer whose notifications it gets.`);
}
if (run_computer_id || watch_computer_id) {
const computers = await grabBotComputers({ bot_id, workspace_id });
for (const id of [run_computer_id, watching ? watch_computer_id : null].filter(Boolean)) {
if (!computers.some((c) => String(c.id) == String(id))) {
throw new AppError(`This bot has no access to that computer.`);
}
}
}
if (watching && !(await grabUserComputer({ user_id, computer_id: watch_computer_id! }))?.id) {
throw new AppError(`You have no access to that computer.`);
}
return run_computer_id;
}
src/functions/backend/db/bot-hooks/assert-hook-room.ts
+28
View File
@@ -0,0 +1,28 @@
import BunSQLite from "@moduletrace/bun-sqlite";
import { AppData } from "@/src/data/app-data";
import AppError from "@/src/utils/app-error";
type Params = {
user_id: number | string;
bot_id: number | string;
bot_name?: string | null;
};
/**
* Throws when the user's hooks for this bot are at
* `AppData.BotHookMaxPerBot`.
*/
export default async function assertHookRoom({ user_id, bot_id, bot_name }: Params) {
const count = Number(
(
await BunSQLite.sql<{ n: number }>({
sql: `SELECT COUNT(*) AS n FROM bot_hooks WHERE bot_id = ? AND user_id = ?`,
values: [bot_id, user_id],
})
).payload?.[0]?.n || 0,
);
if (count >= AppData.BotHookMaxPerBot) {
throw new AppError(`${bot_name || "This bot"} already has ${AppData.BotHookMaxPerBot} hooks. Delete one first.`);
}
}
src/functions/backend/db/bot-hooks/create-bot-hook.ts
+11 -39
View File
@@ -1,14 +1,13 @@
import BunSQLite from "@moduletrace/bun-sqlite";
import type { BUN_SQLITE_COBBLE_BOT_HOOKS, BunSQLiteTables } from "@/db/types/db";
import { AppData } from "@/src/data/app-data";
import type { BotHookSignatureFormat, BotHookSource } from "@/src/dict/bot-hook-dict";
import type { BotHookWithToken } from "@/src/types";
import AppError from "@/src/utils/app-error";
import { encrypt } from "@/src/utils/crypt";
import generateHookToken from "@/src/utils/generate-hook-token";
import grabUserConversation from "../bot-sessions/grab-user-conversation";
import grabBotComputers from "../computers/grab-bot-computers";
import grabUserComputer from "../computers/grab-user-computer";
import assertHookComputers from "./assert-hook-computers";
import assertHookRoom from "./assert-hook-room";
import syncComputerNotifyWatch from "./sync-computer-notify-watch";
import grabUserBotHook from "./grab-user-bot-hook";
@@ -69,44 +68,17 @@ export default async function createBotHook({
const conversation = await grabUserConversation({ user_id, bot_id, workspace_id });
const bot_id_num = conversation.bot.id;
const count = Number(
(
await BunSQLite.sql<{ n: number }>({
sql: `SELECT COUNT(*) AS n FROM bot_hooks WHERE bot_id = ? AND user_id = ?`,
values: [bot_id_num, user_id],
})
).payload?.[0]?.n || 0,
);
if (count >= AppData.BotHookMaxPerBot) {
throw new AppError(
`${conversation.bot.name || "This bot"} already has ${AppData.BotHookMaxPerBot} hooks. Delete one first.`,
);
}
await assertHookRoom({ user_id, bot_id: bot_id_num, bot_name: conversation.bot.name });
const watching = source == "browser_notifications";
const run_computer_id = computer_id || (watching ? watch_computer_id : null);
if (watching && !watch_computer_id) {
throw new AppError(`Pick the computer whose notifications it gets.`);
}
if (run_computer_id || watch_computer_id) {
const computers = await grabBotComputers({
bot_id: bot_id_num,
workspace_id: conversation.workspace_id,
});
for (const id of [run_computer_id, watching ? watch_computer_id : null].filter(Boolean)) {
if (!computers.some((c) => String(c.id) == String(id))) {
throw new AppError(`This bot has no access to that computer.`);
}
}
}
if (watching && !(await grabUserComputer({ user_id, computer_id: watch_computer_id! }))?.id) {
throw new AppError(`You have no access to that computer.`);
}
const run_computer_id = await assertHookComputers({
user_id,
bot_id: bot_id_num,
workspace_id: conversation.workspace_id,
source,
computer_id,
watch_computer_id,
});
const secret = watching ? undefined : signing_secret?.trim();