district.js 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# district.js
+
+A powerful Node.js module for building [District](https://usedistrict.org) bots — post, edit, react, run slash commands, and receive events with a clean, object-oriented API.
+
+```bash
+npm install district.js
+```
+
+> Requires Node.js 18+. Create an app and a bot in the [Developer Portal](https://usedistrict.org/developers) to get your **token** (`dbot_…`) and **signing secret** (`dsk_…`).
+
+## Your first bot
+
+```js
+import { Client } from "district.js";
+
+const client = new Client({
+  token: process.env.DISTRICT_TOKEN,          // dbot_…
+  signingSecret: process.env.DISTRICT_SECRET,  // dsk_… (needed to receive events)
+});
+
+client.on("ready", (me) => console.log(`Logged in as ${me.displayName}`));
+
+client.on("messageCreate", (message) => {
+  if (message.authoredByMe) return;            // don't reply to yourself
+  if (message.content === "!ping") message.reply("pong 🏓");
+});
+
+// Starts an HTTP server that receives District's signed webhook events.
+client.listen(3000);
+```
+
+Point your app's **Event Subscription** (in the portal) at `https://your-host:3000/` and tick the events you want. District signs every event; `district.js` verifies the signature for you before emitting it.
+
+## Sending & acting
+
+```js
+// Send to a channel
+const msg = await client.channels.send(channelId, "hello world");
+
+// Act on a message you have
+await msg.edit("hello, world!");
+await msg.react("👍");
+await msg.delete();
+
+// Read history
+const recent = await client.channel(channelId).fetchMessages(50);
+```
+
+## Slash commands
+
+Register the command in the portal (name + handler URL), then:
+
+```js
+client.on("interactionCreate", (interaction) => {
+  if (interaction.commandName === "weather") {
+    interaction.reply(`It's sunny in ${interaction.args.text}`);
+  }
+});
+```
+
+## Events
+
+| Event | Argument |
+| --- | --- |
+| `ready` | `ClientUser` |
+| `messageCreate` | `Message` |
+| `messageUpdate` | `Message` |
+| `messageDelete` | `{ id, channelId, spaceId }` |
+| `messageReactionAdd` | `{ messageId, channelId, userId, emoji, spaceId }` |
+| `messageReactionRemove` | `{ messageId, channelId, userId, emoji, spaceId }` |
+| `interactionCreate` | `Interaction` |
+| `error` | `Error` |
+
+## Using with Express
+
+If you already run a server, mount the middleware (feed it the **raw** body so the signature verifies):
+
+```js
+import express from "express";
+const app = express();
+app.post("/district", express.text({ type: "*/*" }), client.middleware());
+await client.login();
+app.listen(3000);
+```
+
+## Scopes & permissions
+
+A bot only acts where its app is **installed**, and each action needs a scope
+(`send_messages`, `read_messages`, `manage_messages`). See the
+[full API docs](https://usedistrict.org/developers/docs).
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter } from "node:events";
+import http from "node:http";
+import { REST } from "./rest.js";
+import { ClientUser, Message, TextChannel, Interaction, type ClientContext } from "./structures.js";
+import { type EventHeaders } from "./webhook.js";
+import type { ClientOptions, ReactionEvent, DeletedMessage } from "./types.js";
+/** The events a Client emits, and their argument tuples. */
+export interface ClientEvents {
+    ready: [user: ClientUser];
+    messageCreate: [message: Message];
+    messageUpdate: [message: Message];
+    messageDelete: [message: DeletedMessage];
+    messageReactionAdd: [reaction: ReactionEvent];
+    messageReactionRemove: [reaction: ReactionEvent];
+    interactionCreate: [interaction: Interaction];
+    error: [error: Error];
+}
+export declare class Client extends EventEmitter implements ClientContext {
+    readonly rest: REST;
+    /** The bot's own identity — populated after `login()`. */
+    user: ClientUser | null;
+    private signingSecret?;
+    constructor(options: ClientOptions);
+    on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): this;
+    once<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): this;
+    off<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => void): this;
+    emit<K extends keyof ClientEvents>(event: K, ...args: ClientEvents[K]): boolean;
+    /** A handle to a channel, for `.send()` / `.fetchMessages()`. */
+    channel(id: string): TextChannel;
+    readonly channels: {
+        send: (channelId: string, content: string) => Promise<Message>;
+        fetch: (channelId: string, limit?: number) => Promise<Message[]>;
+    };
+    /** Validate the token, load the bot's identity, and emit `ready`. */
+    login(): Promise<ClientUser>;
+    /**
+     * Verify + dispatch a single raw event body. Use this when you run your own
+     * server. Returns true if the signature checked out and the event dispatched.
+     */
+    handle(rawBody: string, headers: EventHeaders): boolean;
+    /** An Express/Connect-style handler. Feed it the RAW request body (use a
+     *  raw/text body parser) so the HMAC signature can be verified. */
+    middleware(): (req: any, res: any) => void;
+    /**
+     * Start a minimal HTTP server that receives District events. Logs in first if
+     * you haven't already. Returns the underlying server.
+     */
+    listen(port: number, path?: string): Promise<http.Server>;
+    private dispatch;
+}

package/dist/client.js

@@ -0,0 +1,139 @@
+// The main entry point — a discord.js-style Client. Post via REST helpers, and
+// receive District's signed webhook events as typed emitter events.
+import { EventEmitter } from "node:events";
+import http from "node:http";
+import { REST } from "./rest.js";
+import { ClientUser, Message, TextChannel, Interaction } from "./structures.js";
+import { verifyAndParse } from "./webhook.js";
+export class Client extends EventEmitter {
+    rest;
+    /** The bot's own identity — populated after `login()`. */
+    user = null;
+    signingSecret;
+    constructor(options) {
+        super();
+        if (!options?.token)
+            throw new Error("district.js: `token` is required");
+        this.rest = new REST(options.token, options.apiBase);
+        this.signingSecret = options.signingSecret;
+    }
+    // ── typed emitter surface ──────────────────────────────────────────────────
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    // ── REST convenience ───────────────────────────────────────────────────────
+    /** A handle to a channel, for `.send()` / `.fetchMessages()`. */
+    channel(id) {
+        return new TextChannel(this, id);
+    }
+    channels = {
+        send: (channelId, content) => new TextChannel(this, channelId).send(content),
+        fetch: (channelId, limit) => new TextChannel(this, channelId).fetchMessages(limit),
+    };
+    /** Validate the token, load the bot's identity, and emit `ready`. */
+    async login() {
+        const res = await this.rest.get("/me");
+        this.user = new ClientUser(res.bot);
+        this.emit("ready", this.user);
+        return this.user;
+    }
+    // ── receiving events ───────────────────────────────────────────────────────
+    /**
+     * Verify + dispatch a single raw event body. Use this when you run your own
+     * server. Returns true if the signature checked out and the event dispatched.
+     */
+    handle(rawBody, headers) {
+        if (!this.signingSecret)
+            throw new Error("district.js: `signingSecret` is required to receive events");
+        const evt = verifyAndParse(this.signingSecret, headers, rawBody);
+        if (!evt)
+            return false;
+        try {
+            this.dispatch(evt);
+        }
+        catch (e) {
+            this.emit("error", e);
+        }
+        return true;
+    }
+    /** An Express/Connect-style handler. Feed it the RAW request body (use a
+     *  raw/text body parser) so the HMAC signature can be verified. */
+    middleware() {
+        return (req, res) => {
+            const raw = typeof req.body === "string" ? req.body : (req.rawBody ?? JSON.stringify(req.body ?? {}));
+            let ok = false;
+            try {
+                ok = this.handle(raw, req.headers);
+            }
+            catch (e) {
+                this.emit("error", e);
+            }
+            res.status(ok ? 204 : 401).end();
+        };
+    }
+    /**
+     * Start a minimal HTTP server that receives District events. Logs in first if
+     * you haven't already. Returns the underlying server.
+     */
+    async listen(port, path = "/") {
+        if (!this.user)
+            await this.login();
+        const server = http.createServer((req, res) => {
+            if (req.method !== "POST" || (path !== "*" && req.url !== path)) {
+                res.statusCode = 404;
+                res.end();
+                return;
+            }
+            let body = "";
+            req.on("data", (c) => (body += c));
+            req.on("end", () => {
+                try {
+                    const ok = this.handle(body, req.headers);
+                    res.statusCode = ok ? 204 : 401;
+                    res.end();
+                }
+                catch (e) {
+                    this.emit("error", e);
+                    res.statusCode = 500;
+                    res.end();
+                }
+            });
+        });
+        server.listen(port);
+        return server;
+    }
+    dispatch(evt) {
+        switch (evt.event) {
+            case "message.create":
+                this.emit("messageCreate", new Message(this, evt.message));
+                break;
+            case "message.update":
+                this.emit("messageUpdate", new Message(this, evt.message));
+                break;
+            case "message.delete":
+                this.emit("messageDelete", { id: evt.message.id, channelId: evt.channel_id, spaceId: evt.space_id });
+                break;
+            case "message.reaction_add":
+                this.emit("messageReactionAdd", toReaction(evt));
+                break;
+            case "message.reaction_remove":
+                this.emit("messageReactionRemove", toReaction(evt));
+                break;
+            case "interaction.create":
+                this.emit("interactionCreate", new Interaction(this, evt));
+                break;
+        }
+    }
+}
+function toReaction(evt) {
+    return { spaceId: evt.space_id, channelId: evt.channel_id, messageId: evt.message_id, userId: evt.user_id, emoji: evt.emoji };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Client, type ClientEvents } from "./client.js";
+export { REST, DistrictAPIError, DEFAULT_API_BASE } from "./rest.js";
+export { ClientUser, Message, TextChannel, Interaction, type ClientContext } from "./structures.js";
+export { verifySignature, parseEvent, verifyAndParse, type EventHeaders } from "./webhook.js";
+export type { ClientOptions, RawMessage, RawSelfUser, DistrictEvent, ReactionEvent, DeletedMessage, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+// district.js — build District bots in Node.js.
+//
+//   import { Client } from "district.js";
+//   const client = new Client({ token: "dbot_…", signingSecret: "dsk_…" });
+//   client.on("messageCreate", (m) => { if (m.content === "!ping") m.reply("pong"); });
+//   client.listen(3000);
+export { Client } from "./client.js";
+export { REST, DistrictAPIError, DEFAULT_API_BASE } from "./rest.js";
+export { ClientUser, Message, TextChannel, Interaction } from "./structures.js";
+export { verifySignature, parseEvent, verifyAndParse } from "./webhook.js";

package/dist/rest.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_API_BASE = "https://dfbestmduuyrsqvwrekn.functions.supabase.co/bot-api";
+export declare class DistrictAPIError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string);
+}
+export declare class REST {
+    private token;
+    private base;
+    constructor(token: string, base?: string);
+    request<T = any>(method: string, path: string, body?: unknown): Promise<T>;
+    get<T = any>(path: string): Promise<T>;
+    post<T = any>(path: string, body?: unknown): Promise<T>;
+    patch<T = any>(path: string, body?: unknown): Promise<T>;
+    delete<T = any>(path: string): Promise<T>;
+    put<T = any>(path: string, body?: unknown): Promise<T>;
+}

package/dist/rest.js

@@ -0,0 +1,49 @@
+// Thin REST client for the District bot API. Every request is authenticated with
+// the bot token; non-2xx responses throw a DistrictAPIError.
+export const DEFAULT_API_BASE = "https://dfbestmduuyrsqvwrekn.functions.supabase.co/bot-api";
+export class DistrictAPIError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(`District API error ${status}: ${code}`);
+        this.status = status;
+        this.code = code;
+        this.name = "DistrictAPIError";
+    }
+}
+export class REST {
+    token;
+    base;
+    constructor(token, base = DEFAULT_API_BASE) {
+        this.token = token;
+        this.base = base.replace(/\/+$/, "");
+    }
+    async request(method, path, body) {
+        const res = await fetch(`${this.base}${path}`, {
+            method,
+            headers: {
+                authorization: `Bot ${this.token}`,
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        const json = text ? safeParse(text) : {};
+        if (!res.ok)
+            throw new DistrictAPIError(res.status, json?.error ?? res.statusText);
+        return json;
+    }
+    get(path) { return this.request("GET", path); }
+    post(path, body) { return this.request("POST", path, body); }
+    patch(path, body) { return this.request("PATCH", path, body); }
+    delete(path) { return this.request("DELETE", path); }
+    put(path, body) { return this.request("PUT", path, body); }
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/structures.d.ts

@@ -0,0 +1,67 @@
+import type { REST } from "./rest.js";
+import type { RawMessage, RawSelfUser } from "./types.js";
+/** Minimal client surface the structures need (avoids a circular import). */
+export interface ClientContext {
+    rest: REST;
+    user: ClientUser | null;
+}
+export declare class ClientUser {
+    id: string;
+    handle: string;
+    displayName: string;
+    avatarUrl: string | null;
+    constructor(raw: RawSelfUser);
+    /** Alias for `handle`, for discord.js familiarity. */
+    get username(): string;
+}
+export declare class Message {
+    private client;
+    id: string;
+    channelId: string;
+    content: string | null;
+    authorId: string;
+    createdAt: string | null;
+    editedAt: string | null;
+    parentId: string | null;
+    constructor(client: ClientContext, raw: RawMessage);
+    /** True if this message was sent by the current bot. */
+    get authoredByMe(): boolean;
+    /** Reply to this message (threads it via replyTo). */
+    reply(content: string): Promise<Message>;
+    /** Edit this message (only the bot's own messages). */
+    edit(content: string): Promise<this>;
+    /** Delete this message. */
+    delete(): Promise<void>;
+    /** Add a reaction from the bot. */
+    react(emoji: string): Promise<void>;
+    /** Remove the bot's reaction. */
+    removeReaction(emoji: string): Promise<void>;
+}
+export declare class TextChannel {
+    private client;
+    id: string;
+    constructor(client: ClientContext, id: string);
+    /** Send a message to this channel. */
+    send(content: string): Promise<Message>;
+    /** Fetch recent messages (oldest → newest), up to 100. */
+    fetchMessages(limit?: number): Promise<Message[]>;
+}
+export declare class Interaction {
+    private client;
+    commandName: string;
+    commandId: string;
+    spaceId: string;
+    channelId: string;
+    userId: string;
+    args: Record<string, unknown>;
+    constructor(client: ClientContext, raw: {
+        command: string;
+        command_id: string;
+        space_id: string;
+        channel_id: string;
+        user_id: string;
+        args: Record<string, unknown>;
+    });
+    /** Respond to the command by posting a message in its channel. */
+    reply(content: string): Promise<Message>;
+}

package/dist/structures.js

@@ -0,0 +1,102 @@
+// Rich objects returned by the client — each carries a back-reference so you can
+// act on it directly: message.reply(), channel.send(), interaction.reply().
+export class ClientUser {
+    id;
+    handle;
+    displayName;
+    avatarUrl;
+    constructor(raw) {
+        this.id = raw.id;
+        this.handle = raw.handle;
+        this.displayName = raw.display_name;
+        this.avatarUrl = raw.avatar_url;
+    }
+    /** Alias for `handle`, for discord.js familiarity. */
+    get username() { return this.handle; }
+}
+export class Message {
+    client;
+    id;
+    channelId;
+    content;
+    authorId;
+    createdAt;
+    editedAt;
+    parentId;
+    constructor(client, raw) {
+        this.client = client;
+        this.id = raw.id;
+        this.channelId = raw.channel_id;
+        this.content = raw.content ?? null;
+        this.authorId = raw.author_id;
+        this.createdAt = raw.created_at ?? null;
+        this.editedAt = raw.edited_at ?? null;
+        this.parentId = raw.parent_id ?? null;
+    }
+    /** True if this message was sent by the current bot. */
+    get authoredByMe() { return !!this.client.user && this.authorId === this.client.user.id; }
+    /** Reply to this message (threads it via replyTo). */
+    async reply(content) {
+        const { message } = await this.client.rest.post(`/channels/${this.channelId}/messages`, { content, replyTo: this.id });
+        return new Message(this.client, { ...message, content, author_id: this.client.user?.id ?? "" });
+    }
+    /** Edit this message (only the bot's own messages). */
+    async edit(content) {
+        await this.client.rest.patch(`/channels/${this.channelId}/messages/${this.id}`, { content });
+        this.content = content;
+        return this;
+    }
+    /** Delete this message. */
+    async delete() {
+        await this.client.rest.delete(`/channels/${this.channelId}/messages/${this.id}`);
+    }
+    /** Add a reaction from the bot. */
+    async react(emoji) {
+        await this.client.rest.put(`/channels/${this.channelId}/messages/${this.id}/reactions/${encodeURIComponent(emoji)}`);
+    }
+    /** Remove the bot's reaction. */
+    async removeReaction(emoji) {
+        await this.client.rest.delete(`/channels/${this.channelId}/messages/${this.id}/reactions/${encodeURIComponent(emoji)}`);
+    }
+}
+export class TextChannel {
+    client;
+    id;
+    constructor(client, id) {
+        this.client = client;
+        this.id = id;
+    }
+    /** Send a message to this channel. */
+    async send(content) {
+        const { message } = await this.client.rest.post(`/channels/${this.id}/messages`, { content });
+        return new Message(this.client, { ...message, content, author_id: this.client.user?.id ?? "" });
+    }
+    /** Fetch recent messages (oldest → newest), up to 100. */
+    async fetchMessages(limit = 50) {
+        const { messages } = await this.client.rest.get(`/channels/${this.id}/messages?limit=${limit}`);
+        return (messages ?? []).map((m) => new Message(this.client, m));
+    }
+}
+export class Interaction {
+    client;
+    commandName;
+    commandId;
+    spaceId;
+    channelId;
+    userId;
+    args;
+    constructor(client, raw) {
+        this.client = client;
+        this.commandName = raw.command;
+        this.commandId = raw.command_id;
+        this.spaceId = raw.space_id;
+        this.channelId = raw.channel_id;
+        this.userId = raw.user_id;
+        this.args = raw.args ?? {};
+    }
+    /** Respond to the command by posting a message in its channel. */
+    async reply(content) {
+        const { message } = await this.client.rest.post(`/channels/${this.channelId}/messages`, { content });
+        return new Message(this.client, { ...message, content, author_id: this.client.user?.id ?? "" });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+export interface ClientOptions {
+    /** The bot token from the Developer Portal → Bot tab (starts with `dbot_`). */
+    token: string;
+    /**
+     * The app's signing secret (starts with `dsk_`). Required only if you receive
+     * events via `client.listen()` / `client.middleware()` — it verifies the HMAC
+     * signature District sends on every event.
+     */
+    signingSecret?: string;
+    /** Override the API base URL. Defaults to District's hosted bot API. */
+    apiBase?: string;
+}
+/** Raw message shape as returned by the REST API / delivered in events. */
+export interface RawMessage {
+    id: string;
+    channel_id: string;
+    content: string | null;
+    author_id: string;
+    created_at?: string;
+    edited_at?: string | null;
+    parent_id?: string | null;
+}
+/** The bot's own identity (`GET /me`). */
+export interface RawSelfUser {
+    id: string;
+    handle: string;
+    display_name: string;
+    avatar_url: string | null;
+    is_bot: boolean;
+}
+export type DistrictEvent = {
+    event: "message.create";
+    space_id: string;
+    channel_id: string;
+    message: RawMessage;
+} | {
+    event: "message.update";
+    space_id: string;
+    channel_id: string;
+    message: RawMessage;
+} | {
+    event: "message.delete";
+    space_id: string;
+    channel_id: string;
+    message: {
+        id: string;
+    };
+} | {
+    event: "message.reaction_add";
+    space_id: string;
+    channel_id: string;
+    message_id: string;
+    user_id: string;
+    emoji: string;
+} | {
+    event: "message.reaction_remove";
+    space_id: string;
+    channel_id: string;
+    message_id: string;
+    user_id: string;
+    emoji: string;
+} | {
+    event: "interaction.create";
+    command: string;
+    command_id: string;
+    space_id: string;
+    channel_id: string;
+    user_id: string;
+    args: Record<string, unknown>;
+};
+export interface ReactionEvent {
+    spaceId: string;
+    channelId: string;
+    messageId: string;
+    userId: string;
+    emoji: string;
+}
+export interface DeletedMessage {
+    id: string;
+    channelId: string;
+    spaceId: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Shared types for district.js.
+export {};

package/dist/webhook.d.ts

@@ -0,0 +1,18 @@
+import type { DistrictEvent } from "./types.js";
+export interface EventHeaders {
+    "x-district-event"?: string;
+    "x-district-timestamp"?: string;
+    "x-district-signature"?: string;
+}
+/**
+ * Verify an event's HMAC-SHA256 signature. District signs `${timestamp}.${rawBody}`
+ * with your app's signing secret. Always call this before trusting a payload.
+ */
+export declare function verifySignature(secret: string, timestamp: string, rawBody: string, signature: string): boolean;
+/** Parse a verified raw body into a typed event. Throws on malformed JSON. */
+export declare function parseEvent(rawBody: string): DistrictEvent;
+/**
+ * Verify + parse in one step. Returns the event, or null if the signature is
+ * invalid (or the secret is missing).
+ */
+export declare function verifyAndParse(secret: string, headers: EventHeaders, rawBody: string): DistrictEvent | null;

package/dist/webhook.js

@@ -0,0 +1,37 @@
+// Verifying + parsing the signed events District POSTs to your endpoint.
+import crypto from "node:crypto";
+/**
+ * Verify an event's HMAC-SHA256 signature. District signs `${timestamp}.${rawBody}`
+ * with your app's signing secret. Always call this before trusting a payload.
+ */
+export function verifySignature(secret, timestamp, rawBody, signature) {
+    if (!secret || !timestamp || !signature)
+        return false;
+    const expected = crypto.createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest("hex");
+    try {
+        return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+    }
+    catch {
+        return false;
+    }
+}
+/** Parse a verified raw body into a typed event. Throws on malformed JSON. */
+export function parseEvent(rawBody) {
+    return JSON.parse(rawBody);
+}
+/**
+ * Verify + parse in one step. Returns the event, or null if the signature is
+ * invalid (or the secret is missing).
+ */
+export function verifyAndParse(secret, headers, rawBody) {
+    const ts = headers["x-district-timestamp"] ?? "";
+    const sig = headers["x-district-signature"] ?? "";
+    if (!verifySignature(secret, ts, rawBody, sig))
+        return null;
+    try {
+        return parseEvent(rawBody);
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "district.js",
+  "version": "0.1.0",
+  "description": "A powerful Node.js module for building District bots — post, react, run slash commands, and receive events.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "keywords": ["district", "bot", "api", "chat", "sdk"],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}