talkiebot 0.1.0

package/server/jobs/runner.js

@@ -0,0 +1,246 @@
+import { spawn } from "child_process";
+import { writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+function detectPlanFromTool(toolName, input) {
+  if (toolName !== "Write" && toolName !== "Edit") return null;
+  const filePath = input.file_path || "";
+  const content = input.content || input.new_string || "";
+  if (!content || content.length < 100) return null;
+  const isPlanFile = /plan/i.test(filePath);
+  const headingCount = (content.match(/^#{1,3}\s+.+/gm) || []).length;
+  const listItemCount = (content.match(/^(?:\d+\.|[-*])\s+/gm) || []).length;
+  const hasPlanHeading = /^#{1,3}\s+.*(?:plan|implementation|approach|strategy|roadmap|phases?|proposal)/im.test(content);
+  const hasStructure = headingCount >= 2 && listItemCount >= 4;
+  if (!isPlanFile && !hasPlanHeading && !hasStructure) return null;
+  let title = "Untitled Plan";
+  const titleMatch = content.match(/^#{1,3}\s+(.*(?:plan|implementation|approach|strategy|roadmap|phases?|proposal).*)/im);
+  if (titleMatch) {
+    title = titleMatch[1].replace(/\*\*/g, "").replace(/`/g, "").trim();
+  } else {
+    const firstHeading = content.match(/^#{1,3}\s+(.+)/m);
+    if (firstHeading) {
+      title = firstHeading[1].replace(/\*\*/g, "").replace(/`/g, "").trim();
+    }
+  }
+  if (title.length > 100) title = title.slice(0, 97) + "...";
+  return { title, content };
+}
+function spawnClaude(options) {
+  const { prompt, history, images, rawMode, callbacks } = options;
+  const tempImagePaths = [];
+  if (images && images.length > 0) {
+    const tempDir = join(tmpdir(), "talkie-images");
+    mkdirSync(tempDir, { recursive: true });
+    for (const img of images) {
+      const base64Data = img.dataUrl.split(",")[1];
+      if (!base64Data) continue;
+      const ext = img.fileName.split(".").pop() || "png";
+      const tempPath = join(tempDir, `${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`);
+      writeFileSync(tempPath, Buffer.from(base64Data, "base64"));
+      tempImagePaths.push(tempPath);
+    }
+  }
+  let fullPrompt;
+  if (rawMode) {
+    let imageBlock = "";
+    if (tempImagePaths.length > 0) {
+      imageBlock = "Read these image files and then follow the instructions below:\n" + tempImagePaths.map((p) => p).join("\n") + "\n\n";
+    }
+    fullPrompt = `${imageBlock}${prompt}`;
+  } else {
+    const recentMessages = (history || []).slice(-10);
+    let contextBlock = "";
+    if (recentMessages.length > 0) {
+      contextBlock = "[Recent conversation]\n" + recentMessages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n") + "\n[/Recent conversation]\n\n";
+    }
+    let imageBlock = "";
+    if (tempImagePaths.length > 0) {
+      imageBlock = "[Attached Images - Use the Read tool to view these image files]\n" + tempImagePaths.map((p) => p).join("\n") + "\n[/Attached Images]\n\n";
+    }
+    const isPlanRequest = /\b(?:plan|design|architect|propose|strategy|roadmap|outline)\b/i.test(prompt);
+    const planInstruction = isPlanRequest ? "\n[PLAN MODE - The user is asking you to make a plan. Write the full detailed plan (with markdown headings, numbered steps, etc.) to a file using the Write tool at /tmp/talkie-plan.md. Then give a brief voice summary of what you planned.]" : "";
+    fullPrompt = `${contextBlock}${imageBlock}[VOICE MODE - Keep responses to 1-2 sentences, no markdown, speak naturally]${planInstruction}
+
+User: ${prompt}`;
+  }
+  const args = [
+    "-p",
+    fullPrompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--permission-mode",
+    "bypassPermissions",
+    "--no-session-persistence"
+  ];
+  const claudePath = process.env.CLAUDE_PATH || "claude";
+  console.log("Spawning claude:", claudePath, "prompt length:", fullPrompt.length, rawMode ? "(raw mode)" : "(voice mode)");
+  const env = { ...process.env, FORCE_COLOR: "0" };
+  delete env.CLAUDECODE;
+  const claude = spawn(claudePath, args, {
+    cwd: process.cwd(),
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  let buffer = "";
+  const toolInputs = {};
+  const toolNames = {};
+  let currentToolId = null;
+  claude.stdout.on("data", (data) => {
+    buffer += data.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        if (event.type === "assistant") {
+          const textContent = event.message?.content?.find((c) => c.type === "text");
+          if (textContent?.text) {
+            let text = textContent.text.replace(/<thinking>[\s\S]*?<\/thinking>\s*/g, "");
+            if (text.trim()) {
+              callbacks.onText(text);
+            }
+          }
+          const toolUseBlocks = event.message?.content?.filter((c) => c.type === "tool_use") || [];
+          for (const toolBlock of toolUseBlocks) {
+            if (toolBlock.id && toolBlock.input) {
+              toolInputs[toolBlock.id] = JSON.stringify(toolBlock.input);
+            }
+            let inputDetail = "";
+            if (toolBlock.input) {
+              if (toolBlock.input.file_path) inputDetail = toolBlock.input.file_path;
+              else if (toolBlock.input.command) inputDetail = toolBlock.input.command;
+              else if (toolBlock.input.pattern) inputDetail = toolBlock.input.pattern;
+            }
+            callbacks.onActivity({
+              type: "tool_start",
+              tool: toolBlock.name,
+              id: toolBlock.id,
+              input: inputDetail
+            });
+            if (callbacks.onPlan && toolBlock.input) {
+              const plan = detectPlanFromTool(toolBlock.name, toolBlock.input);
+              if (plan) callbacks.onPlan(plan);
+            }
+          }
+        } else if (event.type === "content_block_start") {
+          if (event.content_block?.type === "tool_use") {
+            currentToolId = event.content_block.id;
+            toolInputs[currentToolId] = "";
+            toolNames[currentToolId] = event.content_block.name;
+            callbacks.onActivity({
+              type: "tool_start",
+              tool: event.content_block.name,
+              id: event.content_block.id
+            });
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta?.type === "text_delta" && event.delta?.text) {
+            let text = event.delta.text.replace(/<thinking>[\s\S]*?<\/thinking>\s*/g, "");
+            if (text) {
+              callbacks.onText(text);
+            }
+          } else if (event.delta?.type === "input_json_delta" && currentToolId) {
+            toolInputs[currentToolId] = (toolInputs[currentToolId] || "") + event.delta.partial_json;
+          }
+        } else if (event.type === "content_block_stop" && currentToolId) {
+          try {
+            const inputJson = toolInputs[currentToolId];
+            if (inputJson) {
+              const input = JSON.parse(inputJson);
+              let inputDetail = "";
+              if (input.file_path) inputDetail = input.file_path;
+              else if (input.command) inputDetail = input.command;
+              else if (input.pattern) inputDetail = input.pattern;
+              if (inputDetail) {
+                callbacks.onActivity({
+                  type: "tool_input",
+                  id: currentToolId,
+                  input: inputDetail
+                });
+              }
+              if (callbacks.onPlan) {
+                const toolName = toolNames[currentToolId] || "";
+                const plan = detectPlanFromTool(toolName, input);
+                if (plan) callbacks.onPlan(plan);
+              }
+            }
+          } catch {
+          }
+          currentToolId = null;
+        } else if (event.type === "result") {
+          const subtype = event.subtype || "complete";
+          callbacks.onActivity({
+            type: "all_complete",
+            status: subtype === "error" ? "error" : "complete"
+          });
+        } else if (event.type === "user") {
+          const toolResults = event.message?.content?.filter((c) => c.type === "tool_result") || [];
+          for (const result of toolResults) {
+            const toolId = result.tool_use_id;
+            const toolName = toolNames[toolId] || "tool";
+            const isError = result.is_error === true;
+            let output = "";
+            if (typeof result.content === "string") {
+              output = result.content.slice(0, 200);
+            } else if (Array.isArray(result.content)) {
+              const textContent = result.content.find((c) => c.type === "text");
+              output = textContent?.text?.slice(0, 200) || "";
+            }
+            callbacks.onActivity({
+              type: "tool_end",
+              tool: toolName,
+              id: toolId,
+              status: isError ? "error" : "complete",
+              output
+            });
+          }
+        }
+      } catch (e) {
+        console.log("Parse error for line:", line.slice(0, 100));
+      }
+    }
+  });
+  claude.stderr.on("data", (data) => {
+    const text = data.toString();
+    console.error("Claude stderr:", text);
+    callbacks.onError(text);
+  });
+  const cleanupTempFiles = () => {
+    for (const p of tempImagePaths) {
+      try {
+        unlinkSync(p);
+      } catch {
+      }
+    }
+  };
+  const promise = new Promise((resolve) => {
+    claude.on("close", (code) => {
+      cleanupTempFiles();
+      callbacks.onComplete(code || 0);
+      resolve(code || 0);
+    });
+    claude.on("error", (err) => {
+      cleanupTempFiles();
+      callbacks.onError(err.message);
+      callbacks.onComplete(1);
+      resolve(1);
+    });
+  });
+  return {
+    pid: claude.pid || 0,
+    kill: () => {
+      try {
+        claude.kill("SIGTERM");
+      } catch {
+      }
+    },
+    promise
+  };
+}
+export {
+  spawnClaude
+};

package/server/notifications/dispatcher.js

@@ -0,0 +1,40 @@
+class NotificationDispatcher {
+  channels = [];
+  register(channel) {
+    if (channel.isAvailable()) {
+      this.channels.push(channel);
+      console.log(`Notification channel registered: ${channel.name}`);
+    } else {
+      console.log(`Notification channel not available: ${channel.name}`);
+    }
+  }
+  unregister(name) {
+    this.channels = this.channels.filter((c) => c.name !== name);
+  }
+  async dispatch(notification) {
+    const results = await Promise.allSettled(
+      this.channels.map((channel) => channel.send(notification))
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const channel = this.channels[i];
+      if (result.status === "rejected") {
+        console.error(`Notification failed on ${channel.name}:`, result.reason);
+      }
+    }
+  }
+  getChannels() {
+    return this.channels.map((c) => c.name);
+  }
+}
+let dispatcher = null;
+function getNotificationDispatcher() {
+  if (!dispatcher) {
+    dispatcher = new NotificationDispatcher();
+  }
+  return dispatcher;
+}
+export {
+  NotificationDispatcher,
+  getNotificationDispatcher
+};

package/server/notifications/macos.js

@@ -0,0 +1,24 @@
+import { spawn } from "child_process";
+function escapeAppleScript(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+class MacOSNotificationChannel {
+  name = "macos";
+  async send(notification) {
+    const title = escapeAppleScript(notification.title);
+    const body = escapeAppleScript(notification.body.slice(0, 200));
+    const sound = notification.type === "job_failed" ? "Basso" : "Glass";
+    const script = `display notification "${body}" with title "${title}" sound name "${sound}"`;
+    return new Promise((resolve) => {
+      const proc = spawn("osascript", ["-e", script]);
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+    });
+  }
+  isAvailable() {
+    return process.platform === "darwin";
+  }
+}
+export {
+  MacOSNotificationChannel
+};

package/server/ssl.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import selfsigned from "selfsigned";
+const TALKIE_DIR = join(homedir(), ".talkie");
+const OLD_DIR = join(homedir(), ".talkboy");
+const CERT_PATH = join(TALKIE_DIR, "cert.pem");
+const KEY_PATH = join(TALKIE_DIR, "key.pem");
+const TAILSCALE_CERT_PATH = join(TALKIE_DIR, "tailscale.crt");
+const TAILSCALE_KEY_PATH = join(TALKIE_DIR, "tailscale.key");
+function getSSLCerts() {
+  if (existsSync(OLD_DIR) && !existsSync(TALKIE_DIR)) {
+    renameSync(OLD_DIR, TALKIE_DIR);
+  }
+  if (!existsSync(TALKIE_DIR)) {
+    mkdirSync(TALKIE_DIR, { recursive: true });
+  }
+  if (existsSync(TAILSCALE_CERT_PATH) && existsSync(TAILSCALE_KEY_PATH)) {
+    console.log("Using Tailscale HTTPS certificates");
+    return {
+      cert: readFileSync(TAILSCALE_CERT_PATH, "utf-8"),
+      key: readFileSync(TAILSCALE_KEY_PATH, "utf-8"),
+      isTailscale: true
+    };
+  }
+  if (existsSync(CERT_PATH) && existsSync(KEY_PATH)) {
+    return {
+      cert: readFileSync(CERT_PATH, "utf-8"),
+      key: readFileSync(KEY_PATH, "utf-8")
+    };
+  }
+  console.log("Generating self-signed SSL certificates...");
+  const attrs = [{ name: "commonName", value: "localhost" }];
+  const pems = selfsigned.generate(attrs, {
+    algorithm: "sha256",
+    days: 365,
+    keySize: 2048,
+    extensions: [
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          { type: 7, ip: "127.0.0.1" }
+        ]
+      }
+    ]
+  });
+  writeFileSync(CERT_PATH, pems.cert);
+  writeFileSync(KEY_PATH, pems.private);
+  console.log(`SSL certificates saved to ${TALKIE_DIR}`);
+  return {
+    cert: pems.cert,
+    key: pems.private
+  };
+}
+export {
+  getSSLCerts
+};

package/server/state.js

@@ -0,0 +1,30 @@
+let state = {
+  avatarState: "idle",
+  transcript: "",
+  lastUserMessage: "",
+  lastAssistantMessage: "",
+  messages: [],
+  claudeSessionId: null,
+  pendingMessage: null,
+  responseCallbacks: []
+};
+function updateState(update) {
+  state = { ...state, ...update };
+}
+function resetState() {
+  state = {
+    avatarState: "idle",
+    transcript: "",
+    lastUserMessage: "",
+    lastAssistantMessage: "",
+    messages: [],
+    claudeSessionId: null,
+    pendingMessage: null,
+    responseCallbacks: []
+  };
+}
+export {
+  resetState,
+  state,
+  updateState
+};

package/server/telegram/commands.js

@@ -0,0 +1,160 @@
+import { InlineKeyboard } from "grammy";
+import * as conversations from "../db/repositories/conversations.js";
+import * as telegramState from "../db/repositories/telegram.js";
+const WEB_UI_URL = process.env.TALKIE_URL || "https://localhost:5173";
+function setupCommands(bot) {
+  bot.command("start", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    await ctx.reply(
+      `Welcome to Talkie!
+
+I'm your mobile interface to Claude Code conversations.
+
+Commands:
+/conversations - List recent conversations
+/new <name> - Create new conversation
+/current - Show current conversation
+/status - Check what Claude is doing
+/help - Show this message
+
+Web UI: ${WEB_UI_URL}
+
+Just send me a text message to chat with Claude!`
+    );
+  });
+  bot.command("help", async (ctx) => {
+    await ctx.reply(
+      `Talkie Commands:
+
+/conversations - List recent conversations
+/new <name> - Create new conversation
+/current - Show current conversation
+/status - Check what Claude is doing
+/help - Show this message
+
+Send any text message to continue your current conversation.`
+    );
+  });
+  bot.command("conversations", async (ctx) => {
+    const convos = conversations.listConversations(5, 0);
+    if (convos.length === 0) {
+      await ctx.reply("No conversations yet. Send a message or use /new to create one.");
+      return;
+    }
+    const keyboard = new InlineKeyboard();
+    for (const conv of convos) {
+      const title = conv.title.length > 30 ? conv.title.slice(0, 30) + "..." : conv.title;
+      keyboard.text(title, `select_conv:${conv.id}`).row();
+    }
+    keyboard.text("+ Create new", "create_conv");
+    await ctx.reply("Select a conversation:", { reply_markup: keyboard });
+  });
+  bot.command("new", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const name = ctx.match?.trim() || "New conversation";
+    const id = crypto.randomUUID();
+    const conv = conversations.createConversation({ id, title: name });
+    telegramState.setTelegramConversation(userId, conv.id);
+    await ctx.reply(`Created new conversation: "${conv.title}"
+
+Send me a message to start chatting.`);
+  });
+  bot.command("current", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const state = telegramState.getTelegramState(userId);
+    if (!state?.current_conversation_id) {
+      await ctx.reply("No conversation selected. Use /conversations to pick one or /new to create one.");
+      return;
+    }
+    const conv = conversations.getConversation(state.current_conversation_id);
+    if (!conv) {
+      telegramState.setTelegramConversation(userId, null);
+      await ctx.reply("Current conversation no longer exists. Use /conversations to pick a new one.");
+      return;
+    }
+    const keyboard = new InlineKeyboard().text("Switch conversation", "switch_conv").text("Open in web", "open_web");
+    await ctx.reply(
+      `Current conversation: "${conv.title}"
+
+Created: ${new Date(conv.created_at).toLocaleDateString()}
+Last updated: ${new Date(conv.updated_at).toLocaleString()}`,
+      { reply_markup: keyboard }
+    );
+  });
+  bot.command("status", async (ctx) => {
+    try {
+      const { Agent, fetch: undiciFetch } = await import("undici");
+      const response = await undiciFetch(`${WEB_UI_URL}/api/status`, {
+        dispatcher: new Agent({ connect: { rejectUnauthorized: false } })
+      });
+      const data = await response.json();
+      const stateEmoji = {
+        idle: "\u{1F634}",
+        listening: "\u{1F442}",
+        thinking: "\u{1F914}",
+        speaking: "\u{1F5E3}",
+        happy: "\u{1F60A}",
+        confused: "\u{1F615}"
+      };
+      await ctx.reply(
+        `Talkie Status:
+
+Server: ${data.running ? "\u2705 Running" : "\u274C Stopped"}
+Database: ${data.dbStatus === "connected" ? "\u2705 Connected" : "\u26A0\uFE0F Unavailable"}
+Claude: ${stateEmoji[data.avatarState] || "\u2753"} ${data.avatarState}`
+      );
+    } catch {
+      await ctx.reply("Could not reach Talkie server. Is it running?");
+    }
+  });
+  bot.callbackQuery(/^select_conv:(.+)$/, async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const convId = ctx.match[1];
+    const conv = conversations.getConversation(convId);
+    if (!conv) {
+      await ctx.answerCallbackQuery({ text: "Conversation not found" });
+      return;
+    }
+    telegramState.setTelegramConversation(userId, convId);
+    await ctx.answerCallbackQuery({ text: `Switched to: ${conv.title}` });
+    await ctx.editMessageText(`Selected: "${conv.title}"
+
+Send me a message to continue chatting.`);
+  });
+  bot.callbackQuery("create_conv", async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!userId) return;
+    const id = crypto.randomUUID();
+    const conv = conversations.createConversation({ id, title: "New conversation" });
+    telegramState.setTelegramConversation(userId, conv.id);
+    await ctx.answerCallbackQuery({ text: "Created new conversation" });
+    await ctx.editMessageText(`Created new conversation.
+
+Send me a message to start chatting.`);
+  });
+  bot.callbackQuery("switch_conv", async (ctx) => {
+    const convos = conversations.listConversations(5, 0);
+    if (convos.length === 0) {
+      await ctx.answerCallbackQuery({ text: "No conversations available" });
+      return;
+    }
+    const keyboard = new InlineKeyboard();
+    for (const conv of convos) {
+      const title = conv.title.length > 30 ? conv.title.slice(0, 30) + "..." : conv.title;
+      keyboard.text(title, `select_conv:${conv.id}`).row();
+    }
+    keyboard.text("+ Create new", "create_conv");
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText("Select a conversation:", { reply_markup: keyboard });
+  });
+  bot.callbackQuery("open_web", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: `Open ${WEB_UI_URL} in your browser` });
+  });
+}
+export {
+  setupCommands
+};