@atercates/claude-deck 0.2.1

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

@@ -0,0 +1,74 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { queries, type Session } from "@/lib/db";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// POST /api/sessions/[id]/fork - Fork a session
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id: parentId } = await params;
+
+    // Parse body if present, otherwise use empty object
+    let body: { name?: string } = {};
+    try {
+      body = await request.json();
+    } catch {
+      // No body provided, use defaults
+    }
+    const { name } = body;
+
+    // Get parent session
+    const parent = await queries.getSession(parentId);
+    if (!parent) {
+      return NextResponse.json(
+        { error: "Parent session not found" },
+        { status: 404 }
+      );
+    }
+
+    // Create new session
+    const newId = randomUUID();
+    const newName = name || `${parent.name} (fork)`;
+    const agentType = parent.agent_type || "claude";
+    const tmuxName = `${agentType}-${newId}`;
+
+    await queries.createSession(
+      newId,
+      newName,
+      tmuxName,
+      parent.working_directory,
+      parentId,
+      parent.model,
+      parent.system_prompt,
+      parent.group_path || "sessions",
+      agentType,
+      parent.auto_approve,
+      parent.project_id || "uncategorized"
+    );
+
+    // NOTE: We do NOT copy claude_session_id here.
+    // When the forked session is first attached, it will use --fork-session flag
+    // with the parent's claude_session_id to create a new branched conversation.
+    // The new session ID will be captured automatically.
+
+    // Messages are no longer stored in our DB - skipping message copy
+
+    const session = await queries.getSession(newId);
+
+    return NextResponse.json(
+      {
+        session,
+      },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error("Error forking session:", error);
+    return NextResponse.json(
+      { error: "Failed to fork session" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/sessions/[id]/mcp-config/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { queries, type Session } from "@/lib/db";
+import { ensureMcpConfig } from "@/lib/mcp-config";
+
+// POST /api/sessions/[id]/mcp-config - Ensure MCP config exists for this session
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const session = await queries.getSession(id) as Session | undefined;
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    // Expand ~ to home directory
+    const workingDirectory = session.working_directory.replace(
+      /^~/,
+      process.env.HOME || ""
+    );
+
+    ensureMcpConfig(workingDirectory, id);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Failed to write MCP config:", error);
+    return NextResponse.json(
+      { error: "Failed to write MCP config" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+import { queries } from "@/lib/db";
+import {
+  getSessionMessages,
+  getClaudeProjectNames,
+  getSessions,
+} from "@/lib/claude/jsonl-reader";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+async function findProjectForSession(
+  sessionId: string
+): Promise<string | null> {
+  const projectNames = getClaudeProjectNames();
+  for (const projectName of projectNames) {
+    const { sessions } = await getSessions(projectName, 100, 0);
+    if (sessions.some((s) => s.sessionId === sessionId)) {
+      return projectName;
+    }
+  }
+  return null;
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const { searchParams } = new URL(request.url);
+    const limit = parseInt(searchParams.get("limit") || "100", 10);
+    const offset = parseInt(searchParams.get("offset") || "0", 10);
+
+    const session = await queries.getSession(id);
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    const claudeSessionId = session.claude_session_id || id;
+    const projectName = await findProjectForSession(claudeSessionId);
+
+    if (!projectName) {
+      return NextResponse.json({ messages: [], total: 0, hasMore: false });
+    }
+
+    const result = await getSessionMessages(
+      projectName,
+      claudeSessionId,
+      limit,
+      offset
+    );
+
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("Error fetching messages:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch messages" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,188 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { queries, type Session } from "@/lib/db";
+
+const execAsync = promisify(exec);
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+interface PRInfo {
+  number: number;
+  url: string;
+  state: string;
+  title: string;
+}
+
+/**
+ * Check if gh CLI is installed and authenticated
+ */
+async function checkGhCli(): Promise<boolean> {
+  try {
+    await execAsync("gh auth status", { timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get PR info for a branch
+ */
+async function getPRForBranch(
+  projectPath: string,
+  branchName: string
+): Promise<PRInfo | null> {
+  try {
+    const { stdout } = await execAsync(
+      `gh pr list --head "${branchName}" --json number,url,state,title --limit 1`,
+      { cwd: projectPath, timeout: 10000 }
+    );
+    const prs = JSON.parse(stdout);
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a new PR for a branch
+ */
+async function createPR(
+  projectPath: string,
+  branchName: string,
+  baseBranch: string,
+  title: string,
+  body?: string
+): Promise<PRInfo> {
+  // First push the branch if not already pushed
+  try {
+    await execAsync(`git push -u origin "${branchName}"`, {
+      cwd: projectPath,
+      timeout: 30000,
+    });
+  } catch {
+    // Branch might already be pushed, continue
+  }
+
+  const bodyArg = body ? `--body "${body.replace(/"/g, '\\"')}"` : '--body ""';
+  const { stdout } = await execAsync(
+    `gh pr create --title "${title.replace(/"/g, '\\"')}" --base "${baseBranch}" ${bodyArg} --json number,url,state,title`,
+    { cwd: projectPath, timeout: 30000 }
+  );
+  return JSON.parse(stdout);
+}
+
+// GET /api/sessions/[id]/pr - Get PR info for session
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const session = await queries.getSession(id);
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    if (!session.worktree_path || !session.branch_name) {
+      return NextResponse.json(
+        { error: "Session is not a worktree session" },
+        { status: 400 }
+      );
+    }
+
+    // Check gh CLI
+    if (!(await checkGhCli())) {
+      return NextResponse.json(
+        {
+          error:
+            "GitHub CLI not installed or not authenticated. Run 'gh auth login' first.",
+        },
+        { status: 400 }
+      );
+    }
+
+    const pr = await getPRForBranch(session.worktree_path, session.branch_name);
+
+    // Update session with PR info if found
+    if (pr) {
+      await queries.updateSessionPR(pr.url, pr.number, pr.state, id);
+    }
+
+    return NextResponse.json({ pr });
+  } catch (error) {
+    console.error("Error fetching PR:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch PR info" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/sessions/[id]/pr - Create PR for session
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { title, description } = body;
+
+    const session = await queries.getSession(id);
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    if (!session.worktree_path || !session.branch_name) {
+      return NextResponse.json(
+        { error: "Session is not a worktree session" },
+        { status: 400 }
+      );
+    }
+
+    // Check gh CLI
+    if (!(await checkGhCli())) {
+      return NextResponse.json(
+        {
+          error:
+            "GitHub CLI not installed or not authenticated. Run 'gh auth login' first.",
+        },
+        { status: 400 }
+      );
+    }
+
+    // Check if PR already exists
+    const existingPR = await getPRForBranch(
+      session.worktree_path,
+      session.branch_name
+    );
+    if (existingPR) {
+      return NextResponse.json(
+        { error: "PR already exists for this branch", pr: existingPR },
+        { status: 409 }
+      );
+    }
+
+    // Create PR
+    const prTitle = title || session.name;
+    const pr = await createPR(
+      session.worktree_path,
+      session.branch_name,
+      session.base_branch || "main",
+      prTitle,
+      description
+    );
+
+    // Save PR info to session
+    await queries.updateSessionPR(pr.url, pr.number, pr.state, id);
+
+    return NextResponse.json({ pr }, { status: 201 });
+  } catch (error) {
+    console.error("Error creating PR:", error);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json(
+      { error: `Failed to create PR: ${message}` },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { queries, type Session } from "@/lib/db";
+
+const execAsync = promisify(exec);
+
+// Get terminal preview (last N lines) from tmux session
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+
+    // Look up session to get the tmux name
+    const session = await queries.getSession(id);
+    const agentType = session?.agent_type || "claude";
+    const sessionName = session?.tmux_name || `${agentType}-${id}`;
+
+    // Capture visible pane content plus scrollback, take last 50 lines
+    const { stdout } = await execAsync(
+      `tmux capture-pane -t "${sessionName}" -p -S -100 2>/dev/null || echo ""`
+    );
+
+    // Take the last 50 non-empty lines (trim trailing empty lines)
+    const allLines = stdout.split("\n");
+    let lastNonEmpty = allLines.length - 1;
+    while (lastNonEmpty > 0 && allLines[lastNonEmpty].trim() === "") {
+      lastNonEmpty--;
+    }
+    const lines = allLines.slice(
+      Math.max(0, lastNonEmpty - 49),
+      lastNonEmpty + 1
+    );
+
+    return NextResponse.json({ lines });
+  } catch (error) {
+    console.error("Error getting session preview:", error);
+    return NextResponse.json({ lines: [] });
+  }
+}

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

@@ -0,0 +1,229 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { queries, type Session } from "@/lib/db";
+import { deleteWorktree, isClaudeDeckWorktree } from "@/lib/worktrees";
+import { releasePort } from "@/lib/ports";
+import { killWorker } from "@/lib/orchestration";
+import { generateBranchName, getCurrentBranch, renameBranch } from "@/lib/git";
+import { runInBackground } from "@/lib/async-operations";
+
+const execAsync = promisify(exec);
+
+// Sanitize a name for use as tmux session name
+function sanitizeTmuxName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-") // Replace non-alphanumeric with dashes
+    .replace(/-+/g, "-") // Collapse multiple dashes
+    .replace(/^-|-$/g, "") // Remove leading/trailing dashes
+    .slice(0, 50); // Limit length
+}
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// GET /api/sessions/[id] - Get single session
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const session = await queries.getSession(id);
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ session });
+  } catch (error) {
+    console.error("Error fetching session:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch session" },
+      { status: 500 }
+    );
+  }
+}
+
+// PATCH /api/sessions/[id] - Update session
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+
+    const existing = await queries.getSession(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    // Build update query dynamically based on provided fields
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    // Handle name change - also rename tmux session and git branch (for worktrees)
+    if (body.name !== undefined && body.name !== existing.name) {
+      const newTmuxName = sanitizeTmuxName(body.name);
+      const oldTmuxName = existing.tmux_name;
+
+      // Try to rename the tmux session
+      if (oldTmuxName && newTmuxName) {
+        try {
+          await execAsync(
+            `tmux rename-session -t "${oldTmuxName}" "${newTmuxName}"`
+          );
+          updates.push(`tmux_name = ?`);
+          values.push(newTmuxName);
+        } catch {
+          // tmux session might not exist or rename failed - that's ok, just update the name
+          // Still update tmux_name in DB so future attachments use the new name
+          updates.push(`tmux_name = ?`);
+          values.push(newTmuxName);
+        }
+      }
+
+      // If this is a worktree session, also rename the git branch
+      if (existing.worktree_path && isClaudeDeckWorktree(existing.worktree_path)) {
+        try {
+          const currentBranch = await getCurrentBranch(existing.worktree_path);
+          const newBranchName = generateBranchName(body.name);
+
+          if (currentBranch !== newBranchName) {
+            const result = await renameBranch(
+              existing.worktree_path,
+              currentBranch,
+              newBranchName
+            );
+            console.log(
+              `Renamed branch ${currentBranch} → ${newBranchName}`,
+              result.remoteRenamed ? "(also on remote)" : "(local only)"
+            );
+          }
+        } catch (error) {
+          console.error("Failed to rename git branch:", error);
+          // Continue with session rename even if branch rename fails
+        }
+      }
+
+      updates.push(`name = ?`);
+      values.push(body.name);
+    }
+    if (body.status !== undefined) {
+      updates.push(`status = ?`);
+      values.push(body.status);
+    }
+    if (body.workingDirectory !== undefined) {
+      updates.push(`working_directory = ?`);
+      values.push(body.workingDirectory);
+    }
+    if (body.systemPrompt !== undefined) {
+      updates.push(`system_prompt = ?`);
+      values.push(body.systemPrompt);
+    }
+    if (body.groupPath !== undefined) {
+      updates.push(`group_path = ?`);
+      values.push(body.groupPath);
+    }
+
+    if (updates.length > 0) {
+      updates.push("updated_at = datetime('now')");
+      values.push(id);
+
+      const { getDb } = await import("@/lib/db");
+      getDb()
+        .prepare(`UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`)
+        .run(...values);
+    }
+
+    const session = await queries.getSession(id);
+    return NextResponse.json({ session });
+  } catch (error) {
+    console.error("Error updating session:", error);
+    return NextResponse.json(
+      { error: "Failed to update session" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/sessions/[id] - Delete session
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+
+    const existing = await queries.getSession(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    // If this is a conductor, delete all its workers first
+    const workers = await queries.getWorkersByConductor(id);
+    for (const worker of workers) {
+      try {
+        await killWorker(worker.id, false); // false = don't cleanup worktree yet
+      } catch (error) {
+        console.error(`Failed to kill worker ${worker.id}:`, error);
+      }
+      await queries.deleteSession(worker.id);
+    }
+
+    // Release port if this session had one assigned
+    if (existing.dev_server_port) {
+      releasePort(id);
+    }
+
+    // Delete from database immediately for instant UI feedback
+    await queries.deleteSession(id);
+
+    // Clean up worktree in background (non-blocking)
+    if (existing.worktree_path && isClaudeDeckWorktree(existing.worktree_path)) {
+      const worktreePath = existing.worktree_path; // Capture for closure
+      runInBackground(async () => {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+
+        const { stdout } = await execAsync(
+          `git -C "${worktreePath}" rev-parse --path-format=absolute --git-common-dir 2>/dev/null || echo ""`,
+          { timeout: 5000 }
+        );
+        const gitCommonDir = stdout.trim().replace(/\/.git$/, "");
+
+        if (gitCommonDir) {
+          await deleteWorktree(worktreePath, gitCommonDir, false);
+        }
+      }, `cleanup-worktree-${id}`);
+    }
+
+    // Also cleanup worker worktrees in background
+    if (workers.length > 0) {
+      for (const worker of workers) {
+        if (worker.worktree_path && isClaudeDeckWorktree(worker.worktree_path)) {
+          const worktreePath = worker.worktree_path; // Capture for closure
+          const workerId = worker.id; // Capture ID for task name
+          runInBackground(async () => {
+            const { exec } = await import("child_process");
+            const { promisify } = await import("util");
+            const execAsync = promisify(exec);
+
+            const { stdout } = await execAsync(
+              `git -C "${worktreePath}" rev-parse --path-format=absolute --git-common-dir 2>/dev/null || echo ""`,
+              { timeout: 5000 }
+            );
+            const gitCommonDir = stdout.trim().replace(/\/.git$/, "");
+
+            if (gitCommonDir) {
+              await deleteWorktree(worktreePath, gitCommonDir, false);
+            }
+          }, `cleanup-worker-worktree-${workerId}`);
+        }
+      }
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error deleting session:", error);
+    return NextResponse.json(
+      { error: "Failed to delete session" },
+      { status: 500 }
+    );
+  }
+}