@atercates/claude-deck 0.2.3 → 0.2.5

package/lib/claude/process-manager.ts

@@ -1,278 +0,0 @@
-import { spawn, ChildProcess } from "child_process";
-import { WebSocket } from "ws";
-import { StreamParser } from "./stream-parser";
-import { queries } from "../db";
-import type { ClaudeSessionOptions, ClientEvent } from "./types";
-
-interface ManagedSession {
-  process: ChildProcess | null;
-  parser: StreamParser;
-  clients: Set<WebSocket>;
-  status: "idle" | "running" | "waiting" | "error";
-}
-
-export class ClaudeProcessManager {
-  private sessions: Map<string, ManagedSession> = new Map();
-
-  // Register a WebSocket client for a session
-  registerClient(sessionId: string, ws: WebSocket): void {
-    let session = this.sessions.get(sessionId);
-
-    if (!session) {
-      session = {
-        process: null,
-        parser: new StreamParser(sessionId),
-        clients: new Set(),
-        status: "idle",
-      };
-
-      // Set up parser event handlers
-      session.parser.on("event", (event: ClientEvent) => {
-        this.broadcastToSession(sessionId, event);
-        this.handleEvent(sessionId, event);
-      });
-
-      session.parser.on("parse_error", (error) => {
-        this.broadcastToSession(sessionId, {
-          type: "error",
-          sessionId,
-          timestamp: new Date().toISOString(),
-          data: { error: `Parse error: ${error.error}` },
-        });
-      });
-
-      this.sessions.set(sessionId, session);
-    }
-
-    session.clients.add(ws);
-
-    // Send current status
-    ws.send(
-      JSON.stringify({
-        type: "status",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { status: session.status },
-      })
-    );
-  }
-
-  // Unregister a WebSocket client
-  unregisterClient(sessionId: string, ws: WebSocket): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.clients.delete(ws);
-
-      // Clean up if no clients remain and process not running
-      if (session.clients.size === 0 && !session.process) {
-        this.sessions.delete(sessionId);
-      }
-    }
-  }
-
-  // Send a prompt to Claude
-  async sendPrompt(
-    sessionId: string,
-    prompt: string,
-    options: ClaudeSessionOptions = {}
-  ): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
-    }
-
-    if (session.process) {
-      throw new Error(`Session ${sessionId} already has a running process`);
-    }
-
-    // Build Claude CLI command
-    const args = ["-p", "--output-format", "stream-json", "--verbose"];
-
-    // Add model if specified
-    if (options.model) {
-      args.push("--model", options.model);
-    }
-
-    // Handle session continuity
-    const dbSession = await queries.getSession(sessionId);
-
-    if (dbSession?.claude_session_id) {
-      // Resume existing Claude session
-      args.push("--resume", dbSession.claude_session_id);
-    }
-
-    // Add system prompt if specified
-    if (options.systemPrompt) {
-      args.push("--system-prompt", options.systemPrompt);
-    }
-
-    // Add the prompt
-    args.push(prompt);
-
-    // Spawn Claude process
-    const cwd =
-      options.workingDirectory ||
-      dbSession?.working_directory?.replace("~", process.env.HOME || "") ||
-      process.env.HOME ||
-      "/";
-
-    console.log(`Spawning Claude for session ${sessionId}:`, args.join(" "));
-    console.log(`CWD: ${cwd}`);
-
-    // Reset parser for new conversation turn
-    session.parser = new StreamParser(sessionId);
-    session.parser.on("event", (event: ClientEvent) => {
-      console.log(
-        `Parser event [${sessionId}]:`,
-        event.type,
-        JSON.stringify(event.data).substring(0, 100)
-      );
-      this.broadcastToSession(sessionId, event);
-      this.handleEvent(sessionId, event);
-    });
-
-    // Find claude binary path
-    const claudePath =
-      process.env.HOME + "/.nvm/versions/node/v20.19.0/bin/claude";
-
-    const claudeProcess = spawn(claudePath, args, {
-      cwd,
-      env: {
-        ...process.env,
-        PATH: `/usr/local/bin:/opt/homebrew/bin:${process.env.PATH}`,
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    session.process = claudeProcess;
-    session.status = "running";
-    this.updateDbStatus(sessionId, "running");
-
-    this.broadcastToSession(sessionId, {
-      type: "status",
-      sessionId,
-      timestamp: new Date().toISOString(),
-      data: { status: "running" },
-    });
-
-    // Handle stdout (stream-json output)
-    claudeProcess.stdout?.on("data", (data: Buffer) => {
-      const text = data.toString();
-      console.log(`Claude stdout [${sessionId}]:`, text.substring(0, 200));
-      session.parser.write(text);
-    });
-
-    // Handle stderr (errors and other output)
-    claudeProcess.stderr?.on("data", (data: Buffer) => {
-      const text = data.toString();
-      console.error(`Claude stderr [${sessionId}]:`, text);
-    });
-
-    claudeProcess.on("error", (err) => {
-      console.error(`Claude spawn error [${sessionId}]:`, err);
-    });
-
-    // Handle process exit
-    claudeProcess.on("close", (code) => {
-      console.log(
-        `Claude process exited for session ${sessionId} with code ${code}`
-      );
-
-      session.parser.end();
-      session.process = null;
-      session.status = code === 0 ? "idle" : "error";
-
-      this.updateDbStatus(sessionId, session.status);
-
-      this.broadcastToSession(sessionId, {
-        type: "status",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { status: session.status, exitCode: code || 0 },
-      });
-    });
-
-    claudeProcess.on("error", (err) => {
-      console.error(`Claude process error for session ${sessionId}:`, err);
-
-      session.process = null;
-      session.status = "error";
-
-      this.updateDbStatus(sessionId, "error");
-
-      this.broadcastToSession(sessionId, {
-        type: "error",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { error: err.message },
-      });
-    });
-  }
-
-  // Cancel a running Claude process
-  cancelSession(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (session?.process) {
-      session.process.kill("SIGTERM");
-    }
-  }
-
-  // Get session status
-  getSessionStatus(
-    sessionId: string
-  ): "idle" | "running" | "waiting" | "error" | null {
-    return this.sessions.get(sessionId)?.status ?? null;
-  }
-
-  // Broadcast event to all clients of a session
-  private broadcastToSession(sessionId: string, event: ClientEvent): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      console.log(`No session found for broadcast: ${sessionId}`);
-      return;
-    }
-
-    console.log(
-      `Broadcasting to ${session.clients.size} clients for session ${sessionId}`
-    );
-    const message = JSON.stringify(event);
-    for (const client of session.clients) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(message);
-        console.log(`Sent message to client`);
-      } else {
-        console.log(`Client not open, state: ${client.readyState}`);
-      }
-    }
-  }
-
-  // Handle events for persistence
-  private handleEvent(sessionId: string, event: ClientEvent): void {
-    switch (event.type) {
-      case "init": {
-        // Store Claude's session ID for future --resume
-        const claudeSessionId = event.data.claudeSessionId;
-        if (claudeSessionId) {
-          queries.updateSessionClaudeId(claudeSessionId, sessionId);
-        }
-        break;
-      }
-
-      case "complete": {
-        // Update session timestamp
-        queries.updateSessionStatus("idle", sessionId);
-        break;
-      }
-
-      case "error": {
-        queries.updateSessionStatus("error", sessionId);
-        break;
-      }
-    }
-  }
-
-  // Update session status in database
-  private updateDbStatus(sessionId: string, status: string): void {
-    queries.updateSessionStatus(status, sessionId);
-  }
-}

package/lib/status-detector.ts

@@ -1,375 +0,0 @@
-/**
- * Session Status Detection System
- *
- * States:
- * - "running" (GREEN): Sustained activity within cooldown period
- * - "waiting" (YELLOW): Cooldown expired, NOT acknowledged (needs attention)
- * - "idle" (GRAY): Cooldown expired, acknowledged (user saw it)
- * - "dead": Session doesn't exist
- *
- * Detection Strategy:
- * 1. Busy indicators + recent activity (highest priority - actively working)
- * 2. Waiting patterns - user input needed
- * 3. Spike detection - activity timestamp changes (2+ in 1s = sustained)
- * 4. Cooldown - 2s grace period after activity stops
- */
-
-import { exec } from "child_process";
-import { promisify } from "util";
-
-const execAsync = promisify(exec);
-
-// Configuration constants
-const CONFIG = {
-  ACTIVITY_COOLDOWN_MS: 2000, // Grace period after activity
-  SPIKE_WINDOW_MS: 1000, // Window to detect sustained activity
-  SUSTAINED_THRESHOLD: 2, // Changes needed to confirm activity
-  CACHE_VALIDITY_MS: 2000, // How long tmux cache is valid
-  RECENT_ACTIVITY_MS: 120000, // Window for "recent" activity (2 min, tmux updates slowly)
-} as const;
-
-// Detection patterns
-const BUSY_INDICATORS = [
-  "esc to interrupt",
-  "(esc to interrupt)",
-  "· esc to interrupt",
-];
-
-const SPINNER_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-const WHIMSICAL_WORDS = [
-  "accomplishing",
-  "actioning",
-  "actualizing",
-  "baking",
-  "booping",
-  "brewing",
-  "calculating",
-  "cerebrating",
-  "channelling",
-  "churning",
-  "clauding",
-  "coalescing",
-  "cogitating",
-  "combobulating",
-  "computing",
-  "concocting",
-  "conjuring",
-  "considering",
-  "contemplating",
-  "cooking",
-  "crafting",
-  "creating",
-  "crunching",
-  "deciphering",
-  "deliberating",
-  "determining",
-  "discombobulating",
-  "divining",
-  "doing",
-  "effecting",
-  "elucidating",
-  "enchanting",
-  "envisioning",
-  "finagling",
-  "flibbertigibbeting",
-  "forging",
-  "forming",
-  "frolicking",
-  "generating",
-  "germinating",
-  "hatching",
-  "herding",
-  "honking",
-  "hustling",
-  "ideating",
-  "imagining",
-  "incubating",
-  "inferring",
-  "jiving",
-  "manifesting",
-  "marinating",
-  "meandering",
-  "moseying",
-  "mulling",
-  "mustering",
-  "musing",
-  "noodling",
-  "percolating",
-  "perusing",
-  "philosophising",
-  "pondering",
-  "pontificating",
-  "processing",
-  "puttering",
-  "puzzling",
-  "reticulating",
-  "ruminating",
-  "scheming",
-  "schlepping",
-  "shimmying",
-  "shucking",
-  "simmering",
-  "smooshing",
-  "spelunking",
-  "spinning",
-  "stewing",
-  "sussing",
-  "synthesizing",
-  "thinking",
-  "tinkering",
-  "transmuting",
-  "unfurling",
-  "unravelling",
-  "vibing",
-  "wandering",
-  "whirring",
-  "wibbling",
-  "wizarding",
-  "working",
-  "wrangling",
-];
-
-const WAITING_PATTERNS = [
-  /\[Y\/n\]/i,
-  /\[y\/N\]/i,
-  /Allow\?/i,
-  /Approve\?/i,
-  /Continue\?/i,
-  /Press Enter to/i,
-  /waiting for input/i,
-  /\(yes\/no\)/i,
-  /Do you want to/i,
-  /Enter to confirm.*Esc to cancel/i,
-  />\s*1\.\s*Yes/,
-  /Yes, allow all/i,
-  /allow all edits/i,
-  /allow all commands/i,
-];
-
-export type SessionStatus = "running" | "waiting" | "idle" | "dead";
-
-interface StateTracker {
-  lastChangeTime: number;
-  acknowledged: boolean;
-  lastActivityTimestamp: number;
-  spikeWindowStart: number | null;
-  spikeChangeCount: number;
-}
-
-interface SessionCache {
-  data: Map<string, number>;
-  updatedAt: number;
-}
-
-// Content analysis helpers
-function checkBusyIndicators(content: string): boolean {
-  const lines = content.split("\n");
-  // Focus on last 10 lines to avoid old scrollback false positives
-  const recentContent = lines.slice(-10).join("\n").toLowerCase();
-
-  // Check text indicators in recent lines
-  if (BUSY_INDICATORS.some((ind) => recentContent.includes(ind))) return true;
-
-  // Check whimsical words + "tokens" pattern in recent lines
-  if (
-    recentContent.includes("tokens") &&
-    WHIMSICAL_WORDS.some((w) => recentContent.includes(w))
-  )
-    return true;
-
-  // Check spinners in last 5 lines
-  const last5 = lines.slice(-5).join("");
-  if (SPINNER_CHARS.some((s) => last5.includes(s))) return true;
-
-  return false;
-}
-
-function checkWaitingPatterns(content: string): boolean {
-  const recentLines = content.split("\n").slice(-5).join("\n");
-  return WAITING_PATTERNS.some((p) => p.test(recentLines));
-}
-
-class SessionStatusDetector {
-  private trackers = new Map<string, StateTracker>();
-  private cache: SessionCache = { data: new Map(), updatedAt: 0 };
-
-  // Cache management
-  async refreshCache(): Promise<void> {
-    if (Date.now() - this.cache.updatedAt < CONFIG.CACHE_VALIDITY_MS) return;
-
-    try {
-      const { stdout } = await execAsync(
-        `tmux list-sessions -F '#{session_name}\t#{session_activity}' 2>/dev/null || echo ""`
-      );
-
-      const newData = new Map<string, number>();
-      for (const line of stdout.trim().split("\n")) {
-        if (!line) continue;
-        const [name, activity] = line.split("\t");
-        if (name && activity) newData.set(name, parseInt(activity, 10) || 0);
-      }
-
-      this.cache = { data: newData, updatedAt: Date.now() };
-    } catch {
-      // Keep existing cache on error
-    }
-  }
-
-  sessionExists(name: string): boolean {
-    return this.cache.data.has(name);
-  }
-
-  getTimestamp(name: string): number {
-    return this.cache.data.get(name) || 0;
-  }
-
-  async capturePane(name: string): Promise<string> {
-    try {
-      const { stdout } = await execAsync(
-        `tmux capture-pane -t "${name}" -p 2>/dev/null || echo ""`
-      );
-      return stdout.trim();
-    } catch {
-      return "";
-    }
-  }
-
-  private getTracker(name: string, timestamp: number): StateTracker {
-    let tracker = this.trackers.get(name);
-    if (!tracker) {
-      tracker = {
-        lastChangeTime: Date.now() - CONFIG.ACTIVITY_COOLDOWN_MS,
-        acknowledged: true,
-        lastActivityTimestamp: timestamp,
-        spikeWindowStart: null,
-        spikeChangeCount: 0,
-      };
-      this.trackers.set(name, tracker);
-    }
-    return tracker;
-  }
-
-  // Spike detection: filters single activity spikes from sustained activity
-  private processSpikeDetection(
-    tracker: StateTracker,
-    currentTimestamp: number
-  ): "running" | null {
-    const now = Date.now();
-    const timestampChanged = tracker.lastActivityTimestamp !== currentTimestamp;
-
-    if (timestampChanged) {
-      tracker.lastActivityTimestamp = currentTimestamp;
-
-      const windowExpired =
-        tracker.spikeWindowStart === null ||
-        now - tracker.spikeWindowStart > CONFIG.SPIKE_WINDOW_MS;
-
-      if (windowExpired) {
-        // Start new detection window
-        tracker.spikeWindowStart = now;
-        tracker.spikeChangeCount = 1;
-      } else {
-        // Within window - count change
-        tracker.spikeChangeCount++;
-        if (tracker.spikeChangeCount >= CONFIG.SUSTAINED_THRESHOLD) {
-          // Sustained activity confirmed
-          tracker.lastChangeTime = now;
-          tracker.acknowledged = false;
-          tracker.spikeWindowStart = null;
-          tracker.spikeChangeCount = 0;
-          return "running";
-        }
-      }
-    } else if (
-      tracker.spikeChangeCount === 1 &&
-      tracker.spikeWindowStart !== null
-    ) {
-      // Check if single spike should be filtered
-      if (now - tracker.spikeWindowStart > CONFIG.SPIKE_WINDOW_MS) {
-        tracker.spikeWindowStart = null;
-        tracker.spikeChangeCount = 0;
-      }
-    }
-
-    return null;
-  }
-
-  private isInSpikeWindow(tracker: StateTracker): boolean {
-    return (
-      tracker.spikeWindowStart !== null &&
-      Date.now() - tracker.spikeWindowStart < CONFIG.SPIKE_WINDOW_MS
-    );
-  }
-
-  private isInCooldown(tracker: StateTracker): boolean {
-    return Date.now() - tracker.lastChangeTime < CONFIG.ACTIVITY_COOLDOWN_MS;
-  }
-
-  private getIdleOrWaiting(tracker: StateTracker): SessionStatus {
-    return tracker.acknowledged ? "idle" : "waiting";
-  }
-
-  async getStatus(sessionName: string): Promise<SessionStatus> {
-    await this.refreshCache();
-
-    // Dead check
-    if (!this.sessionExists(sessionName)) {
-      this.trackers.delete(sessionName);
-      return "dead";
-    }
-
-    const timestamp = this.getTimestamp(sessionName);
-    const tracker = this.getTracker(sessionName, timestamp);
-    const content = await this.capturePane(sessionName);
-
-    // 1. Busy indicators in last 10 lines (highest priority - Claude is actively working)
-    // No activity timestamp check needed since we only look at recent terminal lines
-    if (checkBusyIndicators(content)) {
-      tracker.lastChangeTime = Date.now();
-      tracker.acknowledged = false;
-      return "running";
-    }
-
-    // 2. Waiting patterns (only if not actively running)
-    if (checkWaitingPatterns(content)) return "waiting";
-
-    // 3. Spike detection
-    const spikeResult = this.processSpikeDetection(tracker, timestamp);
-    if (spikeResult) return spikeResult;
-
-    // 4. During spike window, maintain stable status
-    if (this.isInSpikeWindow(tracker)) {
-      return this.isInCooldown(tracker)
-        ? "running"
-        : this.getIdleOrWaiting(tracker);
-    }
-
-    // 5. Cooldown check
-    if (this.isInCooldown(tracker)) return "running";
-
-    // 6. Cooldown expired
-    return this.getIdleOrWaiting(tracker);
-  }
-
-  acknowledge(sessionName: string): void {
-    const tracker = this.trackers.get(sessionName);
-    if (tracker) tracker.acknowledged = true;
-  }
-
-  async getAllStatuses(names: string[]): Promise<Map<string, SessionStatus>> {
-    await this.refreshCache();
-    const results = await Promise.all(
-      names.map(async (name) => ({ name, status: await this.getStatus(name) }))
-    );
-    return new Map(results.map((r) => [r.name, r.status]));
-  }
-
-  cleanup(): void {
-    for (const [name] of this.trackers) {
-      if (!this.sessionExists(name)) this.trackers.delete(name);
-    }
-  }
-}
-
-export const statusDetector = new SessionStatusDetector();