@gitterm/discord-bot 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,262 @@
-# Temporary Holding Version
+# @gitterm/discord-bot
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Discord bot that puts a coding agent on your repository. Mention it in a channel and it opens a
+thread, an OpenCode agent works on the request in a [GitTerm](https://gitterm.dev) sandbox, asks
+back with buttons when it needs a decision, and replies in the thread.
+
+You run one small process anywhere (your laptop, a VPS, Railway, a container). It connects to
+Discord's gateway, so it needs no public URL.
+
+## Set up in five minutes
+
+1. **Create the bot under Bots in the GitTerm dashboard** and choose Discord. Pick a model, the
+   repository, GitHub access, and optionally tools, where it answers, and who can use it. GitTerm
+   saves these settings (never your tokens) and gives you the bot's API token, shown once, in a
+   ready `.env` that holds only secrets. Change its settings on the bot's page any time; the bot
+   loads them each time it starts.
+
+2. **Create the Discord bot.** In the
+   [Discord developer portal](https://discord.com/developers/applications), create an
+   application, open **Bot**, copy the token into `DISCORD_BOT_TOKEN`, and turn on **Message
+   Content Intent** (the bot reads thread messages for context and typed answers).
+
+3. **Start it** next to the `.env`, from the terminal or from your own code:
+
+   ```sh
+   npx @gitterm/discord-bot
+   ```
+
+   ```ts
+   import { createDiscordBot } from "@gitterm/discord-bot";
+
+   await createDiscordBot({
+     repo: "https://github.com/acme/app",
+     model: "anthropic/claude-sonnet-5-5",
+   }).start(); // tokens from the environment, or token / gitterm: { token }
+   ```
+
+   The bot checks everything before it connects (token, model credential, GitHub access, tools,
+   compute) and prints what to fix if something is missing.
+
+4. **Invite it.** Open the invite link the bot prints on startup and pick your server. It asks
+   only for what it uses: view channels, send messages, create and post in threads, read history,
+   add reactions, and embed links.
+
+5. **Mention it** in a channel: `@Acme Agent why does the login page flash on load?`
+
+## How it works
+
+- **One sandbox per repository.** The first message creates a GitTerm workspace for the
+  repository. It pauses when idle and wakes up with the next message, so the checkout, installed
+  dependencies, and branches stay where the agent left them, and you pay only while it works.
+- **One session per thread.** A mention in a channel opens a thread for the conversation; mention
+  the bot (or reply to it) in the thread to continue with full context. Anyone in the thread can
+  follow up, and messages posted between mentions are passed along as context. Threads work in
+  parallel; messages within one thread wait their turn. Mentioning the bot inside a thread you
+  started yourself works the same way, with the thread so far as context.
+- **Pick a repository per thread.** With `repos`, people name one in a thread's first message
+  (`@Acme Agent in acme/api, why is login slow?`); a channel without a repository asks which one.
+  The thread stays on that repository.
+- **Credited pull requests.** The agent opens pull requests that start with "Requested by <name> in Discord", without linking the conversation (the repository may be public). The request gets 👀 when picked up, then ✅ or ❌.
+- **It asks back.** Agent questions appear as a card with a button per option (a menu for
+  multiple choice or long lists, a dialog for a written answer). Tool approvals show _Allow
+  once_, _Always allow_, and _Deny_. The person who asked can also reply in the thread with an
+  option number, `yes`, or `no`.
+- **Images reach the agent.** PNG, JPEG, GIF, and WebP files up to 5 MB, posted with the mention
+  or earlier in the thread, are attached to the run. Other files are only named.
+- **Restarts are safe.** Runs live in GitTerm, not in the bot. A restarted bot reattaches to
+  running work and posts the result. The state file only holds thread → run ids, so losing it
+  costs thread continuity, never sandboxes (they are found by their tags).
+- **Open the sandbox yourself.** Each repository's sandbox is the GitTerm workspace named
+  `discord-bot-<repository>`. Its dashboard page has the server URL and password, so you can
+  attach the OpenCode TUI or desktop app and see every thread's session. Prompts you send there
+  are not posted back to Discord.
+
+### Commands
+
+Mention the bot with one word:
+
+| Command  | What it does                                                               |
+| -------- | -------------------------------------------------------------------------- |
+| `stop`   | Cancel the work in this thread.                                            |
+| `status` | Show the repository, sandbox state, model, tools, and who may use the bot. |
+| `reset`  | Terminate the sandbox; the next message creates a fresh one.               |
+| `help`   | Explain how to use the bot.                                                |
+
+Use `reset` after changing the bot's instructions, connections, or workspace settings: they apply
+when a sandbox is created.
+
+## Configuration
+
+Settings saved for the bot under Bots in the dashboard load when it starts, found by its API
+token. Every setting below overrides them, from code or from the terminal: in code, pass it to
+`createDiscordBot(await withSavedConfig({ ... }))`; on the command line, set the environment
+variable (a `.env` file in the working directory is loaded) or the flag. Without saved settings,
+these are the whole configuration.
+
+| Option                            | Environment variable / flag                                                                 | Meaning                                                                                                                                                     |
+| --------------------------------- | ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `token`                           | `DISCORD_BOT_TOKEN`                                                                         | Bot token.                                                                                                                                                  |
+| `client`                          | —                                                                                           | A discord.js client you already run; see [below](#add-it-to-a-bot-you-already-run).                                                                         |
+| `gitterm`                         | `GITTERM_API_TOKEN`, `GITTERM_SERVER_URL`                                                   | `{ token, serverUrl }` or a client. Falls back to the `gitterm login` config.                                                                               |
+| `repo`                            | `GITTERM_BOT_REPO`, `--repo`                                                                | Repository for every channel; `url#branch` picks a branch.                                                                                                  |
+| `channels`                        | `GITTERM_BOT_CHANNELS` (`1234=https://github.com/acme/api,…`)                               | Per-channel repositories by channel id. Without `repo`, the bot answers only in these channels.                                                             |
+| `repos`                           | `GITTERM_BOT_REPOS`                                                                         | More repositories people can name in a thread's first message (`in acme/api`).                                                                              |
+| `connections`                     | `GITTERM_BOT_CONNECTIONS` (`Linear,Sentry`)                                                 | Tools besides GitHub, by name as shown under Integrations, integration key (`executor`), or id. GitHub access for the repository is attached automatically. |
+| `model`                           | `GITTERM_BOT_MODEL`, `--model`, `GITTERM_BOT_MODEL_CREDENTIAL`, `GITTERM_BOT_MODEL_API_KEY` | `provider/model` for every run; only that provider's credential reaches the sandbox. See [Models](#models).                                                 |
+| `instructions`                    | `GITTERM_BOT_INSTRUCTIONS`, `GITTERM_BOT_INSTRUCTIONS_FILE`, `--instructions-file`          | What the agent should know and how it should behave; see [Instructions](#instructions).                                                                     |
+| `env`                             | `GITTERM_BOT_SANDBOX_ENV_FILE` (a dotenv file)                                              | Environment variables for new sandboxes, e.g. test credentials.                                                                                             |
+| `setup`                           | `GITTERM_BOT_SETUP`                                                                         | Commands run in the checkout before the agent starts, e.g. `pnpm install`.                                                                                  |
+| `allowedUsers`                    | `GITTERM_BOT_ALLOWED_USERS`                                                                 | Only these user ids may use the bot. Default: everyone in the channel.                                                                                      |
+| `workspace`                       | `GITTERM_BOT_PROVIDER` (provider only)                                                      | Any `workspaces.create()` setting for new sandboxes: provider, image, setup, OpenCode config.                                                               |
+| `workspace.repositoryCredentials` | `GITTERM_BOT_GITHUB_TOKEN`                                                                  | Your own GitHub token instead of a GitTerm GitHub connection.                                                                                               |
+| `stateFile`                       | `GITTERM_BOT_STATE_FILE`                                                                    | Where thread sessions are kept. Default `.gitterm-bot/discord.json`.                                                                                        |
+| `runTimeoutMs`                    | `GITTERM_BOT_RUN_TIMEOUT_MINUTES`                                                           | Give up on a request after this long, including time waiting for answers. Default 60 min.                                                                   |
+| `inputTimeoutMs`                  | —                                                                                           | How long a question or approval waits for an answer. Default 30 min.                                                                                        |
+| `logger`                          | —                                                                                           | Where the bot logs. Default `console`.                                                                                                                      |
+
+Copy channel ids with Developer Mode on. GitHub access is automatic: GitTerm attaches the GitHub
+connection that covers the repository's owner, or the deployment's shared one. Tools are attached
+only when you name them, because the bot acts with your accounts on behalf of everyone in the
+channel. `workspace` takes any [`@gitterm/sdk`](https://www.npmjs.com/package/@gitterm/sdk)
+`workspaces.create()` option except the repository, name, agent, connections, and tags, which the
+bot owns.
+
+### Instructions
+
+Tell the agent about your team and how to behave. The text is added after the bot's own rules and
+loaded into every session:
+
+```ts
+import { readFile } from "node:fs/promises";
+
+createDiscordBot({
+  repo: "https://github.com/acme/app",
+  instructions: await readFile("bot-instructions.md", "utf8"),
+});
+```
+
+```sh
+npx @gitterm/discord-bot --repo https://github.com/acme/app --instructions-file bot-instructions.md
+```
+
+Instructions are written into a sandbox when it is created; after changing them, mention the bot
+with `reset`. Project knowledge that belongs with the code (how to run tests, where things live)
+is better in an `AGENTS.md` in the repository, which OpenCode reads on its own.
+
+### Models
+
+Pick the model and the bot hands the sandbox that one provider's credential, nothing else. A
+sandbox anyone in the channel can drive should not hold every model account on your dashboard.
+
+```ts
+model: "anthropic/claude-sonnet-5-5"                                    // the provider's default saved credential
+model: { id: "anthropic/claude-sonnet-5-5", credential: "team" }        // a saved credential by label
+model: { id: "anthropic/claude-sonnet-5-5", apiKey: process.env.KEY }   // a key for this bot only, never saved
+```
+
+On the command line: `GITTERM_BOT_MODEL`, plus `GITTERM_BOT_MODEL_CREDENTIAL` or
+`GITTERM_BOT_MODEL_API_KEY`. Models that need no key (such as OpenCode's free models) get no
+credential. Without a model, the sandbox gets every saved dashboard credential and the dashboard's
+default model. Credentials are set when a sandbox is created; after switching to another
+provider, mention the bot with `reset`.
+
+## Running from code
+
+`createDiscordBot()` returns `{ start(), stop() }`. `start()` resolves once the bot is connected;
+`stop()` disconnects it. Runs keep going in GitTerm while the bot is down, and the next
+`start()` picks them up.
+
+```ts
+import { createDiscordBot } from "@gitterm/discord-bot";
+
+const bot = createDiscordBot({
+  repo: "https://github.com/acme/app#main",
+  channels: { "1234567890": "https://github.com/acme/api" },
+  instructions: "Run `pnpm test` before opening a pull request.",
+  workspace: {
+    provider: { type: "railway" },
+    setup: { beforeAgent: ["pnpm install"] },
+  },
+  logger: myLogger, // anything with info, warn, and error
+});
+
+await bot.start();
+process.once("SIGTERM", () => void bot.stop());
+```
+
+### Add it to a bot you already run
+
+Pass your discord.js client and the agent answers its mentions alongside your own handlers. The
+client needs the `Guilds`, `GuildMessages`, and `MessageContent` intents (the bot tells you which
+are missing). You log it in and destroy it yourself; `start()` resolves once it is ready, so log
+in without waiting on it. Make sure none of your own handlers also answer mentions of the bot.
+
+```ts
+import { Client, GatewayIntentBits } from "discord.js";
+import { createDiscordBot } from "@gitterm/discord-bot";
+
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+  ],
+});
+client.on("interactionCreate", handleMySlashCommands);
+
+const agent = createDiscordBot({ client, repo: "https://github.com/acme/app" });
+await Promise.all([agent.start(), client.login(process.env.DISCORD_BOT_TOKEN)]);
+```
+
+### Slack and Discord in one process
+
+```ts
+import { createDiscordBot } from "@gitterm/discord-bot";
+import { createSlackBot } from "@gitterm/slack-bot";
+
+const settings = {
+  repo: "https://github.com/acme/app",
+  gitterm: { token: process.env.GITTERM_API_TOKEN },
+};
+await Promise.all([createSlackBot(settings).start(), createDiscordBot(settings).start()]);
+```
+
+Each platform gets its own sandbox and its own state file.
+
+## Hosting
+
+The image runs either bot and picks the platform from the token in the `.env`. In the folder
+with the `.env`:
+
+```sh
+docker run -d --name gitterm-discord-bot --restart unless-stopped \
+  -v "$PWD/.env:/data/.env:ro" -v gitterm-discord-bot:/data \
+  ghcr.io/opeoginni/gitterm-bot
+```
+
+The `.env` is mounted rather than passed with `--env-file`, which doesn't read dotenv quoting.
+Thread sessions are kept in the `/data` volume. Without Docker, any machine with Node 22.12+
+works: run `npx @gitterm/discord-bot` and keep `.gitterm-bot/` on persistent storage.
+
+Run one bot process per Discord application. Two processes with the same token would both answer.
+
+## Security
+
+- **Who can use it:** anyone who can post in a channel the bot can see, unless you list
+  `allowedUsers`. Only those people can then make requests and approve the agent's tool requests.
+  Use channel permissions for the rest.
+- **What the agent can reach:** whatever the attached GitTerm connections allow. Scope the GitHub
+  connection and MCP credentials accordingly, and use OpenCode `permission` rules (via
+  `workspace.opencode.config`) to deny commands outright.
+- **What the bot stores:** GitTerm workspace and run ids, written with mode `0600`. No tokens.
+- Agent replies never ping anyone, and only images are forwarded to the agent.
+
+## Limits
+
+- The agent is OpenCode. T3 Code workspaces have no run API for bots to drive.
+- A question left unanswered past the workspace's idle timeout lets the sandbox pause, which
+  cancels the run.
+- Direct messages are not supported; talk to the bot in server channels.
+
+See [`@gitterm/bot`](https://www.npmjs.com/package/@gitterm/bot) to put the same agent behind another chat platform.

package/dist/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { ChatAdapter } from "@gitterm/bot";
+import { Client } from "discord.js";
+export type DiscordAdapterOptions = {
+    /** Bot token from the Discord developer portal. Defaults to `DISCORD_BOT_TOKEN`. */
+    token?: string;
+    /**
+     * A discord.js client you already run, to add the agent to an existing bot. It needs the
+     * Guilds, GuildMessages, and MessageContent intents. You log it in and destroy it yourself;
+     * `start()` resolves once it is ready. Make sure your own handlers do not also answer the same
+     * mentions.
+     */
+    client?: Client;
+};
+/**
+ * Discord over the gateway: no public URL needed. Mention the bot in a channel and it opens a
+ * thread for the conversation; every thread is one agent session.
+ */
+export declare function createDiscordAdapter(options?: DiscordAdapterOptions): ChatAdapter;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { BOT_ENV_HELP, cliOptions, hasRepository } from "@gitterm/bot";
+
+// src/index.ts
+import { createBot, withSavedConfig as loadSaved } from "@gitterm/bot";
+
+// src/adapter.ts
+import { once } from "node:events";
+import { downloadImage } from "@gitterm/bot";
+import {
+  Client,
+  Events,
+  GatewayIntentBits,
+  IntentsBitField,
+  MessageFlags,
+  PermissionsBitField,
+  ThreadAutoArchiveDuration
+} from "discord.js";
+
+// src/components.ts
+import { splitMessage, tablesToCode } from "@gitterm/bot";
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  EmbedBuilder,
+  ModalBuilder,
+  StringSelectMenuBuilder,
+  TextInputBuilder,
+  TextInputStyle
+} from "discord.js";
+var MESSAGE_LIMIT = 1900;
+var BUTTONS_PER_ROW = 5;
+var BUTTON_OPTION_LIMIT = 20;
+var SELECT_LIMIT = 25;
+var OPEN_COLOR = 15246141;
+var SETTLED_COLOR = 12107719;
+var truncate = (value, limit) => value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+var customId = (promptId, control, value) => ["gt", promptId, control, ...value === undefined ? [] : [String(value)]].join(":");
+function parseCustomId(id) {
+  const [prefix, promptId, control, value] = id.split(":");
+  return prefix === "gt" && promptId && control ? { promptId, control, value } : null;
+}
+function answerContents(markdown, footer) {
+  const chunks = splitMessage(tablesToCode(markdown), MESSAGE_LIMIT);
+  const last = chunks.length - 1;
+  return chunks.map((chunk, index) => index === last ? `${chunk}
+-# ${footer}` : chunk);
+}
+function embed(prompt, color) {
+  if (prompt.kind === "permission") {
+    const patterns = prompt.request.patterns.filter(Boolean).join(`
+`);
+    return new EmbedBuilder().setColor(color).setTitle("Approval needed").setDescription(truncate(`The agent wants to run **${prompt.request.title}**${patterns ? `
+\`\`\`
+${patterns}
+\`\`\`` : ""}`, 4000));
+  }
+  const { question } = prompt;
+  const counter = prompt.total > 1 ? `Question ${prompt.index + 1} of ${prompt.total} · ` : "";
+  const options = question.options.map((option, i) => `${i + 1}. **${option.label}**${option.description ? ` — ${option.description}` : ""}`).join(`
+`);
+  return new EmbedBuilder().setColor(color).setTitle(truncate(`${counter}${question.header || "Question"}`, 256)).setDescription(truncate([`**${question.question}**`, options].filter(Boolean).join(`
+
+`), 4000));
+}
+function controls(prompt) {
+  const rows = [];
+  if (prompt.kind === "permission") {
+    rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(customId(prompt.id, "p", "once")).setLabel("Allow once").setStyle(ButtonStyle.Primary), new ButtonBuilder().setCustomId(customId(prompt.id, "p", "always")).setLabel("Always allow").setStyle(ButtonStyle.Secondary), new ButtonBuilder().setCustomId(customId(prompt.id, "p", "reject")).setLabel("Deny").setStyle(ButtonStyle.Danger)));
+    return rows;
+  }
+  const { question } = prompt;
+  const options = question.options;
+  if (options.length > 0 && (question.multiple || options.length > BUTTON_OPTION_LIMIT)) {
+    const shown = options.slice(0, SELECT_LIMIT);
+    rows.push(new ActionRowBuilder().addComponents(new StringSelectMenuBuilder().setCustomId(customId(prompt.id, "m")).setPlaceholder(question.multiple ? "Choose one or more" : "Choose one").setMinValues(1).setMaxValues(question.multiple ? shown.length : 1).addOptions(shown.map((option, i) => ({
+      label: truncate(option.label, 100),
+      value: String(i),
+      ...option.description ? { description: truncate(option.description, 100) } : {}
+    })))));
+  } else {
+    for (let start = 0;start < options.length; start += BUTTONS_PER_ROW) {
+      rows.push(new ActionRowBuilder().addComponents(options.slice(start, start + BUTTONS_PER_ROW).map((option, i) => new ButtonBuilder().setCustomId(customId(prompt.id, "o", start + i)).setLabel(truncate(option.label, 80)).setStyle(ButtonStyle.Secondary))));
+    }
+  }
+  if (question.custom) {
+    rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(customId(prompt.id, "c")).setLabel("Write your own answer").setStyle(ButtonStyle.Primary)));
+  }
+  return rows;
+}
+function promptMessage(prompt) {
+  const hint = prompt.kind === "permission" ? "Or reply **yes**, **always**, or **no** in this thread." : prompt.question.options.length > 0 ? "Choose below or reply with the option's number." : "Reply in this thread or use the button.";
+  return {
+    content: `<@${prompt.requester.id}> ${hint}`,
+    embeds: [embed(prompt, OPEN_COLOR)],
+    components: controls(prompt),
+    allowedMentions: { users: [prompt.requester.id] }
+  };
+}
+function settledMessage(prompt, outcome) {
+  return {
+    content: "",
+    embeds: [
+      embed(prompt, SETTLED_COLOR).addFields({ name: "Outcome", value: truncate(outcome, 1024) })
+    ],
+    components: []
+  };
+}
+function customAnswerModal(prompt) {
+  return new ModalBuilder().setCustomId(customId(prompt.id, "modal")).setTitle(truncate(prompt.question.header || "Your answer", 45)).addComponents(new ActionRowBuilder().addComponents(new TextInputBuilder().setCustomId("answer").setLabel(truncate(prompt.question.question, 45)).setStyle(TextInputStyle.Paragraph).setRequired(true)));
+}
+
+// src/adapter.ts
+var INTENTS = [
+  GatewayIntentBits.Guilds,
+  GatewayIntentBits.GuildMessages,
+  GatewayIntentBits.MessageContent
+];
+var THREAD_NAME_LIMIT = 90;
+var HISTORY_LIMIT = 100;
+var RECENT_MESSAGES = 500;
+var NO_MENTIONS = { parse: [] };
+var INVITE_PERMISSIONS = new PermissionsBitField([
+  "ViewChannel",
+  "SendMessages",
+  "SendMessagesInThreads",
+  "CreatePublicThreads",
+  "ReadMessageHistory",
+  "AddReactions",
+  "EmbedLinks"
+]);
+var userOf = (message) => ({
+  id: message.author.id,
+  name: message.member?.displayName ?? message.author.displayName ?? message.author.username
+});
+var file = (attachment) => ({
+  id: attachment.id,
+  name: attachment.name,
+  mime: attachment.contentType?.split(";")[0] ?? "application/octet-stream",
+  size: attachment.size,
+  async download(signal) {
+    return downloadImage(attachment.url, {
+      hosts: ["cdn.discordapp.com", "media.discordapp.net"],
+      signal
+    });
+  }
+});
+async function onInteraction(events, interaction) {
+  if (!interaction.isButton() && !interaction.isStringSelectMenu() && !interaction.isModalSubmit()) {
+    return;
+  }
+  const parsed = parseCustomId(interaction.customId);
+  if (!parsed)
+    return;
+  const prompt = events.prompt(parsed.promptId);
+  const by = {
+    id: interaction.user.id,
+    name: (interaction.member && "displayName" in interaction.member ? interaction.member.displayName : undefined) ?? interaction.user.displayName
+  };
+  const stale = () => interaction.reply({ content: "This was already answered.", flags: MessageFlags.Ephemeral });
+  if (interaction.isButton() && parsed.control === "c") {
+    if (prompt?.kind !== "question")
+      return stale();
+    return interaction.showModal(customAnswerModal(prompt));
+  }
+  let answer;
+  if (prompt?.kind === "permission" && parsed.control === "p") {
+    answer = { kind: "permission", response: parsed.value };
+  } else if (prompt?.kind === "question") {
+    const labelAt = (value) => prompt.question.options[Number(value)]?.label;
+    const labels = interaction.isStringSelectMenu() && parsed.control === "m" ? interaction.values.map(labelAt) : interaction.isButton() && parsed.control === "o" ? [labelAt(parsed.value)] : interaction.isModalSubmit() && parsed.control === "modal" ? [interaction.fields.getTextInputValue("answer").trim()] : [];
+    const valid = labels.filter((label) => Boolean(label));
+    if (valid.length > 0)
+      answer = { kind: "question", labels: valid };
+  }
+  const outcome = answer ? events.answer(parsed.promptId, answer, by) : "stale";
+  if (outcome === "forbidden") {
+    return interaction.reply({
+      content: "Only people allowed to use this bot can answer.",
+      flags: MessageFlags.Ephemeral
+    });
+  }
+  if (outcome !== "answered")
+    return stale();
+  if (interaction.isModalSubmit() && !interaction.isFromMessage()) {
+    return interaction.reply({ content: "Sent to the agent.", flags: MessageFlags.Ephemeral });
+  }
+  return interaction.deferUpdate();
+}
+function createDiscordAdapter(options = {}) {
+  const owned = !options.client;
+  const token = owned ? (options.token ?? process.env.DISCORD_BOT_TOKEN)?.trim() : undefined;
+  if (owned && !token)
+    throw new Error("DISCORD_BOT_TOKEN is required");
+  if (options.client) {
+    const intents = new IntentsBitField(options.client.options.intents);
+    const missing = INTENTS.filter((intent) => !intents.has(intent));
+    if (missing.length > 0) {
+      throw new Error(`The Discord client needs the ${missing.map((intent) => GatewayIntentBits[intent]).join(", ")} intent(s)`);
+    }
+  }
+  const client = options.client ?? new Client({ intents: INTENTS });
+  const recent = new Map;
+  const botId = () => client.user?.id ?? "";
+  const stripMention = (text) => text.replaceAll(`<@${botId()}>`, "").replaceAll(`<@!${botId()}>`, "").trim();
+  const thread = async (id) => {
+    const channel = await client.channels.fetch(id);
+    if (!channel?.isThread())
+      throw new Error(`Discord channel ${id} is not a thread`);
+    return channel;
+  };
+  async function onMessage(events, message) {
+    if (message.author.bot || !message.inGuild())
+      return;
+    const mentioned = message.mentions.users.has(botId()) || message.mentions.repliedUser?.id === botId();
+    const channel = message.channel;
+    let location;
+    if (channel.isThread()) {
+      if (!channel.parentId)
+        return;
+      location = { channel: channel.parentId, thread: channel.id };
+    } else {
+      if (!mentioned || !events.accepts(channel.id) || !("threads" in channel))
+        return;
+      const name = stripMention(message.content).slice(0, THREAD_NAME_LIMIT) || "GitTerm agent";
+      const opened = await message.startThread({
+        name,
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay
+      });
+      location = { channel: channel.id, thread: opened.id };
+    }
+    recent.set(message.id, message);
+    if (recent.size > RECENT_MESSAGES)
+      recent.delete(recent.keys().next().value);
+    events.message({
+      id: message.id,
+      thread: location,
+      author: userOf(message),
+      text: stripMention(message.content),
+      files: [...message.attachments.values()].map(file),
+      mentioned,
+      inThread: channel.isThread(),
+      tenant: message.guildId
+    });
+  }
+  return {
+    platform: "discord",
+    displayName: "Discord",
+    async start(events) {
+      client.on(Events.MessageCreate, (message) => {
+        onMessage(events, message).catch((error) => console.error("Discord message handling failed", error));
+      });
+      client.on(Events.InteractionCreate, (interaction) => {
+        onInteraction(events, interaction).catch((error) => console.error("Discord interaction handling failed", error));
+      });
+      if (!client.isReady()) {
+        const ready = once(client, Events.ClientReady);
+        if (owned)
+          await client.login(token);
+        await ready;
+      }
+      const applicationId = client.application?.id ?? client.user?.id ?? "";
+      console.info(`Invite the bot: https://discord.com/oauth2/authorize?client_id=${applicationId}&scope=bot&permissions=${INVITE_PERMISSIONS.bitfield}`);
+      return { scope: applicationId };
+    },
+    async stop() {
+      if (owned)
+        await client.destroy();
+    },
+    async history(location, after) {
+      const channel = await thread(location.thread);
+      const fetched = await channel.messages.fetch({
+        limit: HISTORY_LIMIT,
+        ...after ? { after } : {}
+      });
+      const messages = [...fetched.values()].toReversed();
+      if (!after) {
+        const starter = await channel.fetchStarterMessage().catch(() => null);
+        if (starter)
+          messages.unshift(starter);
+      }
+      return messages.map((message) => ({
+        id: message.id,
+        author: message.author.bot ? { id: message.author.id, name: "assistant" } : userOf(message),
+        fromBot: message.author.bot,
+        text: stripMention(message.content),
+        files: [...message.attachments.values()].map(file)
+      }));
+    },
+    async post(location, text) {
+      const sent = await (await thread(location.thread)).send({ content: text, allowedMentions: NO_MENTIONS });
+      return sent.id;
+    },
+    async edit(location, messageId, text) {
+      await (await thread(location.thread)).messages.edit(messageId, { content: text });
+    },
+    async remove(location, messageId) {
+      await (await thread(location.thread)).messages.delete(messageId);
+    },
+    async reply(location, markdown, footer, delivery) {
+      const channel = await thread(location.thread);
+      const contents = answerContents(markdown, footer);
+      for (let index = delivery?.sent ?? 0;index < contents.length; index++) {
+        await channel.send({ content: contents[index], allowedMentions: NO_MENTIONS });
+        await delivery?.recordSent(index + 1);
+      }
+    },
+    async ask(location, prompt) {
+      const sent = await (await thread(location.thread)).send(promptMessage(prompt));
+      return sent.id;
+    },
+    async settle(location, messageId, prompt, outcome) {
+      await (await thread(location.thread)).messages.edit(messageId, settledMessage(prompt, outcome));
+    },
+    async mark(message, state) {
+      await recent.get(message.id)?.react({ seen: "\uD83D\uDC40", done: "✅", failed: "❌" }[state]);
+      if (state !== "seen")
+        recent.delete(message.id);
+    }
+  };
+}
+
+// src/index.ts
+function createDiscordBot(options) {
+  const { token, client, ...bot } = options;
+  return createBot({
+    ...bot,
+    adapter: createDiscordAdapter({ ...token ? { token } : {}, ...client ? { client } : {} })
+  });
+}
+async function withSavedConfig(options = {}) {
+  return { ...options, ...await loadSaved(options, "discord", options.logger) };
+}
+
+// src/cli.ts
+var USAGE = `Usage: gitterm-discord-bot [-h] [--repo <url>[#branch]] [--model <provider/model>]
+                    [--instructions-file <path>]
+
+Environment (a .env file in the working directory is loaded):
+  DISCORD_BOT_TOKEN               Bot token; enable the Message Content intent
+${BOT_ENV_HELP}
+
+The invite link for your server is printed when the bot starts.`;
+var { command, options: local } = cliOptions();
+if (command === "help" || !hasRepository(local) && !process.env.GITTERM_API_TOKEN) {
+  console.log(USAGE);
+  process.exitCode = command === "help" ? 0 : 1;
+} else {
+  const options = await withSavedConfig(local);
+  if (!hasRepository(options)) {
+    console.log(USAGE);
+    console.error(`
+No repository: set GITTERM_BOT_REPO, or save this bot under Bots in GitTerm.`);
+    process.exit(1);
+  }
+  const bot = createDiscordBot(options);
+  await bot.start();
+  const shutdown = () => void bot.stop().finally(() => process.exit(0));
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}

package/dist/components.d.ts

@@ -0,0 +1,27 @@
+import { type ChatPrompt } from "@gitterm/bot";
+import { ActionRowBuilder, ButtonBuilder, EmbedBuilder, ModalBuilder, StringSelectMenuBuilder } from "discord.js";
+/** `gt:<prompt id>:<control>[:<value>]`; Discord allows 100 characters. */
+export declare const customId: (promptId: string, control: string, value?: string | number) => string;
+export declare function parseCustomId(id: string): {
+    promptId: string;
+    control: string;
+    value: string | undefined;
+} | null;
+/** The agent's answer as message contents; the last carries the footer as subtext. */
+export declare function answerContents(markdown: string, footer: string): string[];
+export declare function promptMessage(prompt: ChatPrompt): {
+    content: string;
+    embeds: EmbedBuilder[];
+    components: (ActionRowBuilder<ButtonBuilder> | ActionRowBuilder<StringSelectMenuBuilder>)[];
+    allowedMentions: {
+        users: string[];
+    };
+};
+export declare function settledMessage(prompt: ChatPrompt, outcome: string): {
+    content: string;
+    embeds: EmbedBuilder[];
+    components: never[];
+};
+export declare function customAnswerModal(prompt: Extract<ChatPrompt, {
+    kind: "question";
+}>): ModalBuilder;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { type Bot, type BotOptions } from "@gitterm/bot";
+import { type DiscordAdapterOptions } from "./adapter.js";
+export { createDiscordAdapter, type DiscordAdapterOptions } from "./adapter.js";
+export type { Bot, RepoTarget, WorkspaceOverrides } from "@gitterm/bot";
+export type DiscordBotOptions = Omit<BotOptions, "adapter"> & DiscordAdapterOptions;
+/**
+ * A Discord bot that runs a coding agent on your repository in a GitTerm sandbox.
+ *
+ * ```ts
+ * await createDiscordBot({ repo: "https://github.com/acme/app" }).start();
+ * ```
+ *
+ * Tokens default to `DISCORD_BOT_TOKEN` and `GITTERM_API_TOKEN`; pass `client` to add the agent
+ * to a discord.js client you already run.
+ */
+export declare function createDiscordBot(options: DiscordBotOptions): Bot;
+/**
+ * Adds the settings saved for this bot under Bots in the GitTerm dashboard, found by its API
+ * token. Anything you pass wins: `createDiscordBot(await withSavedConfig({ ... }))`.
+ */
+export declare function withSavedConfig(options?: DiscordBotOptions): Promise<DiscordBotOptions>;

package/dist/index.js

@@ -0,0 +1,336 @@
+// src/index.ts
+import { createBot, withSavedConfig as loadSaved } from "@gitterm/bot";
+
+// src/adapter.ts
+import { once } from "node:events";
+import { downloadImage } from "@gitterm/bot";
+import {
+  Client,
+  Events,
+  GatewayIntentBits,
+  IntentsBitField,
+  MessageFlags,
+  PermissionsBitField,
+  ThreadAutoArchiveDuration
+} from "discord.js";
+
+// src/components.ts
+import { splitMessage, tablesToCode } from "@gitterm/bot";
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  EmbedBuilder,
+  ModalBuilder,
+  StringSelectMenuBuilder,
+  TextInputBuilder,
+  TextInputStyle
+} from "discord.js";
+var MESSAGE_LIMIT = 1900;
+var BUTTONS_PER_ROW = 5;
+var BUTTON_OPTION_LIMIT = 20;
+var SELECT_LIMIT = 25;
+var OPEN_COLOR = 15246141;
+var SETTLED_COLOR = 12107719;
+var truncate = (value, limit) => value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+var customId = (promptId, control, value) => ["gt", promptId, control, ...value === undefined ? [] : [String(value)]].join(":");
+function parseCustomId(id) {
+  const [prefix, promptId, control, value] = id.split(":");
+  return prefix === "gt" && promptId && control ? { promptId, control, value } : null;
+}
+function answerContents(markdown, footer) {
+  const chunks = splitMessage(tablesToCode(markdown), MESSAGE_LIMIT);
+  const last = chunks.length - 1;
+  return chunks.map((chunk, index) => index === last ? `${chunk}
+-# ${footer}` : chunk);
+}
+function embed(prompt, color) {
+  if (prompt.kind === "permission") {
+    const patterns = prompt.request.patterns.filter(Boolean).join(`
+`);
+    return new EmbedBuilder().setColor(color).setTitle("Approval needed").setDescription(truncate(`The agent wants to run **${prompt.request.title}**${patterns ? `
+\`\`\`
+${patterns}
+\`\`\`` : ""}`, 4000));
+  }
+  const { question } = prompt;
+  const counter = prompt.total > 1 ? `Question ${prompt.index + 1} of ${prompt.total} · ` : "";
+  const options = question.options.map((option, i) => `${i + 1}. **${option.label}**${option.description ? ` — ${option.description}` : ""}`).join(`
+`);
+  return new EmbedBuilder().setColor(color).setTitle(truncate(`${counter}${question.header || "Question"}`, 256)).setDescription(truncate([`**${question.question}**`, options].filter(Boolean).join(`
+
+`), 4000));
+}
+function controls(prompt) {
+  const rows = [];
+  if (prompt.kind === "permission") {
+    rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(customId(prompt.id, "p", "once")).setLabel("Allow once").setStyle(ButtonStyle.Primary), new ButtonBuilder().setCustomId(customId(prompt.id, "p", "always")).setLabel("Always allow").setStyle(ButtonStyle.Secondary), new ButtonBuilder().setCustomId(customId(prompt.id, "p", "reject")).setLabel("Deny").setStyle(ButtonStyle.Danger)));
+    return rows;
+  }
+  const { question } = prompt;
+  const options = question.options;
+  if (options.length > 0 && (question.multiple || options.length > BUTTON_OPTION_LIMIT)) {
+    const shown = options.slice(0, SELECT_LIMIT);
+    rows.push(new ActionRowBuilder().addComponents(new StringSelectMenuBuilder().setCustomId(customId(prompt.id, "m")).setPlaceholder(question.multiple ? "Choose one or more" : "Choose one").setMinValues(1).setMaxValues(question.multiple ? shown.length : 1).addOptions(shown.map((option, i) => ({
+      label: truncate(option.label, 100),
+      value: String(i),
+      ...option.description ? { description: truncate(option.description, 100) } : {}
+    })))));
+  } else {
+    for (let start = 0;start < options.length; start += BUTTONS_PER_ROW) {
+      rows.push(new ActionRowBuilder().addComponents(options.slice(start, start + BUTTONS_PER_ROW).map((option, i) => new ButtonBuilder().setCustomId(customId(prompt.id, "o", start + i)).setLabel(truncate(option.label, 80)).setStyle(ButtonStyle.Secondary))));
+    }
+  }
+  if (question.custom) {
+    rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(customId(prompt.id, "c")).setLabel("Write your own answer").setStyle(ButtonStyle.Primary)));
+  }
+  return rows;
+}
+function promptMessage(prompt) {
+  const hint = prompt.kind === "permission" ? "Or reply **yes**, **always**, or **no** in this thread." : prompt.question.options.length > 0 ? "Choose below or reply with the option's number." : "Reply in this thread or use the button.";
+  return {
+    content: `<@${prompt.requester.id}> ${hint}`,
+    embeds: [embed(prompt, OPEN_COLOR)],
+    components: controls(prompt),
+    allowedMentions: { users: [prompt.requester.id] }
+  };
+}
+function settledMessage(prompt, outcome) {
+  return {
+    content: "",
+    embeds: [
+      embed(prompt, SETTLED_COLOR).addFields({ name: "Outcome", value: truncate(outcome, 1024) })
+    ],
+    components: []
+  };
+}
+function customAnswerModal(prompt) {
+  return new ModalBuilder().setCustomId(customId(prompt.id, "modal")).setTitle(truncate(prompt.question.header || "Your answer", 45)).addComponents(new ActionRowBuilder().addComponents(new TextInputBuilder().setCustomId("answer").setLabel(truncate(prompt.question.question, 45)).setStyle(TextInputStyle.Paragraph).setRequired(true)));
+}
+
+// src/adapter.ts
+var INTENTS = [
+  GatewayIntentBits.Guilds,
+  GatewayIntentBits.GuildMessages,
+  GatewayIntentBits.MessageContent
+];
+var THREAD_NAME_LIMIT = 90;
+var HISTORY_LIMIT = 100;
+var RECENT_MESSAGES = 500;
+var NO_MENTIONS = { parse: [] };
+var INVITE_PERMISSIONS = new PermissionsBitField([
+  "ViewChannel",
+  "SendMessages",
+  "SendMessagesInThreads",
+  "CreatePublicThreads",
+  "ReadMessageHistory",
+  "AddReactions",
+  "EmbedLinks"
+]);
+var userOf = (message) => ({
+  id: message.author.id,
+  name: message.member?.displayName ?? message.author.displayName ?? message.author.username
+});
+var file = (attachment) => ({
+  id: attachment.id,
+  name: attachment.name,
+  mime: attachment.contentType?.split(";")[0] ?? "application/octet-stream",
+  size: attachment.size,
+  async download(signal) {
+    return downloadImage(attachment.url, {
+      hosts: ["cdn.discordapp.com", "media.discordapp.net"],
+      signal
+    });
+  }
+});
+async function onInteraction(events, interaction) {
+  if (!interaction.isButton() && !interaction.isStringSelectMenu() && !interaction.isModalSubmit()) {
+    return;
+  }
+  const parsed = parseCustomId(interaction.customId);
+  if (!parsed)
+    return;
+  const prompt = events.prompt(parsed.promptId);
+  const by = {
+    id: interaction.user.id,
+    name: (interaction.member && "displayName" in interaction.member ? interaction.member.displayName : undefined) ?? interaction.user.displayName
+  };
+  const stale = () => interaction.reply({ content: "This was already answered.", flags: MessageFlags.Ephemeral });
+  if (interaction.isButton() && parsed.control === "c") {
+    if (prompt?.kind !== "question")
+      return stale();
+    return interaction.showModal(customAnswerModal(prompt));
+  }
+  let answer;
+  if (prompt?.kind === "permission" && parsed.control === "p") {
+    answer = { kind: "permission", response: parsed.value };
+  } else if (prompt?.kind === "question") {
+    const labelAt = (value) => prompt.question.options[Number(value)]?.label;
+    const labels = interaction.isStringSelectMenu() && parsed.control === "m" ? interaction.values.map(labelAt) : interaction.isButton() && parsed.control === "o" ? [labelAt(parsed.value)] : interaction.isModalSubmit() && parsed.control === "modal" ? [interaction.fields.getTextInputValue("answer").trim()] : [];
+    const valid = labels.filter((label) => Boolean(label));
+    if (valid.length > 0)
+      answer = { kind: "question", labels: valid };
+  }
+  const outcome = answer ? events.answer(parsed.promptId, answer, by) : "stale";
+  if (outcome === "forbidden") {
+    return interaction.reply({
+      content: "Only people allowed to use this bot can answer.",
+      flags: MessageFlags.Ephemeral
+    });
+  }
+  if (outcome !== "answered")
+    return stale();
+  if (interaction.isModalSubmit() && !interaction.isFromMessage()) {
+    return interaction.reply({ content: "Sent to the agent.", flags: MessageFlags.Ephemeral });
+  }
+  return interaction.deferUpdate();
+}
+function createDiscordAdapter(options = {}) {
+  const owned = !options.client;
+  const token = owned ? (options.token ?? process.env.DISCORD_BOT_TOKEN)?.trim() : undefined;
+  if (owned && !token)
+    throw new Error("DISCORD_BOT_TOKEN is required");
+  if (options.client) {
+    const intents = new IntentsBitField(options.client.options.intents);
+    const missing = INTENTS.filter((intent) => !intents.has(intent));
+    if (missing.length > 0) {
+      throw new Error(`The Discord client needs the ${missing.map((intent) => GatewayIntentBits[intent]).join(", ")} intent(s)`);
+    }
+  }
+  const client = options.client ?? new Client({ intents: INTENTS });
+  const recent = new Map;
+  const botId = () => client.user?.id ?? "";
+  const stripMention = (text) => text.replaceAll(`<@${botId()}>`, "").replaceAll(`<@!${botId()}>`, "").trim();
+  const thread = async (id) => {
+    const channel = await client.channels.fetch(id);
+    if (!channel?.isThread())
+      throw new Error(`Discord channel ${id} is not a thread`);
+    return channel;
+  };
+  async function onMessage(events, message) {
+    if (message.author.bot || !message.inGuild())
+      return;
+    const mentioned = message.mentions.users.has(botId()) || message.mentions.repliedUser?.id === botId();
+    const channel = message.channel;
+    let location;
+    if (channel.isThread()) {
+      if (!channel.parentId)
+        return;
+      location = { channel: channel.parentId, thread: channel.id };
+    } else {
+      if (!mentioned || !events.accepts(channel.id) || !("threads" in channel))
+        return;
+      const name = stripMention(message.content).slice(0, THREAD_NAME_LIMIT) || "GitTerm agent";
+      const opened = await message.startThread({
+        name,
+        autoArchiveDuration: ThreadAutoArchiveDuration.OneDay
+      });
+      location = { channel: channel.id, thread: opened.id };
+    }
+    recent.set(message.id, message);
+    if (recent.size > RECENT_MESSAGES)
+      recent.delete(recent.keys().next().value);
+    events.message({
+      id: message.id,
+      thread: location,
+      author: userOf(message),
+      text: stripMention(message.content),
+      files: [...message.attachments.values()].map(file),
+      mentioned,
+      inThread: channel.isThread(),
+      tenant: message.guildId
+    });
+  }
+  return {
+    platform: "discord",
+    displayName: "Discord",
+    async start(events) {
+      client.on(Events.MessageCreate, (message) => {
+        onMessage(events, message).catch((error) => console.error("Discord message handling failed", error));
+      });
+      client.on(Events.InteractionCreate, (interaction) => {
+        onInteraction(events, interaction).catch((error) => console.error("Discord interaction handling failed", error));
+      });
+      if (!client.isReady()) {
+        const ready = once(client, Events.ClientReady);
+        if (owned)
+          await client.login(token);
+        await ready;
+      }
+      const applicationId = client.application?.id ?? client.user?.id ?? "";
+      console.info(`Invite the bot: https://discord.com/oauth2/authorize?client_id=${applicationId}&scope=bot&permissions=${INVITE_PERMISSIONS.bitfield}`);
+      return { scope: applicationId };
+    },
+    async stop() {
+      if (owned)
+        await client.destroy();
+    },
+    async history(location, after) {
+      const channel = await thread(location.thread);
+      const fetched = await channel.messages.fetch({
+        limit: HISTORY_LIMIT,
+        ...after ? { after } : {}
+      });
+      const messages = [...fetched.values()].toReversed();
+      if (!after) {
+        const starter = await channel.fetchStarterMessage().catch(() => null);
+        if (starter)
+          messages.unshift(starter);
+      }
+      return messages.map((message) => ({
+        id: message.id,
+        author: message.author.bot ? { id: message.author.id, name: "assistant" } : userOf(message),
+        fromBot: message.author.bot,
+        text: stripMention(message.content),
+        files: [...message.attachments.values()].map(file)
+      }));
+    },
+    async post(location, text) {
+      const sent = await (await thread(location.thread)).send({ content: text, allowedMentions: NO_MENTIONS });
+      return sent.id;
+    },
+    async edit(location, messageId, text) {
+      await (await thread(location.thread)).messages.edit(messageId, { content: text });
+    },
+    async remove(location, messageId) {
+      await (await thread(location.thread)).messages.delete(messageId);
+    },
+    async reply(location, markdown, footer, delivery) {
+      const channel = await thread(location.thread);
+      const contents = answerContents(markdown, footer);
+      for (let index = delivery?.sent ?? 0;index < contents.length; index++) {
+        await channel.send({ content: contents[index], allowedMentions: NO_MENTIONS });
+        await delivery?.recordSent(index + 1);
+      }
+    },
+    async ask(location, prompt) {
+      const sent = await (await thread(location.thread)).send(promptMessage(prompt));
+      return sent.id;
+    },
+    async settle(location, messageId, prompt, outcome) {
+      await (await thread(location.thread)).messages.edit(messageId, settledMessage(prompt, outcome));
+    },
+    async mark(message, state) {
+      await recent.get(message.id)?.react({ seen: "\uD83D\uDC40", done: "✅", failed: "❌" }[state]);
+      if (state !== "seen")
+        recent.delete(message.id);
+    }
+  };
+}
+
+// src/index.ts
+function createDiscordBot(options) {
+  const { token, client, ...bot } = options;
+  return createBot({
+    ...bot,
+    adapter: createDiscordAdapter({ ...token ? { token } : {}, ...client ? { client } : {} })
+  });
+}
+async function withSavedConfig(options = {}) {
+  return { ...options, ...await loadSaved(options, "discord", options.logger) };
+}
+export {
+  createDiscordAdapter,
+  createDiscordBot,
+  withSavedConfig
+};

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@gitterm/discord-bot",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Discord bot that runs a coding agent on your repository in a GitTerm sandbox",
+  "keywords": [
+    "agent",
+    "bot",
+    "discord",
+    "gitterm",
+    "opencode"
+  ],
+  "homepage": "https://gitterm.dev",
+  "license": "MIT",
+  "author": "Opeyemi Oginni",
+  "bin": {
+    "gitterm-discord-bot": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts src/cli.ts --outdir dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run check-types && bun run build",
+    "check-types": "tsc --noEmit",
+    "start:local": "bun --watch src/cli.ts"
+  },
+  "dependencies": {
+    "@gitterm/bot": "^0.1.1",
+    "@gitterm/sdk": "^0.10.0",
+    "discord.js": "^14.27.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.6",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  }
+}