commune-ai 0.1.0

package/README.md

@@ -0,0 +1,245 @@
+# commune-ai
+
+**Email infrastructure for AI agents**
+
+Build agents that receive emails, reply in threads, access conversation history, and search across all organizational emails. Most teams get their first agent responding in **~15 minutes**.
+
+## What you get
+
+1. **Webhook Integration** - Receive emails instantly as structured data
+2. **Thread-aware Replies** - Reply in email conversations with full context
+3. **User History** - Access complete conversation history per user
+4. **Organization Search** - Semantic search across all emails (coming soon)
+
+> By default, the SDK talks to the hosted Commune API. If you self‑host,
+> pass `baseUrl` to the client.
+
+---
+
+## Install
+```bash
+npm install commune-ai
+# or
+yarn add commune-ai
+# or
+pnpm add commune-ai
+```
+
+---
+
+## Receive emails instantly
+
+Get emails delivered to your agent as structured webhook data.
+
+```ts
+import express from "express";
+import { CommuneClient, createWebhookHandler } from "commune-ai";
+
+const client = new CommuneClient({
+  apiKey: process.env.COMMUNE_API_KEY,
+});
+
+const handler = createWebhookHandler({
+  onEvent: async (message, context) => {
+    // Every email arrives as structured data:
+    // message = {
+    //   channel: "email",
+    //   conversation_id: "thread_id",
+    //   participants: [{ role: "sender", identity: "user@example.com" }],
+    //   content: "Can you help with pricing?",
+    //   metadata: { subject: "Pricing Question", ... }
+    // }
+
+    console.log(`New email: ${message.content}`);
+
+    // Your agent logic here
+    const reply = `Thanks for your email! I'll help with that.`;
+
+    // Reply in the same email thread
+    const sender = message.participants.find(p => p.role === "sender")?.identity;
+    if (sender) {
+      await client.messages.send({
+        to: sender,
+        text: reply,
+        conversation_id: message.conversation_id,
+        domainId: context.payload.domainId,
+        inboxId: context.payload.inboxId,
+      });
+    }
+  },
+});
+
+const app = express();
+app.post("/webhook", express.raw({ type: "*/*" }), handler);
+app.listen(3000, () => console.log("Agent listening on :3000"));
+```
+
+**Email structure:**
+```ts
+interface UnifiedMessage {
+  channel: "email";
+  message_id: string;
+  conversation_id: string; // email thread ID
+  participants: Array<{
+    role: "sender" | "to" | "cc" | "bcc";
+    identity: string; // email address
+  }>;
+  content: string;
+  content_html?: string;
+  metadata: {
+    subject?: string;
+    created_at: string;
+    // ... more email metadata
+  };
+}
+```
+
+---
+
+## Reply in email threads
+
+Keep conversations organized by replying in the same email thread.
+
+```ts
+import express from "express";
+import { CommuneClient, createWebhookHandler } from "commune-ai";
+
+const client = new CommuneClient({
+  apiKey: process.env.COMMUNE_API_KEY,
+});
+
+const handler = createWebhookHandler({
+  onEvent: async (message, context) => {
+    const sender = message.participants.find(p => p.role === "sender")?.identity;
+    if (!sender) return;
+
+    // Reply maintains the email thread
+    await client.messages.send({
+      to: sender,
+      text: "Thanks for your question! Here's what I can help with...",
+      conversation_id: message.conversation_id, // keeps it in thread
+      subject: `Re: ${message.metadata.subject}`, // thread subject
+      domainId: context.payload.domainId,
+      inboxId: context.payload.inboxId,
+    });
+  },
+});
+
+const app = express();
+app.post("/webhook", express.raw({ type: "*/*" }), handler);
+app.listen(3000);
+```
+
+---
+
+---
+
+## Access conversation history
+
+Give your agent full context by accessing different types of email history.
+
+```ts
+import { CommuneClient } from "commune-ai";
+const client = new CommuneClient({
+  apiKey: process.env.COMMUNE_API_KEY,
+});
+
+// 1) Thread history - all messages in current conversation
+const threadMessages = await client.messages.listByConversation(
+  message.conversation_id,
+  { order: "asc", limit: 20 }
+);
+
+// 2) User history - all emails from/to a specific person
+const userEmails = await client.messages.list({
+  sender: "customer@example.com",
+  limit: 50,
+  order: "desc", // newest first
+});
+
+// 3) Inbox history - all emails in your domain
+const inboxEmails = await client.messages.list({
+  inbox_id: "inbox_123",
+  limit: 100,
+});
+
+// 4) Organization search - semantic search across all emails (coming soon)
+const searchResults = await client.search({
+  query: "pricing questions from last week",
+  limit: 10,
+  threshold: 0.8,
+});
+
+console.log(`Found ${searchResults.length} relevant emails`);
+for (const result of searchResults) {
+  console.log(`Match (${result.similarity.toFixed(2)}): ${result.message.content}`);
+}
+```
+
+---
+
+## Complete agent example
+
+A production-ready agent that receives emails, accesses conversation history, and provides contextual responses.
+
+```ts
+import "dotenv/config";
+import express from "express";
+import { CommuneClient, createWebhookHandler } from "commune-ai";
+
+const client = new CommuneClient({
+  apiKey: process.env.COMMUNE_API_KEY,
+});
+
+const handler = createWebhookHandler({
+  onEvent: async (message, context) => {
+    const sender = message.participants.find(p => p.role === "sender")?.identity;
+    if (!sender) return;
+
+    // Get conversation history for context
+    const threadHistory = await client.messages.listByConversation(
+      message.conversation_id,
+      { order: "asc", limit: 10 }
+    );
+
+    // Get user's full email history
+    const userHistory = await client.messages.list({
+      sender,
+      limit: 20,
+      order: "desc",
+    });
+
+    // Analyze the conversation
+    const isFollowUp = threadHistory.length > 1;
+    const userEmailCount = userHistory.length;
+
+    // Generate contextual response
+    let response = "";
+    if (isFollowUp) {
+      response = `Welcome back! I see this is a follow-up to our conversation. `;
+    } else if (userEmailCount > 1) {
+      response = `I see you've emailed us before. `;
+    }
+
+    response += `Regarding "${message.content.substring(0, 50)}..." - I'll help you with that.`;
+
+    // Send contextual reply
+    await client.messages.send({
+      to: sender,
+      text: response,
+      conversation_id: message.conversation_id,
+      subject: `Re: ${message.metadata.subject}`,
+      domainId: context.payload.domainId,
+      inboxId: context.payload.inboxId,
+    });
+  },
+});
+
+const app = express();
+app.post("/webhook", express.raw({ type: "*/*" }), handler);
+
+// Health check endpoint
+app.get("/health", (req, res) => res.json({ status: "ok" }));
+
+app.listen(3000, () => console.log("Agent running on port 3000"));
+```

package/dist/client.d.ts

@@ -0,0 +1,59 @@
+import type { AttachmentRecord, ConversationListParams, CreateDomainPayload, DomainEntry, InboxEntry, MessageListParams, SemanticSearchParams, SemanticSearchResult, SendMessagePayload, UnifiedMessage } from './types.js';
+export type ClientOptions = {
+    baseUrl?: string;
+    apiKey: string;
+    headers?: Record<string, string>;
+    fetcher?: typeof fetch;
+};
+export declare class CommuneClient {
+    private baseUrl;
+    private apiKey;
+    private headers?;
+    private fetcher;
+    constructor(options: ClientOptions);
+    private request;
+    domains: {
+        list: () => Promise<DomainEntry[]>;
+        create: (payload: CreateDomainPayload) => Promise<Record<string, unknown>>;
+        get: (domainId: string) => Promise<Record<string, unknown>>;
+        verify: (domainId: string) => Promise<Record<string, unknown>>;
+        records: (domainId: string) => Promise<unknown[]>;
+        status: (domainId: string) => Promise<Record<string, unknown>>;
+        createWebhook: (domainId: string, payload?: {
+            endpoint?: string;
+            events?: string[];
+        }) => Promise<Record<string, unknown>>;
+        saveWebhookSecret: (domainId: string, secret: string) => Promise<Record<string, unknown>>;
+    };
+    inboxes: {
+        list: (domainId: string) => Promise<InboxEntry[]>;
+        create: (domainId: string, payload: {
+            localPart: string;
+            agent?: InboxEntry["agent"];
+            webhook?: InboxEntry["webhook"];
+            status?: string;
+        }) => Promise<InboxEntry>;
+        update: (domainId: string, inboxId: string, payload: {
+            localPart?: string;
+            agent?: InboxEntry["agent"];
+            webhook?: InboxEntry["webhook"];
+            status?: string;
+        }) => Promise<InboxEntry>;
+        remove: (domainId: string, inboxId: string) => Promise<{
+            ok: boolean;
+        }>;
+        setWebhook: (domainId: string, inboxId: string, payload: {
+            endpoint: string;
+            events?: string[];
+        }) => Promise<InboxEntry>;
+    };
+    messages: {
+        send: (payload: SendMessagePayload) => Promise<Record<string, unknown>>;
+        list: (params: MessageListParams) => Promise<UnifiedMessage[]>;
+        listByConversation: (conversationId: string, params?: ConversationListParams) => Promise<UnifiedMessage[]>;
+    };
+    search: (params: SemanticSearchParams) => Promise<SemanticSearchResult[]>;
+    attachments: {
+        get: (attachmentId: string) => Promise<AttachmentRecord>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,153 @@
+const DEFAULT_BASE_URL = 'https://web-production-3f46f.up.railway.app';
+const buildQuery = (params) => {
+    const query = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+        if (value === undefined || value === null || value === '') {
+            return;
+        }
+        query.set(key, String(value));
+    });
+    const serialized = query.toString();
+    return serialized ? `?${serialized}` : '';
+};
+export class CommuneClient {
+    constructor(options) {
+        this.domains = {
+            list: async () => {
+                const response = await this.request(`/api/domains`);
+                if (Array.isArray(response)) {
+                    return response;
+                }
+                return Array.isArray(response.data) ? response.data : [];
+            },
+            create: async (payload) => {
+                return this.request(`/api/domains`, {
+                    method: 'POST',
+                    json: payload,
+                });
+            },
+            get: async (domainId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}`);
+            },
+            verify: async (domainId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/verify`, { method: 'POST' });
+            },
+            records: async (domainId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/records`);
+            },
+            status: async (domainId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/status`);
+            },
+            createWebhook: async (domainId, payload) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/webhook`, {
+                    method: 'POST',
+                    json: payload,
+                });
+            },
+            saveWebhookSecret: async (domainId, secret) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/webhook/secret`, { method: 'POST', json: { secret } });
+            },
+        };
+        this.inboxes = {
+            list: async (domainId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/inboxes`);
+            },
+            create: async (domainId, payload) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/inboxes`, {
+                    method: 'POST',
+                    json: payload,
+                });
+            },
+            update: async (domainId, inboxId, payload) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/inboxes/${encodeURIComponent(inboxId)}`, {
+                    method: 'PUT',
+                    json: payload,
+                });
+            },
+            remove: async (domainId, inboxId) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/inboxes/${encodeURIComponent(inboxId)}`, { method: 'DELETE' });
+            },
+            setWebhook: async (domainId, inboxId, payload) => {
+                return this.request(`/api/domains/${encodeURIComponent(domainId)}/inboxes/${encodeURIComponent(inboxId)}/webhook`, { method: 'POST', json: payload });
+            },
+        };
+        this.messages = {
+            send: async (payload) => {
+                // Always send as email (Slack support coming soon)
+                const emailPayload = { ...payload, channel: 'email' };
+                return this.request('/api/messages/send', {
+                    method: 'POST',
+                    json: emailPayload,
+                });
+            },
+            list: async (params) => {
+                return this.request(`/api/messages${buildQuery({
+                    sender: params.sender,
+                    channel: params.channel,
+                    before: params.before,
+                    after: params.after,
+                    limit: params.limit,
+                    order: params.order,
+                    domain_id: params.domain_id,
+                    inbox_id: params.inbox_id,
+                })}`);
+            },
+            listByConversation: async (conversationId, params = {}) => {
+                return this.request(`/api/conversations/${encodeURIComponent(conversationId)}/messages${buildQuery({
+                    limit: params.limit,
+                    order: params.order,
+                })}`);
+            },
+        };
+        // Semantic search across all organizational emails (coming soon)
+        this.search = async (params) => {
+            // Placeholder for future semantic search implementation
+            // This will search across all emails in the organization
+            return this.request(`/api/search${buildQuery({
+                q: params.query,
+                limit: params.limit || 10,
+                threshold: params.threshold || 0.7,
+                before: params.before,
+                after: params.after,
+                sender: params.sender,
+            })}`);
+        };
+        this.attachments = {
+            get: async (attachmentId) => {
+                return this.request(`/api/attachments/${encodeURIComponent(attachmentId)}`);
+            },
+        };
+        if (!options.apiKey) {
+            throw new Error('API key is required. Get one from your Commune dashboard at https://commune.ai');
+        }
+        this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+        this.apiKey = options.apiKey;
+        this.headers = options.headers;
+        this.fetcher = options.fetcher || fetch;
+    }
+    async request(path, options = {}) {
+        const { json, headers, ...rest } = options;
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            ...rest,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}),
+                ...(this.headers || {}),
+                ...(headers || {}),
+            },
+            body: json ? JSON.stringify(json) : rest.body,
+        });
+        const data = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            const errorValue = data?.error;
+            const message = errorValue?.message ||
+                (typeof data?.error === 'string' ? data.error : undefined) ||
+                response.statusText;
+            throw new Error(message);
+        }
+        if (data.data !== undefined) {
+            return data.data;
+        }
+        return data;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { CommuneClient } from './client.js';
+export type { ApiError, ApiResponse, AttachmentRecord, Channel, ConversationListParams, CreateDomainPayload, Direction, DomainEntry, DomainWebhook, InboxEntry, InboxWebhook, InboundEmailWebhookPayload, MessageListParams, MessageMetadata, Participant, ParticipantRole, SemanticSearchParams, SemanticSearchResult, SendMessagePayload, SvixHeaders, UnifiedMessage, } from './types.js';
+export { verifyResendWebhook } from './webhooks.js';
+export { createWebhookHandler } from './listener.js';
+export type { CommuneWebhookEvent, CommuneWebhookHandlerContext, CreateWebhookHandlerOptions, } from './listener.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { CommuneClient } from './client.js';
+export { verifyResendWebhook } from './webhooks.js';
+// export { verifySlackWebhook } from './webhooks.js'; // Slack support coming soon
+export { createWebhookHandler } from './listener.js';

package/dist/listener.d.ts

@@ -0,0 +1,15 @@
+import type { InboundEmailWebhookPayload, UnifiedMessage } from './types.js';
+export type CommuneWebhookEvent = InboundEmailWebhookPayload;
+export type CommuneWebhookHandlerContext = {
+    payload: CommuneWebhookEvent;
+    rawBody: string;
+    headers: Record<string, string | undefined>;
+};
+export type CreateWebhookHandlerOptions = {
+    onEvent: (message: UnifiedMessage, context: CommuneWebhookHandlerContext) => Promise<void> | void;
+    verify?: (input: {
+        rawBody: string;
+        headers: Record<string, string | undefined>;
+    }) => boolean;
+};
+export declare const createWebhookHandler: ({ onEvent, verify }: CreateWebhookHandlerOptions) => (req: any, res?: any) => Promise<Response | undefined>;

package/dist/listener.js

@@ -0,0 +1,85 @@
+const collectNodeBody = async (req) => {
+    if (req?.body) {
+        if (Buffer.isBuffer(req.body)) {
+            return req.body.toString('utf8');
+        }
+        if (typeof req.body === 'string') {
+            return req.body;
+        }
+    }
+    return await new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+};
+const getHeadersFromNode = (req) => {
+    const headers = {};
+    if (!req?.headers) {
+        return headers;
+    }
+    for (const [key, value] of Object.entries(req.headers)) {
+        headers[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
+    }
+    return headers;
+};
+const parsePayload = (rawBody) => {
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch (error) {
+        return null;
+    }
+};
+export const createWebhookHandler = ({ onEvent, verify }) => {
+    return async (req, res) => {
+        if (req?.method && req.method !== 'POST') {
+            if (res) {
+                res.status(405).json({ error: 'Method Not Allowed' });
+                return;
+            }
+            return new Response(JSON.stringify({ error: 'Method Not Allowed' }), {
+                status: 405,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const isWebRequest = typeof req?.text === 'function';
+        const rawBody = isWebRequest ? await req.text() : await collectNodeBody(req);
+        const headers = isWebRequest
+            ? {
+                'x-commune-signature': req.headers.get('x-commune-signature') || undefined,
+            }
+            : getHeadersFromNode(req);
+        if (verify && !verify({ rawBody, headers })) {
+            if (res) {
+                res.status(401).json({ error: 'Invalid signature' });
+                return;
+            }
+            return new Response(JSON.stringify({ error: 'Invalid signature' }), {
+                status: 401,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const payload = parsePayload(rawBody);
+        if (!payload) {
+            if (res) {
+                res.status(400).json({ error: 'Invalid JSON payload' });
+                return;
+            }
+            return new Response(JSON.stringify({ error: 'Invalid JSON payload' }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        await onEvent(payload.message, { payload, rawBody, headers });
+        if (res) {
+            res.json({ ok: true });
+            return;
+        }
+        return new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,155 @@
+export type Channel = 'email';
+export type Direction = 'inbound' | 'outbound';
+export type ParticipantRole = 'sender' | 'to' | 'cc' | 'bcc' | 'mentioned' | 'participant';
+export interface Participant {
+    role: ParticipantRole;
+    identity: string;
+}
+export interface MessageMetadata {
+    created_at: string;
+    subject?: string;
+    in_reply_to?: string | null;
+    references?: string[];
+    is_private?: boolean;
+    domain_id?: string | null;
+    inbox_id?: string | null;
+    inbox_address?: string | null;
+    message_id?: string | null;
+    provider?: 'resend' | 'email' | string;
+    raw?: unknown;
+}
+export interface UnifiedMessage {
+    _id?: string;
+    channel: Channel;
+    message_id: string;
+    conversation_id: string;
+    direction: Direction;
+    participants: Participant[];
+    content: string;
+    content_html?: string | null;
+    attachments: string[];
+    created_at: string;
+    metadata: MessageMetadata;
+}
+export interface AttachmentRecord {
+    attachment_id: string;
+    message_id: string;
+    filename: string;
+    mime_type: string;
+    size: number;
+    content_base64: string | null;
+    source: Channel;
+    source_url?: string | null;
+    download_error?: boolean;
+}
+export interface DomainWebhook {
+    id?: string;
+    endpoint?: string;
+    events?: string[];
+    secret?: string | null;
+}
+export interface InboxWebhook {
+    endpoint?: string;
+    events?: string[];
+}
+export interface InboxEntry {
+    id: string;
+    localPart: string;
+    address?: string;
+    agent?: {
+        id?: string;
+        name?: string;
+        metadata?: Record<string, unknown>;
+    };
+    webhook?: InboxWebhook;
+    createdAt?: string;
+    status?: string;
+}
+export interface DomainEntry {
+    id: string;
+    name?: string;
+    status?: string;
+    region?: string;
+    records?: unknown[];
+    createdAt?: string;
+    webhook?: DomainWebhook;
+    inboxes?: InboxEntry[];
+}
+export interface SendMessagePayload {
+    conversation_id?: string;
+    to: string | string[];
+    text?: string;
+    html?: string;
+    attachments?: {
+        id?: string;
+        attachment_id?: string;
+    }[];
+    subject?: string;
+    cc?: string[];
+    bcc?: string[];
+    headers?: Record<string, string>;
+    replyTo?: string | string[];
+    reply_to?: string | string[];
+    domainId?: string;
+    inboxId?: string;
+    domain?: string;
+    from?: string;
+    localPart?: string;
+}
+export interface CreateDomainPayload {
+    name: string;
+    region?: string;
+    capabilities?: {
+        sending?: string;
+        receiving?: string;
+    };
+    createWebhook?: boolean;
+}
+export interface MessageListParams {
+    sender?: string;
+    channel?: Channel;
+    before?: string;
+    after?: string;
+    limit?: number;
+    order?: 'asc' | 'desc';
+    domain_id?: string;
+    inbox_id?: string;
+}
+export interface ConversationListParams {
+    limit?: number;
+    order?: 'asc' | 'desc';
+}
+export interface SvixHeaders {
+    id: string;
+    timestamp: string;
+    signature: string;
+}
+export interface InboundEmailWebhookPayload {
+    domainId: string;
+    inboxId?: string;
+    inboxAddress?: string;
+    event: unknown;
+    email: unknown;
+    message: UnifiedMessage;
+}
+export interface ApiError {
+    message?: string;
+    [key: string]: unknown;
+}
+export interface ApiResponse<T> {
+    data: T;
+    error?: ApiError;
+}
+export interface SemanticSearchParams {
+    query: string;
+    limit?: number;
+    threshold?: number;
+    before?: string;
+    after?: string;
+    sender?: string;
+}
+export interface SemanticSearchResult {
+    message: UnifiedMessage;
+    similarity: number;
+    highlights: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/webhooks.d.ts

@@ -0,0 +1,2 @@
+import type { SvixHeaders } from './types.js';
+export declare const verifyResendWebhook: (payload: string, headers: SvixHeaders, secret: string) => unknown;

package/dist/webhooks.js

@@ -0,0 +1,37 @@
+import { Webhook } from 'svix';
+export const verifyResendWebhook = (payload, headers, secret) => {
+    const webhook = new Webhook(secret);
+    const svixHeaders = {
+        'svix-id': headers.id,
+        'svix-timestamp': headers.timestamp,
+        'svix-signature': headers.signature,
+    };
+    return webhook.verify(payload, svixHeaders);
+};
+// Slack webhook verification (coming soon)
+// export const verifySlackWebhook = ({
+//   rawBody,
+//   timestamp,
+//   signature,
+//   signingSecret,
+// }: {
+//   rawBody: string;
+//   timestamp: string;
+//   signature: string;
+//   signingSecret: string;
+// }) => {
+//   const baseString = `v0:${timestamp}:${rawBody}`;
+//   const hmac = crypto
+//     .createHmac('sha256', signingSecret)
+//     .update(baseString, 'utf8')
+//     .digest('hex');
+//
+//   const expected = `v0=${hmac}`;
+//   const expectedBuffer = Buffer.from(expected, 'utf8');
+//   const signatureBuffer = Buffer.from(signature, 'utf8');
+//   if (expectedBuffer.length !== signatureBuffer.length) {
+//     return false;
+//   }
+//
+//   return crypto.timingSafeEqual(expectedBuffer, signatureBuffer);
+// };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "commune-ai",
+  "version": "0.1.0",
+  "description": "Unified communication SDK for Commune (email + Slack)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "svix": "^1.44.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "typescript": "^5.5.4"
+  }
+}