@1kbirds/chidori-mock-slack 0.1.0

package/README.md

@@ -0,0 +1,89 @@
+# @1kbirds/chidori-mock-slack
+
+In-memory Slack mock for agent testing. The package provides:
+
+- A deterministic in-memory workspace service.
+- A Slack Web API-like client facade.
+- A REST-style `/api/...` adapter.
+- A React Slack review UI.
+- Seed data for users, channels, direct messages, threads, reactions, and files.
+
+## Supported Surface
+
+Client methods:
+
+- `auth.test`
+- `users.list`
+- `users.info`
+- `conversations.list`
+- `conversations.info`
+- `conversations.join`
+- `conversations.history`
+- `conversations.replies`
+- `chat.postMessage`
+- `chat.update`
+- `chat.delete`
+- `reactions.add`
+- `reactions.remove`
+- `files.upload`
+- `search.messages`
+
+REST-style paths:
+
+- `POST|GET /api/auth.test`
+- `POST|GET /api/users.list`
+- `POST|GET /api/users.info`
+- `POST|GET /api/conversations.list`
+- `POST|GET /api/conversations.info`
+- `POST|GET /api/conversations.join`
+- `POST|GET /api/conversations.history`
+- `POST|GET /api/conversations.replies`
+- `POST /api/chat.postMessage`
+- `POST /api/chat.update`
+- `POST /api/chat.delete`
+- `POST /api/reactions.add`
+- `POST /api/reactions.remove`
+- `POST /api/files.upload`
+- `POST|GET /api/search.messages`
+
+## Search Support
+
+The first implementation supports common search terms:
+
+- Plain text across message text, channel name, and user name.
+- `in:channel`
+- `from:user`
+- `has:reaction`
+- `has:file`
+
+## Review
+
+Run verification:
+
+```sh
+npm run build
+npm test
+```
+
+Start the React review app:
+
+```sh
+npm run dev:slack
+```
+
+Then open `http://127.0.0.1:5176/`.
+
+Manual review should confirm:
+
+- Seeded users, channels, direct messages, messages, reactions, files, and threads render.
+- Posting a channel message updates history.
+- Posting a thread reply updates thread replies and reply counts.
+- Reactions can be added.
+- Messages can be deleted.
+- Mock file upload creates file metadata and a channel message.
+- Search filters the visible conversation.
+- Reset restores deterministic seeded state.
+
+## Fidelity Notes
+
+The mock intentionally keeps all state in memory. It focuses on common Slack workflows agents need to rehearse: listing channels/users, reading history, posting/updating/deleting messages, replying in threads, adding reactions, uploading file metadata, and searching messages. OAuth, Events API, Socket Mode, app manifests, granular permissions, enterprise grid, workflow builder, block kit rendering, and full search grammar are deferred.

package/dist/api.d.ts

@@ -0,0 +1,14 @@
+import { type SlackMock } from "./service";
+export interface SlackApiRequest {
+    method: "GET" | "POST";
+    path: string;
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    body?: Record<string, unknown>;
+}
+export interface SlackApiResponse<T = unknown> {
+    status: number;
+    headers: Record<string, string>;
+    body: T;
+}
+export declare function handleSlackApiRequest(mock: SlackMock, request: SlackApiRequest): SlackApiResponse;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAG5D,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,CAAC,CAAC;CACT;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,CAKjG"}

package/dist/api.js

@@ -0,0 +1,74 @@
+import { asSlackResponse } from "./service";
+export function handleSlackApiRequest(mock, request) {
+    const path = new URL(request.path, "https://slack.com").pathname.replace(/\/+$/, "");
+    const params = { ...(request.query ?? {}), ...(request.body ?? {}) };
+    const body = route(mock, path, params);
+    return { status: body && typeof body === "object" && "ok" in body && body.ok === false ? 200 : 200, headers: { "content-type": "application/json" }, body };
+}
+function route(mock, path, params) {
+    if (path === "/api/auth.test")
+        return asSlackResponse(() => mock.authTest());
+    if (path === "/api/users.list")
+        return asSlackResponse(() => mock.listUsers());
+    if (path === "/api/users.info")
+        return asSlackResponse(() => mock.infoUser(String(params.user)));
+    if (path === "/api/conversations.list")
+        return asSlackResponse(() => mock.listConversations({ types: stringParam(params.types), exclude_archived: boolParam(params.exclude_archived) }));
+    if (path === "/api/conversations.info")
+        return asSlackResponse(() => mock.infoConversation(String(params.channel)));
+    if (path === "/api/conversations.join")
+        return asSlackResponse(() => mock.joinConversation(String(params.channel)));
+    if (path === "/api/conversations.history")
+        return asSlackResponse(() => mock.history({
+            channel: String(params.channel),
+            latest: stringParam(params.latest),
+            oldest: stringParam(params.oldest),
+            inclusive: boolParam(params.inclusive),
+            limit: numberParam(params.limit),
+        }));
+    if (path === "/api/conversations.replies")
+        return asSlackResponse(() => mock.replies({ channel: String(params.channel), ts: String(params.ts), limit: numberParam(params.limit) }));
+    if (path === "/api/chat.postMessage")
+        return asSlackResponse(() => mock.postMessage(params));
+    if (path === "/api/chat.update")
+        return asSlackResponse(() => mock.updateMessage(String(params.channel), String(params.ts), String(params.text)));
+    if (path === "/api/chat.delete")
+        return asSlackResponse(() => mock.deleteMessage(String(params.channel), String(params.ts)));
+    if (path === "/api/reactions.add")
+        return asSlackResponse(() => mock.addReaction(String(params.channel), String(params.timestamp), String(params.name)));
+    if (path === "/api/reactions.remove")
+        return asSlackResponse(() => mock.removeReaction(String(params.channel), String(params.timestamp), String(params.name)));
+    if (path === "/api/files.upload")
+        return asSlackResponse(() => mock.uploadFile({
+            channels: arrayParam(params.channels),
+            filename: String(params.filename),
+            title: stringParam(params.title),
+            content: stringParam(params.content),
+            filetype: stringParam(params.filetype),
+            mimetype: stringParam(params.mimetype),
+        }));
+    if (path === "/api/search.messages")
+        return asSlackResponse(() => mock.searchMessages(String(params.query)));
+    return { ok: false, error: "unknown_method" };
+}
+function stringParam(value) {
+    return value === undefined ? undefined : String(value);
+}
+function boolParam(value) {
+    if (value === undefined)
+        return undefined;
+    return value === true || value === "true";
+}
+function numberParam(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function arrayParam(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === "string")
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    return [];
+}

package/dist/client.d.ts

@@ -0,0 +1,176 @@
+import { type SlackMock } from "./service";
+import type { SlackPostMessageRequest } from "./types";
+export declare function createSlackClient(mock: SlackMock): {
+    auth: {
+        test: () => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            url: string;
+            team: string;
+            user: string;
+            team_id: string;
+            user_id: string;
+        }>;
+    };
+    users: {
+        list: () => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            members: import("./types").SlackUser[];
+        }>;
+        info: ({ user }: {
+            user: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            user: import("./types").SlackUser;
+        }>;
+    };
+    conversations: {
+        list: (params?: {
+            types?: string;
+            exclude_archived?: boolean;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channels: import("./types").SlackChannel[];
+        }>;
+        info: ({ channel }: {
+            channel: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channel: import("./types").SlackChannel;
+        }>;
+        join: ({ channel }: {
+            channel: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channel: import("./types").SlackChannel;
+        }>;
+        history: (params: {
+            channel: string;
+            latest?: string;
+            oldest?: string;
+            inclusive?: boolean;
+            limit?: number;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            messages: import("./types").SlackMessage[];
+            has_more: boolean;
+        }>;
+        replies: (params: {
+            channel: string;
+            ts: string;
+            limit?: number;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            messages: import("./types").SlackMessage[];
+            has_more: boolean;
+        }>;
+    };
+    chat: {
+        postMessage: (params: SlackPostMessageRequest) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channel: string;
+            ts: string;
+            message: import("./types").SlackMessage;
+        }>;
+        update: ({ channel, ts, text }: {
+            channel: string;
+            ts: string;
+            text: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channel: string;
+            ts: string;
+            text: string;
+            message: import("./types").SlackMessage;
+        }>;
+        delete: ({ channel, ts }: {
+            channel: string;
+            ts: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            channel: string;
+            ts: string;
+        }>;
+    };
+    reactions: {
+        add: ({ channel, timestamp, name }: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+        }>;
+        remove: ({ channel, timestamp, name }: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+        }>;
+    };
+    files: {
+        upload: (params: {
+            channels: string[];
+            filename: string;
+            title?: string;
+            content?: string;
+            filetype?: string;
+            mimetype?: string;
+        }) => Promise<{
+            ok: false;
+            error: string;
+        } | {
+            ok: boolean;
+            file: import("./types").SlackFile;
+        }>;
+    };
+    search: {
+        messages: ({ query }: {
+            query: string;
+        }) => Promise<({
+            ok: true;
+        } & import("./types").SlackSearchResult) | {
+            ok: false;
+            error: string;
+        }>;
+    };
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;yBAOpB;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE;;;;;;;;;wBAGlB;YAAE,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;SAAE;;;;;;;4BACzC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE;;;;;;;4BACnB;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE;;;;;;;0BACrB;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,OAAO,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;0BAC1F;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;8BAG3C,uBAAuB;;;;;;;;;wCACb;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;kCACnD;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;4CAGrB;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE;;;;;;+CACjD;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE;;;;;;;;yBAG1E;YAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;8BAI3G;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE;;;;;;;EAGlD"}

package/dist/client.js

@@ -0,0 +1,34 @@
+import { asSlackResponse } from "./service";
+export function createSlackClient(mock) {
+    return {
+        auth: {
+            test: async () => asSlackResponse(() => mock.authTest()),
+        },
+        users: {
+            list: async () => asSlackResponse(() => mock.listUsers()),
+            info: async ({ user }) => asSlackResponse(() => mock.infoUser(user)),
+        },
+        conversations: {
+            list: async (params = {}) => asSlackResponse(() => mock.listConversations(params)),
+            info: async ({ channel }) => asSlackResponse(() => mock.infoConversation(channel)),
+            join: async ({ channel }) => asSlackResponse(() => mock.joinConversation(channel)),
+            history: async (params) => asSlackResponse(() => mock.history(params)),
+            replies: async (params) => asSlackResponse(() => mock.replies(params)),
+        },
+        chat: {
+            postMessage: async (params) => asSlackResponse(() => mock.postMessage(params)),
+            update: async ({ channel, ts, text }) => asSlackResponse(() => mock.updateMessage(channel, ts, text)),
+            delete: async ({ channel, ts }) => asSlackResponse(() => mock.deleteMessage(channel, ts)),
+        },
+        reactions: {
+            add: async ({ channel, timestamp, name }) => asSlackResponse(() => mock.addReaction(channel, timestamp, name)),
+            remove: async ({ channel, timestamp, name }) => asSlackResponse(() => mock.removeReaction(channel, timestamp, name)),
+        },
+        files: {
+            upload: async (params) => asSlackResponse(() => mock.uploadFile(params)),
+        },
+        search: {
+            messages: async ({ query }) => asSlackResponse(() => mock.searchMessages(query)),
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class SlackMockError extends Error {
+    readonly error: string;
+    constructor(error: string, message?: string);
+    toResponse(): {
+        ok: false;
+        error: string;
+    };
+}
+export declare function slackError(error: string, message?: string): SlackMockError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,MAAM,EAAE,OAAO,SAAQ;IAM1C,UAAU,IAAI;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;CAG3C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,cAAc,CAE1E"}

package/dist/errors.js

@@ -0,0 +1,14 @@
+export class SlackMockError extends Error {
+    error;
+    constructor(error, message = error) {
+        super(message);
+        this.name = "SlackMockError";
+        this.error = error;
+    }
+    toResponse() {
+        return { ok: false, error: this.error };
+    }
+}
+export function slackError(error, message) {
+    return new SlackMockError(error, message);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { handleSlackApiRequest } from "./api";
+export type { SlackApiRequest, SlackApiResponse } from "./api";
+export { createSlackClient } from "./client";
+export { SlackMockError } from "./errors";
+export { asSlackResponse, SlackMock } from "./service";
+import { SlackMock } from "./service";
+export { demoChannels, demoFiles, demoMessages, demoSeed, demoTeam, demoUsers } from "./seed";
+export type * from "./types";
+export declare function createSlackMock(...args: ConstructorParameters<typeof SlackMock>): SlackMock;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC9F,mBAAmB,SAAS,CAAC;AAE7B,wBAAgB,eAAe,CAAC,GAAG,IAAI,EAAE,qBAAqB,CAAC,OAAO,SAAS,CAAC,GAAG,SAAS,CAE3F"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { handleSlackApiRequest } from "./api";
+export { createSlackClient } from "./client";
+export { SlackMockError } from "./errors";
+export { asSlackResponse, SlackMock } from "./service";
+import { SlackMock } from "./service";
+export { demoChannels, demoFiles, demoMessages, demoSeed, demoTeam, demoUsers } from "./seed";
+export function createSlackMock(...args) {
+    return new SlackMock(...args);
+}

package/dist/seed.d.ts

@@ -0,0 +1,8 @@
+import type { SlackChannel, SlackFile, SlackMessage, SlackSeed, SlackTeam, SlackUser } from "./types";
+export declare const demoTeam: SlackTeam;
+export declare const demoUsers: SlackUser[];
+export declare const demoChannels: SlackChannel[];
+export declare const demoFiles: SlackFile[];
+export declare const demoMessages: SlackMessage[];
+export declare const demoSeed: SlackSeed;
+//# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEtG,eAAO,MAAM,QAAQ,EAAE,SAItB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,SAAS,EAwBhC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,YAAY,EA4CtC,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,SAAS,EAchC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,YAAY,EAkCtC,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,SAOtB,CAAC"}

package/dist/seed.js

@@ -0,0 +1,133 @@
+export const demoTeam = {
+    id: "TDEMO0001",
+    name: "Chidori Demo",
+    domain: "chidori-demo",
+};
+export const demoUsers = [
+    {
+        id: "UADA00001",
+        team_id: demoTeam.id,
+        name: "ada",
+        real_name: "Ada Lovelace",
+        is_admin: true,
+        profile: { email: "ada@example.com", display_name: "Ada", real_name: "Ada Lovelace" },
+    },
+    {
+        id: "UGRACE001",
+        team_id: demoTeam.id,
+        name: "grace",
+        real_name: "Grace Hopper",
+        profile: { email: "grace@example.com", display_name: "Grace", real_name: "Grace Hopper" },
+    },
+    {
+        id: "UBOT00001",
+        team_id: demoTeam.id,
+        name: "workflowbot",
+        real_name: "Workflow Bot",
+        is_bot: true,
+        profile: { display_name: "Workflow Bot", real_name: "Workflow Bot" },
+    },
+];
+export const demoChannels = [
+    {
+        id: "CGENERAL1",
+        name: "general",
+        is_channel: true,
+        is_private: false,
+        is_archived: false,
+        is_member: true,
+        created: 1780290000,
+        creator: "UADA00001",
+        topic: { value: "Company-wide announcements", creator: "UADA00001", last_set: 1780290000 },
+        purpose: { value: "Shared workspace discussion", creator: "UADA00001", last_set: 1780290000 },
+        num_members: 3,
+        members: ["UADA00001", "UGRACE001", "UBOT00001"],
+    },
+    {
+        id: "CPROJECT1",
+        name: "project-launch",
+        is_channel: true,
+        is_private: false,
+        is_archived: false,
+        is_member: true,
+        created: 1780290000,
+        creator: "UADA00001",
+        topic: { value: "Launch planning", creator: "UADA00001", last_set: 1780290000 },
+        purpose: { value: "Coordinate launch work", creator: "UADA00001", last_set: 1780290000 },
+        num_members: 2,
+        members: ["UADA00001", "UGRACE001"],
+    },
+    {
+        id: "DADA_GRACE",
+        name: "ada-grace",
+        is_channel: false,
+        is_im: true,
+        is_private: true,
+        is_archived: false,
+        is_member: true,
+        created: 1780290000,
+        creator: "UADA00001",
+        topic: { value: "" },
+        purpose: { value: "" },
+        num_members: 2,
+        members: ["UADA00001", "UGRACE001"],
+    },
+];
+export const demoFiles = [
+    {
+        id: "FBRIEF001",
+        created: 1780290100,
+        timestamp: 1780290100,
+        name: "launch-brief.txt",
+        title: "Launch Brief",
+        mimetype: "text/plain",
+        filetype: "text",
+        user: "UGRACE001",
+        size: 72,
+        content: "Launch brief fixture content",
+        url_private: "https://chidori-demo.slack.com/files/UGRACE001/FBRIEF001/launch-brief.txt",
+    },
+];
+export const demoMessages = [
+    {
+        type: "message",
+        channel: "CGENERAL1",
+        user: "UBOT00001",
+        username: "workflowbot",
+        text: "Daily workspace sync is ready.",
+        ts: "1780290050.000001",
+        reactions: [{ name: "white_check_mark", users: ["UADA00001"], count: 1 }],
+    },
+    {
+        type: "message",
+        channel: "CPROJECT1",
+        user: "UGRACE001",
+        text: "Can someone review the launch brief before we send it to the customer?",
+        ts: "1780290100.000001",
+        files: [demoFiles[0]],
+    },
+    {
+        type: "message",
+        channel: "CPROJECT1",
+        user: "UADA00001",
+        text: "I can review it this afternoon.",
+        ts: "1780290200.000001",
+        thread_ts: "1780290100.000001",
+        parent_user_id: "UGRACE001",
+    },
+    {
+        type: "message",
+        channel: "DADA_GRACE",
+        user: "UGRACE001",
+        text: "Thanks for handling the calendar invite.",
+        ts: "1780290300.000001",
+    },
+];
+export const demoSeed = {
+    team: demoTeam,
+    users: demoUsers,
+    channels: demoChannels,
+    messages: demoMessages,
+    files: demoFiles,
+    currentUserId: "UADA00001",
+};