@atercates/claude-deck 0.2.1

package/app/api/sessions/[id]/send-keys/route.ts

@@ -0,0 +1,119 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { queries, type Session } from "@/lib/db";
+import { appendFileSync } from "fs";
+
+const execAsync = promisify(exec);
+
+// Log to file for debugging
+const LOG_FILE = "/tmp/claude-deck-send-keys.log";
+function log(msg: string) {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${msg}\n`;
+  console.log(`[send-keys] ${msg}`);
+  try {
+    appendFileSync(LOG_FILE, line);
+  } catch {}
+}
+
+// POST /api/sessions/[id]/send-keys - Send text to a tmux session
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { text, pressEnter = true } = body;
+
+    log(`=== START send-keys for session ${id} ===`);
+    log(`Text length: ${text?.length || 0}, pressEnter: ${pressEnter}`);
+
+    if (!text) {
+      log("ERROR: No text provided");
+      return NextResponse.json({ error: "No text provided" }, { status: 400 });
+    }
+
+    const session = await queries.getSession(id);
+
+    if (!session) {
+      log(`ERROR: Session ${id} not found in DB`);
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    const tmuxSessionName = `${session.agent_type}-${id}`;
+    log(`Tmux session name: ${tmuxSessionName}`);
+
+    // Check if tmux session exists
+    try {
+      await execAsync(`tmux has-session -t "${tmuxSessionName}" 2>/dev/null`);
+      log(`Tmux session exists`);
+    } catch {
+      log(`ERROR: Tmux session ${tmuxSessionName} not running`);
+      return NextResponse.json(
+        { error: "Tmux session not running" },
+        { status: 400 }
+      );
+    }
+
+    // Write text to a temp file
+    const tempFile = `/tmp/claude-deck-send-${id}.txt`;
+    const fs = await import("fs/promises");
+    await fs.writeFile(tempFile, text);
+    log(`Wrote ${text.length} bytes to ${tempFile}`);
+
+    // Use a named buffer to avoid race conditions
+    const bufferName = `send-${id}`;
+
+    try {
+      // Load file into named tmux buffer
+      log(`Loading buffer "${bufferName}" from ${tempFile}`);
+      const loadCmd = `tmux load-buffer -b "${bufferName}" "${tempFile}"`;
+      log(`Running: ${loadCmd}`);
+      const loadResult = await execAsync(loadCmd);
+      log(
+        `Load stdout: "${loadResult.stdout}", stderr: "${loadResult.stderr}"`
+      );
+
+      // Paste the named buffer to the session
+      log(`Pasting buffer "${bufferName}" to ${tmuxSessionName}`);
+      const pasteCmd = `tmux paste-buffer -b "${bufferName}" -t "${tmuxSessionName}"`;
+      log(`Running: ${pasteCmd}`);
+      const pasteResult = await execAsync(pasteCmd);
+      log(
+        `Paste stdout: "${pasteResult.stdout}", stderr: "${pasteResult.stderr}"`
+      );
+
+      // Delete the buffer after use
+      await execAsync(`tmux delete-buffer -b "${bufferName}"`).catch(() => {});
+
+      // Send Enter if requested
+      if (pressEnter) {
+        log(`Sending Enter to ${tmuxSessionName}`);
+        const enterCmd = `tmux send-keys -t "${tmuxSessionName}" Enter`;
+        log(`Running: ${enterCmd}`);
+        const enterResult = await execAsync(enterCmd);
+        log(
+          `Enter stdout: "${enterResult.stdout}", stderr: "${enterResult.stderr}"`
+        );
+      }
+
+      log(`=== SUCCESS ===`);
+      return NextResponse.json({ success: true });
+    } catch (cmdError) {
+      const msg =
+        cmdError instanceof Error ? cmdError.message : String(cmdError);
+      log(`ERROR in commands: ${msg}`);
+      throw cmdError;
+    } finally {
+      // Clean up temp file
+      await fs.unlink(tempFile).catch(() => {});
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log(`ERROR: ${msg}`);
+    console.error("Error sending keys:", error);
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/app/api/sessions/[id]/summarize/route.ts

@@ -0,0 +1,331 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { queries, getDb, type Session } from "@/lib/db";
+import { randomUUID } from "crypto";
+import { writeFileSync, unlinkSync, readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+
+const execAsync = promisify(exec);
+
+// Get Claude session ID from tmux environment
+async function getClaudeSessionId(tmuxSession: string): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux show-environment -t "${tmuxSession}" CLAUDE_SESSION_ID 2>/dev/null || echo ""`
+    );
+    const line = stdout.trim();
+    if (line.startsWith("CLAUDE_SESSION_ID=")) {
+      const sessionId = line.replace("CLAUDE_SESSION_ID=", "");
+      return sessionId && sessionId !== "null" ? sessionId : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Encode path for Claude's project directory format (/ becomes -)
+function encodeProjectPath(cwd: string): string {
+  return cwd.replace(/\//g, "-");
+}
+
+// Read and parse Claude session JSONL file
+function readClaudeSessionHistory(
+  cwd: string,
+  claudeSessionId: string
+): string | null {
+  const projectPath = encodeProjectPath(cwd);
+  const jsonlPath = `${homedir()}/.claude/projects/${projectPath}/${claudeSessionId}.jsonl`;
+
+  if (!existsSync(jsonlPath)) {
+    console.log(`[summarize] JSONL not found: ${jsonlPath}`);
+    return null;
+  }
+
+  try {
+    const content = readFileSync(jsonlPath, "utf-8");
+    const lines = content.trim().split("\n");
+    const messages: string[] = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+
+        // Extract user messages
+        if (entry.type === "user" && entry.message?.content) {
+          const content =
+            typeof entry.message.content === "string"
+              ? entry.message.content
+              : JSON.stringify(entry.message.content);
+          messages.push(`User: ${content}`);
+        }
+
+        // Extract assistant text responses (skip tool calls and thinking)
+        if (entry.type === "assistant" && entry.message?.content) {
+          const textBlocks = entry.message.content
+            .filter((block: { type: string }) => block.type === "text")
+            .map((block: { text: string }) => block.text)
+            .join("\n");
+          if (textBlocks) {
+            messages.push(`Assistant: ${textBlocks}`);
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+
+    return messages.join("\n\n");
+  } catch (error) {
+    console.error(`[summarize] Error reading JSONL:`, error);
+    return null;
+  }
+}
+
+// Fallback: Capture recent tmux scrollback (last 500 lines)
+async function captureScrollback(sessionName: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux capture-pane -t "${sessionName}" -p -S -500 2>/dev/null`
+    );
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+
+// Get the actual working directory from tmux pane
+async function getTmuxCwd(sessionName: string): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux display-message -t "${sessionName}" -p "#{pane_current_path}" 2>/dev/null`
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// Generate summary using Claude CLI with stdin
+async function generateSummary(conversation: string): Promise<string> {
+  const prompt = `Summarize this Claude Code conversation in under 300 words. Focus on: what was built, key files changed, current state, and any pending work. Be specific.`;
+
+  return new Promise((resolve, reject) => {
+    const claude = spawn("claude", ["-p", prompt], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    claude.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    claude.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    claude.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        console.error("Claude CLI failed:", stderr);
+        reject(new Error(`Claude CLI exited with code ${code}`));
+      }
+    });
+
+    claude.on("error", (err) => {
+      reject(err);
+    });
+
+    // Write conversation to stdin
+    claude.stdin.write(conversation);
+    claude.stdin.end();
+  });
+}
+
+// Wait for Claude prompt to appear in tmux session
+async function waitForClaudeReady(
+  sessionName: string,
+  maxAttempts = 30
+): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const { stdout } = await execAsync(
+        `tmux capture-pane -t "${sessionName}" -p 2>/dev/null`
+      );
+      // Look for Claude's status line which appears when UI is ready
+      if (stdout.includes("⏵⏵") || stdout.includes("accept edits")) {
+        return true;
+      }
+    } catch {
+      // Ignore errors, keep polling
+    }
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
+// Send text to tmux session using load-buffer + paste-buffer
+async function sendToTmux(
+  sessionName: string,
+  text: string,
+  pressEnter = true
+): Promise<void> {
+  const tempFile = `/tmp/claude-deck-send-${Date.now()}.txt`;
+  const bufferName = `send-${Date.now()}`;
+
+  try {
+    writeFileSync(tempFile, text);
+    await execAsync(`tmux load-buffer -b "${bufferName}" "${tempFile}"`);
+    await execAsync(`tmux paste-buffer -b "${bufferName}" -t "${sessionName}"`);
+    await execAsync(`tmux delete-buffer -b "${bufferName}"`).catch(() => {});
+
+    if (pressEnter) {
+      // Wait for Claude to process pasted text before sending Enter
+      await new Promise((r) => setTimeout(r, 500));
+      await execAsync(`tmux send-keys -t "${sessionName}" Enter`);
+    }
+  } finally {
+    try {
+      unlinkSync(tempFile);
+    } catch {}
+  }
+}
+
+// POST /api/sessions/[id]/summarize - Summarize and create fresh session
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const body = await request.json().catch(() => ({}));
+    const { createFork = true, sendContext = true } = body;
+
+    const session = (await queries.getSession(id)) as Session | undefined;
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    // Get tmux session name (pattern: {agent_type}-{id})
+    const tmuxSessionName = `${session.agent_type}-${id}`;
+
+    // Get actual working directory from tmux
+    const cwd =
+      (await getTmuxCwd(tmuxSessionName)) || session.working_directory;
+    const cwdExpanded =
+      cwd?.replace(/^~/, process.env.HOME || "~") || process.env.HOME || "~";
+
+    // Try to get full conversation from Claude's JSONL (only for Claude sessions)
+    let conversation: string | null = null;
+    if (session.agent_type === "claude") {
+      const claudeSessionId = await getClaudeSessionId(tmuxSessionName);
+      if (claudeSessionId && cwdExpanded) {
+        console.log(`[summarize] Found Claude session ID: ${claudeSessionId}`);
+        conversation = readClaudeSessionHistory(cwdExpanded, claudeSessionId);
+        if (conversation) {
+          console.log(
+            `[summarize] Read ${conversation.length} chars from JSONL`
+          );
+        }
+      }
+    }
+
+    // Fallback to terminal scrollback for non-Claude or if JSONL not available
+    if (!conversation) {
+      console.log(
+        `[summarize] Using terminal scrollback for ${session.agent_type}`
+      );
+      conversation = await captureScrollback(tmuxSessionName);
+    }
+
+    if (!conversation || conversation.trim().length < 100) {
+      return NextResponse.json(
+        { error: "No conversation found to summarize" },
+        { status: 400 }
+      );
+    }
+
+    // Generate summary
+    const summary = await generateSummary(conversation);
+
+    // Create a new session with the summary as context
+    let newSession: Session | null = null;
+    if (createFork) {
+      const newId = randomUUID();
+      const newName = `${session.name} (fresh)`;
+      const agentType = session.agent_type || "claude";
+      const tmuxName = `${agentType}-${newId}`;
+
+      // Create new session in DB (using cwd already fetched above)
+      getDb()
+        .prepare(
+          `INSERT INTO sessions (id, name, tmux_name, working_directory, parent_session_id, model, initial_prompt, group_path, agent_type, auto_approve, project_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(
+          newId,
+          newName,
+          tmuxName,
+          cwd,
+          null,
+          session.model,
+          `Continue from previous session. Here's a summary of the work so far:\n\n${summary}`,
+          session.group_path,
+          agentType,
+          session.auto_approve ? 1 : 0,
+          session.project_id || "uncategorized"
+        );
+
+      newSession = (await queries.getSession(newId)) as Session;
+      const newTmuxSession = tmuxName;
+
+      // Start new tmux session with Claude directly
+      const isRoot = process.getuid?.() === 0;
+      const envPrefix = isRoot ? "IS_SANDBOX=1 " : "";
+      const claudeCmd = session.auto_approve
+        ? `${envPrefix}claude --dangerously-skip-permissions`
+        : "claude";
+
+      const tmuxCmd = `tmux set -g mouse on 2>/dev/null; tmux new-session -d -s "${newTmuxSession}" -c "${cwdExpanded}" "${claudeCmd}"`;
+      console.log(`[summarize] Creating tmux session: ${tmuxCmd}`);
+      await execAsync(tmuxCmd);
+      console.log(`[summarize] Tmux session created: ${newTmuxSession}`);
+
+      // Give Claude a moment to start up before polling
+      await new Promise((r) => setTimeout(r, 2000));
+
+      // Wait for Claude to be ready and send context
+      if (sendContext) {
+        console.log(`[summarize] Waiting for Claude to be ready...`);
+        const ready = await waitForClaudeReady(newTmuxSession);
+        console.log(`[summarize] Claude ready: ${ready}`);
+        if (ready) {
+          const contextMessage = `Here's a summary of the previous session to continue from:\n\n${summary}\n\nPlease acknowledge you've received this context and are ready to continue.`;
+          console.log(
+            `[summarize] Sending context message (${contextMessage.length} chars)`
+          );
+          await sendToTmux(newTmuxSession, contextMessage, true);
+          console.log(`[summarize] Context sent!`);
+        } else {
+          console.log(
+            `[summarize] WARNING: Claude not ready, skipping context send`
+          );
+        }
+      }
+    }
+
+    return NextResponse.json({
+      summary,
+      newSession,
+    });
+  } catch (error) {
+    console.error("Error summarizing session:", error);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/api/sessions/init-script/route.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from "next/server";
+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'
+
+# 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
+
+# Ensure ~/.local/bin is in PATH (where claude is installed)
+export PATH="$HOME/.local/bin:$PATH"
+
+# If running as root, set IS_SANDBOX=1 so Claude Code allows --dangerously-skip-permissions
+if [ "$(id -u)" = "0" ]; then
+  export IS_SANDBOX=1
+fi
+
+# Start the agent
+exec ${agentCommand}
+`;
+}
+
+// POST /api/sessions/init-script - Create init script and return path
+export async function POST(request: NextRequest) {
+  try {
+    const { agentCommand } = await request.json();
+
+    if (!agentCommand) {
+      return NextResponse.json(
+        { error: "agentCommand is required" },
+        { status: 400 }
+      );
+    }
+
+    const scriptContent = generateInitScript(agentCommand);
+    const scriptPath = path.join(os.tmpdir(), `claude-deck-init-${Date.now()}.sh`);
+
+    fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+
+    return NextResponse.json({ scriptPath, command: `bash ${scriptPath}` });
+  } catch (error) {
+    console.error("Error creating init script:", error);
+    return NextResponse.json(
+      { error: "Failed to create init script" },
+      { status: 500 }
+    );
+  }
+}