voicecc 1.1.35 → 1.2.0

package/server/voice/chat-server.ts

@@ -1,236 +0,0 @@
-/**
- * Core session management for text chat sessions.
- *
- * Manages ClaudeSession lifecycle for text chat: creation on first message,
- * reuse across messages, and cleanup on close or inactivity timeout.
- * Framework-agnostic -- the Hono route layer in dashboard/routes/chat.ts
- * calls these functions.
- *
- * - getOrCreateSession: lazily creates a session on first message
- * - streamMessage: sends user text to Claude, yields SSE events
- * - closeSession: cleans up a session
- * - Inactivity timeout auto-cleans abandoned sessions after 10 minutes
- */
-
-import { join } from "path";
-
-import { createClaudeSession } from "./claude-session.js";
-import { buildAgentPrompt, buildDefaultPrompt } from "./prompt-builder.js";
-import { acquireSessionLock } from "./session-lock.js";
-import { AGENTS_DIR } from "../services/agent-store.js";
-
-import type { ClaudeSession } from "./claude-session.js";
-import type { SessionLock } from "./session-lock.js";
-import type { ClaudeStreamEvent } from "./types.js";
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-/** Default max concurrent sessions (shared with voice sessions) */
-const DEFAULT_MAX_SESSIONS = 3;
-
-/** Inactivity timeout before auto-cleaning a session (10 minutes) */
-const INACTIVITY_TIMEOUT_MS = 600_000;
-
-/** Interval for checking inactive sessions (60 seconds) */
-const CLEANUP_INTERVAL_MS = 60_000;
-
-// ============================================================================
-// TYPES
-// ============================================================================
-
-/** Tracks an active text chat session */
-interface ActiveChatSession {
-  /** The device token used for this session */
-  deviceToken: string;
-  /** Claude session handle */
-  claudeSession: ClaudeSession;
-  /** Session lock handle */
-  lock: SessionLock;
-  /** Optional agent ID for agent-specific sessions */
-  agentId?: string;
-  /** Whether the session is currently streaming a response */
-  streaming: boolean;
-  /** Timestamp of last activity (used for inactivity timeout) */
-  lastActivity: number;
-}
-
-/** SSE event sent to the client */
-export interface ChatSseEvent {
-  /** Event type */
-  type: "text_delta" | "tool_start" | "tool_end" | "result" | "error";
-  /** Text content or error message */
-  content: string;
-  /** Tool name (only for tool_start events) */
-  toolName?: string;
-}
-
-// ============================================================================
-// STATE
-// ============================================================================
-
-/** Active chat sessions keyed by device token */
-const activeSessions = new Map<string, ActiveChatSession>();
-
-// Start the inactivity cleanup timer
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, session] of activeSessions) {
-    if (now - session.lastActivity > INACTIVITY_TIMEOUT_MS) {
-      console.log(`Chat session timed out due to inactivity, token: ${key}`);
-      closeSession(key).catch((err) => {
-        console.error(`Error cleaning up timed-out chat session: ${err}`);
-      });
-    }
-  }
-}, CLEANUP_INTERVAL_MS);
-
-// ============================================================================
-// MAIN HANDLERS
-// ============================================================================
-
-/**
- * Get or create a chat session for the given token.
- *
- * On first call for a token, acquires a session lock, builds the system
- * prompt, and creates a ClaudeSession. Subsequent calls return the existing
- * session.
- *
- * @param sessionKey - Device token to key the session on
- * @param agentId - Optional agent ID for agent-specific prompts
- * @returns The active chat session
- */
-export async function getOrCreateSession(sessionKey: string, agentId?: string): Promise<ActiveChatSession> {
-  const existing = activeSessions.get(sessionKey);
-  if (existing) return existing;
-
-  const maxSessions = parseInt(process.env.MAX_CONCURRENT_SESSIONS ?? "", 10) || DEFAULT_MAX_SESSIONS;
-  const lock = acquireSessionLock(maxSessions);
-
-  let systemPrompt: string;
-  let cwd: string | undefined;
-
-  if (agentId) {
-    systemPrompt = await buildAgentPrompt(agentId, "text");
-    cwd = join(AGENTS_DIR, agentId);
-    console.log(`Chat session using agent "${agentId}" for token ${sessionKey}`);
-  } else {
-    systemPrompt = buildDefaultPrompt("text");
-  }
-
-  const claudeSession = await createClaudeSession({
-    allowedTools: [],
-    permissionMode: "bypassPermissions",
-    systemPrompt: "",
-    customSystemPrompt: systemPrompt,
-    ...(cwd && { cwd }),
-  });
-
-  const session: ActiveChatSession = {
-    deviceToken: sessionKey,
-    claudeSession,
-    lock,
-    agentId,
-    streaming: false,
-    lastActivity: Date.now(),
-  };
-
-  activeSessions.set(sessionKey, session);
-  console.log(`Chat session created, token: ${sessionKey}`);
-
-  return session;
-}
-
-/**
- * Send a user message and yield SSE events from Claude's response.
- *
- * Sets the streaming flag to prevent concurrent messages. Yields each
- * ClaudeStreamEvent as a ChatSseEvent. Throws if the session is already
- * streaming.
- *
- * @param sessionKey - Device token identifying the session
- * @param text - User message text
- * @yields ChatSseEvent objects for each streaming event
- */
-export async function* streamMessage(sessionKey: string, text: string): AsyncGenerator<ChatSseEvent> {
-  const session = activeSessions.get(sessionKey);
-  if (!session) throw new Error("No active session");
-
-  if (session.streaming) {
-    throw new Error("ALREADY_STREAMING");
-  }
-
-  session.lastActivity = Date.now();
-  session.streaming = true;
-
-  try {
-    const events: AsyncIterable<ClaudeStreamEvent> = session.claudeSession.sendMessage(text);
-
-    for await (const event of events) {
-      const sseEvent: ChatSseEvent = {
-        type: event.type,
-        content: event.content,
-        ...(event.toolName && { toolName: event.toolName }),
-      };
-
-      yield sseEvent;
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "Error during response streaming";
-    console.error(`Stream error for chat token ${sessionKey}:`, err);
-    yield { type: "error", content: msg };
-  } finally {
-    session.streaming = false;
-    session.lastActivity = Date.now();
-  }
-}
-
-/**
- * Close a chat session by closing ClaudeSession, releasing the lock,
- * and removing from the activeSessions map.
- *
- * @param sessionKey - Device token identifying the session
- */
-export async function closeSession(sessionKey: string): Promise<void> {
-  const session = activeSessions.get(sessionKey);
-  if (!session) return;
-
-  activeSessions.delete(sessionKey);
-
-  await session.claudeSession.close();
-  session.lock.release();
-
-  console.log(`Chat session cleaned up, token: ${sessionKey}`);
-}
-
-/**
- * Interrupt the current streaming response for a session.
- *
- * Calls interrupt() on the underlying ClaudeSession to stop generation,
- * and resets the streaming flag so the user can send a new message.
- *
- * @param sessionKey - Device token identifying the session
- * @returns true if a streaming session was interrupted, false if nothing to interrupt
- */
-export function interruptSession(sessionKey: string): boolean {
-  const session = activeSessions.get(sessionKey);
-  if (!session || !session.streaming) return false;
-
-  session.claudeSession.interrupt();
-  session.streaming = false;
-  session.lastActivity = Date.now();
-
-  console.log(`Chat session interrupted, token: ${sessionKey}`);
-  return true;
-}
-
-/**
- * Check if a session exists for the given token.
- *
- * @param sessionKey - Device token to check
- * @returns true if a session exists
- */
-export function hasSession(sessionKey: string): boolean {
-  return activeSessions.has(sessionKey);
-}

package/server/voice/chime.test.ts

@@ -1,69 +0,0 @@
-/**
- * Tests that decodeChimeToPcm produces clean audio without artifacts.
- *
- * The chime PCM is sent directly to the browser as raw int16 samples.
- * If the buffer contains file-format headers, they get played as loud
- * garbage ("bop") before the actual chime.
- *
- * Run: npx tsx --test server/voice/chime.test.ts
- */
-
-import { test } from "node:test";
-import { strict as assert } from "node:assert";
-
-import { decodeChimeToPcm } from "./chime.js";
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-/** Sample rate of the decoded chime */
-const CHIME_RATE = 24000;
-
-/**
- * Max acceptable amplitude for the first 10ms of the chime.
- * Glass.aiff fades in from silence, so early samples should be near-zero.
- * A value above this means non-audio data (e.g. file headers) is present.
- */
-const MAX_AMPLITUDE_FIRST_10MS = 500;
-
-// ============================================================================
-// TESTS
-// ============================================================================
-
-/**
- * The chime starts quietly -- the Glass.aiff sound fades in from silence.
- * If the first samples contain large values, the buffer has non-audio data
- * (file-format headers) that would be heard as a loud pop/bop.
- */
-test("chime PCM starts with near-silent samples (no file header artifacts)", () => {
-  const buf = decodeChimeToPcm();
-  const int16 = new Int16Array(buf.buffer, buf.byteOffset, buf.byteLength / 2);
-
-  const samplesIn10ms = Math.floor(CHIME_RATE * 0.01);
-
-  let maxAmplitude = 0;
-  for (let i = 0; i < samplesIn10ms; i++) {
-    maxAmplitude = Math.max(maxAmplitude, Math.abs(int16[i]));
-  }
-
-  assert.ok(
-    maxAmplitude < MAX_AMPLITUDE_FIRST_10MS,
-    `First 10ms of chime has amplitude ${maxAmplitude} (limit: ${MAX_AMPLITUDE_FIRST_10MS}). ` +
-    `This likely means file-format header bytes are being included as audio data.`
-  );
-});
-
-/**
- * The decoded chime should contain roughly 1-2 seconds of audio.
- * If the buffer is much larger, it likely includes a large file header.
- * If much smaller, the decoding failed.
- */
-test("chime PCM has a plausible duration for Glass.aiff", () => {
-  const buf = decodeChimeToPcm();
-  const sampleCount = buf.byteLength / 2; // int16 = 2 bytes per sample
-  const durationSec = sampleCount / CHIME_RATE;
-
-  assert.ok(durationSec > 0.5, `Chime too short: ${durationSec.toFixed(2)}s`);
-  assert.ok(durationSec < 3.0, `Chime too long: ${durationSec.toFixed(2)}s -- may contain header data`);
-});

package/server/voice/chime.ts

@@ -1,36 +0,0 @@
-/**
- * Shared utility for loading the ready chime as raw PCM.
- *
- * Reads a pre-converted raw 24kHz int16 mono PCM file bundled in init/.
- * Works on both macOS and Linux with no runtime dependencies.
- *
- * Responsibilities:
- * - Load the bundled chime-24k.raw file as a Buffer
- */
-
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/** Path to the bundled raw PCM chime (24kHz int16 mono) */
-const CHIME_PATH = join(__dirname, "..", "..", "init", "chime-24k.raw");
-
-// ============================================================================
-// MAIN ENTRYPOINT
-// ============================================================================
-
-/**
- * Load the bundled chime as raw 24kHz int16 mono PCM.
- *
- * @returns Buffer containing raw 24kHz int16 mono PCM
- * @throws Error if the chime file is missing
- */
-export function decodeChimeToPcm(): Buffer {
-  return readFileSync(CHIME_PATH);
-}

package/server/voice/claude-session.ts

@@ -1,293 +0,0 @@
-/**
- * Claude session via the @anthropic-ai/claude-agent-sdk.
- *
- * Keeps a single persistent Claude Code process alive across turns using
- * streaming I/O (AsyncIterable<SDKUserMessage> input). This eliminates the
- * ~2-3s process spawn overhead on each turn.
- *
- * Responsibilities:
- * - Start a persistent query() on createClaudeSession (process spawns once)
- * - Push user messages into the live session via an async queue
- * - Extract streaming text deltas from SDKPartialAssistantMessage events
- * - Map tool_use content blocks to tool_start / tool_end events
- * - Support interruption via query.interrupt()
- * - Provide clean session teardown
- */
-
-import { query as claudeQuery, type Query, type Options, type SDKMessage, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
-import { buildDefaultPrompt } from "./prompt-builder.js";
-import type { ClaudeSessionConfig, ClaudeStreamEvent } from "./types.js";
-
-/** Injectable query function signature for testing. Matches the SDK query() contract. */
-export type QueryFn = (params: { prompt: AsyncIterable<SDKUserMessage>; options: Options }) => Query;
-
-// ============================================================================
-// ASYNC QUEUE
-// ============================================================================
-
-/** Simple async iterable backed by a push queue. */
-class AsyncQueue<T> implements AsyncIterable<T> {
-  private buf: T[] = [];
-  private resolve: ((r: IteratorResult<T>) => void) | null = null;
-  private done = false;
-
-  push(item: T) {
-    if (this.resolve) {
-      const r = this.resolve;
-      this.resolve = null;
-      r({ value: item, done: false });
-    } else {
-      this.buf.push(item);
-    }
-  }
-
-  close() {
-    this.done = true;
-    if (this.resolve) {
-      const r = this.resolve;
-      this.resolve = null;
-      r({ value: undefined as any, done: true });
-    }
-  }
-
-  /** Discard all buffered items. Used to clear stale events after interruption. */
-  drain(): void {
-    this.buf.length = 0;
-  }
-
-  /** Read one item (used by sendMessage to drain the event channel). */
-  async next(): Promise<T | undefined> {
-    if (this.buf.length > 0) return this.buf.shift()!;
-    if (this.done) return undefined;
-    const result = await new Promise<IteratorResult<T>>((r) => { this.resolve = r; });
-    return result.done ? undefined : result.value;
-  }
-
-  [Symbol.asyncIterator](): AsyncIterator<T> {
-    return {
-      next: (): Promise<IteratorResult<T>> => {
-        if (this.buf.length > 0) {
-          return Promise.resolve({ value: this.buf.shift()!, done: false as const });
-        }
-        if (this.done) {
-          return Promise.resolve({ value: undefined as any, done: true as const });
-        }
-        return new Promise<IteratorResult<T>>((r) => { this.resolve = r; });
-      },
-    };
-  }
-}
-
-// ============================================================================
-// INTERFACES
-// ============================================================================
-
-/** Session object returned by createClaudeSession. */
-interface ClaudeSession {
-  sendMessage(text: string): AsyncIterable<ClaudeStreamEvent>;
-  interrupt(): void;
-  close(): Promise<void>;
-}
-
-// ============================================================================
-// MAIN HANDLERS
-// ============================================================================
-
-async function createClaudeSession(
-  config: ClaudeSessionConfig,
-  queryOverride?: QueryFn,
-): Promise<ClaudeSession> {
-  const systemPrompt = config.systemPrompt || buildDefaultPrompt("voice");
-  let sessionId = "";
-  let closed = false;
-  let lastTurnCompletedCleanly = true;
-
-  // Persistent input stream — user messages are pushed here across turns
-  const userMessages = new AsyncQueue<SDKUserMessage>();
-
-  // Event channel — SDK events are routed here for sendMessage to consume
-  const sdkEvents = new AsyncQueue<SDKMessage>();
-
-  // systemPrompt as string replaces the entire system prompt.
-  // { type: 'preset', preset: 'claude_code', append: '...' } appends to default.
-  const options: Options = {
-    includePartialMessages: true,
-    maxThinkingTokens: 10000,
-    ...(config.customSystemPrompt
-      ? { systemPrompt: config.customSystemPrompt }
-      : { systemPrompt: { type: "preset" as const, preset: "claude_code" as const, append: systemPrompt } }),
-    permissionMode: config.permissionMode as Options["permissionMode"],
-    allowDangerouslySkipPermissions: config.permissionMode === "bypassPermissions",
-    settingSources: ["user", "project", "local"],
-    ...(config.cwd && { cwd: config.cwd }),
-    stderr: (data: string) => {
-      const msg = data.trim();
-      if (msg) console.error(`[claude-stderr] ${msg}`);
-    },
-  };
-
-  // Start persistent query — process spawns once and stays alive.
-  // NOTE: with AsyncIterable<SDKUserMessage> input, the SDK won't yield
-  // events until the first user message is consumed, so we don't block
-  // waiting for a system init event here. Session ID is captured when
-  // the system event arrives during the first turn.
-  const queryFn = queryOverride ?? claudeQuery;
-  const q = queryFn({ prompt: userMessages, options });
-
-  // Background: pump SDK events into our channel
-  (async () => {
-    try {
-      for await (const msg of q) {
-        if (msg.type === "system" && !sessionId) {
-          sessionId = msg.session_id;
-          console.log(`[claude] session ready (id=${sessionId})`);
-        }
-        sdkEvents.push(msg);
-      }
-    } catch (err) {
-      console.error("[claude] SDK pump error:", err);
-    } finally {
-      sdkEvents.close();
-    }
-  })();
-
-  console.log("[claude] persistent process started");
-
-  return {
-    async *sendMessage(text: string): AsyncIterable<ClaudeStreamEvent> {
-      if (closed) {
-        throw new Error("Session is closed.");
-      }
-
-      if (!text.trim()) {
-        throw new Error("Cannot send empty message.");
-      }
-
-      // If the previous turn was interrupted, consume remaining events until its result
-      if (!lastTurnCompletedCleanly) {
-        while (true) {
-          const msg = await sdkEvents.next();
-          if (!msg || msg.type === "result") break;
-        }
-      }
-      sdkEvents.drain();
-      lastTurnCompletedCleanly = false;
-
-      const t0 = Date.now();
-      let hasStreamedContent = false;
-      const toolUseBlocks = new Set<number>();
-      const thinkingBlocks = new Set<number>();
-
-      // Push user message into the live session
-      userMessages.push({
-        type: "user",
-        message: { content: text, role: "user" },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-      });
-
-      // Read events for this turn until result
-      while (true) {
-        const msg = await sdkEvents.next();
-        if (!msg) break; // channel closed (process died)
-
-        // Streaming events (token-level deltas)
-        if (msg.type === "stream_event") {
-          const event = msg.event;
-
-          if (event.type === "content_block_start") {
-            if (event.content_block.type === "tool_use") {
-              hasStreamedContent = true;
-              toolUseBlocks.add(event.index);
-              yield { type: "tool_start", content: "", toolName: event.content_block.name };
-            }
-            if (event.content_block.type === "thinking") {
-              hasStreamedContent = true;
-              thinkingBlocks.add(event.index);
-              console.log(`[claude] thinking started at +${Date.now() - t0}ms`);
-              yield { type: "text_delta", content: "Thinking... " };
-            }
-            continue;
-          }
-
-          if (event.type === "content_block_delta") {
-            if (event.delta.type === "text_delta") {
-              if (!hasStreamedContent) {
-                console.log(`[claude] first delta at +${Date.now() - t0}ms`);
-              }
-              hasStreamedContent = true;
-              yield { type: "text_delta", content: event.delta.text };
-            }
-            continue;
-          }
-
-          if (event.type === "content_block_stop") {
-            if (thinkingBlocks.has(event.index)) {
-              thinkingBlocks.delete(event.index);
-              console.log(`[claude] thinking ended at +${Date.now() - t0}ms`);
-            }
-            if (toolUseBlocks.has(event.index)) {
-              toolUseBlocks.delete(event.index);
-              yield { type: "tool_end", content: "" };
-            }
-            continue;
-          }
-
-          continue;
-        }
-
-        // Full assistant message — fallback if streaming didn't produce deltas
-        if (msg.type === "assistant") {
-          if (hasStreamedContent) {
-            console.log(`[claude] full message at +${Date.now() - t0}ms (skipped, already streamed)`);
-          } else {
-            console.log(`[claude] full message at +${Date.now() - t0}ms (no streaming, using fallback)`);
-            const blocks = msg.message.content;
-            if (Array.isArray(blocks)) {
-              for (const block of blocks) {
-                if (block.type === "text") {
-                  yield { type: "text_delta", content: block.text };
-                }
-                if (block.type === "tool_use") {
-                  yield { type: "tool_start", content: "", toolName: block.name };
-                }
-              }
-            }
-          }
-          toolUseBlocks.clear();
-          continue;
-        }
-
-        // Skip system events and synthetic user messages (tool results)
-        if (msg.type === "system" || msg.type === "user") {
-          continue;
-        }
-
-        // Result — turn complete
-        if (msg.type === "result") {
-          lastTurnCompletedCleanly = true;
-          console.log(`[claude] result at +${Date.now() - t0}ms (streamed=${hasStreamedContent})`);
-          if (msg.is_error) {
-            yield { type: "error", content: msg.subtype === "success" ? String((msg as any).result) : msg.subtype };
-          }
-          break;
-        }
-      }
-
-      yield { type: "result", content: "" };
-    },
-
-    interrupt(): void {
-      q.interrupt();
-    },
-
-    async close(): Promise<void> {
-      closed = true;
-      userMessages.close();
-      await q.interrupt();
-    },
-  };
-}
-
-export { createClaudeSession };
-export type { ClaudeSession };