@atercates/claude-deck 0.2.1

package/app/api/sessions/route.ts

@@ -0,0 +1,209 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { queries, type Session, type Group } from "@/lib/db";
+import { isValidAgentType, type AgentType } from "@/lib/providers";
+import { createWorktree } from "@/lib/worktrees";
+import { setupWorktree, type SetupResult } from "@/lib/env-setup";
+import { findAvailablePort } from "@/lib/ports";
+import { runInBackground } from "@/lib/async-operations";
+import { getProject } from "@/lib/projects";
+
+// GET /api/sessions - List all sessions and groups
+export async function GET() {
+  try {
+    const sessions = await queries.getAllSessions();
+    const groups = await queries.getAllGroups();
+
+    // Convert expanded from 0/1 to boolean
+    const formattedGroups = groups.map((g) => ({
+      ...g,
+      expanded: Boolean(g.expanded),
+    }));
+
+    return NextResponse.json({ sessions, groups: formattedGroups });
+  } catch (error) {
+    console.error("Error fetching sessions:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch sessions" },
+      { status: 500 }
+    );
+  }
+}
+
+// Generate a unique session name
+async function generateSessionName(): Promise<string> {
+  const sessions = await queries.getAllSessions();
+  const existingNumbers = sessions
+    .map((s) => {
+      const match = s.name.match(/^Session (\d+)$/);
+      return match ? parseInt(match[1], 10) : 0;
+    })
+    .filter((n) => n > 0);
+
+  const nextNumber =
+    existingNumbers.length > 0 ? Math.max(...existingNumbers) + 1 : 1;
+  return `Session ${nextNumber}`;
+}
+
+// POST /api/sessions - Create new session
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    const {
+      name: providedName,
+      workingDirectory = "~",
+      parentSessionId = null,
+      model = "sonnet",
+      systemPrompt = null,
+      groupPath = "sessions",
+      claudeSessionId = null,
+      agentType: rawAgentType = "claude",
+      autoApprove = false,
+      projectId = "uncategorized",
+      // Worktree options
+      useWorktree = false,
+      featureName = null,
+      baseBranch = "main",
+      // Tmux option
+      useTmux = true,
+      // Initial prompt to send when session starts
+      initialPrompt = null,
+    } = body;
+
+    // Validate agent type
+    const agentType: AgentType = isValidAgentType(rawAgentType)
+      ? rawAgentType
+      : "claude";
+
+    // Auto-generate name if not provided
+    const name =
+      providedName?.trim() ||
+      (featureName ? featureName : await generateSessionName());
+
+    const id = randomUUID();
+
+    // Handle worktree creation if requested
+    let worktreePath: string | null = null;
+    let branchName: string | null = null;
+    let actualWorkingDirectory = workingDirectory;
+    let port: number | null = null;
+    let setupResult: SetupResult | null = null;
+
+    if (useWorktree && featureName) {
+      try {
+        const worktreeInfo = await createWorktree({
+          projectPath: workingDirectory,
+          featureName,
+          baseBranch,
+        });
+        worktreePath = worktreeInfo.worktreePath;
+        branchName = worktreeInfo.branchName;
+        actualWorkingDirectory = worktreeInfo.worktreePath;
+
+        // Find an available port for the dev server
+        port = await findAvailablePort();
+
+        // Run environment setup in background (non-blocking)
+        // This allows instant UI feedback while npm install runs async
+        const capturedWorktreePath = worktreeInfo.worktreePath;
+        const capturedSourcePath = workingDirectory;
+        const capturedPort = port;
+        runInBackground(async () => {
+          const result = await setupWorktree({
+            worktreePath: capturedWorktreePath,
+            sourcePath: capturedSourcePath,
+            port: capturedPort,
+          });
+          console.log("Worktree setup completed:", {
+            port: capturedPort,
+            envFilesCopied: result.envFilesCopied,
+            stepsRun: result.steps.length,
+            success: result.success,
+          });
+        }, `setup-worktree-${id}`);
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        return NextResponse.json(
+          { error: `Failed to create worktree: ${message}` },
+          { status: 400 }
+        );
+      }
+    }
+
+    const tmuxName = useTmux ? `${agentType}-${id}` : null;
+    await queries.createSession(
+      id,
+      name,
+      tmuxName,
+      actualWorkingDirectory,
+      parentSessionId,
+      model,
+      systemPrompt,
+      groupPath,
+      agentType,
+      autoApprove,
+      projectId
+    );
+
+    // Set worktree info if created
+    if (worktreePath) {
+      await queries.updateSessionWorktree(
+        worktreePath,
+        branchName,
+        baseBranch,
+        port,
+        id
+      );
+    }
+
+    // Set claude_session_id if provided (for importing external sessions)
+    if (claudeSessionId) {
+      const { getDb } = await import("@/lib/db");
+      getDb()
+        .prepare("UPDATE sessions SET claude_session_id = ? WHERE id = ?")
+        .run(claudeSessionId, id);
+    }
+
+    // Messages are no longer stored in our DB - skipping message copy for forked sessions
+
+    const session = await queries.getSession(id);
+
+    // Get project's initial prompt if available
+    const project = projectId ? await getProject(projectId) : null;
+    const projectInitialPrompt = project?.initial_prompt?.trim();
+    const sessionInitialPrompt = initialPrompt?.trim();
+
+    // Combine prompts: project prompt first, then session prompt
+    let combinedPrompt: string | undefined;
+    if (projectInitialPrompt && sessionInitialPrompt) {
+      combinedPrompt = `${projectInitialPrompt}\n\n${sessionInitialPrompt}`;
+    } else if (projectInitialPrompt) {
+      combinedPrompt = projectInitialPrompt;
+    } else if (sessionInitialPrompt) {
+      combinedPrompt = sessionInitialPrompt;
+    }
+
+    // Include setup result and initial prompt in response
+    const response: {
+      session: Session | null;
+      setup?: SetupResult;
+      initialPrompt?: string;
+    } = { session };
+    if (setupResult) {
+      response.setup = setupResult;
+    }
+    if (combinedPrompt) {
+      response.initialPrompt = combinedPrompt;
+    }
+
+    return NextResponse.json(response, { status: 201 });
+  } catch (error) {
+    console.error("Error creating session:", error);
+    return NextResponse.json(
+      { error: "Failed to create session" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/sessions/status/route.ts

@@ -0,0 +1,237 @@
+import { NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { statusDetector, type SessionStatus } from "@/lib/status-detector";
+import type { AgentType } from "@/lib/providers";
+import {
+  getManagedSessionPattern,
+  getProviderIdFromSessionName,
+  getSessionIdFromName,
+} from "@/lib/providers/registry";
+import { getDb } from "@/lib/db";
+
+const execAsync = promisify(exec);
+
+interface SessionStatusResponse {
+  sessionName: string;
+  status: SessionStatus;
+  lastLine?: string;
+  claudeSessionId?: string | null;
+  agentType?: AgentType;
+}
+
+async function getTmuxSessions(): Promise<string[]> {
+  try {
+    const { stdout } = await execAsync(
+      "tmux list-sessions -F '#{session_name}' 2>/dev/null || true"
+    );
+    return stdout.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function getTmuxSessionCwd(sessionName: string): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux display-message -t "${sessionName}" -p "#{pane_current_path}" 2>/dev/null || echo ""`
+    );
+    const cwd = stdout.trim();
+    return cwd || null;
+  } catch {
+    return null;
+  }
+}
+
+// Get Claude session ID from tmux environment variable
+async function getClaudeSessionIdFromEnv(
+  sessionName: string
+): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux show-environment -t "${sessionName}" CLAUDE_SESSION_ID 2>/dev/null || echo ""`
+    );
+    const line = stdout.trim();
+    if (line.startsWith("CLAUDE_SESSION_ID=")) {
+      const sessionId = line.replace("CLAUDE_SESSION_ID=", "");
+      if (sessionId && sessionId !== "null") {
+        return sessionId;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Get Claude session ID by looking at session files on disk
+function getClaudeSessionIdFromFiles(projectPath: string): string | null {
+  const home = os.homedir();
+  const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(home, ".claude");
+  const projectDirName = projectPath.replace(/\//g, "-");
+  const projectDir = path.join(claudeDir, "projects", projectDirName);
+
+  if (!fs.existsSync(projectDir)) {
+    return null;
+  }
+
+  const uuidPattern =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/;
+
+  try {
+    const files = fs.readdirSync(projectDir);
+    let mostRecent: string | null = null;
+    let mostRecentTime = 0;
+
+    for (const file of files) {
+      if (file.startsWith("agent-")) continue;
+      if (!uuidPattern.test(file)) continue;
+
+      const filePath = path.join(projectDir, file);
+      const stat = fs.statSync(filePath);
+
+      if (stat.mtimeMs > mostRecentTime) {
+        mostRecentTime = stat.mtimeMs;
+        mostRecent = file.replace(".jsonl", "");
+      }
+    }
+
+    if (mostRecent && Date.now() - mostRecentTime < 5 * 60 * 1000) {
+      return mostRecent;
+    }
+
+    const configFile = path.join(claudeDir, ".claude.json");
+    if (fs.existsSync(configFile)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+        if (config.projects?.[projectPath]?.lastSessionId) {
+          return config.projects[projectPath].lastSessionId;
+        }
+      } catch {
+        // Ignore config parse errors
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function getClaudeSessionId(sessionName: string): Promise<string | null> {
+  const envId = await getClaudeSessionIdFromEnv(sessionName);
+  if (envId) {
+    return envId;
+  }
+
+  const cwd = await getTmuxSessionCwd(sessionName);
+  if (cwd) {
+    return getClaudeSessionIdFromFiles(cwd);
+  }
+
+  return null;
+}
+
+async function getLastLine(sessionName: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux capture-pane -t "${sessionName}" -p -S -5 2>/dev/null || echo ""`
+    );
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    return lines.pop() || "";
+  } catch {
+    return "";
+  }
+}
+
+// UUID pattern for claude-deck managed sessions (derived from registry)
+const UUID_PATTERN = getManagedSessionPattern();
+
+// Track previous statuses to detect changes
+const previousStatuses = new Map<string, SessionStatus>();
+
+function getAgentTypeFromSessionName(sessionName: string): AgentType {
+  return getProviderIdFromSessionName(sessionName) || "claude";
+}
+
+export async function GET() {
+  try {
+    const sessions = await getTmuxSessions();
+
+    // Get status for claude-deck managed sessions
+    const managedSessions = sessions.filter((s) => UUID_PATTERN.test(s));
+
+    // Use the new status detector
+    const statusMap: Record<string, SessionStatusResponse> = {};
+
+    const db = getDb();
+    const sessionsToUpdate: string[] = [];
+
+    // Process all sessions in parallel for speed
+    const sessionPromises = managedSessions.map(async (sessionName) => {
+      const [status, claudeSessionId, lastLine] = await Promise.all([
+        statusDetector.getStatus(sessionName),
+        getClaudeSessionId(sessionName),
+        getLastLine(sessionName),
+      ]);
+      const id = getSessionIdFromName(sessionName);
+      const agentType = getAgentTypeFromSessionName(sessionName);
+
+      return { sessionName, id, status, claudeSessionId, lastLine, agentType };
+    });
+
+    const results = await Promise.all(sessionPromises);
+
+    for (const {
+      sessionName,
+      id,
+      status,
+      claudeSessionId,
+      lastLine,
+      agentType,
+    } of results) {
+      // Track status changes - update DB when session becomes active
+      const prevStatus = previousStatuses.get(id);
+      if (status === "running" || status === "waiting") {
+        if (prevStatus !== status) {
+          sessionsToUpdate.push(id);
+        }
+      }
+      previousStatuses.set(id, status);
+
+      statusMap[id] = {
+        sessionName,
+        status,
+        lastLine,
+        claudeSessionId,
+        agentType,
+      };
+    }
+
+    // Batch update sessions and claude_session_id
+    for (const id of sessionsToUpdate) {
+      db.prepare(
+        "UPDATE sessions SET updated_at = datetime('now') WHERE id = ?"
+      ).run(id);
+    }
+
+    for (const { id, claudeSessionId } of results) {
+      if (claudeSessionId) {
+        db.prepare(
+          "UPDATE sessions SET claude_session_id = ? WHERE id = ? AND (claude_session_id IS NULL OR claude_session_id != ?)"
+        ).run(claudeSessionId, id, claudeSessionId);
+      }
+    }
+
+    // Cleanup old trackers
+    statusDetector.cleanup();
+
+    return NextResponse.json({ statuses: statusMap });
+  } catch (error) {
+    console.error("Error getting session statuses:", error);
+    return NextResponse.json({ statuses: {} });
+  }
+}

package/app/api/system/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+import os from "os";
+
+export async function GET() {
+  return NextResponse.json({
+    user: os.userInfo().username,
+    hostname: os.hostname(),
+  });
+}

package/app/api/tmux/kill-all/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { queries, type Session } from "@/lib/db";
+
+const execAsync = promisify(exec);
+
+// POST /api/tmux/kill-all - Kill all ClaudeDeck tmux sessions and remove from database
+export async function POST() {
+  try {
+    // Get all tmux sessions
+    const { stdout } = await execAsync(
+      'tmux list-sessions -F "#{session_name}" 2>/dev/null || echo ""',
+      { timeout: 5000 }
+    );
+
+    const tmuxSessions = stdout
+      .trim()
+      .split("\n")
+      .filter(
+        (s) => s && /^(claude|codex|opencode|gemini|aider|cursor)-/.test(s)
+      );
+
+    // Kill each tmux session
+    const killed: string[] = [];
+    for (const session of tmuxSessions) {
+      try {
+        await execAsync(`tmux kill-session -t "${session}"`, { timeout: 5000 });
+        killed.push(session);
+      } catch {
+        // Session might already be dead, continue
+      }
+    }
+
+    // Delete ALL sessions from database
+    const dbSessions = await queries.getAllSessions() as Session[];
+    for (const session of dbSessions) {
+      try {
+        await queries.deleteSession(session.id);
+      } catch {
+        // Continue on error
+      }
+    }
+
+    return NextResponse.json({
+      killed: killed.length,
+      sessions: killed,
+      deletedFromDb: dbSessions.length,
+    });
+  } catch (error) {
+    console.error("Error killing tmux sessions:", error);
+    return NextResponse.json(
+      { error: "Failed to kill sessions" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/tmux/rename/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+// POST /api/tmux/rename - Rename a tmux session
+export async function POST(request: NextRequest) {
+  try {
+    const { oldName, newName } = await request.json();
+
+    if (!oldName || !newName) {
+      return NextResponse.json(
+        { error: "oldName and newName are required" },
+        { status: 400 }
+      );
+    }
+
+    // Rename the tmux session
+    await execAsync(`tmux rename-session -t "${oldName}" "${newName}"`);
+
+    return NextResponse.json({ success: true, newName });
+  } catch (error) {
+    console.error("Error renaming tmux session:", error);
+    return NextResponse.json(
+      { error: "Failed to rename tmux session" },
+      { status: 500 }
+    );
+  }
+}