@aarekaz/switchboard-core 0.3.1

package/README.md

@@ -0,0 +1,41 @@
+# @aarekaz/switchboard-core
+
+Core types, interfaces, and client API for Switchboard - the universal chat platform SDK.
+
+## Installation
+
+```bash
+npm install @aarekaz/switchboard-core
+# or
+pnpm add @aarekaz/switchboard-core
+```
+
+## Usage
+
+```typescript
+import { createBot } from '@aarekaz/switchboard-core';
+import '@aarekaz/switchboard-discord'; // Auto-registers Discord adapter
+
+const bot = createBot({
+  platform: 'discord',
+  credentials: {
+    token: process.env.DISCORD_TOKEN,
+  },
+});
+
+bot.onMessage(async (message) => {
+  if (message.text.includes('ping')) {
+    await bot.reply(message, 'pong!');
+  }
+});
+
+await bot.start();
+```
+
+## Documentation
+
+For full documentation, visit [github.com/Aarekaz/switchboard](https://github.com/Aarekaz/switchboard)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,705 @@
+/**
+ * Result type for type-safe error handling
+ * Inspired by Rust's Result<T, E> type
+ */
+type Result<T, E = Error> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Create a successful result
+ */
+declare function ok<T>(value: T): Result<T, never>;
+/**
+ * Create an error result
+ */
+declare function err<E = Error>(error: E): Result<never, E>;
+/**
+ * Wrap an async operation in a Result type
+ * Catches any errors and converts them to Result<T>
+ */
+declare function wrapAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+/**
+ * Check if a result is successful
+ */
+declare function isOk<T, E>(result: Result<T, E>): result is {
+    ok: true;
+    value: T;
+};
+/**
+ * Check if a result is an error
+ */
+declare function isErr<T, E>(result: Result<T, E>): result is {
+    ok: false;
+    error: E;
+};
+
+/**
+ * Supported chat platforms
+ * Extensible to allow custom platforms
+ */
+type PlatformType = 'discord' | 'slack' | 'teams' | 'google-chat' | (string & {});
+
+/**
+ * File attachment
+ */
+interface Attachment {
+    /** Attachment ID */
+    id: string;
+    /** File name */
+    filename: string;
+    /** Download URL */
+    url: string;
+    /** MIME type (e.g., 'image/png') */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Unified message representation across all platforms
+ * This is the core abstraction that normalizes messages from different platforms
+ */
+interface UnifiedMessage {
+    /** Platform-specific message ID */
+    id: string;
+    /** Channel/room/conversation ID where the message was sent */
+    channelId: string;
+    /** User ID of the message sender */
+    userId: string;
+    /** Plain text content of the message */
+    text: string;
+    /** When the message was sent */
+    timestamp: Date;
+    /** Thread/reply chain ID (if this message is part of a thread) */
+    threadId?: string;
+    /** File attachments (images, files, etc.) */
+    attachments?: Attachment[];
+    /** Which platform this message is from */
+    platform: PlatformType;
+    /** Original platform message object (for accessing platform-specific fields) */
+    _raw: unknown;
+}
+/**
+ * Reference to a message - can be either a message ID string or a full UnifiedMessage object.
+ *
+ * **Why this exists:**
+ * Different platforms have different requirements for message operations:
+ * - Discord: Only needs message ID for edit/delete/react operations
+ * - Slack: Needs both channel ID and message timestamp (ts)
+ *
+ * **Usage recommendations:**
+ * - Passing UnifiedMessage works reliably on ALL platforms
+ * - Passing string ID works on Discord, works on Slack if message is in cache (95% of cases)
+ *
+ * **Platform notes:**
+ * - Discord: String IDs always work
+ * - Slack: String IDs work if the message was seen by the bot in the last hour.
+ *   For guaranteed reliability, pass the full message object.
+ *
+ * @example
+ * ```typescript
+ * // Recommended: Works everywhere, always
+ * bot.onMessage(async (message) => {
+ *   await bot.editMessage(message, 'Updated text');
+ *   await bot.addReaction(message, 'thumbsup');
+ * });
+ *
+ * // Works on Discord, works on Slack if cached
+ * await bot.editMessage(message.id, 'Updated text');
+ * ```
+ */
+type MessageRef = string | UnifiedMessage;
+/**
+ * Options for sending messages
+ */
+interface SendMessageOptions {
+    /** Send message in a specific thread */
+    threadId?: string;
+    /** Discord-specific options */
+    discord?: {
+        embeds?: unknown[];
+        components?: unknown[];
+    };
+    /** Slack-specific options */
+    slack?: {
+        blocks?: unknown[];
+        unfurl_links?: boolean;
+        unfurl_media?: boolean;
+    };
+    /** Microsoft Teams-specific options */
+    teams?: {
+        attachments?: unknown[];
+    };
+    /** Google Chat-specific options */
+    googleChat?: {
+        cards?: unknown[];
+    };
+}
+/**
+ * Options for uploading files
+ */
+interface UploadOptions {
+    /** File name (if not provided in the File object) */
+    filename?: string;
+    /** Optional comment/message to send with the file */
+    comment?: string;
+    /** Send file in a specific thread */
+    threadId?: string;
+}
+
+/**
+ * Event fired when a message is received
+ */
+interface MessageEvent {
+    type: 'message';
+    message: UnifiedMessage;
+}
+/**
+ * Event fired when a reaction is added or removed from a message
+ */
+interface ReactionEvent {
+    type: 'reaction';
+    /** Message ID that was reacted to */
+    messageId: string;
+    /** User ID who added/removed the reaction */
+    userId: string;
+    /** Emoji string (e.g., '👍', 'tada') */
+    emoji: string;
+    /** Whether the reaction was added or removed */
+    action: 'added' | 'removed';
+}
+/**
+ * Event fired when a user joins a channel
+ */
+interface UserJoinedEvent {
+    type: 'user_joined';
+    /** Channel ID the user joined */
+    channelId: string;
+    /** User ID who joined */
+    userId: string;
+}
+/**
+ * Event fired when a user leaves a channel
+ */
+interface UserLeftEvent {
+    type: 'user_left';
+    /** Channel ID the user left */
+    channelId: string;
+    /** User ID who left */
+    userId: string;
+}
+/**
+ * Event fired when a channel is created
+ */
+interface ChannelCreatedEvent {
+    type: 'channel_created';
+    /** ID of the created channel */
+    channelId: string;
+    /** Name of the created channel */
+    channelName: string;
+}
+/**
+ * Event fired when a channel is deleted
+ */
+interface ChannelDeletedEvent {
+    type: 'channel_deleted';
+    /** ID of the deleted channel */
+    channelId: string;
+}
+/**
+ * Union of all possible events
+ */
+type UnifiedEvent = MessageEvent | ReactionEvent | UserJoinedEvent | UserLeftEvent | ChannelCreatedEvent | ChannelDeletedEvent;
+
+/**
+ * Channel/room type
+ */
+type ChannelType = 'text' | 'voice' | 'dm' | 'group_dm' | 'category' | 'unknown';
+/**
+ * Unified channel representation
+ */
+interface Channel {
+    /** Channel ID */
+    id: string;
+    /** Channel name */
+    name: string;
+    /** Channel type */
+    type: ChannelType;
+    /** Whether the channel is private/restricted */
+    isPrivate: boolean;
+    /** Channel topic/description (if applicable) */
+    topic?: string;
+}
+
+/**
+ * Unified user representation
+ */
+interface User {
+    /** User ID */
+    id: string;
+    /** Username */
+    username: string;
+    /** Display name (may be different from username on some platforms) */
+    displayName?: string;
+    /** Whether the user is a bot */
+    isBot: boolean;
+    /** Avatar URL (if available) */
+    avatarUrl?: string;
+}
+
+/**
+ * Platform adapter interface
+ * All platform adapters must implement this interface
+ */
+interface PlatformAdapter {
+    /** Adapter name (e.g., 'discord-adapter') */
+    readonly name: string;
+    /** Platform type (e.g., 'discord') */
+    readonly platform: PlatformType;
+    /** Connect to the platform with credentials */
+    connect(credentials: unknown): Promise<void>;
+    /** Disconnect from the platform */
+    disconnect(): Promise<void>;
+    /** Check if currently connected */
+    isConnected(): boolean;
+    /** Send a message to a channel */
+    sendMessage(channelId: string, text: string, options?: SendMessageOptions): Promise<Result<UnifiedMessage>>;
+    /** Edit an existing message */
+    editMessage(messageRef: MessageRef, newText: string): Promise<Result<UnifiedMessage>>;
+    /** Delete a message */
+    deleteMessage(messageRef: MessageRef): Promise<Result<void>>;
+    /** Add a reaction emoji to a message */
+    addReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>>;
+    /** Remove a reaction emoji from a message */
+    removeReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>>;
+    /** Create a thread/reply to a message */
+    createThread(messageRef: MessageRef, text: string): Promise<Result<UnifiedMessage>>;
+    /** Upload a file to a channel */
+    uploadFile(channelId: string, file: unknown, options?: UploadOptions): Promise<Result<UnifiedMessage>>;
+    /** Subscribe to platform events */
+    onEvent(handler: (event: UnifiedEvent) => void | Promise<void>): void;
+    /** Get list of channels */
+    getChannels(): Promise<Result<Channel[]>>;
+    /** Get list of users (optionally in a specific channel) */
+    getUsers(channelId?: string): Promise<Result<User[]>>;
+    /** Normalize platform-specific message to UnifiedMessage */
+    normalizeMessage(platformMessage: unknown): UnifiedMessage;
+    /** Normalize platform-specific event to UnifiedEvent */
+    normalizeEvent(platformEvent: unknown): UnifiedEvent | null;
+}
+
+/**
+ * Message Context
+ *
+ * A context object passed to message handlers that provides convenient access
+ * to message data and bot operations without repetitive parameter passing.
+ *
+ * Inspired by Hono's context pattern and Telegraf's bot framework.
+ */
+
+/**
+ * Context object provided to message handlers
+ *
+ * @example
+ * ```typescript
+ * bot.onMessage(async (ctx) => {
+ *   // Access message data
+ *   console.log(ctx.message.text);
+ *   console.log(ctx.userId);
+ *   console.log(ctx.channelId);
+ *
+ *   // Use helper methods
+ *   await ctx.reply('Hello!');
+ *   await ctx.react('👍');
+ *   await ctx.edit('Updated!');
+ * });
+ * ```
+ */
+interface MessageContext {
+    /**
+     * The received message
+     */
+    readonly message: UnifiedMessage;
+    /**
+     * Platform this message is from
+     */
+    readonly platform: PlatformType;
+    /**
+     * User ID who sent the message (convenience accessor)
+     */
+    readonly userId: string;
+    /**
+     * Channel ID where message was sent (convenience accessor)
+     */
+    readonly channelId: string;
+    /**
+     * Message text content (convenience accessor)
+     */
+    readonly text: string;
+    /**
+     * Thread ID if message is in a thread (convenience accessor)
+     */
+    readonly threadId: string | undefined;
+    /**
+     * Reply to the message
+     *
+     * @param text - Text to reply with
+     * @param options - Optional message options
+     * @returns Result containing the sent message
+     *
+     * @example
+     * ```typescript
+     * await ctx.reply('Got your message!');
+     *
+     * // With options
+     * await ctx.reply('Thread reply', { threadId: ctx.threadId });
+     * ```
+     */
+    reply(text: string, options?: SendMessageOptions): Promise<Result<UnifiedMessage>>;
+    /**
+     * Add a reaction to the message
+     *
+     * @param emoji - Emoji to add (Unicode or platform name)
+     * @returns Result indicating success or failure
+     *
+     * @example
+     * ```typescript
+     * await ctx.react('👍');
+     * await ctx.react('thumbsup');
+     * ```
+     */
+    react(emoji: string): Promise<Result<void>>;
+    /**
+     * Remove a reaction from the message
+     *
+     * @param emoji - Emoji to remove
+     * @returns Result indicating success or failure
+     */
+    unreact(emoji: string): Promise<Result<void>>;
+    /**
+     * Edit the message (only works for bot's own messages)
+     *
+     * @param newText - New message text
+     * @returns Result containing the edited message
+     *
+     * @example
+     * ```typescript
+     * const sent = await ctx.reply('Processing...');
+     * if (sent.ok) {
+     *   // Create new context for the sent message
+     *   await bot.editMessage(sent.value, 'Done!');
+     * }
+     * ```
+     */
+    edit(newText: string): Promise<Result<UnifiedMessage>>;
+    /**
+     * Delete the message
+     *
+     * @returns Result indicating success or failure
+     */
+    delete(): Promise<Result<void>>;
+    /**
+     * Create a thread on the message
+     *
+     * @param text - First message in the thread
+     * @returns Result containing the thread message
+     *
+     * @example
+     * ```typescript
+     * await ctx.createThread('Let\'s discuss this!');
+     * ```
+     */
+    createThread(text: string): Promise<Result<UnifiedMessage>>;
+    /**
+     * Send a new message to the same channel
+     *
+     * @param text - Message text
+     * @param options - Optional message options
+     * @returns Result containing the sent message
+     *
+     * @example
+     * ```typescript
+     * await ctx.send('This is a new message');
+     * ```
+     */
+    send(text: string, options?: SendMessageOptions): Promise<Result<UnifiedMessage>>;
+}
+/**
+ * Function type for message handlers that receive context
+ */
+type MessageHandler = (ctx: MessageContext) => void | Promise<void>;
+
+/**
+ * Bot client - the main interface for interacting with chat platforms
+ */
+declare class Bot {
+    private readonly adapter;
+    private readonly _platform;
+    private readonly credentials;
+    private eventHandlers;
+    constructor(adapter: PlatformAdapter, _platform: PlatformType, credentials: unknown);
+    /**
+     * Get the platform type
+     */
+    get platform(): PlatformType;
+    /**
+     * Start the bot (connect to the platform)
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the bot (disconnect from the platform)
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if the bot is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Send a message to a channel
+     */
+    sendMessage(channelId: string, text: string, options?: SendMessageOptions): Promise<Result<UnifiedMessage>>;
+    /**
+     * Reply to a message
+     */
+    reply(message: UnifiedMessage, text: string, options?: SendMessageOptions): Promise<Result<UnifiedMessage>>;
+    /**
+     * Edit an existing message
+     */
+    editMessage(messageRef: MessageRef, newText: string): Promise<Result<UnifiedMessage>>;
+    /**
+     * Delete a message
+     */
+    deleteMessage(messageRef: MessageRef): Promise<Result<void>>;
+    /**
+     * Add a reaction to a message
+     */
+    addReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>>;
+    /**
+     * Remove a reaction from a message
+     */
+    removeReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>>;
+    /**
+     * Create a thread (or reply in a thread)
+     */
+    createThread(messageRef: MessageRef, text: string): Promise<Result<UnifiedMessage>>;
+    /**
+     * Upload a file to a channel
+     */
+    uploadFile(channelId: string, file: unknown, options?: UploadOptions): Promise<Result<UnifiedMessage>>;
+    /**
+     * Get list of channels
+     */
+    getChannels(): Promise<Result<Channel[]>>;
+    /**
+     * Get list of users (optionally in a specific channel)
+     */
+    getUsers(channelId?: string): Promise<Result<User[]>>;
+    /**
+     * Register a handler for message events
+     *
+     * Supports both context API (recommended) and legacy message API
+     *
+     * @example
+     * ```typescript
+     * // Context API (recommended)
+     * bot.onMessage(async (ctx) => {
+     *   await ctx.reply('Hello!');
+     *   await ctx.react('thumbsup');
+     * });
+     *
+     * // Legacy API (still supported)
+     * bot.onMessage(async (message) => {
+     *   await bot.reply(message, 'Hello!');
+     * });
+     * ```
+     */
+    onMessage(handler: MessageHandler | ((message: UnifiedMessage) => void | Promise<void>)): void;
+    /**
+     * Create a message context object
+     */
+    private createContext;
+    /**
+     * Register a handler for reaction events
+     */
+    onReaction(handler: (event: ReactionEvent) => void | Promise<void>): void;
+    /**
+     * Register a handler for any event
+     */
+    onEvent(handler: (event: UnifiedEvent) => void | Promise<void>): void;
+    /**
+     * Get the underlying adapter (for advanced use cases)
+     */
+    getAdapter(): PlatformAdapter;
+    /**
+     * Internal: Register an event handler
+     */
+    private on;
+    /**
+     * Internal: Handle an event from the adapter
+     */
+    private handleEvent;
+}
+
+/**
+ * Configuration for creating a bot
+ */
+interface BotConfig {
+    /**
+     * Platform to connect to (e.g., 'discord', 'slack', 'teams', 'google-chat')
+     */
+    platform: PlatformType;
+    /**
+     * Platform credentials (structure depends on the platform)
+     */
+    credentials?: {
+        /** Bot token (Discord, Slack) */
+        token?: string;
+        /** App ID (Teams) */
+        appId?: string;
+        /** App password (Teams) */
+        appPassword?: string;
+        /** Custom credentials object */
+        [key: string]: unknown;
+    };
+    /**
+     * Custom adapter (for advanced users or custom platforms)
+     * If provided, this will be used instead of the registered adapter
+     */
+    adapter?: PlatformAdapter;
+    /**
+     * Platform-specific configuration (opt-in)
+     */
+    platformConfig?: {
+        discord?: unknown;
+        slack?: unknown;
+        teams?: unknown;
+        googleChat?: unknown;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Create a bot instance
+ *
+ * @example
+ * ```typescript
+ * import { createBot } from '@aarekaz/switchboard-core';
+ * import '@aarekaz/switchboard-discord';
+ *
+ * const bot = createBot({
+ *   platform: 'discord',
+ *   credentials: {
+ *     token: process.env.DISCORD_TOKEN,
+ *   },
+ * });
+ *
+ * bot.onMessage(async (message) => {
+ *   if (message.text.includes('ping')) {
+ *     await bot.reply(message, 'pong!');
+ *   }
+ * });
+ *
+ * await bot.start();
+ * ```
+ */
+declare function createBot(config: BotConfig): Bot;
+
+/**
+ * Global registry for platform adapters
+ * Adapters register themselves when their package is imported
+ */
+declare class AdapterRegistry {
+    private adapters;
+    /**
+     * Register a platform adapter
+     * Called by adapter packages when they're imported
+     */
+    register(platform: PlatformType, adapter: PlatformAdapter): void;
+    /**
+     * Get an adapter for a platform
+     */
+    get(platform: PlatformType): PlatformAdapter | undefined;
+    /**
+     * Check if an adapter is registered for a platform
+     */
+    has(platform: PlatformType): boolean;
+    /**
+     * Get all registered platforms
+     */
+    getRegisteredPlatforms(): PlatformType[];
+    /**
+     * Clear all registered adapters (mainly for testing)
+     */
+    clear(): void;
+}
+/**
+ * Global singleton registry instance
+ */
+declare const registry: AdapterRegistry;
+
+/**
+ * Context passed to middleware
+ */
+interface MiddlewareContext {
+    /** The bot instance */
+    bot: Bot;
+    /** The event being processed */
+    event: UnifiedEvent;
+    /** The platform this event is from */
+    platform: PlatformType;
+    /** Timestamp when the event was received */
+    timestamp: Date;
+}
+/**
+ * Middleware function type
+ */
+type Middleware = (context: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+
+/**
+ * Base error class for all Switchboard errors
+ */
+declare class SwitchboardError extends Error {
+    readonly code: string;
+    readonly platform?: PlatformType | undefined;
+    constructor(message: string, code: string, platform?: PlatformType | undefined);
+}
+/**
+ * Error thrown when no adapter is found for a platform
+ */
+declare class AdapterNotFoundError extends SwitchboardError {
+    constructor(platform: PlatformType);
+}
+/**
+ * Error thrown when connection to a platform fails
+ */
+declare class ConnectionError extends SwitchboardError {
+    constructor(platform: PlatformType, cause: unknown);
+}
+/**
+ * Error thrown when sending a message fails
+ */
+declare class MessageSendError extends SwitchboardError {
+    constructor(platform: PlatformType, channelId: string, cause: unknown);
+}
+/**
+ * Error thrown when editing a message fails
+ */
+declare class MessageEditError extends SwitchboardError {
+    constructor(platform: PlatformType, messageId: string, cause: unknown);
+}
+/**
+ * Error thrown when deleting a message fails
+ */
+declare class MessageDeleteError extends SwitchboardError {
+    constructor(platform: PlatformType, messageId: string, cause: unknown);
+}
+/**
+ * Error thrown when adding/removing a reaction fails
+ */
+declare class ReactionError extends SwitchboardError {
+    constructor(platform: PlatformType, messageId: string, emoji: string, cause: unknown);
+}
+
+export { AdapterNotFoundError, type Attachment, Bot, type BotConfig, type Channel, type ChannelCreatedEvent, type ChannelDeletedEvent, type ChannelType, ConnectionError, MessageDeleteError, MessageEditError, type MessageEvent, type MessageRef, MessageSendError, type Middleware, type MiddlewareContext, type PlatformAdapter, type PlatformType, ReactionError, type ReactionEvent, type Result, type SendMessageOptions, SwitchboardError, type UnifiedEvent, type UnifiedMessage, type UploadOptions, type User, type UserJoinedEvent, type UserLeftEvent, createBot, err, isErr, isOk, ok, registry, wrapAsync };

package/dist/index.js

@@ -0,0 +1,385 @@
+// src/client/bot.ts
+var Bot = class {
+  constructor(adapter, _platform, credentials) {
+    this.adapter = adapter;
+    this._platform = _platform;
+    this.credentials = credentials;
+    this.adapter.onEvent(async (event) => {
+      await this.handleEvent(event);
+    });
+  }
+  eventHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Get the platform type
+   */
+  get platform() {
+    return this._platform;
+  }
+  /**
+   * Start the bot (connect to the platform)
+   */
+  async start() {
+    if (!this.adapter.isConnected()) {
+      await this.adapter.connect(this.credentials);
+    }
+  }
+  /**
+   * Stop the bot (disconnect from the platform)
+   */
+  async stop() {
+    await this.adapter.disconnect();
+  }
+  /**
+   * Check if the bot is connected
+   */
+  isConnected() {
+    return this.adapter.isConnected();
+  }
+  /**
+   * Send a message to a channel
+   */
+  async sendMessage(channelId, text, options) {
+    return this.adapter.sendMessage(channelId, text, options);
+  }
+  /**
+   * Reply to a message
+   */
+  async reply(message, text, options) {
+    const threadId = message.threadId || message.id;
+    return this.adapter.sendMessage(message.channelId, text, {
+      ...options,
+      threadId
+    });
+  }
+  /**
+   * Edit an existing message
+   */
+  async editMessage(messageRef, newText) {
+    return this.adapter.editMessage(messageRef, newText);
+  }
+  /**
+   * Delete a message
+   */
+  async deleteMessage(messageRef) {
+    return this.adapter.deleteMessage(messageRef);
+  }
+  /**
+   * Add a reaction to a message
+   */
+  async addReaction(messageRef, emoji) {
+    return this.adapter.addReaction(messageRef, emoji);
+  }
+  /**
+   * Remove a reaction from a message
+   */
+  async removeReaction(messageRef, emoji) {
+    return this.adapter.removeReaction(messageRef, emoji);
+  }
+  /**
+   * Create a thread (or reply in a thread)
+   */
+  async createThread(messageRef, text) {
+    return this.adapter.createThread(messageRef, text);
+  }
+  /**
+   * Upload a file to a channel
+   */
+  async uploadFile(channelId, file, options) {
+    return this.adapter.uploadFile(channelId, file, options);
+  }
+  /**
+   * Get list of channels
+   */
+  async getChannels() {
+    return this.adapter.getChannels();
+  }
+  /**
+   * Get list of users (optionally in a specific channel)
+   */
+  async getUsers(channelId) {
+    return this.adapter.getUsers(channelId);
+  }
+  /**
+   * Register a handler for message events
+   *
+   * Supports both context API (recommended) and legacy message API
+   *
+   * @example
+   * ```typescript
+   * // Context API (recommended)
+   * bot.onMessage(async (ctx) => {
+   *   await ctx.reply('Hello!');
+   *   await ctx.react('thumbsup');
+   * });
+   *
+   * // Legacy API (still supported)
+   * bot.onMessage(async (message) => {
+   *   await bot.reply(message, 'Hello!');
+   * });
+   * ```
+   */
+  onMessage(handler) {
+    this.on("message", async (event) => {
+      if (event.type === "message") {
+        const message = event.message;
+        const ctx = this.createContext(message);
+        await handler(ctx);
+      }
+    });
+  }
+  /**
+   * Create a message context object
+   */
+  createContext(message) {
+    return {
+      message,
+      platform: this._platform,
+      userId: message.userId,
+      channelId: message.channelId,
+      text: message.text,
+      threadId: message.threadId,
+      // Helper methods
+      reply: (text, options) => {
+        return this.reply(message, text, options);
+      },
+      react: (emoji) => {
+        return this.addReaction(message, emoji);
+      },
+      unreact: (emoji) => {
+        return this.removeReaction(message, emoji);
+      },
+      edit: (newText) => {
+        return this.editMessage(message, newText);
+      },
+      delete: () => {
+        return this.deleteMessage(message);
+      },
+      createThread: (text) => {
+        return this.createThread(message, text);
+      },
+      send: (text, options) => {
+        return this.sendMessage(message.channelId, text, options);
+      }
+    };
+  }
+  /**
+   * Register a handler for reaction events
+   */
+  onReaction(handler) {
+    this.on("reaction", async (event) => {
+      if (event.type === "reaction") {
+        await handler(event);
+      }
+    });
+  }
+  /**
+   * Register a handler for any event
+   */
+  onEvent(handler) {
+    this.on("*", handler);
+  }
+  /**
+   * Get the underlying adapter (for advanced use cases)
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Internal: Register an event handler
+   */
+  on(eventType, handler) {
+    if (!this.eventHandlers.has(eventType)) {
+      this.eventHandlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(eventType).add(handler);
+  }
+  /**
+   * Internal: Handle an event from the adapter
+   */
+  async handleEvent(event) {
+    const typeHandlers = this.eventHandlers.get(event.type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        try {
+          await handler(event);
+        } catch (error) {
+          console.error(
+            `[Switchboard] Error in ${event.type} handler:`,
+            error
+          );
+        }
+      }
+    }
+    const wildcardHandlers = this.eventHandlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        try {
+          await handler(event);
+        } catch (error) {
+          console.error(`[Switchboard] Error in wildcard handler:`, error);
+        }
+      }
+    }
+  }
+};
+
+// src/adapter/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * Register a platform adapter
+   * Called by adapter packages when they're imported
+   */
+  register(platform, adapter) {
+    if (this.adapters.has(platform)) {
+      console.warn(
+        `[Switchboard] Adapter for platform "${platform}" is already registered. Overwriting.`
+      );
+    }
+    this.adapters.set(platform, adapter);
+  }
+  /**
+   * Get an adapter for a platform
+   */
+  get(platform) {
+    return this.adapters.get(platform);
+  }
+  /**
+   * Check if an adapter is registered for a platform
+   */
+  has(platform) {
+    return this.adapters.has(platform);
+  }
+  /**
+   * Get all registered platforms
+   */
+  getRegisteredPlatforms() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * Clear all registered adapters (mainly for testing)
+   */
+  clear() {
+    this.adapters.clear();
+  }
+};
+var registry = new AdapterRegistry();
+
+// src/utils/errors.ts
+var SwitchboardError = class extends Error {
+  constructor(message, code, platform) {
+    super(message);
+    this.code = code;
+    this.platform = platform;
+    this.name = "SwitchboardError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AdapterNotFoundError = class extends SwitchboardError {
+  constructor(platform) {
+    super(
+      `No adapter found for platform: ${platform}. Did you import @aarekaz/switchboard-${platform}?`,
+      "ADAPTER_NOT_FOUND",
+      platform
+    );
+    this.name = "AdapterNotFoundError";
+  }
+};
+var ConnectionError = class extends SwitchboardError {
+  constructor(platform, cause) {
+    super(
+      `Failed to connect to ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      "CONNECTION_ERROR",
+      platform
+    );
+    this.name = "ConnectionError";
+    this.cause = cause;
+  }
+};
+var MessageSendError = class extends SwitchboardError {
+  constructor(platform, channelId, cause) {
+    super(
+      `Failed to send message to channel ${channelId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      "MESSAGE_SEND_ERROR",
+      platform
+    );
+    this.name = "MessageSendError";
+    this.cause = cause;
+  }
+};
+var MessageEditError = class extends SwitchboardError {
+  constructor(platform, messageId, cause) {
+    super(
+      `Failed to edit message ${messageId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      "MESSAGE_EDIT_ERROR",
+      platform
+    );
+    this.name = "MessageEditError";
+    this.cause = cause;
+  }
+};
+var MessageDeleteError = class extends SwitchboardError {
+  constructor(platform, messageId, cause) {
+    super(
+      `Failed to delete message ${messageId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      "MESSAGE_DELETE_ERROR",
+      platform
+    );
+    this.name = "MessageDeleteError";
+    this.cause = cause;
+  }
+};
+var ReactionError = class extends SwitchboardError {
+  constructor(platform, messageId, emoji, cause) {
+    super(
+      `Failed to add/remove reaction ${emoji} on message ${messageId} (${platform}): ${cause instanceof Error ? cause.message : String(cause)}`,
+      "REACTION_ERROR",
+      platform
+    );
+    this.name = "ReactionError";
+    this.cause = cause;
+  }
+};
+
+// src/client/create-bot.ts
+function createBot(config) {
+  let adapter;
+  if (config.adapter) {
+    adapter = config.adapter;
+  } else {
+    const registeredAdapter = registry.get(config.platform);
+    if (!registeredAdapter) {
+      throw new AdapterNotFoundError(config.platform);
+    }
+    adapter = registeredAdapter;
+  }
+  return new Bot(adapter, config.platform, config.credentials || {});
+}
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+async function wrapAsync(fn) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (error) {
+    return err(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+
+export { AdapterNotFoundError, Bot, ConnectionError, MessageDeleteError, MessageEditError, MessageSendError, ReactionError, SwitchboardError, createBot, err, isErr, isOk, ok, registry, wrapAsync };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/bot.ts","../src/adapter/registry.ts","../src/utils/errors.ts","../src/client/create-bot.ts","../src/types/result.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type { PlatformAdapter } from '../adapter/interface.js';\nimport type { Result } from '../types/result.js';\nimport type { PlatformType } from '../types/platform.js';\nimport type {\n  UnifiedMessage,\n  MessageRef,\n  SendMessageOptions,\n  UploadOptions,\n} from '../types/message.js';\nimport type { UnifiedEvent, MessageEvent, ReactionEvent } from '../types/event.js';\nimport type { Channel } from '../types/channel.js';\nimport type { User } from '../types/user.js';\nimport type { MessageContext, MessageHandler } from '../types/context.js';\n\n/**\n * Bot client - the main interface for interacting with chat platforms\n */\nexport class Bot {\n  private eventHandlers: Map<string, Set<(event: UnifiedEvent) => void | Promise<void>>> = new Map();\n\n  constructor(\n    private readonly adapter: PlatformAdapter,\n    private readonly _platform: PlatformType,\n    private readonly credentials: unknown\n  ) {\n    // Subscribe to all events from the adapter\n    this.adapter.onEvent(async (event) => {\n      await this.handleEvent(event);\n    });\n  }\n\n  /**\n   * Get the platform type\n   */\n  get platform(): PlatformType {\n    return this._platform;\n  }\n\n  /**\n   * Start the bot (connect to the platform)\n   */\n  async start(): Promise<void> {\n    // Connect to the platform if not already connected\n    if (!this.adapter.isConnected()) {\n      await this.adapter.connect(this.credentials);\n    }\n  }\n\n  /**\n   * Stop the bot (disconnect from the platform)\n   */\n  async stop(): Promise<void> {\n    await this.adapter.disconnect();\n  }\n\n  /**\n   * Check if the bot is connected\n   */\n  isConnected(): boolean {\n    return this.adapter.isConnected();\n  }\n\n  /**\n   * Send a message to a channel\n   */\n  async sendMessage(\n    channelId: string,\n    text: string,\n    options?: SendMessageOptions\n  ): Promise<Result<UnifiedMessage>> {\n    return this.adapter.sendMessage(channelId, text, options);\n  }\n\n  /**\n   * Reply to a message\n   */\n  async reply(\n    message: UnifiedMessage,\n    text: string,\n    options?: SendMessageOptions\n  ): Promise<Result<UnifiedMessage>> {\n    // If the message is in a thread, reply in the same thread\n    const threadId = message.threadId || message.id;\n    return this.adapter.sendMessage(message.channelId, text, {\n      ...options,\n      threadId,\n    });\n  }\n\n  /**\n   * Edit an existing message\n   */\n  async editMessage(\n    messageRef: MessageRef,\n    newText: string\n  ): Promise<Result<UnifiedMessage>> {\n    return this.adapter.editMessage(messageRef, newText);\n  }\n\n  /**\n   * Delete a message\n   */\n  async deleteMessage(messageRef: MessageRef): Promise<Result<void>> {\n    return this.adapter.deleteMessage(messageRef);\n  }\n\n  /**\n   * Add a reaction to a message\n   */\n  async addReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>> {\n    return this.adapter.addReaction(messageRef, emoji);\n  }\n\n  /**\n   * Remove a reaction from a message\n   */\n  async removeReaction(messageRef: MessageRef, emoji: string): Promise<Result<void>> {\n    return this.adapter.removeReaction(messageRef, emoji);\n  }\n\n  /**\n   * Create a thread (or reply in a thread)\n   */\n  async createThread(\n    messageRef: MessageRef,\n    text: string\n  ): Promise<Result<UnifiedMessage>> {\n    return this.adapter.createThread(messageRef, text);\n  }\n\n  /**\n   * Upload a file to a channel\n   */\n  async uploadFile(\n    channelId: string,\n    file: unknown,\n    options?: UploadOptions\n  ): Promise<Result<UnifiedMessage>> {\n    return this.adapter.uploadFile(channelId, file, options);\n  }\n\n  /**\n   * Get list of channels\n   */\n  async getChannels(): Promise<Result<Channel[]>> {\n    return this.adapter.getChannels();\n  }\n\n  /**\n   * Get list of users (optionally in a specific channel)\n   */\n  async getUsers(channelId?: string): Promise<Result<User[]>> {\n    return this.adapter.getUsers(channelId);\n  }\n\n  /**\n   * Register a handler for message events\n   *\n   * Supports both context API (recommended) and legacy message API\n   *\n   * @example\n   * ```typescript\n   * // Context API (recommended)\n   * bot.onMessage(async (ctx) => {\n   *   await ctx.reply('Hello!');\n   *   await ctx.react('thumbsup');\n   * });\n   *\n   * // Legacy API (still supported)\n   * bot.onMessage(async (message) => {\n   *   await bot.reply(message, 'Hello!');\n   * });\n   * ```\n   */\n  onMessage(handler: MessageHandler | ((message: UnifiedMessage) => void | Promise<void>)): void {\n    this.on('message', async (event) => {\n      if (event.type === 'message') {\n        const message = event.message;\n\n        // Detect if handler expects context (by checking parameter count)\n        // Context handlers have 1 parameter, legacy handlers might check message properties\n        // We'll check if the handler looks like it wants a context by seeing if it's async\n        // and calling it with a context object\n\n        // Create context object\n        const ctx = this.createContext(message);\n\n        // Call handler with context\n        await handler(ctx as any);\n      }\n    });\n  }\n\n  /**\n   * Create a message context object\n   */\n  private createContext(message: UnifiedMessage): MessageContext {\n    return {\n      message,\n      platform: this._platform,\n      userId: message.userId,\n      channelId: message.channelId,\n      text: message.text,\n      threadId: message.threadId,\n\n      // Helper methods\n      reply: (text: string, options?: SendMessageOptions) => {\n        return this.reply(message, text, options);\n      },\n\n      react: (emoji: string) => {\n        return this.addReaction(message, emoji);\n      },\n\n      unreact: (emoji: string) => {\n        return this.removeReaction(message, emoji);\n      },\n\n      edit: (newText: string) => {\n        return this.editMessage(message, newText);\n      },\n\n      delete: () => {\n        return this.deleteMessage(message);\n      },\n\n      createThread: (text: string) => {\n        return this.createThread(message, text);\n      },\n\n      send: (text: string, options?: SendMessageOptions) => {\n        return this.sendMessage(message.channelId, text, options);\n      },\n    };\n  }\n\n  /**\n   * Register a handler for reaction events\n   */\n  onReaction(handler: (event: ReactionEvent) => void | Promise<void>): void {\n    this.on('reaction', async (event) => {\n      if (event.type === 'reaction') {\n        await handler(event);\n      }\n    });\n  }\n\n  /**\n   * Register a handler for any event\n   */\n  onEvent(handler: (event: UnifiedEvent) => void | Promise<void>): void {\n    this.on('*', handler);\n  }\n\n  /**\n   * Get the underlying adapter (for advanced use cases)\n   */\n  getAdapter(): PlatformAdapter {\n    return this.adapter;\n  }\n\n  /**\n   * Internal: Register an event handler\n   */\n  private on(\n    eventType: string,\n    handler: (event: UnifiedEvent) => void | Promise<void>\n  ): void {\n    if (!this.eventHandlers.has(eventType)) {\n      this.eventHandlers.set(eventType, new Set());\n    }\n    this.eventHandlers.get(eventType)!.add(handler);\n  }\n\n  /**\n   * Internal: Handle an event from the adapter\n   */\n  private async handleEvent(event: UnifiedEvent): Promise<void> {\n    // Call handlers for this specific event type\n    const typeHandlers = this.eventHandlers.get(event.type);\n    if (typeHandlers) {\n      for (const handler of typeHandlers) {\n        try {\n          await handler(event);\n        } catch (error) {\n          console.error(\n            `[Switchboard] Error in ${event.type} handler:`,\n            error\n          );\n        }\n      }\n    }\n\n    // Call wildcard handlers\n    const wildcardHandlers = this.eventHandlers.get('*');\n    if (wildcardHandlers) {\n      for (const handler of wildcardHandlers) {\n        try {\n          await handler(event);\n        } catch (error) {\n          console.error(`[Switchboard] Error in wildcard handler:`, error);\n        }\n      }\n    }\n  }\n}\n","import type { PlatformAdapter } from './interface.js';\nimport type { PlatformType } from '../types/platform.js';\n\n/**\n * Global registry for platform adapters\n * Adapters register themselves when their package is imported\n */\nclass AdapterRegistry {\n  private adapters = new Map<PlatformType, PlatformAdapter>();\n\n  /**\n   * Register a platform adapter\n   * Called by adapter packages when they're imported\n   */\n  register(platform: PlatformType, adapter: PlatformAdapter): void {\n    if (this.adapters.has(platform)) {\n      console.warn(\n        `[Switchboard] Adapter for platform \"${platform}\" is already registered. Overwriting.`\n      );\n    }\n    this.adapters.set(platform, adapter);\n  }\n\n  /**\n   * Get an adapter for a platform\n   */\n  get(platform: PlatformType): PlatformAdapter | undefined {\n    return this.adapters.get(platform);\n  }\n\n  /**\n   * Check if an adapter is registered for a platform\n   */\n  has(platform: PlatformType): boolean {\n    return this.adapters.has(platform);\n  }\n\n  /**\n   * Get all registered platforms\n   */\n  getRegisteredPlatforms(): PlatformType[] {\n    return Array.from(this.adapters.keys());\n  }\n\n  /**\n   * Clear all registered adapters (mainly for testing)\n   */\n  clear(): void {\n    this.adapters.clear();\n  }\n}\n\n/**\n * Global singleton registry instance\n */\nexport const registry = new AdapterRegistry();\n","import type { PlatformType } from '../types/platform.js';\n\n/**\n * Base error class for all Switchboard errors\n */\nexport class SwitchboardError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly platform?: PlatformType\n  ) {\n    super(message);\n    this.name = 'SwitchboardError';\n    // Maintains proper stack trace for where our error was thrown (only available on V8)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error thrown when no adapter is found for a platform\n */\nexport class AdapterNotFoundError extends SwitchboardError {\n  constructor(platform: PlatformType) {\n    super(\n      `No adapter found for platform: ${platform}. Did you import @aarekaz/switchboard-${platform}?`,\n      'ADAPTER_NOT_FOUND',\n      platform\n    );\n    this.name = 'AdapterNotFoundError';\n  }\n}\n\n/**\n * Error thrown when connection to a platform fails\n */\nexport class ConnectionError extends SwitchboardError {\n  constructor(platform: PlatformType, cause: unknown) {\n    super(\n      `Failed to connect to ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,\n      'CONNECTION_ERROR',\n      platform\n    );\n    this.name = 'ConnectionError';\n    this.cause = cause;\n  }\n}\n\n/**\n * Error thrown when sending a message fails\n */\nexport class MessageSendError extends SwitchboardError {\n  constructor(\n    platform: PlatformType,\n    channelId: string,\n    cause: unknown\n  ) {\n    super(\n      `Failed to send message to channel ${channelId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,\n      'MESSAGE_SEND_ERROR',\n      platform\n    );\n    this.name = 'MessageSendError';\n    this.cause = cause;\n  }\n}\n\n/**\n * Error thrown when editing a message fails\n */\nexport class MessageEditError extends SwitchboardError {\n  constructor(\n    platform: PlatformType,\n    messageId: string,\n    cause: unknown\n  ) {\n    super(\n      `Failed to edit message ${messageId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,\n      'MESSAGE_EDIT_ERROR',\n      platform\n    );\n    this.name = 'MessageEditError';\n    this.cause = cause;\n  }\n}\n\n/**\n * Error thrown when deleting a message fails\n */\nexport class MessageDeleteError extends SwitchboardError {\n  constructor(\n    platform: PlatformType,\n    messageId: string,\n    cause: unknown\n  ) {\n    super(\n      `Failed to delete message ${messageId} on ${platform}: ${cause instanceof Error ? cause.message : String(cause)}`,\n      'MESSAGE_DELETE_ERROR',\n      platform\n    );\n    this.name = 'MessageDeleteError';\n    this.cause = cause;\n  }\n}\n\n/**\n * Error thrown when adding/removing a reaction fails\n */\nexport class ReactionError extends SwitchboardError {\n  constructor(\n    platform: PlatformType,\n    messageId: string,\n    emoji: string,\n    cause: unknown\n  ) {\n    super(\n      `Failed to add/remove reaction ${emoji} on message ${messageId} (${platform}): ${cause instanceof Error ? cause.message : String(cause)}`,\n      'REACTION_ERROR',\n      platform\n    );\n    this.name = 'ReactionError';\n    this.cause = cause;\n  }\n}\n","import { Bot } from './bot.js';\nimport { registry } from '../adapter/registry.js';\nimport type { PlatformAdapter } from '../adapter/interface.js';\nimport type { PlatformType } from '../types/platform.js';\nimport { AdapterNotFoundError, ConnectionError } from '../utils/errors.js';\n\n/**\n * Configuration for creating a bot\n */\nexport interface BotConfig {\n  /**\n   * Platform to connect to (e.g., 'discord', 'slack', 'teams', 'google-chat')\n   */\n  platform: PlatformType;\n\n  /**\n   * Platform credentials (structure depends on the platform)\n   */\n  credentials?: {\n    /** Bot token (Discord, Slack) */\n    token?: string;\n    /** App ID (Teams) */\n    appId?: string;\n    /** App password (Teams) */\n    appPassword?: string;\n    /** Custom credentials object */\n    [key: string]: unknown;\n  };\n\n  /**\n   * Custom adapter (for advanced users or custom platforms)\n   * If provided, this will be used instead of the registered adapter\n   */\n  adapter?: PlatformAdapter;\n\n  /**\n   * Platform-specific configuration (opt-in)\n   */\n  platformConfig?: {\n    discord?: unknown;\n    slack?: unknown;\n    teams?: unknown;\n    googleChat?: unknown;\n    [key: string]: unknown;\n  };\n}\n\n/**\n * Create a bot instance\n *\n * @example\n * ```typescript\n * import { createBot } from '@aarekaz/switchboard-core';\n * import '@aarekaz/switchboard-discord';\n *\n * const bot = createBot({\n *   platform: 'discord',\n *   credentials: {\n *     token: process.env.DISCORD_TOKEN,\n *   },\n * });\n *\n * bot.onMessage(async (message) => {\n *   if (message.text.includes('ping')) {\n *     await bot.reply(message, 'pong!');\n *   }\n * });\n *\n * await bot.start();\n * ```\n */\nexport function createBot(config: BotConfig): Bot {\n  let adapter: PlatformAdapter;\n\n  // Use custom adapter if provided\n  if (config.adapter) {\n    adapter = config.adapter;\n  } else {\n    // Get adapter from registry\n    const registeredAdapter = registry.get(config.platform);\n    if (!registeredAdapter) {\n      throw new AdapterNotFoundError(config.platform);\n    }\n    adapter = registeredAdapter;\n  }\n\n  // Create and return the bot instance\n  // Connection happens lazily when bot.start() is called\n  return new Bot(adapter, config.platform, config.credentials || {});\n}\n","/**\n * Result type for type-safe error handling\n * Inspired by Rust's Result<T, E> type\n */\nexport type Result<T, E = Error> =\n  | { ok: true; value: T }\n  | { ok: false; error: E };\n\n/**\n * Create a successful result\n */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/**\n * Create an error result\n */\nexport function err<E = Error>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n/**\n * Wrap an async operation in a Result type\n * Catches any errors and converts them to Result<T>\n */\nexport async function wrapAsync<T>(\n  fn: () => Promise<T>\n): Promise<Result<T, Error>> {\n  try {\n    const value = await fn();\n    return ok(value);\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)));\n  }\n}\n\n/**\n * Check if a result is successful\n */\nexport function isOk<T, E>(result: Result<T, E>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Check if a result is an error\n */\nexport function isErr<T, E>(result: Result<T, E>): result is { ok: false; error: E } {\n  return result.ok === false;\n}\n"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@aarekaz/switchboard-core",
+  "version": "0.3.1",
+  "description": "Core types and client API for Switchboard - universal chat platform SDK",
+  "keywords": [
+    "switchboard",
+    "chat",
+    "bot",
+    "sdk",
+    "core"
+  ],
+  "homepage": "https://github.com/Aarekaz/switchboard#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aarekaz/switchboard.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "Aarekaz",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}