wispy-cli 0.5.0 → 0.6.1

package/README.md

@@ -142,13 +142,124 @@ Wispy remembers across sessions via `~/.wispy/memory/`:
 /memory references "API docs: https://..."
 ```
 
+## Multi-Channel Bot Support (v0.6.0)
+
+Run Wispy as a bot on Telegram, Discord, and Slack — all at once or individually.
+
+### Quick Start
+
+```bash
+# Set up a channel (interactive)
+wispy channel setup telegram
+wispy channel setup discord
+wispy channel setup slack
+
+# Start all configured channels
+wispy --serve
+
+# Or start a single channel
+wispy --telegram
+wispy --discord
+wispy --slack
+
+# List configured channels
+wispy channel list
+
+# Test a channel connection
+wispy channel test telegram
+```
+
+### Telegram Setup
+
+1. Talk to [@BotFather](https://t.me/BotFather) on Telegram
+2. Send `/newbot`, follow prompts, copy the token
+3. Run `wispy channel setup telegram`
+
+**Or** set the env var:
+```bash
+export WISPY_TELEGRAM_TOKEN=your-token
+wispy --telegram
+```
+
+Bot commands: `/start`, `/clear`, `/model`, `/help`
+
+### Discord Setup
+
+1. Go to [Discord Developer Portal](https://discord.com/developers/applications)
+2. Create an app → Bot → copy the token
+3. Enable **Message Content Intent** in Bot settings
+4. Invite bot to your server with `bot` + `applications.commands` scopes
+5. Run `wispy channel setup discord`
+
+**Or** set the env var:
+```bash
+export WISPY_DISCORD_TOKEN=your-token
+wispy --discord
+```
+
+Triggers: mention @Wispy, `!clear`, `!model`, `!help`, or DM the bot.
+
+### Slack Setup
+
+1. Go to [Slack API](https://api.slack.com/apps) → Create New App → From scratch
+2. Enable **Socket Mode** → copy App-Level Token (`xapp-...`)
+3. OAuth & Permissions → copy Bot User OAuth Token (`xoxb-...`)
+4. Subscribe to `app_mention` + `message.im` events
+5. Add `/wispy` slash command
+6. Run `wispy channel setup slack`
+
+**Or** set env vars:
+```bash
+export WISPY_SLACK_BOT_TOKEN=xoxb-...
+export WISPY_SLACK_APP_TOKEN=xapp-...
+wispy --slack
+```
+
+Triggers: `@mention`, DMs, `/wispy <message>` slash command.
+
+### channels.json Config
+
+Stored at `~/.wispy/channels.json`:
+```json
+{
+  "telegram": { "enabled": true, "token": "..." },
+  "discord":  { "enabled": true, "token": "..." },
+  "slack":    { "enabled": true, "botToken": "...", "appToken": "..." }
+}
+```
+
+### Optional Dependencies
+
+Channel adapters use peer dependencies — install only what you need:
+
+```bash
+npm install grammy          # Telegram
+npm install discord.js      # Discord
+npm install @slack/bolt     # Slack
+```
+
+Each adapter gracefully fails with a helpful install message if the package isn't present.
+
+### Per-Chat Session Isolation
+
+Each chat/channel/DM gets its own conversation history stored in:
+`~/.wispy/channel-sessions/<channel>/<chatId>.json`
+
+No cross-contamination between users or channels.
+
 ## Architecture
 
 ```
-wispy (CLI REPL)
+wispy (CLI REPL / TUI)
   ↕ Gemini/Claude/OpenAI API (tool calling)
   ↕ AWOS Server (auto-started, sandboxed tools)
   ↕ Local Node (macOS file/browser/app actions)
+
+wispy --serve (Channel Bot Mode)
+  ↕ Telegram (grammY long polling)
+  ↕ Discord (discord.js gateway)
+  ↕ Slack (bolt socket mode)
+  ↕ Gemini/Claude/OpenAI API (per-chat sessions)
 ```
 
 ## Requirements

package/bin/wispy.mjs

@@ -4,8 +4,15 @@
  * Wispy CLI entry point
  *
  * Flags:
- *   --tui    Launch Ink-based TUI mode
- *   (default) Launch interactive REPL
+ *   --tui              Launch Ink-based TUI mode
+ *   --serve            Start all configured channel bots
+ *   --telegram         Start Telegram bot only
+ *   --discord          Start Discord bot only
+ *   --slack            Start Slack bot only
+ *   channel setup <name>   Interactive channel token setup
+ *   channel list           List configured channels
+ *   channel test <name>    Test channel connection
+ *   (default)          Launch interactive REPL
  */
 
 import { fileURLToPath } from "node:url";
@@ -13,17 +20,83 @@ import path from "node:path";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-// Check for --tui flag
 const args = process.argv.slice(2);
+
+// ── channel sub-command ───────────────────────────────────────────────────────
+if (args[0] === "channel") {
+  const { channelSetup, channelList, channelTest } = await import(
+    path.join(__dirname, "..", "lib", "channels", "index.mjs")
+  );
+
+  const sub  = args[1];
+  const name = args[2];
+
+  if (sub === "setup" && name) {
+    await channelSetup(name);
+  } else if (sub === "list") {
+    await channelList();
+  } else if (sub === "test" && name) {
+    await channelTest(name);
+  } else {
+    console.log(`
+🌿 Wispy Channel Commands:
+
+  wispy channel setup telegram    — interactive Telegram bot setup
+  wispy channel setup discord     — interactive Discord bot setup
+  wispy channel setup slack       — interactive Slack bot setup
+  wispy channel list              — show configured channels
+  wispy channel test <name>       — test a channel connection
+
+  wispy --serve                   — start all configured channel bots
+  wispy --telegram                — start Telegram bot only
+  wispy --discord                 — start Discord bot only
+  wispy --slack                   — start Slack bot only
+`);
+  }
+  process.exit(0);
+}
+
+// ── Bot / serve modes ─────────────────────────────────────────────────────────
+const serveMode    = args.includes("--serve");
+const telegramMode = args.includes("--telegram");
+const discordMode  = args.includes("--discord");
+const slackMode    = args.includes("--slack");
+
+if (serveMode || telegramMode || discordMode || slackMode) {
+  const { ChannelManager } = await import(
+    path.join(__dirname, "..", "lib", "channels", "index.mjs")
+  );
+
+  const manager = new ChannelManager();
+
+  const only = [];
+  if (telegramMode) only.push("telegram");
+  if (discordMode)  only.push("discord");
+  if (slackMode)    only.push("slack");
+  // serveMode → only stays empty → all channels started
+
+  await manager.startAll(only);
+
+  // Keep process alive and stop cleanly on Ctrl+C
+  process.on("SIGINT",  async () => { await manager.stopAll(); process.exit(0); });
+  process.on("SIGTERM", async () => { await manager.stopAll(); process.exit(0); });
+
+  // Prevent Node from exiting
+  setInterval(() => {}, 60_000);
+  // eslint-disable-next-line no-constant-condition
+  await new Promise(() => {}); // keep alive
+}
+
+// ── TUI mode ──────────────────────────────────────────────────────────────────
 const tuiMode = args.includes("--tui");
 
 if (tuiMode) {
-  // Remove --tui from args so wispy-tui doesn't see it
   const newArgs = args.filter(a => a !== "--tui");
   process.argv = [process.argv[0], process.argv[1], ...newArgs];
   const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
   await import(tuiScript);
 } else {
+  // Default: interactive REPL
   const mainScript = path.join(__dirname, "..", "lib", "wispy-repl.mjs");
   await import(mainScript);
 }

package/lib/channels/base.mjs

@@ -0,0 +1,66 @@
+/**
+ * Base ChannelAdapter — abstract interface for all channel adapters
+ *
+ * Normalized message format:
+ *   { chatId, userId, username, text, raw }
+ */
+
+export class ChannelAdapter {
+  constructor(config = {}) {
+    this.config = config;
+    this._messageCallback = null;
+  }
+
+  /**
+   * Start the adapter (connect, begin polling, etc.)
+   * @returns {Promise<void>}
+   */
+  async start() {
+    throw new Error(`${this.constructor.name}.start() not implemented`);
+  }
+
+  /**
+   * Stop the adapter gracefully.
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    throw new Error(`${this.constructor.name}.stop() not implemented`);
+  }
+
+  /**
+   * Send a message to a specific chat.
+   * @param {string} chatId
+   * @param {string} text
+   * @returns {Promise<void>}
+   */
+  async sendMessage(chatId, text) {
+    throw new Error(`${this.constructor.name}.sendMessage() not implemented`);
+  }
+
+  /**
+   * Register a callback invoked when a message arrives.
+   * @param {(msg: NormalizedMessage) => void} callback
+   */
+  onMessage(callback) {
+    this._messageCallback = callback;
+  }
+
+  /**
+   * Emit a normalized message to registered callback.
+   * @protected
+   */
+  _emit(chatId, userId, username, text, raw) {
+    if (this._messageCallback) {
+      this._messageCallback({ chatId, userId, username, text, raw });
+    }
+  }
+}
+
+/**
+ * @typedef {Object} NormalizedMessage
+ * @property {string} chatId    - Unique chat / channel / DM identifier
+ * @property {string} userId    - Sender identifier
+ * @property {string} username  - Human-readable sender name
+ * @property {string} text      - Plain text content of the message
+ * @property {*}      raw       - Original platform event object
+ */

package/lib/channels/discord.mjs

@@ -0,0 +1,144 @@
+/**
+ * Discord channel adapter — uses discord.js v14
+ *
+ * Token priority:
+ *   1. WISPY_DISCORD_TOKEN env var
+ *   2. ~/.wispy/channels.json  → discord.token
+ *
+ * Trigger conditions:
+ *   - Bot is mentioned (@Wispy ...)
+ *   - Message starts with ! command prefix
+ *   - DM to the bot
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+
+export class DiscordAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this._client = null;
+  }
+
+  async start() {
+    let discord;
+    try {
+      discord = await import("discord.js");
+    } catch {
+      throw new Error(
+        'discord.js is not installed. Run: npm install discord.js\n' +
+        '(or: npm install -g discord.js)'
+      );
+    }
+
+    const { Client, GatewayIntentBits, Partials, Events } = discord;
+
+    const token = process.env.WISPY_DISCORD_TOKEN ?? this.config.token;
+    if (!token) {
+      throw new Error(
+        'Discord bot token not found.\n' +
+        'Set WISPY_DISCORD_TOKEN or add "discord": {"token":"..."} to ~/.wispy/channels.json'
+      );
+    }
+
+    this._client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+      ],
+      partials: [Partials.Channel, Partials.Message],
+    });
+
+    this._client.once(Events.ClientReady, (readyClient) => {
+      console.log(`🌿 Discord bot ready: ${readyClient.user.tag}`);
+      this._botUserId = readyClient.user.id;
+    });
+
+    this._client.on(Events.MessageCreate, async (message) => {
+      // Ignore own messages
+      if (message.author.bot) return;
+
+      const isDM = !message.guild;
+      const isMentioned = message.mentions.has(this._botUserId ?? "");
+      const isCommand = message.content.startsWith("!");
+
+      if (!isDM && !isMentioned && !isCommand) return;
+
+      const chatId = message.channel.id;
+      const userId = message.author.id;
+      const username = message.author.username;
+
+      // Strip mention from text
+      let text = message.content
+        .replace(/<@!?\d+>/g, "")
+        .trim();
+
+      // Handle ! commands
+      if (isCommand) {
+        const cmd = text.split(/\s+/)[0].toLowerCase();
+        if (cmd === "!clear") {
+          this._emit(chatId, userId, username, "__CLEAR__", message);
+          message.reply("🌿 Conversation cleared!");
+          return;
+        }
+        if (cmd === "!model") {
+          const model = process.env.WISPY_MODEL ?? "(auto)";
+          const provider = process.env.WISPY_PROVIDER ?? "(auto)";
+          message.reply(`🌿 Model: \`${model}\` | Provider: \`${provider}\``);
+          return;
+        }
+        if (cmd === "!help") {
+          message.reply(
+            "**🌿 Wispy Help**\n" +
+            "Mention me (@Wispy) or DM me to chat.\n\n" +
+            "Commands:\n" +
+            "`!clear` — reset this channel's conversation\n" +
+            "`!model` — show current AI model\n" +
+            "`!help` — this message"
+          );
+          return;
+        }
+        // Unknown ! command — pass through to AI
+        text = text.replace(/^!\S+\s*/, "");
+        if (!text) return;
+      }
+
+      if (!text) return;
+
+      this._emit(chatId, userId, username, text, message);
+    });
+
+    await this._client.login(token);
+  }
+
+  async stop() {
+    if (this._client) {
+      await this._client.destroy();
+      this._client = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    if (!this._client) throw new Error("Discord client not started");
+
+    const channel = await this._client.channels.fetch(chatId).catch(() => null);
+    if (!channel) throw new Error(`Discord channel not found: ${chatId}`);
+
+    // Discord limit is 2000 chars
+    const chunks = splitText(text, 1990);
+    for (const chunk of chunks) {
+      await channel.send(chunk);
+    }
+  }
+}
+
+/** Split text into chunks ≤ maxLen characters */
+function splitText(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  for (let i = 0; i < text.length; i += maxLen) {
+    chunks.push(text.slice(i, i + maxLen));
+  }
+  return chunks;
+}

package/lib/channels/index.mjs

@@ -0,0 +1,507 @@
+/**
+ * Channel Manager — loads config, starts/stops adapters, routes messages
+ *
+ * Config: ~/.wispy/channels.json
+ *   {
+ *     "telegram": { "enabled": true, "token": "..." },
+ *     "discord":  { "enabled": true, "token": "..." },
+ *     "slack":    { "enabled": true, "botToken": "...", "appToken": "..." }
+ *   }
+ *
+ * Per-chat conversation history is stored in ~/.wispy/channel-sessions/<channel>/<chatId>.json
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+
+const WISPY_DIR       = path.join(os.homedir(), ".wispy");
+const CHANNELS_CONFIG = path.join(WISPY_DIR, "channels.json");
+const SESSIONS_DIR    = path.join(WISPY_DIR, "channel-sessions");
+
+// ── Config helpers ────────────────────────────────────────────────────────────
+
+export async function loadChannelsConfig() {
+  try {
+    const raw = await readFile(CHANNELS_CONFIG, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export async function saveChannelsConfig(cfg) {
+  await mkdir(WISPY_DIR, { recursive: true });
+  await writeFile(CHANNELS_CONFIG, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+
+// ── Per-chat session storage ──────────────────────────────────────────────────
+
+async function sessionPath(channelName, chatId) {
+  const dir = path.join(SESSIONS_DIR, channelName);
+  await mkdir(dir, { recursive: true });
+  // Sanitize chatId to be filename-safe
+  const safe = String(chatId).replace(/[^a-zA-Z0-9_\-]/g, "_");
+  return path.join(dir, `${safe}.json`);
+}
+
+async function loadSession(channelName, chatId) {
+  try {
+    const raw = await readFile(await sessionPath(channelName, chatId), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+async function saveSession(channelName, chatId, messages) {
+  const p = await sessionPath(channelName, chatId);
+  const trimmed = messages.slice(-50);
+  await writeFile(p, JSON.stringify(trimmed, null, 2) + "\n", "utf8");
+}
+
+async function clearSession(channelName, chatId) {
+  await saveSession(channelName, chatId, []);
+}
+
+// ── AI engine (minimal inline, reuses provider detection from wispy-repl logic)─
+
+import { createInterface } from "node:readline";
+import { appendFile } from "node:fs/promises";
+
+const PROVIDERS = {
+  google:     { envKeys: ["GOOGLE_AI_KEY", "GEMINI_API_KEY"], defaultModel: "gemini-2.5-flash" },
+  anthropic:  { envKeys: ["ANTHROPIC_API_KEY"], defaultModel: "claude-sonnet-4-20250514" },
+  openai:     { envKeys: ["OPENAI_API_KEY"], defaultModel: "gpt-4o" },
+  openrouter: { envKeys: ["OPENROUTER_API_KEY"], defaultModel: "anthropic/claude-sonnet-4-20250514" },
+  groq:       { envKeys: ["GROQ_API_KEY"], defaultModel: "llama-3.3-70b-versatile" },
+  deepseek:   { envKeys: ["DEEPSEEK_API_KEY"], defaultModel: "deepseek-chat" },
+  ollama:     { envKeys: ["OLLAMA_HOST"], defaultModel: "llama3.2", local: true },
+};
+
+function getEnvKey(envKeys) {
+  for (const k of envKeys) { if (process.env[k]) return process.env[k]; }
+  return null;
+}
+
+async function tryKeychainKey(service) {
+  try {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const exec = promisify(execFile);
+    const { stdout } = await exec("security", ["find-generic-password", "-s", service, "-a", "poropo", "-w"], { timeout: 3000 });
+    return stdout.trim() || null;
+  } catch { return null; }
+}
+
+let _detectedProvider = null;
+
+async function getProvider() {
+  if (_detectedProvider) return _detectedProvider;
+
+  // WISPY_PROVIDER override
+  const forced = process.env.WISPY_PROVIDER;
+  if (forced && PROVIDERS[forced]) {
+    const key = getEnvKey(PROVIDERS[forced].envKeys);
+    if (key || PROVIDERS[forced].local) {
+      _detectedProvider = { provider: forced, key, model: process.env.WISPY_MODEL ?? PROVIDERS[forced].defaultModel };
+      return _detectedProvider;
+    }
+  }
+
+  // Config file
+  try {
+    const cfg = JSON.parse(await readFile(path.join(WISPY_DIR, "config.json"), "utf8"));
+    if (cfg.provider && PROVIDERS[cfg.provider]) {
+      const key = getEnvKey(PROVIDERS[cfg.provider].envKeys) ?? cfg.apiKey;
+      if (key || PROVIDERS[cfg.provider].local) {
+        _detectedProvider = { provider: cfg.provider, key, model: cfg.model ?? PROVIDERS[cfg.provider].defaultModel };
+        return _detectedProvider;
+      }
+    }
+  } catch {}
+
+  // Auto-detect env
+  for (const p of ["google","anthropic","openai","openrouter","groq","deepseek","ollama"]) {
+    const key = getEnvKey(PROVIDERS[p].envKeys);
+    if (key || (p === "ollama" && process.env.OLLAMA_HOST)) {
+      _detectedProvider = { provider: p, key, model: process.env.WISPY_MODEL ?? PROVIDERS[p].defaultModel };
+      return _detectedProvider;
+    }
+  }
+
+  // macOS Keychain
+  for (const [service, provider] of [["google-ai-key","google"],["anthropic-api-key","anthropic"],["openai-api-key","openai"]]) {
+    const key = await tryKeychainKey(service);
+    if (key) {
+      process.env[PROVIDERS[provider].envKeys[0]] = key;
+      _detectedProvider = { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
+      return _detectedProvider;
+    }
+  }
+
+  return null;
+}
+
+const OPENAI_COMPAT = {
+  openai:     "https://api.openai.com/v1/chat/completions",
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+  groq:       "https://api.groq.com/openai/v1/chat/completions",
+  deepseek:   "https://api.deepseek.com/v1/chat/completions",
+  ollama:     `${process.env.OLLAMA_HOST ?? "http://localhost:11434"}/v1/chat/completions`,
+};
+
+async function callLLM(messages, providerInfo) {
+  const { provider, key, model } = providerInfo;
+
+  if (provider === "google") {
+    return callGemini(messages, key, model);
+  }
+  if (provider === "anthropic") {
+    return callAnthropic(messages, key, model);
+  }
+  return callOpenAICompat(messages, key, model, provider);
+}
+
+async function callGemini(messages, key, model) {
+  const systemInstruction = messages.find(m => m.role === "system")?.content ?? "";
+  const contents = messages
+    .filter(m => m.role !== "system")
+    .map(m => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }],
+    }));
+
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        system_instruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+        contents,
+        generationConfig: { temperature: 0.7, maxOutputTokens: 4096 },
+      }),
+    }
+  );
+  if (!resp.ok) throw new Error(`Gemini API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
+  const data = await resp.json();
+  return data.candidates?.[0]?.content?.parts?.map(p => p.text ?? "").join("") ?? "";
+}
+
+async function callAnthropic(messages, key, model) {
+  const systemPrompt = messages.find(m => m.role === "system")?.content ?? "";
+  const anthropicMessages = messages.filter(m => m.role !== "system").map(m => ({
+    role: m.role === "assistant" ? "assistant" : "user",
+    content: m.content,
+  }));
+
+  const resp = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-api-key": key, "anthropic-version": "2023-06-01" },
+    body: JSON.stringify({ model, max_tokens: 4096, system: systemPrompt, messages: anthropicMessages }),
+  });
+  if (!resp.ok) throw new Error(`Anthropic API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
+  const data = await resp.json();
+  return data.content?.map(c => c.text ?? "").join("") ?? "";
+}
+
+async function callOpenAICompat(messages, key, model, provider) {
+  const endpoint = OPENAI_COMPAT[provider] ?? OPENAI_COMPAT.openai;
+  const headers = { "Content-Type": "application/json" };
+  if (key) headers["Authorization"] = `Bearer ${key}`;
+  if (provider === "openrouter") headers["HTTP-Referer"] = "https://wispy.dev";
+
+  const oaiMessages = messages.filter(m => m.role !== "tool_result").map(m => ({
+    role: m.role === "assistant" ? "assistant" : m.role,
+    content: m.content,
+  }));
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ model, messages: oaiMessages, temperature: 0.7, max_tokens: 4096 }),
+  });
+  if (!resp.ok) throw new Error(`OpenAI-compat API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
+  const data = await resp.json();
+  return data.choices?.[0]?.message?.content ?? "";
+}
+
+const SYSTEM_PROMPT = `You are Wispy 🌿 — a small ghost AI assistant living in chat platforms.
+You're helpful, concise, and friendly. You can answer questions, write code, help with tasks.
+Keep responses concise and conversational. End each message with 🌿.
+Respond in the same language the user writes in.`;
+
+/**
+ * Process a user message and return Wispy's response.
+ * Maintains per-chat conversation history.
+ */
+export async function processUserMessage(channelName, chatId, userText) {
+  // Handle __CLEAR__ signal
+  if (userText === "__CLEAR__") {
+    await clearSession(channelName, chatId);
+    return null; // Caller should send confirmation
+  }
+
+  const providerInfo = await getProvider();
+  if (!providerInfo) {
+    return "⚠️ No AI provider configured. Run `wispy` first to set up your API key. 🌿";
+  }
+
+  // Load conversation history
+  const history = await loadSession(channelName, chatId);
+
+  // Build messages array
+  const messages = [
+    { role: "system", content: SYSTEM_PROMPT },
+    ...history,
+    { role: "user", content: userText },
+  ];
+
+  let response;
+  try {
+    response = await callLLM(messages, providerInfo);
+  } catch (err) {
+    return `❌ Error: ${err.message.slice(0, 200)} 🌿`;
+  }
+
+  // Save history (keep last 40 turns)
+  const updatedHistory = [
+    ...history,
+    { role: "user", content: userText },
+    { role: "assistant", content: response },
+  ].slice(-40);
+  await saveSession(channelName, chatId, updatedHistory);
+
+  return response;
+}
+
+// ── ChannelManager ────────────────────────────────────────────────────────────
+
+export class ChannelManager {
+  constructor() {
+    this._adapters = new Map(); // name → { adapter, config }
+  }
+
+  /**
+   * Load config, instantiate and start enabled adapters.
+   * @param {string[]} [only] - optional filter to only start specific channels
+   */
+  async startAll(only = []) {
+    const cfg = await loadChannelsConfig();
+
+    const entries = [
+      { name: "telegram", AdapterClass: () => import("./telegram.mjs").then(m => m.TelegramAdapter) },
+      { name: "discord",  AdapterClass: () => import("./discord.mjs").then(m => m.DiscordAdapter) },
+      { name: "slack",    AdapterClass: () => import("./slack.mjs").then(m => m.SlackAdapter) },
+    ];
+
+    for (const { name, AdapterClass } of entries) {
+      if (only.length > 0 && !only.includes(name)) continue;
+
+      const channelCfg = cfg[name] ?? {};
+      if (channelCfg.enabled === false) {
+        console.log(`⏭  ${name}: disabled in config`);
+        continue;
+      }
+
+      // Check if at least one token is present
+      const hasToken = this._hasToken(name, channelCfg);
+      if (!hasToken) {
+        console.log(`⚠  ${name}: no token configured — skipping (run \`wispy channel setup ${name}\`)`);
+        continue;
+      }
+
+      try {
+        const Cls = await AdapterClass();
+        const adapter = new Cls(channelCfg);
+
+        adapter.onMessage(async ({ chatId, userId, username, text }) => {
+          console.log(`[${name}] ${username}: ${text.slice(0, 80)}`);
+          try {
+            const reply = await processUserMessage(name, chatId, text);
+            if (reply) {
+              await adapter.sendMessage(chatId, reply);
+            }
+          } catch (err) {
+            console.error(`[${name}] Error processing message:`, err.message);
+            try {
+              await adapter.sendMessage(chatId, `❌ Error: ${err.message.slice(0, 200)} 🌿`);
+            } catch {}
+          }
+        });
+
+        await adapter.start();
+        this._adapters.set(name, { adapter, config: channelCfg });
+        console.log(`✅ ${name}: started`);
+      } catch (err) {
+        console.error(`❌ ${name}: failed to start — ${err.message}`);
+      }
+    }
+
+    if (this._adapters.size === 0) {
+      console.log("\n🌿 No channels started. Configure channels with:\n");
+      console.log("  wispy channel setup telegram");
+      console.log("  wispy channel setup discord");
+      console.log("  wispy channel setup slack\n");
+    } else {
+      console.log(`\n🌿 ${this._adapters.size} channel(s) running. Press Ctrl+C to stop.\n`);
+    }
+  }
+
+  async stopAll() {
+    for (const [name, { adapter }] of this._adapters) {
+      try {
+        await adapter.stop();
+        console.log(`🛑 ${name}: stopped`);
+      } catch (err) {
+        console.error(`⚠ ${name}: stop error — ${err.message}`);
+      }
+    }
+    this._adapters.clear();
+  }
+
+  _hasToken(name, cfg) {
+    if (name === "telegram") return !!(process.env.WISPY_TELEGRAM_TOKEN ?? cfg.token);
+    if (name === "discord")  return !!(process.env.WISPY_DISCORD_TOKEN  ?? cfg.token);
+    if (name === "slack")    return !!(
+      (process.env.WISPY_SLACK_BOT_TOKEN ?? cfg.botToken) &&
+      (process.env.WISPY_SLACK_APP_TOKEN ?? cfg.appToken)
+    );
+    return false;
+  }
+}
+
+// ── Channel setup CLI helpers ─────────────────────────────────────────────────
+
+export async function channelSetup(channelName) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(r => rl.question(q, r));
+
+  const cfg = await loadChannelsConfig();
+
+  console.log(`\n🌿 Setting up ${channelName} channel\n`);
+
+  if (channelName === "telegram") {
+    console.log("1. Go to https://t.me/BotFather");
+    console.log("2. Send /newbot and follow instructions");
+    console.log("3. Copy the bot token\n");
+    const token = (await ask("  Paste bot token: ")).trim();
+    if (!token) { rl.close(); return; }
+    cfg.telegram = { ...(cfg.telegram ?? {}), enabled: true, token };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ Telegram token saved! Run: wispy --telegram");
+  }
+
+  else if (channelName === "discord") {
+    console.log("1. Go to https://discord.com/developers/applications");
+    console.log("2. Create an app → Bot → Copy token");
+    console.log("3. Enable Message Content Intent in Bot settings\n");
+    const token = (await ask("  Paste bot token: ")).trim();
+    if (!token) { rl.close(); return; }
+    cfg.discord = { ...(cfg.discord ?? {}), enabled: true, token };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ Discord token saved! Run: wispy --discord");
+  }
+
+  else if (channelName === "slack") {
+    console.log("1. Go to https://api.slack.com/apps → Create New App → From scratch");
+    console.log("2. Enable Socket Mode → copy App-Level Token (starts with xapp-)");
+    console.log("3. OAuth & Permissions → copy Bot User OAuth Token (starts with xoxb-)");
+    console.log("4. Subscribe to: app_mention, message.im events");
+    console.log("5. Add /wispy slash command\n");
+    const botToken = (await ask("  Paste bot token (xoxb-...): ")).trim();
+    const appToken = (await ask("  Paste app token (xapp-...): ")).trim();
+    if (!botToken || !appToken) { rl.close(); return; }
+    cfg.slack = { ...(cfg.slack ?? {}), enabled: true, botToken, appToken };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ Slack tokens saved! Run: wispy --slack");
+  }
+
+  else {
+    console.log(`Unknown channel: ${channelName}. Use: telegram, discord, slack`);
+  }
+
+  rl.close();
+}
+
+export async function channelList() {
+  const cfg = await loadChannelsConfig();
+  const channels = ["telegram", "discord", "slack"];
+
+  console.log("\n🌿 Configured channels:\n");
+  for (const name of channels) {
+    const c = cfg[name];
+    if (!c) {
+      console.log(`  ○ ${name.padEnd(10)} not configured`);
+      continue;
+    }
+    const enabled = c.enabled !== false;
+    const hasToken = name === "slack"
+      ? !!(c.botToken && c.appToken)
+      : !!c.token;
+    const status = !hasToken ? "no token" : enabled ? "✅ enabled" : "disabled";
+    console.log(`  ${enabled && hasToken ? "●" : "○"} ${name.padEnd(10)} ${status}`);
+  }
+  console.log(`\nConfig file: ${CHANNELS_CONFIG}\n`);
+}
+
+export async function channelTest(channelName) {
+  const cfg = await loadChannelsConfig();
+  const channelCfg = cfg[channelName] ?? {};
+
+  console.log(`\n🌿 Testing ${channelName} connection...\n`);
+
+  if (channelName === "telegram") {
+    const token = process.env.WISPY_TELEGRAM_TOKEN ?? channelCfg.token;
+    if (!token) { console.log("❌ No token configured"); return; }
+    try {
+      const { Bot } = await import("grammy").catch(() => { throw new Error("grammy not installed — run: npm install grammy"); });
+      const bot = new Bot(token);
+      const me = await bot.api.getMe();
+      console.log(`✅ Connected as @${me.username} (${me.first_name})`);
+      await bot.stop().catch(() => {});
+    } catch (err) {
+      console.log(`❌ ${err.message}`);
+    }
+  }
+
+  else if (channelName === "discord") {
+    const token = process.env.WISPY_DISCORD_TOKEN ?? channelCfg.token;
+    if (!token) { console.log("❌ No token configured"); return; }
+    try {
+      const { Client, GatewayIntentBits } = await import("discord.js").catch(() => { throw new Error("discord.js not installed — run: npm install discord.js"); });
+      const client = new Client({ intents: [GatewayIntentBits.Guilds] });
+      await client.login(token);
+      console.log(`✅ Connected as ${client.user?.tag}`);
+      await client.destroy();
+    } catch (err) {
+      console.log(`❌ ${err.message}`);
+    }
+  }
+
+  else if (channelName === "slack") {
+    const botToken = process.env.WISPY_SLACK_BOT_TOKEN ?? channelCfg.botToken;
+    if (!botToken) { console.log("❌ No bot token configured"); return; }
+    try {
+      const resp = await fetch("https://slack.com/api/auth.test", {
+        headers: { Authorization: `Bearer ${botToken}` },
+      });
+      const data = await resp.json();
+      if (data.ok) {
+        console.log(`✅ Connected as @${data.user} on team ${data.team}`);
+      } else {
+        console.log(`❌ Slack error: ${data.error}`);
+      }
+    } catch (err) {
+      console.log(`❌ ${err.message}`);
+    }
+  }
+
+  else {
+    console.log(`Unknown channel: ${channelName}`);
+  }
+  console.log("");
+}

package/lib/channels/slack.mjs

@@ -0,0 +1,181 @@
+/**
+ * Slack channel adapter — uses @slack/bolt (socket mode)
+ *
+ * Token priority:
+ *   1. WISPY_SLACK_BOT_TOKEN + WISPY_SLACK_APP_TOKEN env vars
+ *   2. ~/.wispy/channels.json  → slack.botToken / slack.appToken
+ *
+ * Triggers:
+ *   - app_mention in channels
+ *   - Direct messages to the bot
+ *   - /wispy slash command
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+
+export class SlackAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this._app = null;
+  }
+
+  async start() {
+    let bolt;
+    try {
+      bolt = await import("@slack/bolt");
+    } catch {
+      throw new Error(
+        '@slack/bolt is not installed. Run: npm install @slack/bolt\n' +
+        '(or: npm install -g @slack/bolt)'
+      );
+    }
+
+    const { App } = bolt;
+
+    const botToken  = process.env.WISPY_SLACK_BOT_TOKEN  ?? this.config.botToken;
+    const appToken  = process.env.WISPY_SLACK_APP_TOKEN  ?? this.config.appToken;
+
+    if (!botToken || !appToken) {
+      throw new Error(
+        'Slack tokens not found.\n' +
+        'Set WISPY_SLACK_BOT_TOKEN and WISPY_SLACK_APP_TOKEN,\n' +
+        'or add them under "slack" in ~/.wispy/channels.json'
+      );
+    }
+
+    this._app = new App({
+      token: botToken,
+      appToken,
+      socketMode: true,
+    });
+
+    // ── app_mention ───────────────────────────────────────────────────────────
+    this._app.event("app_mention", async ({ event, say }) => {
+      const chatId   = event.channel;
+      const userId   = event.user;
+      const username = event.user; // Slack doesn't provide username in event directly
+      const text     = stripMention(event.text ?? "");
+
+      if (!text) {
+        await say("🌿 What can I help you with?");
+        return;
+      }
+
+      // Store say() so sendMessage can reply in-thread
+      this._sayers = this._sayers ?? new Map();
+      this._sayers.set(chatId, say);
+
+      this._emit(chatId, userId, username, text, event);
+    });
+
+    // ── Direct messages ───────────────────────────────────────────────────────
+    this._app.message(async ({ message, say }) => {
+      // Only handle DMs (channel_type === "im") and bot messages
+      if (message.subtype) return; // ignore message subtypes (edits, etc.)
+      if (!message.channel_type || message.channel_type !== "im") return;
+
+      const chatId   = message.channel;
+      const userId   = message.user ?? "";
+      const username = message.user ?? "user";
+      const text     = (message.text ?? "").trim();
+
+      if (!text) return;
+
+      this._sayers = this._sayers ?? new Map();
+      this._sayers.set(chatId, say);
+
+      this._emit(chatId, userId, username, text, message);
+    });
+
+    // ── /wispy slash command ──────────────────────────────────────────────────
+    this._app.command("/wispy", async ({ command, ack, say }) => {
+      await ack();
+
+      const chatId   = command.channel_id;
+      const userId   = command.user_id;
+      const username = command.user_name;
+      const text     = (command.text ?? "").trim();
+
+      if (!text) {
+        await say("🌿 Usage: `/wispy <your message>`");
+        return;
+      }
+
+      // Handle built-in slash subcommands
+      if (text === "clear") {
+        this._emit(chatId, userId, username, "__CLEAR__", command);
+        await say("🌿 Conversation cleared!");
+        return;
+      }
+      if (text === "model") {
+        const model = process.env.WISPY_MODEL ?? "(auto)";
+        await say(`🌿 Model: \`${model}\``);
+        return;
+      }
+      if (text === "help") {
+        await say(
+          "🌿 *Wispy Help*\n" +
+          "• Mention @Wispy in a channel to chat\n" +
+          "• DM Wispy directly\n" +
+          "• Use `/wispy <message>` anywhere\n\n" +
+          "Commands:\n" +
+          "`/wispy clear` — reset conversation\n" +
+          "`/wispy model` — show current AI model\n" +
+          "`/wispy help` — this message"
+        );
+        return;
+      }
+
+      this._sayers = this._sayers ?? new Map();
+      this._sayers.set(chatId, say);
+
+      this._emit(chatId, userId, username, text, command);
+    });
+
+    await this._app.start();
+    console.log("🌿 Slack bot started (socket mode)");
+  }
+
+  async stop() {
+    if (this._app) {
+      await this._app.stop();
+      this._app = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    if (!this._app) throw new Error("Slack app not started");
+
+    // Use stored say() if available (preserves thread context)
+    const say = this._sayers?.get(chatId);
+    if (say) {
+      // Slack has a 3001 char limit for blocks; use chat.postMessage for long text
+      const chunks = splitText(text, 3000);
+      for (const chunk of chunks) {
+        await say(chunk);
+      }
+      return;
+    }
+
+    // Fallback: use web client
+    const chunks = splitText(text, 3000);
+    for (const chunk of chunks) {
+      await this._app.client.chat.postMessage({ channel: chatId, text: chunk });
+    }
+  }
+}
+
+/** Strip leading Slack mention (<@UXXXXX>) from text */
+function stripMention(text) {
+  return text.replace(/^<@[A-Z0-9]+>\s*/i, "").trim();
+}
+
+/** Split text into chunks ≤ maxLen characters */
+function splitText(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  for (let i = 0; i < text.length; i += maxLen) {
+    chunks.push(text.slice(i, i + maxLen));
+  }
+  return chunks;
+}

package/lib/channels/telegram.mjs

@@ -0,0 +1,125 @@
+/**
+ * Telegram channel adapter — uses grammY
+ *
+ * Token priority:
+ *   1. WISPY_TELEGRAM_TOKEN env var
+ *   2. ~/.wispy/channels.json  → telegram.token
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+
+export class TelegramAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this._bot = null;
+  }
+
+  async start() {
+    let grammy;
+    try {
+      grammy = await import("grammy");
+    } catch {
+      throw new Error(
+        'grammy is not installed. Run: npm install grammy\n' +
+        '(or: npm install -g grammy)'
+      );
+    }
+
+    const { Bot, InputFile } = grammy;
+    const token = process.env.WISPY_TELEGRAM_TOKEN ?? this.config.token;
+    if (!token) {
+      throw new Error(
+        'Telegram bot token not found.\n' +
+        'Set WISPY_TELEGRAM_TOKEN or add "telegram": {"token":"..."} to ~/.wispy/channels.json'
+      );
+    }
+
+    this._bot = new Bot(token);
+
+    // ── Commands ─────────────────────────────────────────────────────────────
+    this._bot.command("start", (ctx) => {
+      ctx.reply(
+        "🌿 *Wispy* — AI workspace assistant\n\n" +
+        "Just send me a message and I'll help you out\\.\n\n" +
+        "Commands:\n" +
+        "/clear — reset this chat's conversation\n" +
+        "/model — show current AI model\n" +
+        "/help — show this help",
+        { parse_mode: "MarkdownV2" }
+      );
+    });
+
+    this._bot.command("help", (ctx) => {
+      ctx.reply(
+        "🌿 *Wispy Help*\n\n" +
+        "/start — welcome message\n" +
+        "/clear — reset conversation\n" +
+        "/model — show current model\n" +
+        "/help — this message\n\n" +
+        "Send any message to chat with Wispy\\!",
+        { parse_mode: "MarkdownV2" }
+      );
+    });
+
+    this._bot.command("clear", (ctx) => {
+      const chatId = String(ctx.chat.id);
+      this._emit(chatId, String(ctx.from?.id ?? ""), ctx.from?.username ?? "user", "__CLEAR__", ctx);
+      ctx.reply("🌿 Conversation cleared!");
+    });
+
+    this._bot.command("model", (ctx) => {
+      const model = process.env.WISPY_MODEL ?? "(auto)";
+      const provider = process.env.WISPY_PROVIDER ?? "(auto)";
+      ctx.reply(`🌿 Current model: \`${model}\`\nProvider: \`${provider}\``, { parse_mode: "Markdown" });
+    });
+
+    // ── Regular messages ──────────────────────────────────────────────────────
+    this._bot.on("message:text", (ctx) => {
+      const chatId = String(ctx.chat.id);
+      const userId = String(ctx.from?.id ?? "");
+      const username = ctx.from?.username ?? ctx.from?.first_name ?? "user";
+      const text = ctx.message.text ?? "";
+
+      // Skip command messages that weren't caught above
+      if (text.startsWith("/")) return;
+
+      this._emit(chatId, userId, username, text, ctx);
+    });
+
+    // Start long polling
+    this._bot.start();
+    console.log("🌿 Telegram bot started (long polling)");
+  }
+
+  async stop() {
+    if (this._bot) {
+      await this._bot.stop();
+      this._bot = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    if (!this._bot) throw new Error("Telegram bot not started");
+
+    // Telegram has 4096 char limit per message
+    const chunks = splitText(text, 4000);
+    for (const chunk of chunks) {
+      // Try Markdown first, fall back to plain text if it fails
+      try {
+        await this._bot.api.sendMessage(chatId, chunk, { parse_mode: "Markdown" });
+      } catch {
+        await this._bot.api.sendMessage(chatId, chunk);
+      }
+    }
+  }
+}
+
+/** Split text into chunks ≤ maxLen characters */
+function splitText(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  for (let i = 0; i < text.length; i += maxLen) {
+    chunks.push(text.slice(i, i + maxLen));
+  }
+  return chunks;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wispy-cli",
-  "version": "0.5.0",
-  "description": "🌿 Wispy — AI workspace assistant with multi-agent orchestration",
+  "version": "0.6.1",
+  "description": "🌿 Wispy — AI workspace assistant with multi-agent orchestration and multi-channel bot support",
   "license": "Apache-2.0",
   "author": "Minseo & Poropo",
   "repository": {
@@ -20,7 +20,12 @@
     "claude",
     "openai",
     "tui",
-    "ink"
+    "ink",
+    "telegram",
+    "discord",
+    "slack",
+    "bot",
+    "chatbot"
   ],
   "type": "module",
   "bin": {
@@ -43,6 +48,22 @@
     "ink-text-input": "^6.0.0",
     "react": "^18.3.1"
   },
+  "peerDependencies": {
+    "grammy": ">=1.0.0",
+    "discord.js": ">=14.0.0",
+    "@slack/bolt": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "grammy": {
+      "optional": true
+    },
+    "discord.js": {
+      "optional": true
+    },
+    "@slack/bolt": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20.0.0"
   }