walkietalkiebot 0.3.0

package/server/telegram/handlers.js

@@ -0,0 +1,299 @@
+import { InlineKeyboard } from "grammy";
+import * as conversations from "../db/repositories/conversations.js";
+import * as messages from "../db/repositories/messages.js";
+import * as telegramState from "../db/repositories/telegram.js";
+import * as activities from "../db/repositories/activities.js";
+const WEB_UI_URL = process.env.WTB_URL || "https://localhost:5173";
+function setupHandlers(bot) {
+  bot.on("message:text", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const text = ctx.message.text;
+    if (text.startsWith("/")) return;
+    let state = telegramState.getTelegramState(userId);
+    if (!state?.current_conversation_id) {
+      const id = crypto.randomUUID();
+      const title = text.length > 40 ? text.slice(0, 40) + "..." : text;
+      conversations.createConversation({ id, title });
+      telegramState.setTelegramConversation(userId, id);
+      state = { user_id: userId, current_conversation_id: id, updated_at: Date.now() };
+    }
+    const conversationId = state.current_conversation_id;
+    const conv = conversations.getConversation(conversationId);
+    if (!conv) {
+      telegramState.setTelegramConversation(userId, null);
+      await ctx.reply("Your conversation was deleted. Creating a new one...");
+      const id = crypto.randomUUID();
+      const title = text.length > 40 ? text.slice(0, 40) + "..." : text;
+      conversations.createConversation({ id, title });
+      telegramState.setTelegramConversation(userId, id);
+    }
+    const messageId = crypto.randomUUID();
+    messages.createMessage({
+      id: messageId,
+      conversationId,
+      role: "user",
+      content: text,
+      source: "telegram"
+    });
+    await ctx.replyWithChatAction("typing");
+    try {
+      const { Agent: UndiciAgent, fetch: undiciFetch } = await import("undici");
+      const response = await undiciFetch(`${WEB_UI_URL}/api/claude-code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: text,
+          history: messages.getMessagesForConversation(conversationId).map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        }),
+        dispatcher: new UndiciAgent({ connect: { rejectUnauthorized: false } })
+      });
+      if (!response.ok) {
+        throw new Error(`API error: ${response.status}`);
+      }
+      let fullResponse = "";
+      const toolCalls = [];
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (reader) {
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            const data = line.slice(6);
+            try {
+              const event = JSON.parse(data);
+              if (event.text) {
+                fullResponse += event.text;
+              }
+              if (event.activity) {
+                if (event.activity.type === "tool_start") {
+                  toolCalls.push({
+                    id: event.activity.id || crypto.randomUUID(),
+                    tool: event.activity.tool,
+                    input: event.activity.input,
+                    status: "complete"
+                  });
+                } else if (event.activity.type === "tool_end") {
+                  const tc = toolCalls.find((t) => t.id === event.activity.id);
+                  if (tc) {
+                    tc.status = event.activity.status || "complete";
+                  }
+                }
+              }
+              if (event.error) {
+                console.error("Claude Code error:", event.error);
+              }
+            } catch {
+            }
+          }
+          await ctx.replyWithChatAction("typing");
+        }
+      }
+      if (fullResponse.trim()) {
+        const assistantMessageId = crypto.randomUUID();
+        messages.createMessage({
+          id: assistantMessageId,
+          conversationId,
+          role: "assistant",
+          content: fullResponse,
+          source: "telegram"
+        });
+        if (toolCalls.length > 0) {
+          activities.createActivitiesBatch(
+            toolCalls.map((tc) => ({
+              id: tc.id,
+              conversationId,
+              messageId: assistantMessageId,
+              tool: tc.tool,
+              input: tc.input,
+              status: tc.status,
+              timestamp: Date.now()
+            }))
+          );
+        }
+        const maxLength = 4096;
+        if (fullResponse.length > maxLength) {
+          for (let i = 0; i < fullResponse.length; i += maxLength) {
+            await ctx.reply(fullResponse.slice(i, i + maxLength));
+          }
+        } else {
+          await ctx.reply(fullResponse);
+        }
+      } else {
+        await ctx.reply("I didn't get a response. Please try again.");
+      }
+    } catch (err) {
+      console.error("Error processing Telegram message:", err);
+      const keyboard = new InlineKeyboard().text("Try again", "retry_message");
+      await ctx.reply(
+        "Sorry, I encountered an error processing your message. Make sure the Walkie Talkie Bot server is running and Claude Code is available.",
+        { reply_markup: keyboard }
+      );
+    }
+  });
+  bot.callbackQuery("retry_message", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "Please send your message again" });
+    await ctx.deleteMessage();
+  });
+  bot.on("message:voice", async (ctx) => {
+    await ctx.reply(
+      "Voice messages aren't supported yet. Please type your message instead, or use the web UI for voice input."
+    );
+  });
+  bot.on("message:video", async (ctx) => {
+    await ctx.reply(
+      "Videos aren't supported yet. Please describe what you'd like to share, or use the web UI to attach files."
+    );
+  });
+  bot.on("message:video_note", async (ctx) => {
+    await ctx.reply(
+      "Video messages aren't supported yet. Please type your message instead."
+    );
+  });
+  bot.on("message:photo", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const caption = ctx.message.caption || "";
+    const photos = ctx.message.photo;
+    const photo = photos[photos.length - 1];
+    await ctx.replyWithChatAction("typing");
+    try {
+      const file = await ctx.api.getFile(photo.file_id);
+      const fileUrl = `https://api.telegram.org/file/bot${ctx.api.token}/${file.file_path}`;
+      const imageResponse = await fetch(fileUrl);
+      const imageBuffer = await imageResponse.arrayBuffer();
+      const base64 = Buffer.from(imageBuffer).toString("base64");
+      const mimeType = file.file_path?.endsWith(".png") ? "image/png" : "image/jpeg";
+      const dataUrl = `data:${mimeType};base64,${base64}`;
+      let state = telegramState.getTelegramState(userId);
+      if (!state?.current_conversation_id) {
+        const id = crypto.randomUUID();
+        const title = caption || "Image conversation";
+        conversations.createConversation({ id, title: title.slice(0, 40) });
+        telegramState.setTelegramConversation(userId, id);
+        state = { user_id: userId, current_conversation_id: id, updated_at: Date.now() };
+      }
+      const conversationId = state.current_conversation_id;
+      const { Agent, fetch: undiciFetch } = await import("undici");
+      const analyzeResponse = await undiciFetch(`${WEB_UI_URL}/api/analyze-image`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          dataUrl,
+          fileName: file.file_path || "photo.jpg",
+          type: mimeType,
+          apiKey: process.env.ANTHROPIC_API_KEY
+        }),
+        dispatcher: new Agent({ connect: { rejectUnauthorized: false } })
+      });
+      if (!analyzeResponse.ok) {
+        const error = await analyzeResponse.text();
+        await ctx.reply(`Couldn't analyze image: ${error}
+
+Make sure an API key is configured in Settings.`);
+        return;
+      }
+      const { description } = await analyzeResponse.json();
+      const messageText = caption ? `[Image attached: ${description}]
+
+User says: ${caption}` : `[Image attached: ${description}]
+
+Describe what you see and ask if I have any questions about it.`;
+      const messageId = crypto.randomUUID();
+      messages.createMessage({
+        id: messageId,
+        conversationId,
+        role: "user",
+        content: caption || "[Sent an image]",
+        source: "telegram",
+        images: [{
+          id: crypto.randomUUID(),
+          dataUrl,
+          fileName: file.file_path || "photo.jpg",
+          description
+        }]
+      });
+      const response = await undiciFetch(`${WEB_UI_URL}/api/claude-code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: messageText,
+          history: messages.getMessagesForConversation(conversationId).slice(0, -1).map((m) => ({
+            role: m.role,
+            content: m.content
+          }))
+        }),
+        dispatcher: new Agent({ connect: { rejectUnauthorized: false } })
+      });
+      if (!response.ok) {
+        throw new Error(`API error: ${response.status}`);
+      }
+      let fullResponse = "";
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (reader) {
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            try {
+              const event = JSON.parse(line.slice(6));
+              if (event.text) fullResponse += event.text;
+            } catch {
+            }
+          }
+          await ctx.replyWithChatAction("typing");
+        }
+      }
+      if (fullResponse.trim()) {
+        messages.createMessage({
+          id: crypto.randomUUID(),
+          conversationId,
+          role: "assistant",
+          content: fullResponse,
+          source: "telegram"
+        });
+        const maxLength = 4096;
+        if (fullResponse.length > maxLength) {
+          for (let i = 0; i < fullResponse.length; i += maxLength) {
+            await ctx.reply(fullResponse.slice(i, i + maxLength));
+          }
+        } else {
+          await ctx.reply(fullResponse);
+        }
+      } else {
+        await ctx.reply("I received the image but didn't get a response. Please try again.");
+      }
+    } catch (err) {
+      console.error("Error processing Telegram photo:", err);
+      await ctx.reply(
+        "Sorry, I had trouble processing that image. Make sure the Walkie Talkie Bot server is running and an API key is configured."
+      );
+    }
+  });
+  bot.on("message:document", async (ctx) => {
+    await ctx.reply(
+      "File attachments aren't supported via Telegram yet. Please use the web UI to attach files."
+    );
+  });
+  bot.on("message:sticker", async (ctx) => {
+    await ctx.reply("\u{1F60A}");
+  });
+}
+export {
+  setupHandlers
+};

package/server/telegram/index.js

@@ -0,0 +1,46 @@
+import { Bot } from "grammy";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { setupCommands } from "./commands.js";
+import { setupHandlers } from "./handlers.js";
+let bot = null;
+function getToken() {
+  if (process.env.TELEGRAM_BOT_TOKEN) {
+    return process.env.TELEGRAM_BOT_TOKEN;
+  }
+  const tokenPath = join(homedir(), ".wtb", "telegram.token");
+  if (existsSync(tokenPath)) {
+    return readFileSync(tokenPath, "utf-8").trim();
+  }
+  return null;
+}
+async function startTelegramBot() {
+  const token = getToken();
+  if (!token) {
+    throw new Error("Telegram bot token not found. Set TELEGRAM_BOT_TOKEN env or create ~/.wtb/telegram.token");
+  }
+  bot = new Bot(token);
+  setupCommands(bot);
+  setupHandlers(bot);
+  await bot.start({
+    onStart: () => {
+      console.log("Telegram bot started");
+    }
+  });
+}
+function stopTelegramBot() {
+  if (bot) {
+    bot.stop();
+    bot = null;
+    console.log("Telegram bot stopped");
+  }
+}
+function getBot() {
+  return bot;
+}
+export {
+  getBot,
+  startTelegramBot,
+  stopTelegramBot
+};

package/server/test/helpers.js

@@ -0,0 +1,14 @@
+import Database from "better-sqlite3";
+import { initDbForTesting } from "../db/index.js";
+function createTestDb() {
+  const db = new Database(":memory:");
+  initDbForTesting(db);
+  return db;
+}
+function resetTestDb() {
+  return createTestDb();
+}
+export {
+  createTestDb,
+  resetTestDb
+};

package/skills/export-tape/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: export-tape
+description: Export a Walkie Talkie Bot conversation as markdown or JSON. Use when the user wants to export or share a conversation.
+allowed-tools: list_conversations, export_conversation
+---
+
+# Export Conversation
+
+Export a saved conversation as formatted markdown or structured JSON.
+
+## Steps
+
+1. If the user doesn't specify a conversation, use `list_conversations` to show recent tapes
+2. Use `export_conversation` with the chosen conversation ID
+3. Default format is "markdown". Use "json" if the user wants structured data.
+4. Present the exported content to the user
+
+## Formats
+
+- **markdown**: Human-readable with headers, role labels, and tool activity summary
+- **json**: Full structured data including messages, images, and activities
+
+## Notes
+
+- Works offline (no WTB server needed)
+- Exported markdown includes tool activity history at the end

package/skills/launch-voice/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: launch-voice
+description: Launch Walkie Talkie Bot's voice interface in the browser. Use when the user wants to switch to voice interaction.
+allowed-tools: launch_wtb, get_wtb_status
+---
+
+# Launch Voice UI
+
+Start the Walkie Talkie Bot web server and open the voice interface in the browser.
+
+## Steps
+
+1. Check if WTB is already running with `get_wtb_status`
+2. If not running, use `launch_wtb` to start the server and open the browser
+3. Tell the user the URL (typically https://localhost:5173)
+
+## Requirements
+
+- The `walkietalkiebot` npm package must be installed globally or available via npx
+- Chrome or Edge is recommended (Web Speech API support)
+- The browser will show a certificate warning on first visit (self-signed cert)
+
+## If Not Installed
+
+Tell the user to install with: `npm install -g walkietalkiebot`

package/skills/manage-plans/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: manage-plans
+description: Create, update, and track implementation plans in Walkie Talkie Bot. Use when the user wants to manage structured plans.
+allowed-tools: list_plans, get_plan, create_plan, update_plan, delete_plan
+---
+
+# Manage Plans
+
+Create and manage implementation plans in Walkie Talkie Bot's database.
+
+## Status Workflow
+
+Plans follow this lifecycle:
+1. **draft** — newly created, not yet reviewed
+2. **approved** — reviewed and accepted
+3. **in_progress** — actively being worked on
+4. **completed** — all steps finished
+5. **archived** — stored for reference
+
+## Steps
+
+- **Create**: Use `create_plan` with a title and markdown content. Default status is "draft".
+- **List**: Use `list_plans` to see all plans with their current status.
+- **View**: Use `get_plan` to read the full content of a specific plan.
+- **Update**: Use `update_plan` to change title, content, or advance the status.
+- **Delete**: Use `delete_plan` to permanently remove a plan.
+
+## Notes
+
+- Plans can be linked to conversations via `conversationId`
+- Use markdown formatting in plan content
+- Works offline (no WTB server needed)

package/skills/save-conversation/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: save-conversation
+description: Save the current conversation to Walkie Talkie Bot as a cassette tape. Use when the user wants to archive or save a conversation.
+allowed-tools: create_conversation, add_message, list_conversations
+---
+
+# Save Conversation
+
+Save the current Claude Code conversation as a cassette tape in Walkie Talkie Bot's database.
+
+## Steps
+
+1. Ask the user for a title, or generate one from the conversation topic
+2. Use `create_conversation` to create a new tape with that title
+3. For each meaningful exchange in the conversation, use `add_message` to add it:
+   - Set `role` to "user" or "assistant" as appropriate
+   - Set `source` to "claude-code"
+4. Report the conversation ID and title back to the user
+
+## Notes
+
+- This tool works offline (no WTB server needed)
+- Messages are stored in `~/.wtb/wtb.db`
+- The saved tape will appear in the tape collection when the web UI is running

package/skills/search-tapes/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: search-tapes
+description: Search across all Walkie Talkie Bot conversations for specific content. Use when the user wants to find something they discussed before.
+allowed-tools: search_conversations, get_conversation
+---
+
+# Search Tapes
+
+Full-text search across all saved conversations in Walkie Talkie Bot.
+
+## Steps
+
+1. Use `search_conversations` with the user's query
+2. Present results with conversation titles, matching snippets, and timestamps
+3. If the user wants to see a full conversation, use `get_conversation` with its ID
+
+## Notes
+
+- Uses FTS5 for fast, ranked full-text search
+- Works offline (no WTB server needed)
+- Returns highlighted snippets showing where the match was found