pi-tau-mux 1.0.9

package/README.md

@@ -0,0 +1,91 @@
+# pi-tau-mux
+
+**A lightweight client extension that connects Pi to [pi-tau-mux-server](https://github.com/dwainm/pi-tau-mux-server).**
+
+This extension turns your Pi session into a client that registers with the standalone Tau mux server, enabling real-time mirroring in the browser across multiple Pi instances.
+
+## Architecture
+
+```
+┌─────────────┐                    ┌──────────────────────┐                    ┌─────────────┐
+│  Pi TUI     │                    │  pi-tau-mux-server   │                    │  Browser    │
+│  (terminal) │    WebSocket /pi    │  (standalone daemon) │    WebSocket /ws   │  (Tau UI)  │
+│             │◄───────────────────►│                      │◄──────────────────►│             │
+└─────────────┘                    │  Aggregates all      │                    └─────────────┘
+                                   │  Pi instances        │
+┌─────────────┐                    │                      │                    ┌─────────────┐
+│  Pi TUI     │                    │  Serves web UI       │                    │  Phone      │
+│  (another)  │◄───────────────────►│  Scans sessions      │◄──────────────────►│  (QR scan)  │
+└─────────────┘                    └──────────────────────┘                    └─────────────┘
+```
+
+**This extension** = lightweight client (registers, forwards events, unregisters)  
+**[pi-tau-mux-server](https://github.com/dwainm/pi-tau-mux-server)** = standalone server (web UI, session browser, Tailscale support)
+
+## Install
+
+```bash
+pi install git:github.com/dwainm/pi-tau-mux
+```
+
+## Usage
+
+1. **Start the mux server** (one-time or auto-start):
+   ```bash
+   pi-tau-mux-server
+   ```
+   Or let the extension prompt you when Pi starts.
+
+2. **Start Pi normally** — the extension auto-connects to the mux server
+
+3. **Open the web UI** at the URL shown (e.g., `http://localhost:3001` or your Tailscale URL)
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/tauconnect` | Connect to the mux server |
+| `/taudisconnect` | Disconnect from the mux server |
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `TAU_HOST` | `localhost` | Mux server host |
+| `TAU_PORT` | `3001` | Mux server port |
+| `TAU_AUTO_CONNECT` | `1` | Set to `0` to disable auto-connect |
+
+## Features
+
+### Session Mirroring
+- Real-time streaming of messages, tool calls, and thinking blocks
+- Multiple Pi instances can connect to the same mux server
+- Browser shows all active sessions across projects
+
+### Tailscale Support
+The mux server auto-detects Tailscale and uses your Tailscale IP or MagicDNS hostname. Scan the QR code from any device on your tailnet.
+
+### Session Browser
+View history from any past Pi session, grouped by project. Active sessions show a "LIVE" indicator.
+
+## Related
+
+- **[pi-tau-mux-server](https://github.com/dwainm/pi-tau-mux-server)** — The standalone server (install globally)
+- **[pi-coding-agent](https://github.com/mariozechner/pi-coding-agent)** — The Pi coding agent
+- **[Tau (original)](https://github.com/deflating/tau)** — This is a fork with tmux awareness and mux architecture
+
+## Why the Split?
+
+The original Tau ran an HTTP server inside each Pi process. This worked for single instances but caused issues with:
+- Multiple Pi instances (port conflicts)
+- Remote access (needed each port forwarded)
+- Resource usage (server per Pi process)
+
+The mux architecture solves these:
+- **One server** for all Pi instances
+- **One port** to forward or expose via Tailscale
+- **Session aggregation** across all running Pi instances
+
+## License
+
+MIT

package/extensions/imessage-bridge.ts

@@ -0,0 +1,373 @@
+/**
+ * iMessage Bridge Extension
+ *
+ * Connects Pi to iMessage via BlueBubbles REST API.
+ * Polls for incoming messages, injects them as user messages,
+ * and sends assistant responses back via iMessage.
+ *
+ * Config via environment variables:
+ *   BB_PASSWORD  - BlueBubbles server password (default: Zawsx@12)
+ *   BB_URL       - BlueBubbles server URL (default: http://localhost:1234)
+ *   BB_PHONE     - Phone number to bridge (default: +61435599858)
+ *   BB_POLL_INTERVAL - Poll interval in ms (default: 2000)
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as http from "node:http";
+import * as https from "node:https";
+
+const BB_PASSWORD = process.env.BB_PASSWORD || "Zawsx@12";
+const BB_URL = process.env.BB_URL || "http://localhost:1234";
+const BB_PHONE = process.env.BB_PHONE || "+61435599858";
+const BB_POLL_INTERVAL = parseInt(process.env.BB_POLL_INTERVAL || "2000");
+const CHAT_GUID = `iMessage;-;${BB_PHONE}`;
+const ATTACHMENTS_DIR = path.join(process.env.HOME || "~", "claude-memory/imessage/attachments");
+
+export default function (pi: ExtensionAPI) {
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+  let lastMessageTime = 0;
+  let waitingForReply = false; // true when we've injected an iMessage and are waiting for the turn to end
+  let latestCtx: ExtensionContext | null = null;
+  let enabled = false;
+
+  fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+
+  // ═══════════════════════════════════════
+  // HTTP helpers
+  // ═══════════════════════════════════════
+
+  function request(method: string, urlPath: string, body?: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const url = new URL(urlPath, BB_URL);
+      url.searchParams.set("password", BB_PASSWORD);
+
+      const mod = url.protocol === "https:" ? https : http;
+      const payload = body ? JSON.stringify(body) : undefined;
+
+      const req = mod.request(url, {
+        method,
+        headers: payload ? { "Content-Type": "application/json" } : {},
+      }, (res) => {
+        let data = "";
+        res.on("data", (chunk: Buffer) => data += chunk);
+        res.on("end", () => {
+          try { resolve(JSON.parse(data)); }
+          catch { resolve(data); }
+        });
+      });
+
+      req.on("error", reject);
+      if (payload) req.write(payload);
+      req.end();
+    });
+  }
+
+  function downloadAttachment(guid: string, mime: string): Promise<{ path: string; isAudio: boolean } | null> {
+    return new Promise((resolve) => {
+      const url = new URL(`/api/v1/attachment/${guid}/download`, BB_URL);
+      url.searchParams.set("password", BB_PASSWORD);
+
+      const mod = url.protocol === "https:" ? https : http;
+      mod.get(url, (res) => {
+        const contentType = res.headers["content-type"] || mime;
+        const extMap: Record<string, string> = {
+          "image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif",
+          "image/webp": ".webp", "image/heic": ".heic",
+          "video/mp4": ".mp4", "audio/mpeg": ".mp3",
+          "audio/mp4": ".m4a", "audio/x-m4a": ".m4a",
+          "audio/aac": ".aac", "audio/caf": ".caf",
+          "application/pdf": ".pdf",
+        };
+        const isAudio = (contentType || "").startsWith("audio/");
+        const ext = extMap[contentType || ""] || "";
+        const filename = `${guid.replace(/\//g, "_")}${ext}`;
+        const filepath = path.join(ATTACHMENTS_DIR, filename);
+
+        const chunks: Buffer[] = [];
+        res.on("data", (chunk: Buffer) => chunks.push(chunk));
+        res.on("end", () => {
+          fs.writeFileSync(filepath, Buffer.concat(chunks));
+          log(`Downloaded attachment: ${filepath}`);
+          resolve({ path: filepath, isAudio });
+        });
+        res.on("error", () => resolve(null));
+      }).on("error", () => resolve(null));
+    });
+  }
+
+  // ═══════════════════════════════════════
+  // Logging
+  // ═══════════════════════════════════════
+
+  function log(msg: string) {
+    console.log(`[iMessage] ${msg}`);
+  }
+
+  // ═══════════════════════════════════════
+  // Send iMessage via BlueBubbles
+  // ═══════════════════════════════════════
+
+  async function sendIMessage(text: string) {
+    try {
+      await request("POST", "/api/v1/message/text", {
+        chatGuid: CHAT_GUID,
+        message: text,
+      });
+      log(`Sent reply (${text.length} chars)`);
+    } catch (err: any) {
+      log(`Failed to send: ${err.message}`);
+    }
+  }
+
+  async function sendTypingIndicator() {
+    try {
+      await request("POST", `/api/v1/chat/${CHAT_GUID}/typing`);
+    } catch {}
+  }
+
+  // ═══════════════════════════════════════
+  // Poll for new messages
+  // ═══════════════════════════════════════
+
+  async function getLatestMessageTime(): Promise<number> {
+    try {
+      const res = await request("POST", "/api/v1/message/query", {
+        limit: 1, sort: "DESC",
+      });
+      const msgs = res?.data || [];
+      return msgs.length > 0 ? msgs[0].dateCreated || 0 : 0;
+    } catch (err: any) {
+      log(`Error getting latest message time: ${err.message}`);
+      return 0;
+    }
+  }
+
+  async function pollMessages() {
+    if (!enabled || !latestCtx) return;
+
+    try {
+      const res = await request("POST", "/api/v1/message/query", {
+        limit: 20,
+        sort: "DESC",
+        after: lastMessageTime,
+        with: ["chat", "handle", "attachment"],
+      });
+
+      const messages = (res?.data || []).reverse();
+
+      for (const msg of messages) {
+        const msgTime = msg.dateCreated || 0;
+        if (msgTime <= lastMessageTime) continue;
+
+        lastMessageTime = Math.max(lastMessageTime, msgTime);
+
+        // Skip our own messages
+        if (msg.isFromMe) continue;
+
+        // Check it's from Matt
+        const handle = msg.handle || {};
+        const address = handle.address || "";
+        const fromMatt = BB_PHONE && address.includes(BB_PHONE.replace("+", ""));
+        if (!fromMatt) {
+          const chats = msg.chats || [];
+          const chatMatch = chats.some((c: any) => (c.chatIdentifier || "").includes(BB_PHONE));
+          if (!chatMatch) continue;
+        }
+
+        // Process the message
+        await processMessage(msg);
+      }
+    } catch (err: any) {
+      log(`Poll error: ${err.message}`);
+    }
+  }
+
+  async function processMessage(msg: any) {
+    let text = msg.text || "";
+    const attachments = msg.attachments || [];
+
+    const attachmentPaths: string[] = [];
+    let voiceNotePath: string | null = null;
+
+    for (const att of attachments) {
+      const guid = att.guid || "";
+      const mime = att.mimeType || "";
+      if (!guid) continue;
+      const result = await downloadAttachment(guid, mime);
+      if (result) {
+        attachmentPaths.push(result.path);
+        if (result.isAudio) voiceNotePath = result.path;
+      }
+    }
+
+    // Build the message content
+    let fullMessage = text;
+    if (voiceNotePath) {
+      fullMessage = `[Voice note from Matt at ${voiceNotePath} — transcribe and respond]`;
+      if (text) fullMessage += ` (caption: ${text})`;
+    } else if (attachmentPaths.length > 0) {
+      fullMessage += ` [Attachments: ${attachmentPaths.join(", ")}]`;
+    }
+
+    if (!fullMessage.trim()) return;
+
+    log(`From Matt: ${fullMessage.substring(0, 100)}...`);
+
+    // Send typing indicator
+    await sendTypingIndicator();
+
+    // Inject as a real user message
+    waitingForReply = true;
+
+    // Build content array with images if applicable
+    const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
+    const imageAttachments = attachmentPaths.filter(p =>
+      imageExts.some(ext => p.toLowerCase().endsWith(ext))
+    );
+
+    if (imageAttachments.length > 0 && !voiceNotePath) {
+      const content: any[] = [];
+      if (text) content.push({ type: "text", text: `[iMessage from Matt] ${text}` });
+      for (const imgPath of imageAttachments) {
+        try {
+          const imgData = fs.readFileSync(imgPath);
+          const ext = path.extname(imgPath).toLowerCase().replace(".", "");
+          const mediaType = ext === "jpg" ? "image/jpeg" : `image/${ext}`;
+          content.push({
+            type: "image",
+            source: { type: "base64", mediaType, data: imgData.toString("base64") },
+          });
+        } catch {}
+      }
+      pi.sendUserMessage(content, { deliverAs: "followUp" });
+    } else {
+      pi.sendUserMessage(`[iMessage from Matt] ${fullMessage}`, { deliverAs: "followUp" });
+    }
+  }
+
+  // ═══════════════════════════════════════
+  // Capture responses and send back
+  // ═══════════════════════════════════════
+
+  pi.on("turn_end", async (event, ctx) => {
+    if (!enabled || !waitingForReply) return;
+    waitingForReply = false;
+
+    // Extract the assistant's text response from the turn
+    const message = event.message;
+    if (!message) return;
+
+    // Get text content from the message
+    let responseText = "";
+    if (typeof message.content === "string") {
+      responseText = message.content;
+    } else if (Array.isArray(message.content)) {
+      responseText = message.content
+        .filter((b: any) => b.type === "text")
+        .map((b: any) => b.text)
+        .join("\n");
+    }
+
+    if (!responseText.trim()) return;
+
+    // Strip markdown for iMessage (keep it readable)
+    const cleanText = responseText
+      .replace(/```[\s\S]*?```/g, "[code block]") // collapse code blocks
+      .replace(/`([^`]+)`/g, "$1") // inline code → plain
+      .replace(/\*\*([^*]+)\*\*/g, "$1") // bold → plain
+      .replace(/\*([^*]+)\*/g, "$1") // italic → plain
+      .replace(/^#{1,6}\s+/gm, "") // strip headers
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // links → text
+      .trim();
+
+    // iMessage has a practical limit — split long messages
+    const MAX_LEN = 4000;
+    if (cleanText.length <= MAX_LEN) {
+      await sendIMessage(cleanText);
+    } else {
+      // Split on paragraph boundaries
+      const paragraphs = cleanText.split(/\n\n+/);
+      let chunk = "";
+      for (const para of paragraphs) {
+        if (chunk.length + para.length + 2 > MAX_LEN) {
+          if (chunk) await sendIMessage(chunk.trim());
+          chunk = para;
+        } else {
+          chunk += (chunk ? "\n\n" : "") + para;
+        }
+      }
+      if (chunk) await sendIMessage(chunk.trim());
+    }
+  });
+
+  // ═══════════════════════════════════════
+  // Lifecycle
+  // ═══════════════════════════════════════
+
+  pi.on("session_start", async (_event, ctx) => {
+    latestCtx = ctx;
+
+    // Check if BlueBubbles is reachable
+    try {
+      const res = await request("GET", "/api/v1/ping");
+      if (res?.message === "pong") {
+        enabled = true;
+        log("Connected to BlueBubbles");
+        ctx.ui.setStatus("imessage", "📱 iMessage bridge active");
+
+        // Start from current latest message
+        lastMessageTime = await getLatestMessageTime();
+        log(`Starting poll from message time: ${lastMessageTime}`);
+
+        // Start polling
+        if (pollTimer) clearInterval(pollTimer);
+        pollTimer = setInterval(pollMessages, BB_POLL_INTERVAL);
+      } else {
+        log("BlueBubbles not responding — bridge disabled");
+      }
+    } catch (err: any) {
+      log(`BlueBubbles unreachable (${err.message}) — bridge disabled`);
+    }
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+    enabled = false;
+    log("Bridge shut down");
+  });
+
+  // ═══════════════════════════════════════
+  // Commands
+  // ═══════════════════════════════════════
+
+  pi.registerCommand("imessage", {
+    description: "Send an iMessage to Matt",
+    args: [{ name: "message", description: "Message text", required: true }],
+    execute: async (args, ctx) => {
+      if (!enabled) {
+        ctx.ui.notify("iMessage bridge not connected", "error");
+        return;
+      }
+      const text = args.join(" ");
+      await sendIMessage(text);
+      ctx.ui.notify(`Sent iMessage: ${text.substring(0, 50)}...`, "info");
+    },
+  });
+
+  pi.registerCommand("imessage-status", {
+    description: "Check iMessage bridge status",
+    execute: async (_args, ctx) => {
+      ctx.ui.notify(
+        enabled
+          ? `iMessage bridge active. Polling every ${BB_POLL_INTERVAL / 1000}s. Last message time: ${lastMessageTime}`
+          : "iMessage bridge disabled (BlueBubbles unreachable)",
+        "info"
+      );
+    },
+  });
+}