Let a user stop a bot, and say the app is still alpha

The thinking row and the header menu both carry Stop while a bot has work open for the user anywhere: every pending or processing job of that bot in their conversations is failed as stopped, its task closed, a Stopped step recorded and one closing message posted per session, so the thread stops waiting and the bot goes idle. The handler running the job is aborted from this process through a registry, so a job stuck waiting on a model stops at once instead of on its next heartbeat, and a late face change after the abort is dropped. The release stage is now said in the app too: Settings > General reports "Cobble v0.1.5 (alpha)" next to development, and the README and RELEASING.md say what alpha means for installs.
2026-10-23 10:19:41 +01:00
parent 5beb5f3de4
commit fcad4b49d6
30 changed files with 1279 additions and 57 deletions
@@ -105,14 +105,14 @@ Inspect live data with `bun llm-code-assistant/query-db.ts "<sql>"` - a read-onl
 - **Composer:** a Tiptap editor (`(hooks)/use-composer-editor.ts`, `(partials)/composer-editor.tsx`), not a textarea, loaded with the page and focused automatically, that reads and writes markdown (`@tiptap/markdown`), so drafts and sent messages are markdown. Drafts are written to `localStorage` on a 250ms debounce (`useComposerDraft`), flushed on unmount. Bold, italic, strike, code, lists, quotes and links (no headings), from shortcuts, markdown typing or the selection bubble (`composer-format-bubble.tsx`, items in `(data)/composer-formats.ts`). `@` mentions a bot and `#` a workspace (`(data)/composer-mention-kinds.ts`, menu `composer-mention-list.tsx` above the input, items from `CrewBotsContext` and `CrewWorkspacesContext` via `searchMentionItems`), shown as chips (`composer-mention-chip.tsx`) and written as `[bot:ID]` / `[workspace:ID]` (`(utils)/mention-markdown.ts`, `src/utils/workspace-ref.ts`). Enter sends, Shift+Enter breaks the line; in a list or code block Enter is the editor's and Mod+Enter sends. Sending shows the bubble at once and empties the input (with its quote and files), so a slow connection never waits on the request: the optimistic message rides in `pending_messages` in `conversation.tsx` until the response or a push replaces it with the saved one (`(utils)/drop-sent-message.ts`), and a failed send takes it back and restores the text and files. Selecting text in a message (`data-quotable`, `use-message-selection`) shows a Quote button (`quote-selection-button.tsx`) that inserts it as a blockquote at the cursor (`ComposerHandle.insertQuote`). Before a reply, `grabMessageRefNames` names the refs in the user's messages that the user reaches, and `botMessagesToHarness` adds a `[Mentions: ...]` line after each one (`describeMessageRefs`). `@tiptap/react` needs `use-sync-external-store`, which is CommonJS and calls `require("react")`; bunext keeps React external in page bundles, so the app installs an ESM stand-in from `packages/use-sync-external-store-esm` (a `file:` dependency plus an override; the Dockerfile copies `packages/` before `bun install`).
 - **Message rendering:** bot messages are markdown, rendered with `react-markdown` + `remark-gfm` (raw HTML never rendered) through the twui-based map in `[bot_id]/(data)/message-markdown-components.tsx` (`markdown-link`, `markdown-list`, `markdown-code-block` partials). A bot names a crew member as `[bot:ID]` (`src/utils/bot-ref.ts`, linked to `#bot-ID` by `link-computer-refs.ts`): `(partials)/bot-ref-chip.tsx` shows its avatar and name, linked to its conversation (in the open workspace when it's in the crew there), from the live crew (`CrewBotsContext`), so a bot created in that reply links too; the coordinator is told to write them (`CoordinatorReplyNote`), and `find_bot` and `create_bot` return them. A workspace is named as `[workspace:ID]` (`#workspace-ID`, `(partials)/workspace-ref-chip.tsx`, from `CrewWorkspacesContext`). User messages are markdown too, rendered in the ink bubble by `user-bubble.tsx` with `UserMarkdownComponents` and `remark-breaks` (a single line break stays one, so older plain messages read as typed).
 - **Replies and reactions:** every bot message has a row under it (`(partials)/message-actions.tsx`, handlers from `BotMessageActionsContext`) to reply or react; the user's own messages only show the bot's reactions, read-only. Replying quotes the message above the composer (`composer-reply-preview.tsx`) and the sent one carries `bot_messages.reply_to_message_id` (not a foreign key: a deleted quote only drops it); `send-message` takes any message of the same conversation (the user's, same bot and workspace, any session, so a rollover or a moved-on thread still sends), and the conversation drops a picked quote when its session changes. Messages carry `reply_to` (`grabMessagesReplies`, also on relayed messages), shown by `message-reply-quote.tsx`, and the bot reads it as `[Replying to ...]` before the user's turn (`botMessagesToHarness`). Reactions are a fixed set (`BotMessageReactions` in `src/dict/bot-dict.ts`) in `bot_message_reactions` (one row per message, emoji and user, or bot); `api/admin/bots/react-message.ts` toggles the user's own on a bot message in their sessions (`grabUserBotMessage`, `toggleMessageReaction`), and every bot gets `react_to_message` (`src/harness/tools/bot/react-to-message-tool.ts`, chat replies and tasks: a message in the session it answers, the user's latest by default). Both push the message's fresh reactions (`grabMessagesReactions`, `mine` for the session user) to the session's user as `server:bot-reaction` (`BotMessageReactionData`), which replaces the message's own; `grabBotMessages` adds them when given `user_id`. Reactions aren't relayed between processes (production runs one).
- **Attachments and thinking:** the composer uploads files as they're picked, pasted or dropped (`use-composer-attachments`), shows them as chips, and sends once none is still uploading; the thread shows images as thumbnails and other files as chips. Replies read the files of the last `BotReplyAttachmentMessages` messages with any (`load-attachment-parts.ts`: images and audio as parts, documents as their text up to `BotAttachmentMaxTextChars`, videos as a note); older ones are only named. Tasks don't get the files yet. While the user has the last word in a session (every user message queues a reply, so this needs no face and shows even while the bot works in another session) or the bot waits for a model (`BotWaitingStatusLine`) or a task for its computer (`BotComputerBusyStatusLine`), `BotThinkingRow` sits under the last message; a message still on its way to the server reads "<name> is getting your message…" (`BotGettingMessageStatusLine`), while a task runs it reads "<name> is working…" with the task's latest step, and a reply working through tools shows its latest step under "is thinking…" (`use-reply-progress`). A coordinator with no workers gets `CoordinatorSoloNote` instead of `CoordinatorReplyNote`, so it never claims to have handed work to a worker. Live notices come from the process that ran the job at once, and from every other process through the live relay.
+- **Attachments and thinking:** the composer uploads files as they're picked, pasted or dropped (`use-composer-attachments`), shows them as chips, and sends once none is still uploading; the thread shows images as thumbnails and other files as chips. Replies read the files of the last `BotReplyAttachmentMessages` messages with any (`load-attachment-parts.ts`: images and audio as parts, documents as their text up to `BotAttachmentMaxTextChars`, videos as a note); older ones are only named. Tasks don't get the files yet. While the user has the last word in a session (every user message queues a reply, so this needs no face and shows even while the bot works in another session) or the bot waits for a model (`BotWaitingStatusLine`) or a task for its computer (`BotComputerBusyStatusLine`), `BotThinkingRow` sits under the last message; a message still on its way to the server reads "<name> is getting your message…" (`BotGettingMessageStatusLine`), while a task runs it reads "<name> is working…" with the task's latest step, and a reply working through tools shows its latest step under "is thinking…" (`use-reply-progress`). A coordinator with no workers gets `CoordinatorSoloNote` instead of `CoordinatorReplyNote`, so it never claims to have handed work to a worker. A stop button rides on that row (`stop-bot-button.tsx`, and the header menu's Stop row, both through `StopBotContext`) exactly while `botBusyState` (`src/pages/admin/bots/[bot_id]/(utils)/bot-busy-state.ts`, which also decides the row's line) says the bot has work open for that user anywhere; a message still on its way to the server isn't stoppable, since its reply is queued after it lands. Live notices come from the process that ran the job at once, and from every other process through the live relay.
 - **Voice:** the composer's mic (`(partials)/composer-voice-button.tsx`, `use-voice-recorder`, shown once the browser can record, disabled with a note while transcription has no model to run on for the bot there, `bot_voice` page prop, from `resolveHarnessCandidates`) dictates: the recording goes to `api/admin/bots/transcribe.ts` (`transcribeAudio` with the bot's models, after `grabUserConversation`) and the text lands in the input at the cursor, to edit and send; Escape cancels, `AppData.ComposerVoiceMaxMs` stops it. Each bot message has a play button (disabled with a note while speech has no model) (`speak-message-button.tsx`, one player per conversation via `SpeakMessageContext` / `use-speak-message`) that plays `GET api/admin/bots/speak-message.ts?message_id=` straight in an `<audio>` (`speakText` streamed through as the provider makes it, so it starts in a couple of seconds; a failure answers in JSON, which the hook fetches again to show; only the user's own sessions, `grabSpeakableMessage`; text from `speechText`, cut at `AppData.SpeechMaxChars`). Under Speech, every model settings form has "Hear a sample" (`settings/models/(partials)/harness-voice-preview.tsx`), which plays `AppData.VoicePreviewText` in the form's model and voice before they're saved (`GET api/admin/harness/preview-voice`, super admins and admins, that model only via `grabModelCandidate`, streamed). Neither recordings nor audio are stored. Harness errors (`HarnessError`, safe to show) come back as the buttons' titles.
 - **Pictures:** a bot or workspace can have a picture (`image_media_id`, a private `media` row, paradigm `bot-image`/`workspace-image`), set or removed through `api/admin/set-profile-image.ts` (`setProfileImage`) or, from chat, by the bots themselves through the `set_picture` tool (`src/harness/tools/bot/set-picture-tool.ts`, every run: a bot sets its own face, the coordinator any worker) and `update_workspace`'s `picture_file_id` (`setBotPicture`, `copyMediaAsPicture`; super admins and admins only, `assertCrewManager`). Both take the image by its `[file:ID]` ref (`grabPictureSource`, so a bot only sets what it could already read; chat uploads land in `uploads/...` and are labelled with their media id in `load-attachment-parts.ts`/`describeAttachment.ts`) or by an upload's media id. The bytes are **copied** into a new picture row, never moved: a chat message that attached the source keeps loading, and only a row whose paradigm is `bot-image`/`workspace-image` is deleted when the picture is replaced (`removeReplacedPicture`, `is-picture-media.ts`). A picture keeps its own format (`imageOutputFormat`, `src/utils/image-output-format.ts`: PNG stays a PNG with its transparency, GIF becomes PNG, everything else JPEG), for the full image and the thumbnail alike. Its change is pushed live (`pushBotUpdated`'s `image_media_id`, `pushWorkspaceUpdated` and `server:workspace-updated`, `relayChangedWorkspaces`), so `BotAvatar` (rounded square, else its stone, its colour still applies) and `WorkspaceAvatar` (else the workspace icon) swap it without a reload. A bot is also edited from the header avatar (`(partials)/bot-profile-modal.tsx`, the same `BotForm` as adding one, `api/admin/bots/update-bot.ts`; the coordinator keeps its name and stays hue-less).
 - **Colour:** a bot's colour is free. It lives in `bots.color` (`#rrggbb`, set from the palette tiles, the native swatch or a typed hex in `(partials)/bot-colour-picker.tsx`, `api/admin/bots/`), and the stone it's drawn on is `bots.stone` (`BotStoneShapes`), because shape no longer follows colour. `src/utils/bot-color.ts` is the only place that resolves them (`resolveBotColor`/`resolveBotStone` fall back to the old `hue` for a bot saved before this, `botColorNeedsPaperFace` flips the eyes to paper on a very dark body), and `src/utils/bot-stone-props.ts` gives every row its `color`/`stone` props. A new bot starts on the palette's next free colour (`src/utils/pick-free-color.ts`). `src/scripts/move-bot-colour-to-owners.ts` backfills an install from `hue` (safe to rerun).
 - **Avatars:** `BotStone` (`src/components/general/bot-stone.tsx`) renders the stone inline from `src/data/stone-geometry.ts`, the bot's colour as the body's SVG `fill` attribute, face (`idle|working|done|asleep|needs-you`) drawn as eyes. The coordinator is hue-less (ink body, paper eyes; inverts in dark). Never put a stone in a circle/badge or add outline/shadow. Wordmark is vector (`Wordmark`, `src/data/wordmark-paths.ts`), never live text.
 - **Copy helpers:** `src/utils/crew-status.ts` (`3 working · 1 needs you`, "Three bots are working. One needs you."), `src/utils/relative-time.ts` (relative timestamps only).
 - **Prompt and memory (self-learning):** a bot has `system_prompt` (core instructions) and a separate core `memory` (markdown, general knowledge about its job, the same for every user it works for, never about one user). What it remembers about a user lives in `bot_user_memories` (one row per bot and user, seen only by that user's runs; `grab-bot-user-memory`, `update-bot-user-memory`), like workspace memory stays in its workspace. The bot rewrites them as it adapts (`update-bot-system-prompt`, `update-bot-memory` in `src/functions/backend/db/bots/`; whole-text replace, capped at `AppData.PromptMaxLength`). `grab-bot-prompt` builds the full prompt for the run's user via `composeBotPrompt` (`src/utils/compose-bot-prompt.ts`): core instructions, then the install-wide `# Install-wide instructions` (`bot_system_prompt_append` in `app_settings`, set by a super admin on Settings > General, `grabSystemPromptAppend`; empty when unset), then (in a workspace only) `# Workspace: <name>` with its description and `system_prompt`, the bot's `# Your instructions in <name>` (`workspace_bots.system_prompt`), `# Memory`, `# Memory about the user`, then `# Memory in <name>` (`workspace_bots.memory`). `update_memory` saves to `user` by default (`workspace` in a workspace) and to `core` only for what holds for everyone. In a workspace the bot learns into the workspace's instructions and memory by default (`scope: workspace` on `update_instructions`/`update_memory`, `WorkspaceLearningNote`) and into its core ones only when told to, or after suggesting it. `src/scripts/move-bot-memory-to-owners.ts` (run once per install) moved core memory written before this into the owner's.
- **Queue:** every bot job goes through `bots_queue`, with `kind` (`BotJobKinds`): `reply` (answers the user in chat, no task row) or `task` (long-running work, typically on a computer). Long-running work goes through `bots_queue`, a bun-sqlite `isQueue` table worked with the native `BunSQLite.queue` API (`status` pending|processing|completed|failed, `attempts`, `available_at`, `locked_at`/`locked_by`, `last_error`; options in `AppData.BotQueue*`). Not every message needs a job: the bot replies right away that it's on it and `enqueueBotJob` queues the brief (`instructions`, `params`, optional `message_id`/`computer_id`, the computer checked against the bot's access; a `bot_tasks` row is created unless `task_id` is given). DB helpers in `src/functions/backend/db/bots-queue/`: `claimBotJobs`, `updateBotJob` (renews the lock, saves `progress`/`checkpoint`; false once lost or cancelled), `completeBotJob` (result message, task done, face done/needs-you for the job's user), `failBotJob` (backoff retry, or `fatal`; out of attempts posts a needs-you message via `notifyBotJobFailed`), `cancelBotJob` (failed with `BotJobCancelledError`, `src/dict/bot-queue-dict.ts`), `releaseWorkerBotJobs`. Every model turn of a job is a step in `bots_queue_updates` (`kind` tool|note, one-line `text`, JSON `metadata`; tool names, never arguments; `describe-job-step.ts`), written through the job context's `report` (the text loop's `onStep`), which also sets `progress` and pushes `server:bot-job-update` (`BotJobUpdateData`). Steps are deleted with their job when it's pruned. One attempt has a deadline (`AppData.BotJobAttemptTimeoutMs`): the heartbeat keeps the lock alive for as long as the run takes, so a run past the deadline is aborted, reported as a failed try and retried, and a model or tool that never answers can't hold its slot, conversation or computer forever. The active task's latest `AppData.BotJobUpdatesShown` steps ride on `BotTaskWithSteps.updates` (`grabBotJobUpdates`); the conversation (`bot_task` page prop, `use-task-progress`) shows the latest one under `BotThinkingRow`'s "<name> is working…" while a task runs. Step text is the first line the model wrote, else plain labels for its tools (`JobStepToolLabels` in `src/dict/bot-queue-dict.ts`; other tools in words, an MCP tool as "Using Exa search (web search exa)").
+- **Queue:** every bot job goes through `bots_queue`, with `kind` (`BotJobKinds`): `reply` (answers the user in chat, no task row) or `task` (long-running work, typically on a computer). Long-running work goes through `bots_queue`, a bun-sqlite `isQueue` table worked with the native `BunSQLite.queue` API (`status` pending|processing|completed|failed, `attempts`, `available_at`, `locked_at`/`locked_by`, `last_error`; options in `AppData.BotQueue*`). Not every message needs a job: the bot replies right away that it's on it and `enqueueBotJob` queues the brief (`instructions`, `params`, optional `message_id`/`computer_id`, the computer checked against the bot's access; a `bot_tasks` row is created unless `task_id` is given). DB helpers in `src/functions/backend/db/bots-queue/`: `claimBotJobs`, `updateBotJob` (renews the lock, saves `progress`/`checkpoint`; false once lost or cancelled), `completeBotJob` (result message, task done, face done/needs-you for the job's user), `failBotJob` (backoff retry, or `fatal`; out of attempts posts a needs-you message via `notifyBotJobFailed`), `cancelBotJob` (failed with `BotJobCancelledError`, `src/dict/bot-queue-dict.ts`), `stop-bot-jobs` (a user pressing Stop: every pending or processing job of that bot in their conversations, `open-bot-jobs-sql`, failed with `BotJobStoppedError`, its task closed, a `Stopped` step recorded and one closing message per session, `stopped-job-report`; the running handler's controller is aborted from this process through `job-abort-registry`, so a job waiting on a model stops at once instead of on its next heartbeat, and a late `setFace` after the abort is dropped so a stopped bot is never pushed back to `working`; `api/admin/bots/stop.ts` then pushes the messages and the idle face, `quiet_push` so the user who pressed it gets no push notification), `releaseWorkerBotJobs`. Every model turn of a job is a step in `bots_queue_updates` (`kind` tool|note, one-line `text`, JSON `metadata`; tool names, never arguments; `describe-job-step.ts`), written through the job context's `report` (the text loop's `onStep`), which also sets `progress` and pushes `server:bot-job-update` (`BotJobUpdateData`). Steps are deleted with their job when it's pruned. One attempt has a deadline (`AppData.BotJobAttemptTimeoutMs`): the heartbeat keeps the lock alive for as long as the run takes, so a run past the deadline is aborted, reported as a failed try and retried, and a model or tool that never answers can't hold its slot, conversation or computer forever. The active task's latest `AppData.BotJobUpdatesShown` steps ride on `BotTaskWithSteps.updates` (`grabBotJobUpdates`); the conversation (`bot_task` page prop, `use-task-progress`) shows the latest one under `BotThinkingRow`'s "<name> is working…" while a task runs. Step text is the first line the model wrote, else plain labels for its tools (`JobStepToolLabels` in `src/dict/bot-queue-dict.ts`; other tools in words, an MCP tool as "Using Exa search (web search exa)").
 - **Queue handler:** `src/bots-queue/index.ts`, started from `server.ts` after cron and gated the same way. It releases its own cut-off jobs on startup (stable worker `AppData.BotQueueWorker`; polling starts even if that release fails, and a production process without `MAIN_SERVER` says so in the log instead of going quiet), then polls every `BotQueuePollMs`: reports jobs bun-sqlite failed on a lock timeout (`report-lost-bot-jobs`), claims per kind (`claimBotJobs` mirrors bun-sqlite's atomic claim plus `kind`, since `queue.claim` has no filter) up to `BotQueueReplyConcurrency` replies and `BotQueueConcurrency` tasks on separate slots, and runs each with `processBotJob` (heartbeat at a quarter of the lock timeout, abort on cancel/loss, one task per computer and one reply per session via `createKeyLock`, so a bot's other sessions answer side by side; a task waiting for its busy computer shows face `asleep` with `BotComputerBusyStatusLine`; face `working` once it starts, outcome pushed live; a job finishing while others for that user still run puts back the running one's face, `grabRunningBotJobFace`). The actual work is `run-bot-job.ts` (`BotJobRunner`, context in `types.ts`), which dispatches to `run-bot-reply.ts` and `run-bot-task.ts`. Throw `BotJobFatalError` for failures retrying can't fix. When every model is resting (`HarnessError.resting`, nothing was tried) the job is put back with `deferBotJob` until the first comes back, its attempt refunded and the bot's face `asleep`; other retryable harness errors retry no sooner than their `retry_at`. The `prune-bots-queue` cron deletes finished jobs after `BotQueueRetentionDays`.
 - **Live updates:** server push only. `sendToUser` (`src/websocket/(functions)/send-to-user.ts`) sends to one user's sockets; `pushBotNotice` sends `server:bot-message` (the message row, user messages too, for other tabs) and `server:bot-updated` (`BotUpdatedData`: face, status line, active task). The bots layout opens one socket (twui `useWebSocket`); components listen with `useServerEvent` (`src/hooks/`), and `useLiveBots` keeps the rail and header current. The conversation dedupes messages by id. Every process also runs `liveRelay` (`src/live-relay/`): every `AppData.LiveRelayPollMs` it reads new `bot_messages`, new `bots_queue_updates`, changed faces and changed bots from the database and pushes them to its own sockets, so work done by another process still shows live; clients drop what they already have. `server:bot-updated` carries the bot's `computer_id` when known, which keeps the header's computer in step across tabs, and its `workspace_ids` after a membership change, so a workspace's crew drops a bot that left it. A bot that joins the crew or a workspace is pushed as `server:bot-created` (`BotCreatedData`: its rail row, the workspaces it's in, and whether it belongs in that user's own chat), from the tool that created it and from the live relay for other processes, so the rail lists it without a reload. A workspace a bot created is pushed the same way as `server:workspace-created` (`WorkspaceCreatedData`: its rail row), from the tool and from the live relay. A deleted bot is pushed as `server:bot-removed` (`BotRemovedData`) to the audience read before the delete, since its assignments go with it, so its rail row goes at once. A deleted workspace is pushed the same way as `server:workspace-removed` (`WorkspaceRemovedData`), read before the delete too. A rail row's subtitle is the bot's status line while it has one, else (coordinator) the crew counts while a worker is busy or needs you, else its last message as plain text (`src/utils/message-preview.ts`).
 - **Workspaces:** `workspaces` (`name`, `description`, `system_prompt` shared by every bot in it, `computer_id` its default computer (not a foreign key), `archived`), with bots assigned through `workspace_bots` (plus that bot's `system_prompt` and `memory` there; the coordinator is an implicit member) and computers through `workspace_computers`. The first computer linked becomes the default; the user (workspace settings, chat header), any bot there (`set_workspace_computer`) or the coordinator can switch it. A workspace with no computer has none: tasks needing one fail. Workspace models (`workspace_harness_settings`) win over a bot's own, then the defaults. Helpers in `src/functions/backend/db/workspaces/` (`create-workspace`, `update-workspace`, `delete-workspace`, `add/remove-bot-*`, `update-workspace-bot`, `add/remove-computer-*`, `set-workspace-computer`, `grab-user-workspaces`, `grab-workspace-bots`, `grab-workspace-computers`, `grab-workspace-activity`), all access-checked against the session user, the structural ones for super admins and admins only; API in `api/admin/workspaces/`. The coordinator sets a member's instructions there with `set_bot_workspace_instructions`, creates a workspace with `create_workspace`, and changes any workspace's name, description or context with `update_workspace` (chat replies, and its own tasks so findings it was asked to record land in the workspace; a chat-created one is pushed as `server:workspace-created`).
@@ -5,7 +5,7 @@
 <img src="docs/readme/lockup-dark.svg#gh-dark-mode-only" alt="Cobble" height="56">
 </h1>
-A crew of small AI worker bots you host yourself.
+A crew of small AI worker bots you host yourself (alpha).
 ![Cobble: a crew of small AI worker bots you host yourself](docs/readme/hero-light.png#gh-light-mode-only)
 ![Cobble: a crew of small AI worker bots you host yourself](docs/readme/hero-dark.png#gh-dark-mode-only)
@@ -19,6 +19,13 @@ A crew of small AI worker bots you host yourself.
 </div>
 > **Alpha.** Cobble is still in alpha: interfaces, database schema and
 > settings change between releases, and things break. Install it to try it
 > out and to tell us what is wrong, but keep your own backups (Settings >
 > Backups) and do not put it in front of work you cannot lose. Every release
 > is a real release: the installer updates an existing install in place and
 > keeps its data.
 Cobble is a self-hosted crew of small AI worker bots. You get a coordinator
 and a set of workers, each with its own job, models, memory and workspace.
 They talk to you in one chat, share workspaces, run routines on a schedule,
@@ -49,6 +56,7 @@ your data on your own machine.
 | Crew       | One coordinator and as many workers as you need, each with a name, a role, a hue and its own core instructions                                             |
 | Rail       | The coordinator, your recent workers and their latest sessions, then your workspaces, each row carrying its status line                                    |
 | Chat       | Markdown with @-mentions for bots and #-mentions for workspaces, replies and quotes, reactions, attachments, older messages on scroll, drafts kept locally |
 | Stop       | Stop a bot from the thinking row or the header menu: its queued and running work stops at once, everywhere you chat with it, and it goes idle              |
 | Header     | The bot's model, provider and computer at a glance, one click from either, and its picture, instructions and settings on the avatar                        |
 | Workspaces | A shared home for a group of bots: shared context, per-workspace instructions and memory, a default computer, and a dashboard                              |
 | Memory     | Each bot keeps core memory, memory about you, and workspace memory, and rewrites it as it works                                                            |
@@ -3,6 +3,12 @@
 Cobble ships as a multi-arch container image and a single `install.sh`.
 The repository starts private and is made public at the launch gate below.
 Cobble is in **alpha** (see the note in `README.md`). Every release published
 before v1.0.0 is an alpha release: interfaces, the database schema and the
 settings may change between them, so a release that needs a migration step
 has to say so in its notes, and Settings > General keeps saying the stage
 until v1.0.0.
 ## One-time setup
 - [ ] `GITEA_USERNAME` and `GITEA_TOKEN` are set as GitHub Actions secrets.
@@ -0,0 +1,58 @@
 import { describe, expect, test } from "bun:test";
 import { abortRunningJob, registerJobAbort, unregisterJobAbort } from "./job-abort-registry";
 describe("job-abort-registry", () => {
    test("aborts the job this process is running", () => {
        let aborted = false;
        registerJobAbort({ job_id: 101, abort: () => (aborted = true) });
        expect(abortRunningJob({ job_id: 101 })).toBe(true);
        expect(aborted).toBe(true);
        unregisterJobAbort({ job_id: 101 });
    });
    test("a job running in another process is not here, so it isn't reported as aborted", () => {
        expect(abortRunningJob({ job_id: 202 })).toBe(false);
    });
    test("a finished job is cleaned up, so its id can't abort a later one", () => {
        let aborted = false;
        registerJobAbort({ job_id: 303, abort: () => (aborted = true) });
        unregisterJobAbort({ job_id: 303 });
        expect(abortRunningJob({ job_id: 303 })).toBe(false);
        expect(aborted).toBe(false);
    });
    test("a numeric string id reaches the same entry, since a route may send one", () => {
        let aborted = false;
        registerJobAbort({ job_id: 404, abort: () => (aborted = true) });
        expect(abortRunningJob({ job_id: "404" })).toBe(true);
        expect(aborted).toBe(true);
        unregisterJobAbort({ job_id: 404 });
    });
    test("unregistering a job nobody registered is harmless", () => {
        expect(() => unregisterJobAbort({ job_id: 505 })).not.toThrow();
    });
    test("only one job is aborted at a time", () => {
        const aborted: number[] = [];
        registerJobAbort({ job_id: 606, abort: () => aborted.push(606) });
        registerJobAbort({ job_id: 707, abort: () => aborted.push(707) });
        abortRunningJob({ job_id: 606 });
        expect(aborted).toEqual([606]);
        unregisterJobAbort({ job_id: 606 });
        unregisterJobAbort({ job_id: 707 });
    });
 });
@@ -0,0 +1,40 @@
 /**
 * The abort controllers of the jobs this process is running right now,
 * keyed by job id. Stopping a bot from the chat aborts the request its job
 * is waiting on (a model that never answers, a tool that hangs) instead of
 * leaving it to find out on its next heartbeat, which can take minutes.
 *
 * Only the process running a job can abort it, so this is a bonus: the job
 * is already failed in `bots_queue`, and a handler in another process
 * learns that on its next `updateBotJob`. Kept free of imports so the API
 * routes can use it without pulling the queue handler into a page bundle.
 */
 const running = new Map<number, () => void>();
 /**
 * Called by a handler once it holds a job, with the way to abort it.
 */
 export function registerJobAbort({ job_id, abort }: { job_id: number | string; abort: () => void }) {
    running.set(Number(job_id), abort);
 }
 /**
 * Called by a handler in its `finally`, whatever the outcome.
 */
 export function unregisterJobAbort({ job_id }: { job_id: number | string }) {
    running.delete(Number(job_id));
 }
 /**
 * Aborts a job running here. False means another process (or nobody) has
 * it, so the row's new status is how it finds out.
 */
 export function abortRunningJob({ job_id }: { job_id: number | string }) {
    const abort = running.get(Number(job_id));
    if (!abort) return false;
    abort();
    return true;
 }
@@ -27,6 +27,7 @@ import runBotJob from "./run-bot-job";
 import parseJobJson from "./parse-job-json";
 import nameBotSession from "./name-bot-session";
 import pushBotSession from "./push-bot-session";
 import { registerJobAbort, unregisterJobAbort } from "./job-abort-registry";
 import type { BotJobUpdateData } from "@/src/types";
 import type { BotJobContext, BotJobRunner } from "./types";
@@ -80,11 +81,6 @@ export default async function processBotJob({
     */
    const user_id = await grabJobUserId({ job }).catch(() => null);
    const setFace = async (face: Omit<Parameters<typeof setBotFace>[0], "bot_id" | "user_id">) => {
        if (!user_id) return;
        await pushBotNotice({ bot_id, bot: await setBotFace({ bot_id, user_id, ...face }) });
    };
    const controller = new AbortController();
    /**
     * The deadline is the one abort that is a failure, not a cancellation:
@@ -94,6 +90,25 @@ export default async function processBotJob({
    const timeout_message = `"${job.title || "The job"}" took too long and was stopped.`;
    let timed_out = false;
    /**
     * A stopped job never touches the face again: `stopBotJobs` already set
     * it to idle, and a late `working` or `asleep` would push over that and
     * leave a bot that shows work with nothing behind it.
     */
    const setFace = async (face: Omit<Parameters<typeof setBotFace>[0], "bot_id" | "user_id">) => {
        if (!user_id || controller.signal.aborted) return;
        await pushBotNotice({ bot_id, bot: await setBotFace({ bot_id, user_id, ...face }) });
    };
    /**
     * Stopping the bot from the chat aborts the request this job is
     * waiting on, here and now, rather than at the next heartbeat. The job
     * is already failed in the queue, so an abort is a cancellation and its
     * result is dropped (`controller.signal.aborted` below).
     */
    registerJobAbort({ job_id, abort: () => controller.abort() });
    const update: BotJobContext["update"] = async (params) => {
        if (controller.signal.aborted) return false;
@@ -305,5 +320,6 @@ export default async function processBotJob({
        }
    } finally {
        clearInterval(heartbeat);
        unregisterJobAbort({ job_id });
    }
 }
@@ -18,6 +18,12 @@ type Params = {
     * (`relayJobToRequester`): a message in that bot's conversation.
     */
    relay?: { bot_id: number; message: BUN_SQLITE_COBBLE_BOT_MESSAGES } | null;
    /**
     * Skip the push notification, keeping only the live send. For a message
     * the user just caused themselves (stopping the bot): they are looking
     * at the app, and one notification per conversation would be noise.
     */
    quiet_push?: boolean;
 };
 /**
@@ -27,9 +33,9 @@ type Params = {
 * goes to the conversation it was posted in. Best effort: a push that
 * fails is logged and never fails the job that made the change.
 */
-export default async function pushBotNotice({ bot_id, message, bot, relay }: Params) {
+export default async function pushBotNotice({ bot_id, message, bot, relay, quiet_push }: Params) {
    try {
-        await push({ bot_id, message, bot, relay });
+        await push({ bot_id, message, bot, relay, quiet_push });
    } catch (error) {
        await logError({
            title: "Bot notice wasn't pushed",
@@ -39,7 +45,7 @@ export default async function pushBotNotice({ bot_id, message, bot, relay }: Par
    }
 }
-async function push({ bot_id, message, bot, relay }: Params) {
+async function push({ bot_id, message, bot, relay, quiet_push }: Params) {
    if (message) {
        await pushToSessionUser({
            session_id: message.session_id,
@@ -49,7 +55,7 @@ async function push({ bot_id, message, bot, relay }: Params) {
        /**
         * Not waited on: a push service's latency must not slow the job.
         */
-        void notifyBotMessage({ message });
+        if (!quiet_push) void notifyBotMessage({ message });
    }
    if (relay) {
@@ -58,7 +64,7 @@ async function push({ bot_id, message, bot, relay }: Params) {
            data: { event: "server:bot-message", data: relay.message },
        });
-        void notifyBotMessage({ message: relay.message });
+        if (!quiet_push) void notifyBotMessage({ message: relay.message });
    }
    if (bot) {
@@ -6,9 +6,5 @@ export default async function heartbeat() {
        sql: `SELECT 1 AS alive`,
    });
    bunext.bunextLog.info(
        `Cron: database heartbeat ${db_alive.success ? "ok" : "failed"}`,
    );
    return db_alive;
 }
@@ -3,8 +3,10 @@ import BunSQLite from "@moduletrace/bun-sqlite";
 import type { BUN_SQLITE_COBBLE_CONTAINERS } from "@/db/types/db";
 import refreshComputerContainer from "@/src/functions/backend/db/computers/refresh-computer-container";
-type Row = Pick<BUN_SQLITE_COBBLE_CONTAINERS, "id" | "docker_id" | "status" | "ip_address"> &
+type Row = Pick<
-    { computer_id: number };
+    BUN_SQLITE_COBBLE_CONTAINERS,
    "id" | "docker_id" | "status" | "ip_address"
 > & { computer_id: number };
 /**
 * Reads every computer container's state from docker and records it
@@ -24,10 +26,11 @@ export default async function syncComputers() {
    let changed = 0;
    for (const { computer_id, ...container } of rows) {
-        const refreshed = await refreshComputerContainer({ computer_id, container });
+        const refreshed = await refreshComputerContainer({
            computer_id,
            container,
        });
        if (refreshed?.changed) changed++;
    }
    bunext.bunextLog.info(`Cron: ${rows.length} computer(s) checked, ${changed} changed`);
 }
@@ -4,6 +4,30 @@
 */
 export const BotJobCancelledError = "Cancelled";
 /**
 * `last_error` of a job the user stopped from the chat. A stopped job is
 * never retried and never told about: the user pulled the plug.
 */
 export const BotJobStoppedError = "Stopped by the user";
 /**
 * The last step recorded on a stopped job. It's a step, not a message, so a
 * bot that was stopped mid-thought doesn't answer on its own.
 */
 export const BotJobStoppedStep = "Stopped";
 /**
 * What the thinking row's stop button says, so the row and its tooltip
 * never drift.
 */
 export const BotStopButtonLabel = "Stop";
 /**
 * What the bot says in the conversation once the user has stopped it. It's
 * the bot's turn again, so the thread stops waiting on a reply.
 */
 export const BotStoppedMessage = "Stopped. I'll carry on when you ask me to.";
 /**
 * `last_error` bun-sqlite sets when it releases a job whose handler went
 * silent past the lock timeout on its last attempt.
@@ -0,0 +1,69 @@
 import { Database } from "bun:sqlite";
 import { describe, expect, test } from "bun:test";
 import openBotJobsSql from "./open-bot-jobs-sql";
 import type { SqlCondition } from "@/src/utils/crew-access/types";
 /**
 * What "stop the bot" pulls the plug on: a bot's open jobs for one user,
 * across every one of their conversations with it. The test runs the
 * condition against real SQLite, since a wrong join would either leave a
 * job running (a stuck bot stays stuck) or stop another user's work.
 */
 const db = new Database(":memory:");
 db.run(`CREATE TABLE bot_sessions (id INTEGER PRIMARY KEY, user_id INTEGER, bot_id INTEGER)`);
 db.run(
    `CREATE TABLE bots_queue (id INTEGER PRIMARY KEY, bot_id INTEGER, session_id INTEGER, status TEXT, kind TEXT, title TEXT)`,
 );
 db.run(`INSERT INTO bot_sessions VALUES (100, 7, 2), (101, 7, 2), (102, 8, 2), (103, 9, 3)`);
 db.run(`INSERT INTO bots_queue VALUES
    (1, 2, 100, 'pending', 'reply', 'Thinking'),
    (2, 2, 101, 'processing', 'task', 'The audit'),
    (3, 2, 102, 'processing', 'task', 'Another user''s job'),
    (4, 2, 100, 'completed', 'reply', 'Thinking'),
    (5, 2, 100, 'failed', 'task', 'An old failure'),
    (6, 3, 103, 'pending', 'reply', 'Thinking'),
    (7, 3, 103, 'processing', 'task', 'A finished bot''s job')`);
 function ids(condition: SqlCondition) {
    return db
        .query(`SELECT q.id FROM bots_queue q WHERE ${condition.sql} ORDER BY q.id`)
        .all(...condition.values)
        .map((row) => (row as { id: number }).id);
 }
 describe("openBotJobsSql", () => {
    test("takes every open job of the bot across the user's conversations, tasks and replies alike", () => {
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 7 }))).toEqual([1, 2]);
    });
    test("never takes another user's job, even on the same bot", () => {
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 7 }))).not.toContain(3);
    });
    test("leaves finished jobs alone, so the work they did still counts", () => {
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 7 }))).not.toContain(4);
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 7 }))).not.toContain(5);
    });
    test("another bot's jobs are never in it", () => {
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 7 }))).not.toContain(6);
        expect(ids(openBotJobsSql({ bot_id: 3, user_id: 9 }))).toEqual([6, 7]);
    });
    test("a user with nothing open stops nothing", () => {
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 8 }))).toEqual([3]);
        expect(ids(openBotJobsSql({ bot_id: 2, user_id: 99 }))).toEqual([]);
    });
    test("reads a join alias when one is given", () => {
        const condition = openBotJobsSql({ bot_id: 2, user_id: 7, alias: "j" });
        expect(
            db
                .query(`SELECT j.id FROM bots_queue j WHERE ${condition.sql} ORDER BY j.id`)
                .all(...condition.values)
                .map((row) => (row as { id: number }).id),
        ).toEqual([1, 2]);
    });
 });
@@ -0,0 +1,29 @@
 import type { SqlCondition } from "@/src/utils/crew-access/types";
 type Params = {
    bot_id: number | string;
    /**
     * Only jobs in this user's conversations, never another user's.
     */
    user_id: number | string;
    /**
     * The `bots_queue` alias the condition reads.
     */
    alias?: string;
 };
 /**
 * The SQL for a bot's jobs for one user that can still run or are running:
 * pending (including one held back with `available_at` until a model comes
 * back) and processing (including one waiting for its computer). A job's
 * session is what makes it the user's, so another user's job is never in
 * it. This is what "stop the bot" pulls the plug on: with none of these
 * left, nothing of the bot's starts again until the user asks.
 */
 export default function openBotJobsSql({ bot_id, user_id, alias = "q" }: Params): SqlCondition {
    return {
        sql: `(${alias}.bot_id = ? AND ${alias}.status IN ('pending', 'processing')
            AND ${alias}.session_id IN (SELECT id FROM bot_sessions WHERE user_id = ?))`,
        values: [Number(bot_id), Number(user_id)],
    };
 }
@@ -0,0 +1,31 @@
 import { Database } from "bun:sqlite";
 import { describe, expect, test } from "bun:test";
 import stopBotJobs from "./stop-bot-jobs";
 /**
 * Stopping the bot from the chat stops every open job of it in the user's
 * conversations and nothing else: another user's work, another bot's work
 * and finished jobs all survive, and the bot's own handler must find out
 * (its lock is gone) so it drops what it was producing.
 *
 * The helper talks to bun-sqlite's process-wide client, so this suite has to
 * drive a real one. It's skipped where the client isn't set up rather than
 * failing the other suites; `open-bot-jobs-sql.test.ts` covers the
 * selection itself against real SQLite unconditionally.
 */
 const sqlite_ready = (() => {
    try {
        new Database(":memory:").run(`SELECT 1`);
        return true;
    } catch {
        return false;
    }
 })();
 describe.skipIf(!sqlite_ready)("stopBotJobs", () => {
    test("a user with nothing open is a no-op", async () => {
        const stopped = await stopBotJobs({ bot_id: 999_999, user_id: 999_999 });
        expect(stopped).toBeNull();
    });
 });
@@ -0,0 +1,130 @@
 import BunSQLite from "@moduletrace/bun-sqlite";
 import type { BUN_SQLITE_COBBLE_BOT_MESSAGES, BUN_SQLITE_COBBLE_BOTS_QUEUE } from "@/db/types/db";
 import { BotJobStoppedError, BotJobStoppedStep } from "@/src/dict/bot-queue-dict";
 import insertBotMessage from "../bots/insert-bot-message";
 import setBotFace, { type BotFaceChange } from "../bots/set-bot-face";
 import { abortRunningJob } from "@/src/bots-queue/job-abort-registry";
 import insertBotJobUpdate from "./insert-bot-job-update";
 import openBotJobsSql from "./open-bot-jobs-sql";
 import stoppedJobReport, { pickReportedJobs } from "./stopped-job-report";
 type Params = {
    bot_id: number | string;
    /**
     * Whose conversations stop. Never another user's jobs.
     */
    user_id: number | string;
 };
 export type StoppedBotJobs = {
    /**
     * The jobs that were open and are now failed as stopped.
     */
    jobs: BUN_SQLITE_COBBLE_BOTS_QUEUE[];
    /**
     * One closing message per session the bot worked in, for the live
     * push. It's what ends the thread's "still thinking" state: the last
     * word is the bot's again.
     */
    messages: BUN_SQLITE_COBBLE_BOT_MESSAGES[];
    /**
     * The user's face change (idle), for the live push.
     */
    bot: BotFaceChange;
 };
 /**
 * Pulls the plug on a bot for one user: every job of it that could still
 * run or is running in their conversations (replies it still owes, tasks
 * it's on, across all of them) is failed as stopped, its task closed. A
 * running handler finds out on its next `updateBotJob` (which returns
 * false) and drops whatever it was producing. Each job gets a closing
 * step, so a thread's working row says why it went quiet even after a
 * reload, one message per session ends it out loud, and the bot goes
 * idle. It's not a bus: nothing restarts by itself, so a stopped bot
 * works again only when the user asks. A schedule the user set up still
 * comes round, since that is work they asked for.
 */
 export default async function stopBotJobs({ bot_id, user_id }: Params): Promise<StoppedBotJobs | null> {
    const condition = openBotJobsSql({ bot_id, user_id });
    const open = (
        await BunSQLite.sql<BUN_SQLITE_COBBLE_BOTS_QUEUE>({
            sql: `SELECT * FROM bots_queue q WHERE ${condition.sql} ORDER BY q.id ASC`,
            values: condition.values,
        })
    ).payload || [];
    if (!open.length) return null;
    const now = Date.now();
    const jobs: BUN_SQLITE_COBBLE_BOTS_QUEUE[] = [];
    for (const job of open) {
        /**
         * One by one, and only while it's still open: a job that finished
         * on its own between the read and here keeps its result.
         */
        const res = await BunSQLite.sql<BUN_SQLITE_COBBLE_BOTS_QUEUE>({
            sql: `UPDATE bots_queue SET status = 'failed', last_error = ?, locked_at = NULL, locked_by = NULL, finished_at = ?, updated_at = ?
                WHERE id = ? AND status IN ('pending', 'processing')
                RETURNING *`,
            values: [BotJobStoppedError, now, now, Number(job.id)],
        });
        const stopped = res.payload?.[0];
        if (!stopped?.id) continue;
        jobs.push(stopped);
        /**
         * If this process is the one running it, stop what it's waiting on
         * now. Anywhere else, the handler finds out on its next heartbeat.
         */
        abortRunningJob({ job_id: Number(stopped.id) });
        if (stopped.task_id) {
            await BunSQLite.sql({
                sql: `UPDATE bot_tasks SET status = 'done', updated_at = ? WHERE id = ?`,
                values: [now, Number(stopped.task_id)],
            });
        }
        /**
         * Recorded as the job's last step, so the working row says why it
         * went quiet.
         */
        try {
            await insertBotJobUpdate({
                job_id: Number(stopped.id),
                bot_id: Number(stopped.bot_id) || Number(bot_id),
                kind: "note",
                text: BotJobStoppedStep,
            });
        } catch {
            /**
             * The step is a courtesy: the job is stopped either way.
             */
        }
    }
    const messages: BUN_SQLITE_COBBLE_BOT_MESSAGES[] = [];
    for (const [session_id, job] of pickReportedJobs({ jobs })) {
        const message = await insertBotMessage({
            bot_id: Number(bot_id),
            session_id,
            workspace_id: job.workspace_id || null,
            text: stoppedJobReport({ job }),
        }).catch(() => null);
        if (message?.id) messages.push(message);
    }
    return {
        jobs,
        messages,
        bot: await setBotFace({ bot_id, user_id, face: "idle" }),
    };
 }
@@ -0,0 +1,79 @@
 import { describe, expect, test } from "bun:test";
 import { BotStoppedMessage } from "@/src/dict/bot-queue-dict";
 import stoppedJobReport, { pickReportedJobs } from "./stopped-job-report";
 describe("stoppedJobReport", () => {
    test("a stopped task names the work that was cut off", () => {
        expect(stoppedJobReport({ job: { session_id: 1, kind: "task", title: "The audit" } })).toBe(
            `${BotStoppedMessage} I was on **The audit**.`,
        );
    });
    test("a stopped reply just says so, since it has no title worth quoting", () => {
        expect(stoppedJobReport({ job: { session_id: 1, kind: "reply", title: "Thinking" } })).toBe(
            BotStoppedMessage,
        );
    });
    test("a task without a title doesn't leave a dangling bold sentence", () => {
        expect(stoppedJobReport({ job: { session_id: 1, kind: "task", title: "   " } })).toBe(
            BotStoppedMessage,
        );
    });
    test("the message is a sentence the user can read, and it says the bot waits for them", () => {
        expect(BotStoppedMessage).toContain("Stopped");
        expect(BotStoppedMessage).toContain("when you ask");
    });
 });
 describe("pickReportedJobs", () => {
    test("one job speaks per session, so a reply and the task it started don't both report", () => {
        const picked = pickReportedJobs({
            jobs: [
                { session_id: 7, kind: "reply", id: 1 },
                { session_id: 7, kind: "task", id: 2 },
            ],
        });
        expect([...picked.keys()]).toEqual([7]);
    });
    test("the task wins, since it's the one that can name the work", () => {
        const picked = pickReportedJobs({
            jobs: [
                { session_id: 7, kind: "reply", id: 1 },
                { session_id: 7, kind: "task", id: 2 },
            ],
        });
        expect(picked.get(7)?.id).toBe(2);
    });
    test("a task first isn't replaced by a later reply", () => {
        const picked = pickReportedJobs({
            jobs: [
                { session_id: 7, kind: "task", id: 2 },
                { session_id: 7, kind: "reply", id: 1 },
            ],
        });
        expect(picked.get(7)?.id).toBe(2);
    });
    test("every session gets its own report", () => {
        const picked = pickReportedJobs({
            jobs: [
                { session_id: 7, kind: "reply", id: 1 },
                { session_id: 8, kind: "task", id: 2 },
                { session_id: 9, kind: "task", id: 3 },
            ],
        });
        expect([...picked.keys()].sort()).toEqual([7, 8, 9]);
    });
    test("nothing open picks nothing", () => {
        expect(pickReportedJobs({ jobs: [] }).size).toBe(0);
    });
 });
@@ -0,0 +1,45 @@
 import { BotStoppedMessage } from "@/src/dict/bot-queue-dict";
 type Job = {
    session_id?: number | string | null;
    kind?: string | null;
    title?: string | null;
 };
 /**
 * What the bot says in a conversation the user stopped it in. A task names
 * the work that was cut off, so a long job that quietly went nowhere reads
 * as stopped rather than as finished; a reply has no title worth quoting.
 */
 export default function stoppedJobReport({ job }: { job: Job }): string {
    const title = (job.title || "").trim();
    return job.kind == "task" && title
        ? `${BotStoppedMessage} I was on **${title}**.`
        : BotStoppedMessage;
 }
 /**
 * The job that speaks for each session: one per session, since a reply and
 * the task it started are the same conversation and two notes there read as
 * a stutter. A task wins, because it's the one that can name the work.
 */
 export function pickReportedJobs<T extends Job>({ jobs }: { jobs: T[] }): Map<number, T> {
    const picked = new Map<number, T>();
    for (const job of jobs) {
        /**
         * A job with no session is stopped all the same; it just has
         * nowhere to report it.
         */
        if (job.session_id === null || job.session_id === undefined) continue;
        const known = picked.get(Number(job.session_id));
        if (!known || (known.kind != "task" && job.kind == "task")) {
            picked.set(Number(job.session_id), job);
        }
    }
    return picked;
 }
@@ -0,0 +1,21 @@
 import React from "react";
 import type { StopBot } from "../(hooks)/use-stop-bot";
 export type StopBotState = StopBot & {
    /**
     * The bot has something open for the signed-in user right now (a reply
     * it owes, a task it's on, a wait for a model or a computer), so
     * stopping it has something to pull the plug on.
     */
    can_stop: boolean;
 };
 /**
 * The conversation's stop control, shared by the thinking row under the
 * thread and the header's menu, so both pull the same plug.
 */
 export const StopBotContext = React.createContext<StopBotState>({
    stop: async () => {},
    stopping: false,
    can_stop: false,
 });
@@ -0,0 +1,19 @@
 import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
 import type { APIResponseObject } from "@moduletrace/bunext/types";
 import type { BotConversationRequest } from "@/src/schemas/bot-schema";
 import type { BotStoppedPayload } from "@/src/types";
 /**
 * Pulls the plug on the bot for the signed-in user: every job of it that's
 * queued or running stops, wherever they chat with it. The messages that
 * end the wait arrive over the WebSocket, so nothing here reloads.
 */
 export default async function stopBot({ bot_id, workspace_id }: BotConversationRequest) {
    return await fetchApi<
        BotConversationRequest,
        APIResponseObject<BotStoppedPayload>
    >(`/api/admin/bots/stop`, {
        method: "POST",
        body: { bot_id, workspace_id },
    });
 }
@@ -0,0 +1,65 @@
 import { useRef, useState } from "react";
 import stopBot from "../(functions)/stop-bot";
 export type StopBot = {
    /**
     * Stops every job of the bot for the signed-in user.
     */
    stop: () => Promise<void>;
    /**
     * A stop is on its way to the server.
     */
    stopping: boolean;
    /**
     * Why the last stop didn't work, for the button's title.
     */
    error?: string;
 };
 type Params = {
    bot_id: number;
    workspace_id?: number | null;
 };
 /**
 * The conversation's stop button: pulls the plug on the bot for the
 * signed-in user, wherever they chat with it. It's quiet on the way out:
 * the bot's closing message and idle face arrive as pushes, so nothing
 * here reloads and a failed stop only surfaces as the button's title.
 */
 export default function useStopBot({ bot_id, workspace_id }: Params): StopBot {
    const [stopping, setStopping] = useState(false);
    const [error, setError] = useState<string>();
    /**
     * A ref, not the state: two clicks in one tick both read the old
     * `stopping` and would send two stops.
     */
    const in_flight = useRef(false);
    const stop = async () => {
        if (in_flight.current) return;
        in_flight.current = true;
        setStopping(true);
        setError(undefined);
        try {
            const res = await stopBot({
                bot_id,
                workspace_id: workspace_id || null,
            }).catch(() => null);
            /**
             * A message without a failure is the count ("Stopped 2 jobs."),
             * so only an unsuccessful answer is an error.
             */
            if (!res?.success) setError(res?.msg || "Couldn't stop the bot.");
        } finally {
            in_flight.current = false;
            setStopping(false);
        }
    };
    return { stop, stopping, error };
 }
@@ -2,15 +2,11 @@ import Row from "@moduletrace/twui/layout/Row";
 import Span from "@moduletrace/twui/layout/Span";
 import Stack from "@moduletrace/twui/layout/Stack";
 import BotAvatar from "@/src/components/general/bot-avatar";
 import type { BotFace } from "@/src/dict/bot-dict";
 import botStoneProps from "@/src/utils/bot-stone-props";
-import {
+import { BotGettingMessageStatusLine } from "@/src/dict/bot-queue-dict";
    BotComputerBusyStatusLine,
    BotGettingMessageStatusLine,
    BotReplyJobTitle,
    BotWaitingStatusLine,
 } from "@/src/dict/bot-queue-dict";
 import type { BotWithLastMessage } from "@/src/types";
 import botBusyState from "../(utils)/bot-busy-state";
 import StopBotButton from "./stop-bot-button";
 type Props = {
    bot: BotWithLastMessage;
@@ -45,7 +41,7 @@ type Props = {
 * reply shows from the thread alone: every user message queues one, so while
 * the user has the last word a reply is due here, even while the bot works
 * elsewhere. Only the waits (for a model, for its computer) come from the
- * face.
+ * face. While it shows, a stop button pulls the plug on the bot's work.
 */
 export default function BotThinkingRow({
    bot,
@@ -56,17 +52,14 @@ export default function BotThinkingRow({
    has_task,
 }: Props) {
    const name = bot.name || "The bot";
-    const asleep = bot.face == "asleep";
+    const { waiting, getting, thinking, working, busy, stoppable } = botBusyState({
-    const waiting_model = asleep && bot.status_line == BotWaitingStatusLine && Boolean(awaiting_reply || has_task);
+        bot,
-    const waiting_computer =
+        awaiting_reply,
-        asleep && bot.status_line == BotComputerBusyStatusLine && Boolean(has_task) && !awaiting_reply;
+        receiving,
-    const waiting = waiting_model || waiting_computer;
+        has_task,
-    const getting = Boolean(receiving) && Boolean(awaiting_reply);
+    });
    const thinking = Boolean(awaiting_reply) && !waiting && !getting;
    const working =
        !awaiting_reply && bot.face == "working" && bot.status_line != BotReplyJobTitle && Boolean(has_task);
-    if (!getting && !thinking && !working && !waiting) return null;
+    if (!busy) return null;
    const label = getting
        ? `${name} is ${BotGettingMessageStatusLine.toLowerCase()}…`
@@ -95,6 +88,7 @@ export default function BotThinkingRow({
                    </Span>
                ) : null}
            </Stack>
            <StopBotButton bot_name={bot.name} disabled={!stoppable} />
        </Row>
    );
 }
@@ -16,6 +16,7 @@ import BotRoutinesModal from "./bot-routines-modal";
 import BotModelsModal from "./bot-models-modal";
 import HeaderMenuItem from "./header-menu-item";
 import NewSessionButton from "./new-session-button";
 import StopBotButton from "./stop-bot-button";
 type Props = {
    bot: BotWithLastMessage;
@@ -48,8 +49,9 @@ type Props = {
 /**
 * The conversation header's menu: the sessions, a new session, the bot's
- * computer, its models and its settings. A row that opens a modal closes
+ * computer, its models, its settings and, while it works, stopping it. A
- * the menu first, so the modal never sits behind an open menu.
+ * row that opens a modal closes the menu first, so the modal never sits
 * behind an open menu.
 */
 export default function ConversationHeaderMenu({
    bot,
@@ -136,6 +138,8 @@ export default function ConversationHeaderMenu({
                    onSaved={on_model_saved}
                />
            </Stack>
            <Divider className="my-1 mx-3 w-auto border-hairline dark:border-hairline" />
            <StopBotButton menu bot_name={bot.name} />
            {can_open_settings ? (
                <>
                    <Divider className="my-1 mx-3 w-auto border-hairline dark:border-hairline" />
@@ -0,0 +1,79 @@
 import { useContext } from "react";
 import Button from "@moduletrace/twui/layout/Button";
 import { CircleStop } from "lucide-react";
 import { BotStopButtonLabel } from "@/src/dict/bot-queue-dict";
 import { StopBotContext } from "../(data)/stop-bot-context";
 import HeaderMenuItem from "./header-menu-item";
 type Props = {
    /**
     * Whose work stops, named in the tooltip so it's clear this pulls the
     * bot's plug everywhere the user chats with it.
     */
    bot_name?: string | null;
    /**
     * Shown as a row in the conversation header's menu instead of a button
     * in the thinking row.
     */
    menu?: boolean;
    /**
     * The caller already knows there's nothing to pull (a row that says the
     * bot is only collecting the message), so the button sits out.
     */
    disabled?: boolean;
 };
 /**
 * Pulls the plug on the bot for the signed-in user: its queued and running
 * work stops wherever they chat with it, so a bot stuck waiting for a model
 * (or anything else) comes back. The thinking row carries it while
 * something is running; the header's menu carries it too, disabled when
 * there's nothing to stop.
 */
 export default function StopBotButton({ bot_name, menu, disabled }: Props) {
    const { stop, stopping, error, can_stop } = useContext(StopBotContext);
    const name = bot_name || "the bot";
    const off = Boolean(disabled) || !can_stop || stopping;
    const title = error
        ? error
        : off && !stopping
          ? `Nothing of ${name}'s is running for you.`
          : `Stop ${name}. Its queued and running work stops, everywhere you chat with it.`;
    if (menu) {
        return (
            <HeaderMenuItem
                icon={CircleStop}
                title={BotStopButtonLabel}
                description={title}
                hint={stopping ? "Stopping" : undefined}
                loading={stopping}
                disabled={off}
                onClick={() => {
                    void stop();
                }}
            />
        );
    }
    return (
        <Button
            title={title}
            aria-label={title}
            type="button"
            variant="ghost"
            color="text"
            size="smaller"
            disabled={off}
            loading={stopping}
            loadingIconSize="small"
            beforeIcon={<CircleStop size={14} aria-hidden />}
            onClick={() => {
                void stop();
            }}
            className="shrink-0 text-ink-secondary dark:text-ink-secondary hover:text-ink hover:dark:text-ink hover:bg-sunken hover:dark:bg-sunken rounded-default transition-colors duration-[var(--m-fast)] focus-visible:ring-2 focus-visible:ring-ink"
        >
            {BotStopButtonLabel}
        </Button>
    );
 }
@@ -15,9 +15,15 @@ import { CrewBotsContext } from "../(data)/crew-bots-context";
 import { CrewWorkspacesContext } from "../(data)/crew-workspaces-context";
 import { BotMessageActionsContext } from "../(data)/message-actions-context";
 import { SpeakMessageContext } from "../(data)/speak-message-context";
 import {
    StopBotContext,
    type StopBotState,
 } from "../(data)/stop-bot-context";
 import reactToBotMessage from "../(functions)/react-to-bot-message";
 import botBusyState from "../(utils)/bot-busy-state";
 import dropSentMessage from "../(utils)/drop-sent-message";
 import useBotComputers from "../(hooks)/use-bot-computers";
 import useStopBot from "../(hooks)/use-stop-bot";
 import useTaskProgress from "../(hooks)/use-task-progress";
 import useReplyProgress from "../(hooks)/use-reply-progress";
 import useReplyCatchUp from "../(hooks)/use-reply-catch-up";
@@ -90,6 +96,10 @@ export default function Conversation() {
        workspace_id,
        computers: pageProps?.bot_computers || [],
    });
    const stop_bot = useStopBot({
        bot_id: bot?.id || 0,
        workspace_id,
    });
    const speak = useSpeakMessage({
        enabled: Boolean(pageProps?.bot_voice?.speech),
@@ -233,7 +243,26 @@ export default function Conversation() {
    if (!bot?.id || !live_bot) return null;
-    return (
+    /**
     * What the stop control pulls the plug on, read the way the thinking
     * row reads it: the same conditions, so the header's row is enabled
     * exactly while the thread shows the bot at work.
     */
    const stop_state: StopBotState = {
        ...stop_bot,
        can_stop: botBusyState({
            bot: live_bot,
            awaiting_reply,
            receiving: pending_messages.length > 0,
            has_task: Boolean(progress.task_id),
        }).stoppable,
    };
    /**
     * The thread, kept intact so the stop control can wrap it without
     * reindenting every provider.
     */
    const thread = (
        <CrewBotsContext.Provider value={bots}>
            <CrewWorkspacesContext.Provider value={workspaces}>
                <BotComputersContext.Provider value={bot_computers}>
@@ -316,4 +345,10 @@ export default function Conversation() {
            </CrewWorkspacesContext.Provider>
        </CrewBotsContext.Provider>
    );
    return (
        <StopBotContext.Provider value={stop_state}>
            {thread}
        </StopBotContext.Provider>
    );
 }
@@ -0,0 +1,193 @@
 import { describe, expect, test } from "bun:test";
 import {
    BotComputerBusyStatusLine,
    BotGettingMessageStatusLine,
    BotReplyJobTitle,
    BotWaitingStatusLine,
 } from "@/src/dict/bot-queue-dict";
 import type { BotWithLastMessage } from "@/src/types";
 import botBusyState from "./bot-busy-state";
 function bot(overrides: Partial<BotWithLastMessage>): BotWithLastMessage {
    return { id: 1, name: "Ember", ...overrides } as BotWithLastMessage;
 }
 describe("botBusyState", () => {
    test("a reply owed here is thinking", () => {
        const state = botBusyState({ bot: bot({ face: "idle" }), awaiting_reply: true });
        expect(state.thinking).toBe(true);
        expect(state.busy).toBe(true);
    });
    test("a message still on its way is getting, not thinking", () => {
        const state = botBusyState({
            bot: bot({ face: "working" }),
            awaiting_reply: true,
            receiving: true,
        });
        expect(state.getting).toBe(true);
        expect(state.thinking).toBe(false);
    });
    test("a task running while the bot has the last word is working", () => {
        const state = botBusyState({
            bot: bot({ face: "working", status_line: "Working" }),
            awaiting_reply: false,
            has_task: true,
        });
        expect(state.working).toBe(true);
        expect(state.busy).toBe(true);
    });
    test("a reply's own turn never shows as working on a task", () => {
        const state = botBusyState({
            bot: bot({ face: "working", status_line: BotReplyJobTitle }),
            has_task: true,
        });
        expect(state.working).toBe(false);
        expect(state.busy).toBe(false);
    });
    test("waiting for a model is a wait, with a reply owed here", () => {
        const state = botBusyState({
            bot: bot({ face: "asleep", status_line: BotWaitingStatusLine }),
            awaiting_reply: true,
        });
        expect(state.waiting).toBe(true);
        expect(state.thinking).toBe(false);
        expect(state.busy).toBe(true);
    });
    test("waiting for a model is a wait, with a task running", () => {
        const state = botBusyState({
            bot: bot({ face: "asleep", status_line: BotWaitingStatusLine }),
            has_task: true,
        });
        expect(state.waiting).toBe(true);
        expect(state.busy).toBe(true);
    });
    test("waiting for its computer is a wait only while a task runs", () => {
        const waiting = botBusyState({
            bot: bot({ face: "asleep", status_line: BotComputerBusyStatusLine }),
            has_task: true,
        });
        const idle = botBusyState({
            bot: bot({ face: "asleep", status_line: BotComputerBusyStatusLine }),
        });
        expect(waiting.waiting).toBe(true);
        expect(idle.busy).toBe(false);
    });
    test("a message still on its way wins over the wait, so the row says what the user just did", () => {
        const state = botBusyState({
            bot: bot({ face: "asleep", status_line: BotWaitingStatusLine }),
            awaiting_reply: true,
            receiving: true,
        });
        expect(state.getting).toBe(true);
        expect(state.waiting).toBe(true);
    });
    test("an idle bot with nothing owed and no task shows nothing", () => {
        const state = botBusyState({ bot: bot({ face: "idle" }) });
        expect(state.busy).toBe(false);
    });
    test("a done face with no task shows nothing", () => {
        expect(botBusyState({ bot: bot({ face: "done" }) }).busy).toBe(false);
    });
 });
 describe("botBusyState stoppable", () => {
    test("busy in this thread is stoppable", () => {
        expect(
            botBusyState({
                bot: bot({ face: "idle" }),
                awaiting_reply: true,
            }).stoppable,
        ).toBe(true);
    });
    test("working somewhere else is stoppable too, since the face is per user", () => {
        const state = botBusyState({ bot: bot({ face: "working" }) });
        expect(state.busy).toBe(false);
        expect(state.stoppable).toBe(true);
    });
    test("asleep on a wait line is stoppable, even when this thread shows nothing", () => {
        for (const status_line of [BotWaitingStatusLine, BotComputerBusyStatusLine]) {
            expect(botBusyState({ bot: bot({ face: "asleep", status_line }) }).stoppable).toBe(true);
        }
    });
    test("a bot simply resting is not stoppable", () => {
        const state = botBusyState({
            bot: bot({ face: "asleep", status_line: "Until tomorrow" }),
        });
        expect(state.busy).toBe(false);
        expect(state.stoppable).toBe(false);
    });
    test("a message only being collected is not stoppable: its reply is queued after it", () => {
        const state = botBusyState({
            bot: bot({ face: "idle" }),
            awaiting_reply: true,
            receiving: true,
        });
        expect(state.getting).toBe(true);
        expect(state.stoppable).toBe(false);
    });
    test("done, needs-you and idle mean nothing is running", () => {
        for (const face of ["done", "needs-you", "idle"] as const) {
            const state = botBusyState({ bot: bot({ face }) });
            expect(state.stoppable).toBe(false);
        }
    });
    test("a silently stopped bot is not stoppable", () => {
        const state = botBusyState({
            bot: bot({ face: "idle" }),
            awaiting_reply: false,
            has_task: false,
        });
        expect(state.stoppable).toBe(false);
    });
    test("a reply job's own turn with no task owed is not stoppable", () => {
        /**
         * The face says working while a reply runs somewhere else, which is
         * real work: it's stoppable even though this thread owes nothing.
         */
        const state = botBusyState({
            bot: bot({ face: "working", status_line: BotReplyJobTitle }),
        });
        expect(state.stoppable).toBe(true);
    });
    test("the getting line still labels the row", () => {
        const state = botBusyState({
            bot: bot({ face: "idle", status_line: BotGettingMessageStatusLine }),
            awaiting_reply: true,
            receiving: true,
        });
        expect(state.getting).toBe(true);
    });
 });
@@ -0,0 +1,111 @@
 import type { BotWithLastMessage } from "@/src/types";
 import {
    BotComputerBusyStatusLine,
    BotReplyJobTitle,
    BotWaitingStatusLine,
 } from "@/src/dict/bot-queue-dict";
 type Params = {
    bot: BotWithLastMessage;
    /**
     * The last message in the open thread is the user's, so a reply is due
     * here.
     */
    awaiting_reply?: boolean;
    /**
     * A message is still on its way to the server.
     */
    receiving?: boolean;
    /**
     * A task of the bot's is running.
     */
    has_task?: boolean;
 };
 export type BotBusyState = {
    /**
     * Waiting for a model to come back, or for the bot's computer.
     */
    waiting: boolean;
    /**
     * The user's message hasn't reached the server yet.
     */
    getting: boolean;
    /**
     * A reply is due in this thread.
     */
    thinking: boolean;
    /**
     * A task is running and the bot has the last word.
     */
    working: boolean;
    /**
     * Anything of the above, so the row has something to say.
     */
    busy: boolean;
    /**
     * There's work of the bot's to pull the plug on. A message still on
     * its way doesn't count: its reply is queued after it lands, so a stop
     * now would cancel nothing and be overtaken a moment later. The face
     * covers work in the user's other conversations too, since it's one
     * per user; `asleep` only counts on the two status lines the queue
     * sets while it waits, never a bot that's simply resting.
     */
    stoppable: boolean;
 };
 /**
 * What a bot is doing in a conversation, read from the thread and its face.
 * The thread decides the reply states: every user message queues one, so
 * while the user has the last word a reply is due here, even while the bot
 * works elsewhere. Only the waits (for a model, for its computer) come from
 * the face. The thinking row reads it for its line, and the conversation
 * reads it for the stop control.
 */
 export default function botBusyState({
    bot,
    awaiting_reply,
    receiving,
    has_task,
 }: Params): BotBusyState {
    const asleep = bot.face == "asleep";
    const waiting_model =
        asleep && bot.status_line == BotWaitingStatusLine && Boolean(awaiting_reply || has_task);
    const waiting_computer =
        asleep &&
        bot.status_line == BotComputerBusyStatusLine &&
        Boolean(has_task) &&
        !awaiting_reply;
    const waiting = waiting_model || waiting_computer;
    const getting = Boolean(receiving) && Boolean(awaiting_reply);
    const thinking = Boolean(awaiting_reply) && !waiting && !getting;
    const working =
        !awaiting_reply &&
        bot.face == "working" &&
        bot.status_line != BotReplyJobTitle &&
        Boolean(has_task);
    /**
     * Work runs here (a reply owed, a task of this thread's) or somewhere
     * else of this user's (the face says `working`, or `asleep` on a wait
     * line).
     */
    const stoppable =
        waiting ||
        thinking ||
        working ||
        bot.face == "working" ||
        (asleep &&
            (bot.status_line == BotWaitingStatusLine ||
                bot.status_line == BotComputerBusyStatusLine));
    return {
        waiting,
        getting,
        thinking,
        working,
        busy: getting || thinking || working || waiting,
        stoppable,
    };
 }
@@ -1,5 +1,6 @@
 import Span from "@moduletrace/twui/layout/Span";
 import type { RunningVersion } from "@/src/utils/running-version";
 import versionLabel from "../(utils)/version-label";
 type Props = {
    running?: RunningVersion | null;
@@ -7,21 +8,14 @@ type Props = {
 /**
 * The release this server runs, in words: settings are where someone
- * checks whether an update landed. A development server says so beside
+ * checks whether an update landed. The stage and, on a development server,
- * its version, so the two are never mistaken.
+ * that it is one ride along, so neither what it runs nor what it is can be
 * mistaken.
 */
 export default function VersionLine({ running }: Props) {
-    if (!running) return null;
+    const label = versionLabel({ running });
-    const version = running.version
+    if (!label) return null;
        ? `Cobble ${running.version}`
        : "Cobble";
-    return (
+    return <Span className="text-sm leading-5 text-ink">{label}</Span>;
        <Span className="text-sm leading-5 text-ink">
            {running.mode == "development"
                ? `${version} (development)`
                : version}
        </Span>
    );
 }
@@ -0,0 +1,30 @@
 import { describe, expect, test } from "bun:test";
 import versionLabel from "./version-label";
 describe("versionLabel", () => {
    test("a release names its version and that it is alpha", () => {
        expect(
            versionLabel({
                running: { version: "v0.1.5", mode: "production" },
            }),
        ).toBe("Cobble v0.1.5 (alpha)");
    });
    test("a development server says so beside the stage", () => {
        expect(
            versionLabel({
                running: { version: "0.1.5", mode: "development" },
            }),
        ).toBe("Cobble 0.1.5 (development, alpha)");
    });
    test("a server with no usable version still names the stage", () => {
        expect(
            versionLabel({ running: { version: null, mode: "production" } }),
        ).toBe("Cobble (alpha)");
    });
    test("no running version says nothing at all", () => {
        expect(versionLabel({ running: null })).toBeNull();
    });
 });
@@ -0,0 +1,27 @@
 import type { RunningVersion } from "@/src/utils/running-version";
 /**
 * The stage every release is published as. Cobble is still alpha: the
 * schema, the settings and the screens change between releases, so the app
 * says so wherever it names its version, not only in the README.
 */
 export const ReleaseStage = "alpha";
 type Params = {
    running?: RunningVersion | null;
 };
 /**
 * The running release in words, for the General settings page: "Cobble
 * v0.1.5 (alpha)", and a development server adds that it is one, so a dev
 * build is never mistaken for a release.
 */
 export default function versionLabel({ running }: Params): string | null {
    if (!running) return null;
    const parts = [running.mode == "development" ? "development" : "", ReleaseStage].filter(
        (part) => part.length > 0,
    );
    return `${running.version ? `Cobble ${running.version}` : "Cobble"} (${parts.join(", ")})`;
 }
@@ -0,0 +1,99 @@
 import userAuth from "@/src/functions/backend/auth/user-auth";
 import grabUserConversation from "@/src/functions/backend/db/bot-sessions/grab-user-conversation";
 import countOpenBotJobs from "@/src/functions/backend/db/bots-queue/count-open-bot-jobs";
 import stopBotJobs from "@/src/functions/backend/db/bots-queue/stop-bot-jobs";
 import pushBotNotice from "@/src/bots-queue/push-bot-notice";
 import { BotConversationRequestSchema } from "@/src/schemas/bot-schema";
 import type { BotStoppedPayload } from "@/src/types";
 import AppError from "@/src/utils/app-error";
 import parseWithSchema from "@/src/utils/parse-with-schema";
 import isReadOnlyUser from "@/src/utils/rbac/is-read-only-user";
 import safeErrorMessage from "@/src/utils/safe-error-message";
 import type {
    APIResponseObject,
    BunextAPIRouteHandler,
 } from "@moduletrace/bunext/types";
 /**
 * Pulls the plug on a bot for the session user: every job of it that's
 * queued or running in their conversations with it stops, its tasks close
 * and it goes idle, so a bot stuck waiting for a model (or anything else)
 * comes back at once. Stopping from a workspace stops the bot there and in
 * its own chat: the user asked for the bot to stop, not one tab of it.
 * A bot with nothing open is a no-op. The messages that end the wait go
 * out live, to this tab and the user's others.
 */
 export const handler: BunextAPIRouteHandler<APIResponseObject<BotStoppedPayload>> = async ({
    req,
    body,
 }) => {
    try {
        if (req.method != "POST") {
            throw new AppError(`Method not allowed`);
        }
        const { user, user_types } = await userAuth({ req });
        if (!user?.logged_in_status || !user.id) {
            return { success: false, msg: `Unauthorized`, logoutUser: true };
        }
        if (isReadOnlyUser({ user_types: user_types || [] })) {
            throw new AppError(`This user can only read records.`);
        }
        const { bot_id, workspace_id } = parseWithSchema({
            schema: BotConversationRequestSchema,
            data: body,
        });
        /**
         * Checked against the conversation it was asked from, so the stop
         * button works exactly where the conversation opens.
         */
        const conversation = await grabUserConversation({
            user_id: user.id,
            bot_id,
            workspace_id,
        });
        const stopped = await stopBotJobs({
            bot_id: conversation.bot.id,
            user_id: user.id,
        });
        if (stopped) {
            /**
             * Live only: the user just pressed the button in the app, so
             * their devices don't need a notification per conversation.
             */
            for (const message of stopped.messages) {
                await pushBotNotice({
                    bot_id: conversation.bot.id,
                    message,
                    quiet_push: true,
                });
            }
            await pushBotNotice({ bot_id: conversation.bot.id, bot: stopped.bot });
        }
        return {
            success: true,
            singleRes: {
                bot_id: conversation.bot.id,
                stopped: stopped?.jobs.length || 0,
                remaining:
                    (await countOpenBotJobs({
                        bot_id: conversation.bot.id,
                        user_id: user.id,
                    })) || 0,
            },
            msg: stopped
                ? `Stopped ${stopped.jobs.length} ${stopped.jobs.length == 1 ? "job" : "jobs"}.`
                : `Nothing is running.`,
        };
    } catch (error: unknown) {
        return { success: false, msg: safeErrorMessage({ error }) };
    }
 };
@@ -209,6 +209,17 @@ export type BotTaskWithSteps = BUN_SQLITE_COBBLE_BOT_TASKS & {
    updates: BUN_SQLITE_COBBLE_BOTS_QUEUE_UPDATES[];
 };
 /**
 * What stopping a bot reports back: how many of its jobs were stopped and
 * how many of them are still open (an attempt that has to notice its
 * lock is gone can take a heartbeat).
 */
 export type BotStoppedPayload = {
    bot_id: number;
    stopped: number;
    remaining: number;
 };
 /**
 * `server:bot-job-update` data: a step a running job just took, with the
 * task it's for (null for a reply).