voicecc 1.0.7

package/dashboard/dist/audio-processor.js

@@ -0,0 +1,126 @@
+/**
+ * AudioWorklet processor for browser voice calls.
+ *
+ * Runs in the browser's audio rendering thread. Handles two jobs:
+ * - Mic capture: accumulates input samples into chunks, posts them to main thread
+ * - Speaker playback: reads from a chunk queue fed by main thread, writes to output
+ *
+ * Responsibilities:
+ * - Buffer incoming mic audio and emit fixed-size chunks to main thread
+ * - Accept playback audio from main thread and enqueue into chunk queue
+ * - Provide "clear" support to flush the chunk queue on interruption
+ *
+ * Must be plain JavaScript -- AudioWorklet modules cannot be bundled by Vite.
+ */
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+/** Number of mic samples to accumulate before posting to main thread */
+const CHUNK_SIZE = 512;
+
+// ============================================================================
+// PROCESSOR
+// ============================================================================
+
+class AudioProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+
+    // Mic capture buffer
+    this._micBuffer = new Float32Array(CHUNK_SIZE);
+    this._micBufferIndex = 0;
+
+    // Speaker playback chunk queue
+    this._chunks = [];
+    this._chunkIndex = 0; // read position within current chunk
+
+    // Handle messages from main thread
+    this.port.onmessage = (event) => {
+      const { type, samples } = event.data;
+
+      if (type === "playback" && samples) {
+        this._chunks.push(samples);
+      } else if (type === "clear") {
+        this._chunks.length = 0;
+        this._chunkIndex = 0;
+      }
+    };
+  }
+
+  /**
+   * Read samples from the chunk queue into the output array.
+   * Writes silence (0) when the queue is empty.
+   *
+   * @param {Float32Array} output - Destination array to fill
+   */
+  _readFromQueue(output) {
+    let written = 0;
+
+    while (written < output.length) {
+      if (this._chunks.length === 0) {
+        // Queue empty -- fill remaining with silence
+        for (let i = written; i < output.length; i++) {
+          output[i] = 0;
+        }
+        return;
+      }
+
+      const chunk = this._chunks[0];
+      const available = chunk.length - this._chunkIndex;
+      const needed = output.length - written;
+      const toCopy = Math.min(available, needed);
+
+      for (let i = 0; i < toCopy; i++) {
+        output[written++] = chunk[this._chunkIndex++];
+      }
+
+      if (this._chunkIndex >= chunk.length) {
+        this._chunks.shift();
+        this._chunkIndex = 0;
+      }
+    }
+  }
+
+  /**
+   * Called by the audio rendering thread for each 128-sample frame.
+   *
+   * @param {Float32Array[][]} inputs - Input audio channels (mic)
+   * @param {Float32Array[][]} outputs - Output audio channels (speaker)
+   * @param {Record<string, Float32Array>} parameters - AudioParam values (unused)
+   * @returns {boolean} true to keep the processor alive
+   */
+  process(inputs, outputs, parameters) {
+    // -- Mic capture: accumulate input samples and post chunks --
+    const input = inputs[0];
+    if (input && input[0]) {
+      const inputChannel = input[0];
+      for (let i = 0; i < inputChannel.length; i++) {
+        this._micBuffer[this._micBufferIndex++] = inputChannel[i];
+
+        if (this._micBufferIndex >= CHUNK_SIZE) {
+          // Post a copy to main thread
+          this.port.postMessage({
+            type: "audio",
+            samples: this._micBuffer.slice(),
+          });
+          this._micBufferIndex = 0;
+        }
+      }
+    }
+
+    // -- Speaker playback: read from chunk queue into output (mono -> all channels) --
+    const output = outputs[0];
+    if (output && output[0]) {
+      this._readFromQueue(output[0]);
+      for (let ch = 1; ch < output.length; ch++) {
+        output[ch].set(output[0]);
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor("audio-processor", AudioProcessor);

package/dashboard/dist/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Claude Voice</title>
+    <script type="module" crossorigin src="/assets/index-dAYfRls7.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BXemFrMp.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dashboard/routes/auth.ts

@@ -0,0 +1,119 @@
+/**
+ * Claude Code authentication probe route.
+ *
+ * Runs `claude -p "hi" --output-format json` to check whether the user
+ * is authenticated. When logged out this returns instantly (~30ms) with
+ * exit code 1 and `is_error: true`. When logged in it starts an API call,
+ * so we use a short timeout and kill the process -- if it's still running
+ * after the deadline, the user is authenticated.
+ *
+ * - GET /    -- probe and return { authenticated: boolean }
+ * - POST /login -- open Terminal.app with `claude` for interactive login
+ */
+
+import { Hono } from "hono";
+import { execFile, spawn } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+const CLAUDE_BIN = join(homedir(), ".local", "bin", "claude");
+const PROBE_TIMEOUT_MS = 5_000;
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+/**
+ * Run `claude -p "hi" --output-format json` with stdin closed.
+ *
+ * - Logged out: exits 1 instantly (~30ms) with "Not logged in" in the JSON result.
+ * - Logged in: completes the API call and exits 0 with a JSON response.
+ * - Safety timeout at 5s: kills the process and assumes authenticated.
+ *
+ * @returns true if authenticated, false otherwise
+ */
+async function probeClaudeAuth(): Promise<boolean> {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const done = (value: boolean) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(value);
+    };
+
+    const child = spawn(CLAUDE_BIN, ["-p", "hi", "--output-format", "json"], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const timer = setTimeout(() => {
+      child.kill();
+      done(true);
+    }, PROBE_TIMEOUT_MS);
+
+    let stdout = "";
+    child.stdout.on("data", (chunk: Buffer) => { stdout += chunk.toString(); });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+
+      if (code === 0) {
+        done(true);
+        return;
+      }
+
+      try {
+        const json = JSON.parse(stdout);
+        if (json.is_error && typeof json.result === "string" && json.result.includes("Not logged in")) {
+          done(false);
+          return;
+        }
+      } catch {
+        // couldn't parse JSON
+      }
+
+      done(false);
+    });
+  });
+}
+
+// ============================================================================
+// ROUTES
+// ============================================================================
+
+/**
+ * Create Hono route group for Claude Code auth testing.
+ *
+ * @returns Hono instance with GET / route
+ */
+export function authRoutes(): Hono {
+  const app = new Hono();
+
+  app.get("/", async (c) => {
+    const authenticated = await probeClaudeAuth();
+    return c.json({ authenticated });
+  });
+
+  /** Open Terminal.app with `claude` for interactive login */
+  app.post("/login", async (c) => {
+    const script = `tell application "Terminal"
+  activate
+  do script "${CLAUDE_BIN}"
+end tell`;
+
+    return new Promise((resolve) => {
+      execFile("osascript", ["-e", script], (err) => {
+        if (err) {
+          resolve(c.json({ error: err.message }, 500));
+          return;
+        }
+        resolve(c.json({ success: true }));
+      });
+    });
+  });
+
+  return app;
+}

package/dashboard/routes/browser-call.ts

@@ -0,0 +1,87 @@
+/**
+ * Browser call server management API routes.
+ *
+ * Manages the lifecycle of the browser-server (direct WebSocket audio):
+ * - GET /status -- browser-server running state + tunnel URL
+ * - POST /start -- start tunnel + browser-server (rejects if Twilio server holds the port)
+ * - POST /stop -- stop browser-server + tunnel
+ */
+
+import { Hono } from "hono";
+import { startBrowserCallServer, stopBrowserCallServer, getBrowserCallStatus, isBrowserCallRunning } from "../../services/browser-call-manager.js";
+import { startTunnel, stopTunnel, getTunnelUrl, isTunnelRunning } from "../../services/tunnel.js";
+import { readEnv } from "../../services/env.js";
+import { isRunning as isTwilioRunning } from "../../services/twilio-manager.js";
+
+// ============================================================================
+// STATE
+// ============================================================================
+
+/** Dashboard port -- set by server.ts when calling setDashboardPort */
+let dashboardPort = 0;
+
+/**
+ * Set the dashboard port for browser-server proxying.
+ * Called by server.ts after the Hono server starts listening.
+ *
+ * @param port - The dashboard server port
+ */
+export function setDashboardPort(port: number): void {
+  dashboardPort = port;
+}
+
+// ============================================================================
+// ROUTES
+// ============================================================================
+
+/**
+ * Create Hono route group for browser call operations.
+ *
+ * @returns Hono instance with status, start, stop routes
+ */
+export function browserCallRoutes(): Hono {
+  const app = new Hono();
+
+  /** Get browser call server status + tunnel URL */
+  app.get("/status", (c) => {
+    const status = getBrowserCallStatus();
+    return c.json({ ...status, tunnelUrl: getTunnelUrl() });
+  });
+
+  /** Start tunnel + browser call server */
+  app.post("/start", async (c) => {
+    try {
+      // Port conflict check: Twilio server uses the same port
+      if (isTwilioRunning()) {
+        return c.json({ error: "Twilio server is already running on this port" }, 409);
+      }
+
+      const envVars = await readEnv();
+      const port = parseInt(envVars.TWILIO_PORT || "8080", 10);
+
+      if (!isTunnelRunning()) {
+        await startTunnel(port);
+      }
+
+      if (!isBrowserCallRunning()) {
+        await startBrowserCallServer(dashboardPort);
+      }
+
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to start";
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Stop browser call server. Only stops tunnel if Twilio is also stopped. */
+  app.post("/stop", (c) => {
+    stopBrowserCallServer();
+    if (!isTwilioRunning()) {
+      stopTunnel();
+    }
+    return c.json({ success: true });
+  });
+
+  return app;
+}

package/dashboard/routes/claude-md.ts

@@ -0,0 +1,50 @@
+/**
+ * CLAUDE.md read/write API routes.
+ *
+ * Exposes endpoints to read and write the project's CLAUDE.md file:
+ * - GET / -- read the current CLAUDE.md content
+ * - POST / -- write new content to CLAUDE.md
+ */
+
+import { Hono } from "hono";
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+const CLAUDE_MD_PATH = join(process.cwd(), "CLAUDE.md");
+
+// ============================================================================
+// ROUTES
+// ============================================================================
+
+/**
+ * Create Hono route group for CLAUDE.md operations.
+ *
+ * @returns Hono instance with GET / and POST / routes
+ */
+export function claudeMdRoutes(): Hono {
+  const app = new Hono();
+
+  /** Read the CLAUDE.md file */
+  app.get("/", async (c) => {
+    const content = await readFile(CLAUDE_MD_PATH, "utf-8");
+    return c.json({ content });
+  });
+
+  /** Write new content to CLAUDE.md */
+  app.post("/", async (c) => {
+    const body = await c.req.json<{ content?: string }>();
+
+    if (body.content === undefined) {
+      return c.json({ error: "Missing 'content' in request body" }, 400);
+    }
+
+    await writeFile(CLAUDE_MD_PATH, body.content, "utf-8");
+    return c.json({ success: true });
+  });
+
+  return app;
+}

package/dashboard/routes/conversations.ts

@@ -0,0 +1,203 @@
+/**
+ * Conversation session API routes.
+ *
+ * Lists and reads Claude Code conversation sessions from JSONL log files:
+ * - GET / -- list all sessions with summaries
+ * - GET /:sessionId -- get all messages for a specific session
+ */
+
+import { Hono } from "hono";
+import { readdir, stat, access } from "fs/promises";
+import { join, basename } from "path";
+import { homedir } from "os";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+/** Summary of a conversation session */
+interface ConversationSummary {
+  sessionId: string;
+  firstMessage: string;
+  timestamp: string;
+  messageCount: number;
+}
+
+/** A single conversation turn */
+interface ConversationMessage {
+  role: "user" | "assistant";
+  content: string;
+  timestamp: string;
+}
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+/** Claude Code encodes the project path by replacing "/" with "-" */
+const PROJECT_DIR_NAME = process.cwd().replace(/\//g, "-");
+const SESSIONS_DIR = join(homedir(), ".claude", "projects", PROJECT_DIR_NAME);
+
+// ============================================================================
+// ROUTES
+// ============================================================================
+
+/**
+ * Create Hono route group for conversation operations.
+ *
+ * @returns Hono instance with GET / (list) and GET /:sessionId (detail)
+ */
+export function conversationRoutes(): Hono {
+  const app = new Hono();
+
+  /** List all conversation sessions with summaries */
+  app.get("/", async (c) => {
+    const files = await readdir(SESSIONS_DIR);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+
+    const summaries: ConversationSummary[] = [];
+
+    for (const file of jsonlFiles) {
+      const filePath = join(SESSIONS_DIR, file);
+      const fileStat = await stat(filePath);
+      const sessionId = basename(file, ".jsonl");
+
+      const { firstUserMessage, messageCount } = await extractSessionSummary(filePath);
+
+      summaries.push({
+        sessionId,
+        firstMessage: firstUserMessage,
+        timestamp: fileStat.mtime.toISOString(),
+        messageCount,
+      });
+    }
+
+    summaries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return c.json(summaries);
+  });
+
+  /** Get all messages for a specific session */
+  app.get("/:sessionId", async (c) => {
+    const sessionId = c.req.param("sessionId");
+    const filePath = join(SESSIONS_DIR, `${sessionId}.jsonl`);
+
+    try {
+      await access(filePath);
+    } catch {
+      return c.json({ error: "Session not found" }, 404);
+    }
+
+    const messages = await parseSessionMessages(filePath);
+    return c.json(messages);
+  });
+
+  return app;
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+/**
+ * Read the first user message and count total messages in a session file.
+ *
+ * @param filePath - Absolute path to the JSONL file
+ * @returns The first user message text and total message count
+ */
+async function extractSessionSummary(filePath: string): Promise<{ firstUserMessage: string; messageCount: number }> {
+  let firstUserMessage = "(empty)";
+  let messageCount = 0;
+  let foundFirst = false;
+
+  const rl = createInterface({ input: createReadStream(filePath, "utf-8"), crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "user" && entry.type !== "assistant") continue;
+
+      messageCount++;
+
+      if (!foundFirst && entry.type === "user") {
+        const content = entry.message?.content;
+        if (typeof content === "string") {
+          firstUserMessage = content.slice(0, 120);
+        }
+        foundFirst = true;
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return { firstUserMessage, messageCount };
+}
+
+/**
+ * Parse all user and assistant messages from a session JSONL file.
+ * Deduplicates assistant messages by requestId.
+ *
+ * @param filePath - Absolute path to the JSONL file
+ * @returns Array of ConversationMessage sorted by timestamp
+ */
+async function parseSessionMessages(filePath: string): Promise<ConversationMessage[]> {
+  const messages: ConversationMessage[] = [];
+  const seenUserUuids = new Set<string>();
+  const assistantTexts = new Map<string, { text: string; timestamp: string }>();
+
+  const rl = createInterface({ input: createReadStream(filePath, "utf-8"), crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+
+      if (entry.type === "user" && entry.message?.role === "user") {
+        if (seenUserUuids.has(entry.uuid)) continue;
+        seenUserUuids.add(entry.uuid);
+
+        const content = entry.message.content;
+        if (typeof content === "string" && content.trim()) {
+          messages.push({ role: "user", content, timestamp: entry.timestamp });
+        }
+        continue;
+      }
+
+      if (entry.type === "assistant" && entry.message?.content) {
+        const requestId = entry.requestId;
+        if (!requestId) continue;
+
+        const blocks = entry.message.content;
+        if (!Array.isArray(blocks)) continue;
+
+        const textParts: string[] = [];
+        for (const block of blocks) {
+          if (block.type === "text" && block.text?.trim()) {
+            textParts.push(block.text);
+          }
+        }
+
+        if (textParts.length > 0) {
+          const combined = textParts.join("");
+          const existing = assistantTexts.get(requestId);
+          if (!existing || combined.length > existing.text.length) {
+            assistantTexts.set(requestId, { text: combined, timestamp: entry.timestamp });
+          }
+        }
+        continue;
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  for (const [, { text, timestamp }] of assistantTexts) {
+    messages.push({ role: "assistant", content: text, timestamp });
+  }
+
+  messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  return messages;
+}