npm - walkietalkiebot - Versions diffs - 0.3.0 - Mend

walkietalkiebot 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/.claude-plugin/plugin.json +8 -0
package/.mcp.json +8 -0
package/README.md +169 -0
package/bin/wtb-server.js +336 -0
package/bin/wtb.js +43 -0
package/dist/Talkie_logo.png +0 -0
package/dist/assets/index-UPnYoRh1.js +81 -0
package/dist/assets/index-VbGv60d-.css +1 -0
package/dist/index.html +14 -0
package/mcp-server/dist/index.js +401 -0
package/package.json +86 -0
package/server/api.js +629 -0
package/server/db/index.js +67 -0
package/server/db/repositories/activities.js +85 -0
package/server/db/repositories/activities.test.js +106 -0
package/server/db/repositories/conversations.js +93 -0
package/server/db/repositories/conversations.test.js +137 -0
package/server/db/repositories/jobs.js +128 -0
package/server/db/repositories/messages.js +98 -0
package/server/db/repositories/messages.test.js +152 -0
package/server/db/repositories/plans.js +57 -0
package/server/db/repositories/plans.test.js +98 -0
package/server/db/repositories/search.js +34 -0
package/server/db/repositories/search.test.js +61 -0
package/server/db/repositories/telegram.js +30 -0
package/server/db/schema.js +165 -0
package/server/index.js +137 -0
package/server/jobs/api.js +108 -0
package/server/jobs/manager.js +231 -0
package/server/jobs/runner.js +246 -0
package/server/notifications/dispatcher.js +40 -0
package/server/notifications/macos.js +24 -0
package/server/notifications/types.js +0 -0
package/server/ssl.js +61 -0
package/server/state.js +30 -0
package/server/telegram/commands.js +160 -0
package/server/telegram/handlers.js +299 -0
package/server/telegram/index.js +46 -0
package/server/test/helpers.js +14 -0
package/skills/export-tape/SKILL.md +26 -0
package/skills/launch-voice/SKILL.md +25 -0
package/skills/manage-plans/SKILL.md +32 -0
package/skills/save-conversation/SKILL.md +24 -0
package/skills/search-tapes/SKILL.md +21 -0

package/dist/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="Walkie Talkie Bot — a voice-first AI assistant for Claude Code. Talk instead of type." />
+    <title>Walkie Talkie Bot</title>
+    <script type="module" crossorigin src="/assets/index-UPnYoRh1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-VbGv60d-.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/mcp-server/dist/index.js ADDED Viewed

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { randomUUID } from "crypto";
+const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WTB_PORT = parseInt(process.env.WTB_PORT || "5173", 10);
+const WTB_URL = `https://localhost:${WTB_PORT}`;
+const POSTHOG_KEY = "phc_j7rWavXkXFqSjJIvxhnnAMX3I5UmkcCsnU8J0sKAzog";
+const TELEMETRY = process.env.WTB_TELEMETRY !== "0";
+function trackTool(toolName, category, ok) {
+  if (!TELEMETRY) return;
+  fetch("https://us.i.posthog.com/capture/", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      api_key: POSTHOG_KEY,
+      event: "mcp_tool_called",
+      distinct_id: "anon",
+      properties: { tool: toolName, category, success: ok }
+    })
+  }).catch(() => {
+  });
+}
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+let wtbProcess = null;
+function jsonResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+async function apiGet(path) {
+  const r = await fetch(`${WTB_URL}${path}`);
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
+}
+async function apiPost(path, body) {
+  const r = await fetch(`${WTB_URL}${path}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
+}
+async function apiPatch(path, body) {
+  const r = await fetch(`${WTB_URL}${path}`, { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
+}
+async function apiPut(path, body) {
+  const r = await fetch(`${WTB_URL}${path}`, { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
+}
+async function apiDelete(path) {
+  const r = await fetch(`${WTB_URL}${path}`, { method: "DELETE" });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
+}
+let db = null;
+async function getDb() {
+  if (db) return db;
+  try {
+    const dbIndex = await import(join(__dirname, "..", "server", "db", "index.js"));
+    dbIndex.initDb();
+    db = {
+      convos: await import(join(__dirname, "..", "server", "db", "repositories", "conversations.js")),
+      msgs: await import(join(__dirname, "..", "server", "db", "repositories", "messages.js")),
+      plans: await import(join(__dirname, "..", "server", "db", "repositories", "plans.js")),
+      search: await import(join(__dirname, "..", "server", "db", "repositories", "search.js")),
+      activities: await import(join(__dirname, "..", "server", "db", "repositories", "activities.js"))
+    };
+    return db;
+  } catch (err) {
+    console.error("DB init failed, falling back to HTTP:", err.message);
+    return null;
+  }
+}
+async function isWtbRunning() {
+  try {
+    return (await fetch(`${WTB_URL}/api/status`)).ok;
+  } catch {
+    return false;
+  }
+}
+function serverNotRunning() {
+  return { error: "Walkie Talkie Bot server not running. Data tools work offline. Start server with: npx walkietalkiebot" };
+}
+async function serverCall(fn) {
+  try {
+    return await fn();
+  } catch {
+    return serverNotRunning();
+  }
+}
+async function launchWtb() {
+  if (await isWtbRunning()) {
+    exec(`open -a "Google Chrome" ${WTB_URL} 2>/dev/null || open ${WTB_URL}`);
+    return { success: true, message: "Walkie Talkie Bot is already running", url: WTB_URL };
+  }
+  return new Promise((resolve) => {
+    wtbProcess = spawn("npx", ["wtb"], { detached: true, stdio: "ignore", env: { ...process.env, WTB_PORT: String(WTB_PORT) } });
+    wtbProcess.unref();
+    let attempts = 0;
+    const check = setInterval(async () => {
+      if (await isWtbRunning()) {
+        clearInterval(check);
+        resolve({ success: true, message: "Walkie Talkie Bot launched", url: WTB_URL });
+      } else if (++attempts > 30) {
+        clearInterval(check);
+        resolve({ success: false, message: "Walkie Talkie Bot failed to start" });
+      }
+    }, 500);
+  });
+}
+function formatMarkdown(conv, messages, activities) {
+  let md = `# ${conv.title || "Untitled"}
+`;
+  if (conv.created_at) md += `*Created: ${new Date(conv.created_at).toLocaleString()}*
+---
+`;
+  for (const msg of messages) {
+    md += `**${msg.role === "user" ? "You" : "Assistant"}:**
+${msg.content}
+---
+`;
+  }
+  if (activities.length) {
+    md += "## Tool Activity\n\n";
+    for (const a of activities) md += `- **${a.tool}** (${a.status})${a.duration ? ` ${a.duration}ms` : ""}
+`;
+  }
+  return md;
+}
+const server = new Server(
+  { name: "wtb", version: "0.3.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    // ── Server tools (require running WTB server) ──
+    { name: "launch_wtb", description: "Launch the Walkie Talkie Bot voice interface in a browser.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_wtb_status", description: "Check if Walkie Talkie Bot is running and get its current state.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_transcript", description: "Get the latest voice transcript.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_conversation_history", description: "Get the full conversation history from the current tape.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_claude_session", description: "Get the current Claude Code session ID.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "set_claude_session", description: "Connect to a Claude Code session.", inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID to connect to" } }, required: ["sessionId"] } },
+    { name: "disconnect_claude_session", description: "Disconnect the current Claude Code session.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_pending_message", description: "Poll for a pending user message in IPC mode.", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "respond_to_wtb", description: "Send a response back in IPC mode.", inputSchema: { type: "object", properties: { content: { type: "string", description: "Response content" } }, required: ["content"] } },
+    { name: "update_wtb_state", description: "Update UI state (avatar state, transcript).", inputSchema: { type: "object", properties: { avatarState: { type: "string", enum: ["idle", "listening", "thinking", "speaking"], description: "Avatar state" }, transcript: { type: "string", description: "Transcript text" } }, required: [] } },
+    { name: "analyze_image", description: "Analyze an image using Claude vision API.", inputSchema: { type: "object", properties: { dataUrl: { type: "string", description: "Base64 data URL of the image" }, fileName: { type: "string", description: "Optional filename" }, apiKey: { type: "string", description: "Optional Anthropic API key" } }, required: ["dataUrl"] } },
+    { name: "open_url", description: "Open a URL in the default browser.", inputSchema: { type: "object", properties: { url: { type: "string", description: "URL to open" } }, required: ["url"] } },
+    { name: "create_wtb_job", description: "Create a background job.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" }, prompt: { type: "string", description: "Task/prompt to execute" } }, required: ["conversationId", "prompt"] } },
+    { name: "get_wtb_job", description: "Get the status and result of a background job.", inputSchema: { type: "object", properties: { jobId: { type: "string", description: "Job ID" } }, required: ["jobId"] } },
+    { name: "list_wtb_jobs", description: "List background jobs, optionally filtered by status.", inputSchema: { type: "object", properties: { status: { type: "string", enum: ["queued", "running", "completed", "failed", "cancelled"], description: "Filter by status" } }, required: [] } },
+    // ── Data tools (work offline via direct SQLite) ──
+    { name: "list_conversations", description: "List all saved conversations (cassette tapes). Works offline.", inputSchema: { type: "object", properties: { limit: { type: "number", description: "Max results (default 50)" }, offset: { type: "number", description: "Pagination offset (default 0)" } }, required: [] } },
+    { name: "get_conversation", description: "Get a full conversation by ID with messages, images, and tool activity. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" } }, required: ["conversationId"] } },
+    { name: "create_conversation", description: "Create a new conversation (cassette tape). Works offline.", inputSchema: { type: "object", properties: { title: { type: "string", description: "Conversation title" }, id: { type: "string", description: "Optional custom ID" } }, required: [] } },
+    { name: "rename_conversation", description: "Rename an existing conversation. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" }, title: { type: "string", description: "New title" } }, required: ["conversationId", "title"] } },
+    { name: "delete_conversation", description: "Delete a conversation permanently. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" } }, required: ["conversationId"] } },
+    { name: "search_conversations", description: "Full-text search across all conversations. Uses FTS5 for ranked results. Works offline.", inputSchema: { type: "object", properties: { query: { type: "string", description: "Search query" }, limit: { type: "number", description: "Max results (default 50)" } }, required: ["query"] } },
+    { name: "add_message", description: "Add a message to a conversation. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" }, role: { type: "string", enum: ["user", "assistant"], description: "Message role" }, content: { type: "string", description: "Message content" }, source: { type: "string", description: 'Source (default "mcp")' } }, required: ["conversationId", "role", "content"] } },
+    { name: "list_plans", description: "List all plans. Works offline.", inputSchema: { type: "object", properties: { limit: { type: "number", description: "Max results (default 50)" }, offset: { type: "number", description: "Pagination offset (default 0)" } }, required: [] } },
+    { name: "get_plan", description: "Get a plan by ID with full content. Works offline.", inputSchema: { type: "object", properties: { planId: { type: "string", description: "Plan ID" } }, required: ["planId"] } },
+    { name: "create_plan", description: "Create a new plan with status workflow (draft > approved > in_progress > completed > archived). Works offline.", inputSchema: { type: "object", properties: { title: { type: "string", description: "Plan title" }, content: { type: "string", description: "Plan content (markdown)" }, status: { type: "string", enum: ["draft", "approved", "in_progress", "completed", "archived"], description: 'Initial status (default "draft")' }, conversationId: { type: "string", description: "Link to conversation" } }, required: ["title", "content"] } },
+    { name: "update_plan", description: "Update a plan's title, content, or status. Works offline.", inputSchema: { type: "object", properties: { planId: { type: "string", description: "Plan ID" }, title: { type: "string", description: "New title" }, content: { type: "string", description: "New content" }, status: { type: "string", enum: ["draft", "approved", "in_progress", "completed", "archived"], description: "New status" } }, required: ["planId"] } },
+    { name: "delete_plan", description: "Delete a plan permanently. Works offline.", inputSchema: { type: "object", properties: { planId: { type: "string", description: "Plan ID" } }, required: ["planId"] } },
+    { name: "get_liner_notes", description: "Get liner notes (markdown annotations) for a conversation. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" } }, required: ["conversationId"] } },
+    { name: "set_liner_notes", description: "Set or clear liner notes for a conversation. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" }, linerNotes: { type: "string", description: "Markdown content (or null to clear)" } }, required: ["conversationId"] } },
+    { name: "export_conversation", description: "Export a conversation as markdown or JSON. Works offline.", inputSchema: { type: "object", properties: { conversationId: { type: "string", description: "Conversation ID" }, format: { type: "string", enum: ["markdown", "json"], description: 'Export format (default "markdown")' } }, required: ["conversationId"] } }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+  const typedArgs = args;
+  try {
+    const serverTools = {
+      launch_wtb: () => launchWtb(),
+      get_wtb_status: () => serverCall(() => apiGet("/api/status")),
+      get_transcript: () => serverCall(() => apiGet("/api/transcript")),
+      get_conversation_history: () => serverCall(() => apiGet("/api/history")),
+      get_claude_session: () => serverCall(() => apiGet("/api/session")),
+      set_claude_session: () => serverCall(() => apiPost("/api/session", { sessionId: typedArgs.sessionId })),
+      disconnect_claude_session: () => serverCall(() => apiDelete("/api/session")),
+      get_pending_message: () => serverCall(() => apiGet("/api/pending")),
+      respond_to_wtb: () => serverCall(() => apiPost("/api/respond", { content: typedArgs.content })),
+      update_wtb_state: () => serverCall(() => apiPost("/api/state", typedArgs)),
+      analyze_image: () => serverCall(() => {
+        const a = typedArgs;
+        return apiPost("/api/analyze-image", { dataUrl: a.dataUrl, fileName: a.fileName, apiKey: a.apiKey });
+      }),
+      open_url: () => serverCall(() => apiPost("/api/open-url", { url: typedArgs.url })),
+      create_wtb_job: () => serverCall(() => {
+        const a = typedArgs;
+        return apiPost("/api/jobs", { conversationId: a.conversationId, prompt: a.prompt, source: "mcp" });
+      }),
+      get_wtb_job: () => serverCall(() => apiGet(`/api/jobs/${typedArgs.jobId}`)),
+      list_wtb_jobs: () => serverCall(() => {
+        const a = typedArgs;
+        return apiGet(`/api/jobs${a.status ? `?status=${a.status}` : ""}`);
+      })
+    };
+    if (serverTools[name]) {
+      const result = await serverTools[name]();
+      trackTool(name, "server", !("error" in result));
+      return jsonResult(result);
+    }
+    const d = await getDb();
+    if (!d) {
+      return jsonResult(await serverCall(async () => {
+        switch (name) {
+          case "list_conversations": {
+            const a = typedArgs;
+            return await apiGet(`/api/conversations?limit=${a.limit || 50}&offset=${a.offset || 0}`);
+          }
+          case "get_conversation":
+            return await apiGet(`/api/conversations/${typedArgs.conversationId}`);
+          case "create_conversation": {
+            const a = typedArgs;
+            return await apiPost("/api/conversations", { title: a.title || "New conversation", ...a.id && { id: a.id } });
+          }
+          case "rename_conversation": {
+            const a = typedArgs;
+            return await apiPatch(`/api/conversations/${a.conversationId}`, { title: a.title });
+          }
+          case "delete_conversation":
+            return await apiDelete(`/api/conversations/${typedArgs.conversationId}`);
+          case "search_conversations": {
+            const a = typedArgs;
+            return await apiGet(`/api/search?q=${encodeURIComponent(a.query)}&limit=${a.limit || 50}`);
+          }
+          case "add_message": {
+            const a = typedArgs;
+            return await apiPost(`/api/conversations/${a.conversationId}/messages`, { role: a.role, content: a.content, source: a.source || "mcp" });
+          }
+          case "list_plans": {
+            const a = typedArgs;
+            return await apiGet(`/api/plans?limit=${a.limit || 50}&offset=${a.offset || 0}`);
+          }
+          case "get_plan":
+            return await apiGet(`/api/plans/${typedArgs.planId}`);
+          case "create_plan": {
+            const a = typedArgs;
+            return await apiPost("/api/plans", { title: a.title, content: a.content, status: a.status || "draft", conversationId: a.conversationId });
+          }
+          case "update_plan": {
+            const a = typedArgs;
+            const b = {};
+            if (a.title !== void 0) b.title = a.title;
+            if (a.content !== void 0) b.content = a.content;
+            if (a.status !== void 0) b.status = a.status;
+            return await apiPut(`/api/plans/${a.planId}`, b);
+          }
+          case "delete_plan":
+            return await apiDelete(`/api/plans/${typedArgs.planId}`);
+          case "get_liner_notes":
+            return await apiGet(`/api/conversations/${typedArgs.conversationId}/liner-notes`);
+          case "set_liner_notes": {
+            const a = typedArgs;
+            return await apiPut(`/api/conversations/${a.conversationId}/liner-notes`, { linerNotes: a.linerNotes ?? null });
+          }
+          case "export_conversation": {
+            const a = typedArgs;
+            const conv = await apiGet(`/api/conversations/${a.conversationId}`);
+            if (conv.error) return conv;
+            return a.format === "json" ? { format: "json", data: conv } : { format: "markdown", data: formatMarkdown(conv, conv.messages || [], conv.activities || []) };
+          }
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      }));
+    }
+    trackTool(name, "data", true);
+    switch (name) {
+      case "list_conversations": {
+        const a = typedArgs;
+        const convos = d.convos.listConversations(a.limit || 50, a.offset || 0);
+        const total = d.convos.countConversations();
+        return jsonResult({ conversations: convos, total });
+      }
+      case "get_conversation": {
+        const a = typedArgs;
+        const conv = d.convos.getConversation(a.conversationId);
+        if (!conv) return jsonResult({ error: "Conversation not found" });
+        const messages = d.msgs.getMessagesForConversation(a.conversationId);
+        const imageMap = d.msgs.getImagesForMessages(messages.map((m) => m.id));
+        const messagesWithImages = messages.map((m) => ({ ...m, images: imageMap.get(m.id) || [] }));
+        const activities = d.activities.getActivitiesForConversation(a.conversationId);
+        const linerNotes = d.convos.getLinerNotes(a.conversationId);
+        return jsonResult({ ...conv, messages: messagesWithImages, activities, liner_notes: linerNotes });
+      }
+      case "create_conversation": {
+        const a = typedArgs;
+        const id = a.id || randomUUID();
+        const conv = d.convos.createConversation({ id, title: a.title });
+        return jsonResult(conv);
+      }
+      case "rename_conversation": {
+        const a = typedArgs;
+        const conv = d.convos.updateConversation(a.conversationId, { title: a.title });
+        return jsonResult(conv || { error: "Conversation not found" });
+      }
+      case "delete_conversation": {
+        const a = typedArgs;
+        const ok = d.convos.deleteConversation(a.conversationId);
+        return jsonResult({ success: ok });
+      }
+      case "search_conversations": {
+        const a = typedArgs;
+        const results = d.search.searchMessages(a.query, a.limit || 50);
+        return jsonResult({ results });
+      }
+      case "add_message": {
+        const a = typedArgs;
+        const msg = d.msgs.createMessage({
+          id: randomUUID(),
+          conversationId: a.conversationId,
+          role: a.role,
+          content: a.content,
+          source: a.source || "mcp"
+        });
+        return jsonResult(msg);
+      }
+      case "list_plans": {
+        const a = typedArgs;
+        const plans = d.plans.listPlans(a.limit || 50, a.offset || 0);
+        return jsonResult({ plans });
+      }
+      case "get_plan": {
+        const a = typedArgs;
+        const plan = d.plans.getPlan(a.planId);
+        return jsonResult(plan || { error: "Plan not found" });
+      }
+      case "create_plan": {
+        const a = typedArgs;
+        const plan = d.plans.createPlan({
+          id: randomUUID(),
+          title: a.title,
+          content: a.content,
+          status: a.status || "draft",
+          conversationId: a.conversationId || null
+        });
+        return jsonResult(plan);
+      }
+      case "update_plan": {
+        const a = typedArgs;
+        const updates = {};
+        if (a.title !== void 0) updates.title = a.title;
+        if (a.content !== void 0) updates.content = a.content;
+        if (a.status !== void 0) updates.status = a.status;
+        d.plans.updatePlan(a.planId, updates);
+        return jsonResult({ success: true });
+      }
+      case "delete_plan": {
+        const a = typedArgs;
+        d.plans.deletePlan(a.planId);
+        return jsonResult({ success: true });
+      }
+      case "get_liner_notes": {
+        const a = typedArgs;
+        const notes = d.convos.getLinerNotes(a.conversationId);
+        return jsonResult({ conversationId: a.conversationId, linerNotes: notes });
+      }
+      case "set_liner_notes": {
+        const a = typedArgs;
+        d.convos.updateLinerNotes(a.conversationId, a.linerNotes ?? null);
+        return jsonResult({ success: true });
+      }
+      case "export_conversation": {
+        const a = typedArgs;
+        const conv = d.convos.getConversation(a.conversationId);
+        if (!conv) return jsonResult({ error: "Conversation not found" });
+        const messages = d.msgs.getMessagesForConversation(a.conversationId);
+        const activities = d.activities.getActivitiesForConversation(a.conversationId);
+        if (a.format === "json") {
+          const imageMap = d.msgs.getImagesForMessages(messages.map((m) => m.id));
+          const msgsWithImages = messages.map((m) => ({ ...m, images: imageMap.get(m.id) || [] }));
+          return jsonResult({ format: "json", data: { ...conv, messages: msgsWithImages, activities } });
+        }
+        return jsonResult({ format: "markdown", data: formatMarkdown(conv, messages, activities) });
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    trackTool(name, "data", false);
+    return jsonResult({ error: err.message });
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Walkie Talkie Bot MCP server running (30 tools \u2014 15 data + 15 server)");
+}
+main().catch(console.error);

package/package.json ADDED Viewed

@@ -0,0 +1,86 @@
+{
+  "name": "walkietalkiebot",
+  "version": "0.3.0",
+  "description": "Walkie Talkie Bot — a voice-first AI assistant for Claude Code. Use as a Claude Code plugin (30 MCP tools + 5 skills, offline SQLite) or full server (web UI, 6 retro themes, voice, Telegram)",
+  "homepage": "https://walkietalkie.bot",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bengillin/walkietalkiebot"
+  },
+  "type": "module",
+  "bin": {
+    "wtb": "bin/wtb.js",
+    "wtb-server": "bin/wtb-server.js",
+    "wtb-mcp": "mcp-server/dist/index.js"
+  },
+  "files": [
+    "bin/wtb.js",
+    "bin/wtb-server.js",
+    "mcp-server/dist/",
+    "server/**/*.js",
+    "dist/",
+    ".claude-plugin/",
+    "skills/",
+    ".mcp.json"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build && npm run build:server",
+    "build:server": "node scripts/build-server.js",
+    "preview": "vite preview",
+    "lint": "eslint . --ext ts,tsx",
+    "test": "vitest run && vitest run --config vitest.config.server.ts",
+    "test:client": "vitest run",
+    "test:server": "vitest run --config vitest.config.server.ts",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "voice",
+    "ai",
+    "assistant",
+    "mcp",
+    "speech-recognition",
+    "text-to-speech",
+    "cassette",
+    "retro",
+    "themes",
+    "telegram",
+    "tts",
+    "wake-word",
+    "plugin",
+    "sqlite"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@hono/node-server": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
+    "grammy": "^1.21.0",
+    "hono": "^4.4.0",
+    "open": "^10.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "selfsigned": "^2.4.1",
+    "undici": "^7.19.2",
+    "zustand": "^4.5.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-basic-ssl": "^1.1.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "esbuild": "^0.21.0",
+    "eslint": "^8.55.0",
+    "jsdom": "^27.0.1",
+    "typescript": "^5.3.0",
+    "vite": "^5.0.0",
+    "vitest": "^2.1.9"
+  }
+}