@atercates/claude-deck 0.2.1

package/lib/banner.ts

@@ -0,0 +1,81 @@
+// ClaudeDeck session initialization
+// Writes an init script that shows the banner, configures tmux, then runs the agent
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+/**
+ * Generate an init script that shows the ClaudeDeck banner and configures tmux
+ */
+function generateInitScript(agentCommand: string): string {
+  return `#!/bin/bash
+# ClaudeDeck Session Init Script
+# Auto-generated - do not edit manually
+
+# ANSI Colors (purple theme)
+C_RESET=$'\\033[0m'
+C_PURPLE=$'\\033[38;5;141m'
+C_PURPLE2=$'\\033[38;5;177m'
+C_PINK=$'\\033[38;5;213m'
+C_MUTED=$'\\033[38;5;245m'
+C_BOLD=$'\\033[1m'
+
+# Configure tmux status bar
+tmux set-option status-style 'bg=#1e1e2e,fg=#cdd6f4' 2>/dev/null
+tmux set-option status-left '#[fg=#cba6f7,bold] ClaudeDeck #[fg=#6c7086]| ' 2>/dev/null
+tmux set-option status-left-length 20 2>/dev/null
+tmux set-option status-right '#[fg=#6c7086]| #[fg=#89b4fa]#S #[fg=#6c7086]| #[fg=#a6adc8]%H:%M ' 2>/dev/null
+tmux set-option status-right-length 40 2>/dev/null
+tmux set-option status-position bottom 2>/dev/null
+
+# Clear and show banner
+clear
+
+printf "\\n"
+printf "\${C_PURPLE}     _                    _    ___  ____  \${C_RESET}\\n"
+printf "\${C_PURPLE}    / \\\\   __ _  ___ _ __ | |_ / _ \\\\/ ___| \${C_RESET}\\n"
+printf "\${C_PURPLE2}   / _ \\\\ / _\\\` |/ _ \\\\ '_ \\\\| __| | | \\\\___ \\\\ \${C_RESET}\\n"
+printf "\${C_PURPLE2}  / ___ \\\\ (_| |  __/ | | | |_| |_| |___) |\${C_RESET}\\n"
+printf "\${C_PINK} /_/   \\\\_\\\\__, |\\\\___|_| |_|\\\\__|\\\\___/|____/ \${C_RESET}\\n"
+printf "\${C_PINK}         |___/                            \${C_RESET}\\n"
+printf "\\n"
+printf "\${C_MUTED}         AI Coding Session Manager\${C_RESET}\\n"
+printf "\\n"
+
+# Brief pause to show banner
+sleep 0.8
+
+# Start the agent
+exec ${agentCommand}
+`;
+}
+
+/**
+ * Write init script to temp file and return the command to run it
+ */
+export function wrapWithBanner(agentCommand: string): string {
+  const scriptContent = generateInitScript(agentCommand);
+  const scriptPath = path.join(os.tmpdir(), `claude-deck-init-${Date.now()}.sh`);
+
+  fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+
+  // Return command that runs the script
+  return `bash ${scriptPath}`;
+}
+
+/**
+ * Returns just the banner string (for display elsewhere)
+ */
+export function getBanner(): string {
+  return `
+     _                    _    ___  ____
+    / \\   __ _  ___ _ __ | |_ / _ \\/ ___|
+   / _ \\ / _\` |/ _ \\ '_ \\| __| | | \\___ \\
+  / ___ \\ (_| |  __/ | | | |_| |_| |___) |
+ /_/   \\_\\__, |\\___|_| |_|\\__|\\___/|____/
+         |___/
+
+         AI Coding Session Manager
+`;
+}

package/lib/claude/jsonl-cache.ts

@@ -0,0 +1,86 @@
+import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
+import {
+  extractProjectDirectory,
+  getSessions,
+  getClaudeProjectNames,
+  type SessionInfo,
+} from "./jsonl-reader";
+
+export interface CachedProject {
+  name: string;
+  directory: string | null;
+  displayName: string;
+  sessionCount: number;
+  lastActivity: string | null;
+}
+
+function deriveDisplayName(directory: string | null, encoded: string): string {
+  if (directory) {
+    const parts = directory.split("/");
+    return parts[parts.length - 1] || directory;
+  }
+  const decoded = encoded.replace(/^-/, "/").replace(/-/g, "/");
+  const parts = decoded.split("/");
+  return parts[parts.length - 1] || decoded;
+}
+
+let projectsData: CachedProject[] | null = null;
+let projectsBuilding: Promise<CachedProject[]> | null = null;
+
+async function buildProjects(): Promise<CachedProject[]> {
+  const projectNames = getClaudeProjectNames();
+
+  const allSessions = await sdkListSessions();
+  const cwdToDir = new Map<string, string>();
+  for (const s of allSessions) {
+    if (s.cwd) {
+      const encoded = s.cwd.replace(/\//g, "-");
+      if (!cwdToDir.has(encoded)) cwdToDir.set(encoded, s.cwd);
+    }
+  }
+
+  return Promise.all(
+    projectNames.map(async (name) => {
+      const directory =
+        cwdToDir.get(name) || (await extractProjectDirectory(name));
+      const projectSessions = allSessions
+        .filter((s) => s.cwd === directory)
+        .sort((a, b) => b.lastModified - a.lastModified);
+
+      return {
+        name,
+        directory,
+        displayName: deriveDisplayName(directory, name),
+        sessionCount: projectSessions.length,
+        lastActivity: projectSessions[0]
+          ? new Date(projectSessions[0].lastModified).toISOString()
+          : null,
+      };
+    })
+  );
+}
+
+export async function getCachedProjects(): Promise<CachedProject[]> {
+  if (projectsData) return projectsData;
+  if (projectsBuilding) return projectsBuilding;
+
+  projectsBuilding = buildProjects();
+  projectsData = await projectsBuilding;
+  projectsBuilding = null;
+  return projectsData;
+}
+
+export async function getCachedSessions(
+  projectName: string
+): Promise<SessionInfo[]> {
+  const { sessions } = await getSessions(projectName, 200, 0);
+  return sessions;
+}
+
+export function invalidateProject(_projectName: string): void {
+  projectsData = null;
+}
+
+export function invalidateAll(): void {
+  projectsData = null;
+}

package/lib/claude/jsonl-reader.ts

@@ -0,0 +1,271 @@
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import os from "os";
+import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
+
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+
+export interface JsonlEntry {
+  sessionId?: string;
+  timestamp?: string;
+  type?: string;
+  message?: {
+    role: "user" | "assistant";
+    content: string | ContentBlock[];
+  };
+  uuid?: string;
+  parentUuid?: string | null;
+  leafUuid?: string;
+  summary?: string;
+  customTitle?: string;
+  cwd?: string;
+  isApiErrorMessage?: boolean;
+  toolUseResult?: {
+    agentId?: string;
+  };
+}
+
+export interface ContentBlock {
+  type: string;
+  text?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string;
+  is_error?: boolean;
+}
+
+export interface SessionInfo {
+  sessionId: string;
+  summary: string;
+  lastActivity: string;
+  messageCount: number;
+  cwd: string | null;
+}
+
+export interface SessionMessage {
+  sessionId: string;
+  timestamp: string;
+  role: "user" | "assistant";
+  content: ContentBlock[];
+  uuid?: string;
+  parentUuid?: string | null;
+  subagentTools?: AgentTool[];
+}
+
+export interface AgentTool {
+  toolId: string;
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  toolResult?: string;
+  timestamp: string;
+}
+
+export function getClaudeProjectNames(): string[] {
+  try {
+    return fs
+      .readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+export function getProjectDir(projectName: string): string {
+  return path.join(CLAUDE_PROJECTS_DIR, projectName);
+}
+
+function getJsonlFiles(projectDir: string): string[] {
+  try {
+    return fs
+      .readdirSync(projectDir)
+      .filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"))
+      .map((f) => path.join(projectDir, f));
+  } catch {
+    return [];
+  }
+}
+
+function getAgentFiles(projectDir: string): string[] {
+  try {
+    return fs
+      .readdirSync(projectDir)
+      .filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"))
+      .map((f) => path.join(projectDir, f));
+  } catch {
+    return [];
+  }
+}
+
+async function readJsonlFile(filePath: string): Promise<JsonlEntry[]> {
+  const entries: JsonlEntry[] = [];
+  const stream = fs.createReadStream(filePath);
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // skip malformed lines
+    }
+  }
+  return entries;
+}
+
+export async function extractProjectDirectory(
+  projectName: string
+): Promise<string | null> {
+  const projectDir = getProjectDir(projectName);
+  const files = getJsonlFiles(projectDir);
+
+  for (const file of files.slice(0, 3)) {
+    const stream = fs.createReadStream(file);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.cwd) {
+          rl.close();
+          stream.destroy();
+          return entry.cwd;
+        }
+      } catch {}
+    }
+  }
+  return null;
+}
+
+export async function getSessions(
+  projectName: string,
+  limit = 20,
+  offset = 0
+): Promise<{ sessions: SessionInfo[]; total: number }> {
+  const dir = await extractProjectDirectory(projectName);
+  const sdkSessions = await sdkListSessions(dir ? { dir } : undefined);
+
+  const sessions: SessionInfo[] = sdkSessions
+    .filter((s) => !s.summary?.startsWith('{ "'))
+    .map((s) => ({
+      sessionId: s.sessionId,
+      summary: s.customTitle || s.summary || "New Session",
+      lastActivity: new Date(s.lastModified).toISOString(),
+      messageCount: (s.fileSize ?? 0) > 500 ? 3 : 0,
+      cwd: s.cwd || dir || null,
+    }));
+
+  return {
+    sessions: sessions.slice(offset, offset + limit),
+    total: sessions.length,
+  };
+}
+
+export async function getSessionMessages(
+  projectName: string,
+  sessionId: string,
+  limit = 100,
+  offset = 0
+): Promise<{ messages: SessionMessage[]; total: number; hasMore: boolean }> {
+  const projectDir = getProjectDir(projectName);
+  const files = getJsonlFiles(projectDir);
+  const agentToolsMap = await loadAgentTools(projectDir);
+  const messages: SessionMessage[] = [];
+
+  for (const file of files) {
+    const entries = await readJsonlFile(file);
+    for (const entry of entries) {
+      if (entry.sessionId !== sessionId) continue;
+      if (entry.isApiErrorMessage) continue;
+      if (!entry.message?.role) continue;
+
+      const content: ContentBlock[] = Array.isArray(entry.message.content)
+        ? entry.message.content
+        : [{ type: "text", text: String(entry.message.content) }];
+
+      const msg: SessionMessage = {
+        sessionId: entry.sessionId,
+        timestamp: entry.timestamp || new Date(0).toISOString(),
+        role: entry.message.role,
+        content,
+        uuid: entry.uuid,
+        parentUuid: entry.parentUuid,
+      };
+
+      if (entry.toolUseResult?.agentId) {
+        const tools = agentToolsMap.get(entry.toolUseResult.agentId);
+        if (tools) {
+          msg.subagentTools = tools;
+        }
+      }
+
+      messages.push(msg);
+    }
+  }
+
+  messages.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  const total = messages.length;
+  const sliced = messages.slice(offset, offset + limit);
+
+  return {
+    messages: sliced,
+    total,
+    hasMore: offset + limit < total,
+  };
+}
+
+async function loadAgentTools(
+  projectDir: string
+): Promise<Map<string, AgentTool[]>> {
+  const agentFiles = getAgentFiles(projectDir);
+  const map = new Map<string, AgentTool[]>();
+
+  for (const file of agentFiles) {
+    const agentId = path.basename(file).replace(/^agent-|\.jsonl$/g, "");
+    const entries = await readJsonlFile(file);
+    const tools: AgentTool[] = [];
+    const toolUseMap = new Map<
+      string,
+      { name: string; input: Record<string, unknown>; timestamp: string }
+    >();
+
+    for (const entry of entries) {
+      if (!entry.message?.content || !Array.isArray(entry.message.content))
+        continue;
+
+      for (const block of entry.message.content) {
+        if (block.type === "tool_use" && block.id && block.name) {
+          toolUseMap.set(block.id, {
+            name: block.name,
+            input: block.input || {},
+            timestamp: entry.timestamp || "",
+          });
+        }
+        if (block.type === "tool_result" && block.tool_use_id) {
+          const use = toolUseMap.get(block.tool_use_id);
+          if (use) {
+            tools.push({
+              toolId: block.tool_use_id,
+              toolName: use.name,
+              toolInput: use.input,
+              toolResult: block.content || undefined,
+              timestamp: use.timestamp,
+            });
+          }
+        }
+      }
+    }
+
+    if (tools.length > 0) {
+      map.set(agentId, tools);
+    }
+  }
+
+  return map;
+}

package/lib/claude/process-manager.ts

@@ -0,0 +1,278 @@
+import { spawn, ChildProcess } from "child_process";
+import { WebSocket } from "ws";
+import { StreamParser } from "./stream-parser";
+import { queries, type Session } 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);
+  }
+}