paperclip-plugin-slack-socket 0.1.0

package/dist/manifest.js

@@ -0,0 +1,136 @@
+import { ASK_HUMAN_TOOL_DECLARATION, DEFAULT_CONFIG, JOB_KEYS, PLUGIN_ID, PLUGIN_VERSION, } from "./constants.js";
+const manifest = {
+    id: PLUGIN_ID,
+    apiVersion: 1,
+    version: PLUGIN_VERSION,
+    displayName: "Slack (Socket Mode)",
+    description: "Connect Slack over Socket Mode — no public URL required. Chat with a Paperclip agent in DMs and mentions, get configurable notifications, decide approvals with buttons, let agents ask humans questions, and create issues with /paperclip.",
+    author: "cvh",
+    categories: ["connector", "automation"],
+    capabilities: [
+        "issues.create",
+        "issue.comments.create",
+        "issues.wakeup",
+        "agent.sessions.create",
+        "agent.sessions.send",
+        "agent.sessions.close",
+        "agent.tools.register",
+        "http.outbound",
+        "events.subscribe",
+        "plugin.state.read",
+        "plugin.state.write",
+        "secrets.read-ref",
+        "instance.settings.register",
+        "activity.log.write",
+        "metrics.write",
+        "jobs.schedule",
+    ],
+    entrypoints: {
+        worker: "./dist/worker.js",
+    },
+    instanceConfigSchema: {
+        type: "object",
+        properties: {
+            slackBotTokenRef: {
+                type: "string",
+                format: "secret-ref",
+                title: "Slack Bot Token (secret reference)",
+                description: "Secret UUID holding your Slack Bot OAuth token (xoxb-…). Create the secret in Settings → Secrets, then paste its UUID here.",
+                default: DEFAULT_CONFIG.slackBotTokenRef,
+            },
+            slackAppTokenRef: {
+                type: "string",
+                format: "secret-ref",
+                title: "Slack App-Level Token (secret reference)",
+                description: "Secret UUID holding your Slack App-Level token (xapp-…) with the connections:write scope.",
+                default: DEFAULT_CONFIG.slackAppTokenRef,
+            },
+            companyId: {
+                type: "string",
+                title: "Company ID",
+                description: "Paperclip company UUID used for sessions, issues, and approvals.",
+                default: DEFAULT_CONFIG.companyId,
+            },
+            defaultAgentId: {
+                type: "string",
+                title: "Default Agent ID",
+                description: "Agent that handles DM and @mention conversations.",
+                default: DEFAULT_CONFIG.defaultAgentId,
+            },
+            defaultChannelId: {
+                type: "string",
+                title: "Default Slack Channel ID",
+                description: "Fallback channel for notifications (e.g. C01ABC2DEF3).",
+                default: DEFAULT_CONFIG.defaultChannelId,
+            },
+            notifyOnIssueCreated: {
+                type: "boolean",
+                title: "Notify on issue created",
+                default: DEFAULT_CONFIG.notifyOnIssueCreated,
+            },
+            notifyOnIssueDone: {
+                type: "boolean",
+                title: "Notify on issue completed",
+                default: DEFAULT_CONFIG.notifyOnIssueDone,
+            },
+            notifyOnAgentRunFailed: {
+                type: "boolean",
+                title: "Notify on agent run failure",
+                default: DEFAULT_CONFIG.notifyOnAgentRunFailed,
+            },
+            notifyOnApprovalCreated: {
+                type: "boolean",
+                title: "Notify on approval requested",
+                default: DEFAULT_CONFIG.notifyOnApprovalCreated,
+            },
+            issuesChannelId: {
+                type: "string",
+                title: "Issues Channel ID",
+                description: "Optional channel for issue notifications (falls back to default).",
+                default: DEFAULT_CONFIG.issuesChannelId,
+            },
+            errorsChannelId: {
+                type: "string",
+                title: "Errors Channel ID",
+                description: "Optional channel for agent failure notifications (falls back to default).",
+                default: DEFAULT_CONFIG.errorsChannelId,
+            },
+            approvalsChannelId: {
+                type: "string",
+                title: "Approvals Channel ID",
+                description: "Optional channel for approval notifications (falls back to default).",
+                default: DEFAULT_CONFIG.approvalsChannelId,
+            },
+            paperclipBaseUrl: {
+                type: "string",
+                title: "Paperclip Base URL",
+                description: "Base URL of your Paperclip instance. Load-bearing: used both to build dashboard links and as the target of the approval decision REST calls (POST {paperclipBaseUrl}/api/approvals/:id/approve|reject).",
+                default: DEFAULT_CONFIG.paperclipBaseUrl,
+            },
+            paperclipApiKeyRef: {
+                type: "string",
+                format: "secret-ref",
+                title: "Paperclip Board API Key (secret reference)",
+                description: "Secret reference holding a Paperclip API key for a board-role user, sent as an Authorization: Bearer header on approval decision requests. Leave empty for local_trusted deployments, where every request is implicitly authenticated as board and no header is needed. Required for authenticated deployments so approval decisions (Approve/Reject button clicks) authenticate as a board user.",
+                default: DEFAULT_CONFIG.paperclipApiKeyRef,
+            },
+            sessionIdleHours: {
+                type: "number",
+                title: "Session Idle Hours",
+                description: "Close agent sessions idle longer than this many hours.",
+                default: DEFAULT_CONFIG.sessionIdleHours,
+            },
+        },
+        required: ["slackBotTokenRef", "slackAppTokenRef", "companyId", "defaultAgentId", "defaultChannelId"],
+    },
+    jobs: [
+        {
+            jobKey: JOB_KEYS.cleanup,
+            displayName: "Cleanup idle sessions and expired questions",
+            description: "Closes agent sessions idle beyond the configured TTL and expires unanswered ask-human questions.",
+            schedule: "*/15 * * * *",
+        },
+    ],
+    tools: [ASK_HUMAN_TOOL_DECLARATION],
+};
+export default manifest;

package/dist/mrkdwn.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts Markdown text to Slack mrkdwn. Fenced (```…```) and inline
+ * (`…`) code spans are stashed before any other conversion and restored
+ * verbatim at the end, so Markdown-looking text inside code is never touched.
+ */
+export declare function markdownToMrkdwn(text: string): string;

package/dist/notifications.d.ts

@@ -0,0 +1,8 @@
+import type { PluginContext } from "@paperclipai/plugin-sdk";
+import type { SlackGateway, SlackSocketConfig } from "./types.js";
+export interface NotificationDeps {
+    ctx: PluginContext;
+    gateway: SlackGateway;
+    getConfig: () => Promise<SlackSocketConfig>;
+}
+export declare function registerNotifications({ ctx, gateway, getConfig }: NotificationDeps): void;

package/dist/notifications.js

@@ -0,0 +1,75 @@
+import { STATE_KEYS, stateScope } from "./constants.js";
+import { formatAgentRunFailed, formatIssueCreated, formatIssueDone } from "./formatters.js";
+import { errString } from "./redact.js";
+import { updateIndex } from "./state-index.js";
+export function registerNotifications({ ctx, gateway, getConfig }) {
+    const post = async (channel, content, type, threadTs) => {
+        try {
+            const posted = await gateway.postMessage({ channel, ...content, threadTs });
+            await ctx.metrics.write("slack.notifications.sent", 1, { type }).catch(() => { });
+            return posted;
+        }
+        catch (err) {
+            ctx.logger.warn("Slack notification failed", { err: errString(err), channel });
+            await ctx.metrics.write("slack.notifications.failed", 1, { type }).catch(() => { });
+            return null;
+        }
+    };
+    ctx.events.on("issue.created", async (event) => {
+        const e = event;
+        const cfg = await getConfig();
+        if (!cfg.notifyOnIssueCreated)
+            return;
+        const channel = cfg.issuesChannelId || cfg.defaultChannelId;
+        if (!channel)
+            return;
+        const issueId = e.entityId ?? "";
+        const posted = await post(channel, formatIssueCreated(e.payload, issueId, cfg.paperclipBaseUrl), "issue_created");
+        if (posted && issueId) {
+            const key = STATE_KEYS.issueThread(issueId);
+            const entry = {
+                channel: posted.channel,
+                ts: posted.ts,
+                createdAt: new Date().toISOString(),
+            };
+            await ctx.state.set(stateScope(key), entry);
+            await updateIndex(ctx, STATE_KEYS.issueThreadIndex, (current) => current.includes(key) ? current : [...current, key]);
+        }
+    });
+    ctx.events.on("issue.updated", async (event) => {
+        const e = event;
+        const cfg = await getConfig();
+        if (!cfg.notifyOnIssueDone)
+            return;
+        const payload = e.payload;
+        if (payload?.status !== "done")
+            return;
+        const channel = cfg.issuesChannelId || cfg.defaultChannelId;
+        if (!channel)
+            return;
+        const issueId = e.entityId ?? "";
+        const key = issueId ? STATE_KEYS.issueThread(issueId) : null;
+        const entry = key ? (await ctx.state.get(stateScope(key))) : null;
+        if (entry && key && entry.channel === channel) {
+            // Post the completion notice as a threaded reply on the original
+            // "issue created" message, then the link is no longer needed — the
+            // issue is finished.
+            await post(channel, formatIssueDone(payload, issueId, cfg.paperclipBaseUrl), "issue_done", entry.ts);
+            await ctx.state.delete(stateScope(key));
+            await updateIndex(ctx, STATE_KEYS.issueThreadIndex, (current) => current.filter((k) => k !== key));
+        }
+        else {
+            await post(channel, formatIssueDone(payload, issueId, cfg.paperclipBaseUrl), "issue_done");
+        }
+    });
+    ctx.events.on("agent.run.failed", async (event) => {
+        const e = event;
+        const cfg = await getConfig();
+        if (!cfg.notifyOnAgentRunFailed)
+            return;
+        const channel = cfg.errorsChannelId || cfg.defaultChannelId;
+        if (!channel)
+            return;
+        await post(channel, formatAgentRunFailed(e.payload), "agent_run_failed");
+    });
+}

package/dist/redact.d.ts

@@ -0,0 +1,3 @@
+export declare function redactSecrets(s: string): string;
+/** String(err), with any Slack tokens in the result redacted. */
+export declare function errString(err: unknown): string;

package/dist/redact.js

@@ -0,0 +1,13 @@
+// Log-redaction safety net: Slack bot/app tokens should never reach logs in
+// the first place, but errors thrown by the Slack SDK sometimes echo back
+// request details (including a token) in their message. Scrub known Slack
+// token shapes before any error ever reaches a logger call.
+const BOT_TOKEN_PATTERN = /xox[a-z]-[A-Za-z0-9-]+/gi;
+const APP_TOKEN_PATTERN = /xapp-[A-Za-z0-9-]+/gi;
+export function redactSecrets(s) {
+    return s.replace(BOT_TOKEN_PATTERN, "[REDACTED]").replace(APP_TOKEN_PATTERN, "[REDACTED]");
+}
+/** String(err), with any Slack tokens in the result redacted. */
+export function errString(err) {
+    return redactSecrets(String(err));
+}

package/dist/state-index.d.ts

@@ -0,0 +1,8 @@
+import type { PluginContext } from "@paperclipai/plugin-sdk";
+/**
+ * Atomically (within this process) reads the string[] index stored at
+ * `indexKey`, applies `updater` to it, writes the result back, and returns
+ * it. Concurrent calls for the same `indexKey` are serialized so none of
+ * them observe a stale pre-update value.
+ */
+export declare function updateIndex(ctx: PluginContext, indexKey: string, updater: (current: string[]) => string[]): Promise<string[]>;

package/dist/state-index.js

@@ -0,0 +1,23 @@
+import { stateScope } from "./constants.js";
+// Per-process chain of pending updates, keyed by the index's state key. Each
+// call is appended to the chain for its key so updates run strictly in
+// order: read current -> derive next -> write next, with no interleaving.
+const chains = new Map();
+/**
+ * Atomically (within this process) reads the string[] index stored at
+ * `indexKey`, applies `updater` to it, writes the result back, and returns
+ * it. Concurrent calls for the same `indexKey` are serialized so none of
+ * them observe a stale pre-update value.
+ */
+export async function updateIndex(ctx, indexKey, updater) {
+    const previous = chains.get(indexKey) ?? Promise.resolve();
+    let result;
+    const next = previous.catch(() => { }).then(async () => {
+        const current = (await ctx.state.get(stateScope(indexKey))) ?? [];
+        result = updater(current);
+        await ctx.state.set(stateScope(indexKey), result);
+    });
+    chains.set(indexKey, next);
+    await next;
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,103 @@
+import type { EnvSecretRefBinding } from "@paperclipai/plugin-sdk";
+export type SecretRef = string | EnvSecretRefBinding;
+export interface SlackSocketConfig {
+    slackBotTokenRef: SecretRef;
+    slackAppTokenRef: SecretRef;
+    paperclipApiKeyRef: SecretRef;
+    companyId: string;
+    defaultAgentId: string;
+    defaultChannelId: string;
+    notifyOnIssueCreated: boolean;
+    notifyOnIssueDone: boolean;
+    notifyOnAgentRunFailed: boolean;
+    notifyOnApprovalCreated: boolean;
+    issuesChannelId: string;
+    errorsChannelId: string;
+    approvalsChannelId: string;
+    paperclipBaseUrl: string;
+    sessionIdleHours: number;
+}
+export interface SessionEntry {
+    sessionId: string;
+    channel: string;
+    threadTs: string;
+    lastActivityAt: string;
+}
+export interface IssueThreadEntry {
+    channel: string;
+    ts: string;
+    createdAt: string;
+}
+export type QuestionMode = "reaction" | "answer";
+export interface PendingQuestion {
+    channel: string;
+    ts: string;
+    issueId: string;
+    companyId: string;
+    mode: QuestionMode;
+    question: string;
+    askedAt: string;
+    timeoutMinutes: number;
+}
+export interface InboundMessage {
+    channel: string;
+    channelType: "im" | "channel" | "group";
+    user: string;
+    text: string;
+    ts: string;
+    threadTs?: string;
+}
+export interface InboundReaction {
+    channel: string;
+    messageTs: string;
+    user: string;
+    reaction: string;
+}
+export interface InboundAction {
+    actionId: string;
+    value: string;
+    user: string;
+    userName: string;
+    channel: string;
+    messageTs: string;
+}
+export interface InboundCommand {
+    command: string;
+    text: string;
+    user: string;
+    channel: string;
+}
+export interface OutboundMessage {
+    channel: string;
+    text: string;
+    blocks?: unknown[];
+    threadTs?: string;
+}
+export interface SlackGateway {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isConnected(): boolean;
+    botUserId(): string | undefined;
+    postMessage(msg: OutboundMessage): Promise<{
+        channel: string;
+        ts: string;
+    }>;
+    updateMessage(msg: {
+        channel: string;
+        ts: string;
+        text: string;
+        blocks?: unknown[];
+    }): Promise<void>;
+    postEphemeral(msg: {
+        channel: string;
+        user: string;
+        text: string;
+    }): Promise<void>;
+    openDm(userId: string): Promise<string>;
+    getUserDisplayName(userId: string): Promise<string>;
+    onMessage(handler: (msg: InboundMessage) => Promise<void>): void;
+    onMention(handler: (msg: InboundMessage) => Promise<void>): void;
+    onReaction(handler: (reaction: InboundReaction) => Promise<void>): void;
+    onAction(pattern: RegExp, handler: (action: InboundAction) => Promise<void>): void;
+    onCommand(command: string, handler: (cmd: InboundCommand) => Promise<void>): void;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Shared types for the Slack Socket Mode plugin.
+export {};

package/dist/worker.d.ts

@@ -0,0 +1,12 @@
+import { type PluginContext, type PluginHealthDiagnostics } from "@paperclipai/plugin-sdk";
+import type { SlackGateway } from "./types.js";
+export type GatewayFactory = (opts: {
+    botToken: string;
+    appToken: string;
+}) => SlackGateway;
+type Health = PluginHealthDiagnostics & {
+    message?: string;
+};
+export declare function startRuntime(ctx: PluginContext, makeGateway: GatewayFactory): Promise<Health>;
+declare const plugin: import("@paperclipai/plugin-sdk").PaperclipPlugin;
+export default plugin;

package/dist/worker.js

@@ -0,0 +1,144 @@
+import { definePlugin, runWorker, } from "@paperclipai/plugin-sdk";
+import { createApprovals } from "./approvals.js";
+import { createAskHuman } from "./ask-human.js";
+import { BoltGateway } from "./bolt-gateway.js";
+import { createChat } from "./chat.js";
+import { runCleanup } from "./cleanup.js";
+import { createCommands } from "./commands.js";
+import { loadConfig } from "./config.js";
+import { DEFAULT_CONFIG, JOB_KEYS, SLASH_COMMAND } from "./constants.js";
+import { createEventDeduper } from "./event-dedup.js";
+import { registerNotifications } from "./notifications.js";
+import { errString } from "./redact.js";
+const REQUIRED_FIELDS = ["slackBotTokenRef", "slackAppTokenRef", "companyId", "defaultAgentId"];
+let health = { status: "ok" };
+let gateway = null;
+let lastCtx = null;
+export async function startRuntime(ctx, makeGateway) {
+    const cfg = await loadConfig(ctx);
+    const missing = REQUIRED_FIELDS.filter((field) => !cfg[field]);
+    if (missing.length > 0) {
+        health = { status: "degraded", message: `Slack Socket plugin not configured: missing ${missing.join(", ")}` };
+        ctx.logger.warn("Slack Socket plugin not configured; runtime disabled", { missing });
+        return health;
+    }
+    let botToken;
+    let appToken;
+    try {
+        botToken = await ctx.secrets.resolve(cfg.slackBotTokenRef);
+        appToken = await ctx.secrets.resolve(cfg.slackAppTokenRef);
+    }
+    catch (err) {
+        health = { status: "degraded", message: "Failed to resolve Slack token secrets; check the secret references" };
+        ctx.logger.error("Slack token secret resolution failed", { err: errString(err) });
+        return health;
+    }
+    gateway = makeGateway({ botToken, appToken });
+    const getConfig = () => loadConfig(ctx);
+    const chat = createChat({ ctx, gateway, getConfig });
+    const askHuman = createAskHuman({ ctx, gateway });
+    const approvals = createApprovals({ ctx, gateway, getConfig });
+    const commands = createCommands({ ctx, gateway, getConfig });
+    registerNotifications({ ctx, gateway, getConfig });
+    askHuman.registerTool();
+    // Slack Socket Mode redelivers events at-least-once, and a reconnect can
+    // replay a backlog of stale events. Dedupe/stale-filter mention and
+    // message dispatch before it reaches ask-human's answer routing or chat —
+    // reactions, actions, and commands are not deduped (they're not prone to
+    // the same at-least-once redelivery pattern here and are already
+    // effectively idempotent or externally acked). Keys are namespaced by
+    // event type ("mention:"/"message:") because a single channel @mention
+    // arrives as two distinct Slack events sharing the same ts (app_mention +
+    // message.channels) — without the prefix, consuming one event's key would
+    // shadow the other's and silently drop it as a "duplicate".
+    const eventDeduper = createEventDeduper();
+    gateway.onMention(async (msg) => {
+        if (!eventDeduper.shouldProcess(`mention:${msg.channel}:${msg.ts}`))
+            return;
+        await chat.handleMention(msg);
+    });
+    gateway.onMessage(async (msg) => {
+        if (!eventDeduper.shouldProcess(`message:${msg.channel}:${msg.ts}`))
+            return;
+        if (await askHuman.tryHandleAnswer(msg))
+            return;
+        await chat.handleMessage(msg);
+    });
+    gateway.onReaction((reaction) => askHuman.handleReaction(reaction));
+    gateway.onAction(/^approval_(approve|reject)$/, (action) => approvals.handleAction(action));
+    gateway.onCommand(SLASH_COMMAND, (cmd) => commands.handleCommand(cmd));
+    ctx.jobs.register(JOB_KEYS.cleanup, async () => {
+        if (!gateway)
+            return;
+        await runCleanup(ctx, gateway, await loadConfig(ctx));
+    });
+    await gateway.start();
+    health = { status: "ok" };
+    ctx.logger.info("Slack Socket Mode connected");
+    return health;
+}
+const plugin = definePlugin({
+    async setup(ctx) {
+        lastCtx = ctx;
+        try {
+            await startRuntime(ctx, (opts) => new BoltGateway({ ...opts, logger: ctx.logger }));
+        }
+        catch (err) {
+            health = { status: "degraded", message: `Slack Socket startup failed: ${errString(err)}` };
+            ctx.logger.error("Slack Socket startup failed", { err: errString(err) });
+        }
+    },
+    async onShutdown() {
+        await gateway?.stop().catch(() => { });
+    },
+    async onHealth() {
+        if (health.status !== "ok")
+            return health;
+        if (gateway && !gateway.isConnected()) {
+            return { status: "degraded", message: "Slack Socket Mode disconnected; Bolt is reconnecting" };
+        }
+        return { status: "ok" };
+    },
+    async onValidateConfig(config) {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        const errors = [];
+        for (const field of [...REQUIRED_FIELDS, "defaultChannelId"]) {
+            if (!cfg[field])
+                errors.push(`${field} is required`);
+        }
+        if (errors.length > 0)
+            return { ok: false, errors };
+        if (!lastCtx) {
+            return { ok: false, errors: ["Validation unavailable: plugin context not initialized"] };
+        }
+        let WebClient;
+        try {
+            ({ WebClient } = await import("@slack/web-api"));
+        }
+        catch (err) {
+            errors.push(`Validation unavailable: ${errString(err)}`);
+            return { ok: false, errors };
+        }
+        try {
+            const botToken = await lastCtx.secrets.resolve(cfg.slackBotTokenRef);
+            const auth = await new WebClient(botToken).auth.test();
+            if (!auth.ok)
+                errors.push("Slack auth.test failed for the bot token");
+        }
+        catch (err) {
+            errors.push(`Bot token check failed: ${errString(err)}`);
+        }
+        try {
+            const appToken = await lastCtx.secrets.resolve(cfg.slackAppTokenRef);
+            const conn = await new WebClient(appToken).apps.connections.open();
+            if (!conn.ok)
+                errors.push("apps.connections.open failed for the app token (needs connections:write)");
+        }
+        catch (err) {
+            errors.push(`App token check failed: ${errString(err)}`);
+        }
+        return { ok: errors.length === 0, errors };
+    },
+});
+export default plugin;
+runWorker(plugin, import.meta.url);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "paperclip-plugin-slack-socket",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Slack Socket Mode plugin for Paperclip: agent chat, notifications, approvals, ask-human tool. No public URL required.",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@slack/bolt": "^5.0.0",
+    "@slack/web-api": "^8.0.0"
+  },
+  "peerDependencies": {
+    "@paperclipai/plugin-sdk": "*"
+  },
+  "devDependencies": {
+    "@paperclipai/plugin-sdk": "2026.722.0",
+    "@types/node": "^25.5.2",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.6"
+  },
+  "files": ["dist/", "slack-app-manifest.json"],
+  "paperclipPlugin": {
+    "manifest": "./dist/manifest.js",
+    "worker": "./dist/worker.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xCVH/paperclip-plugin-slack-socket.git"
+  },
+  "bugs": {
+    "url": "https://github.com/0xCVH/paperclip-plugin-slack-socket/issues"
+  },
+  "homepage": "https://github.com/0xCVH/paperclip-plugin-slack-socket#readme",
+  "author": "0xCVH",
+  "license": "MIT"
+}

package/slack-app-manifest.json

@@ -0,0 +1,54 @@
+{
+  "display_information": {
+    "name": "Paperclip",
+    "description": "Chat with your Paperclip agents from Slack",
+    "background_color": "#1f2430"
+  },
+  "features": {
+    "bot_user": {
+      "display_name": "paperclip",
+      "always_online": true
+    },
+    "slash_commands": [
+      {
+        "command": "/paperclip",
+        "description": "Paperclip commands",
+        "usage_hint": "issue <title> | help",
+        "should_escape": false
+      }
+    ]
+  },
+  "oauth_config": {
+    "scopes": {
+      "bot": [
+        "app_mentions:read",
+        "chat:write",
+        "channels:history",
+        "groups:history",
+        "im:history",
+        "im:read",
+        "im:write",
+        "reactions:read",
+        "users:read",
+        "commands"
+      ]
+    }
+  },
+  "settings": {
+    "event_subscriptions": {
+      "bot_events": [
+        "app_mention",
+        "message.channels",
+        "message.groups",
+        "message.im",
+        "reaction_added"
+      ]
+    },
+    "interactivity": {
+      "is_enabled": true
+    },
+    "org_deploy_enabled": false,
+    "socket_mode_enabled": true,
+    "token_rotation_enabled": false
+  }
+}