@atercates/claude-deck 0.2.1

package/app/api/orchestrate/workers/[id]/route.ts

@@ -0,0 +1,89 @@
+import { NextResponse } from "next/server";
+import {
+  getWorkerOutput,
+  sendToWorker,
+  completeWorker,
+  failWorker,
+  killWorker,
+} from "@/lib/orchestration";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// GET /api/orchestrate/workers/[id] - Get worker output
+export async function GET(request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const { searchParams } = new URL(request.url);
+    const lines = parseInt(searchParams.get("lines") || "50", 10);
+
+    const output = await getWorkerOutput(id, lines);
+    return NextResponse.json({ output });
+  } catch (error) {
+    console.error("Failed to get worker output:", error);
+    return NextResponse.json(
+      { error: "Failed to get worker output" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/orchestrate/workers/[id] - Send message or update status
+export async function POST(request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { action, message } = body;
+
+    switch (action) {
+      case "send":
+        if (!message) {
+          return NextResponse.json(
+            { error: "Missing message" },
+            { status: 400 }
+          );
+        }
+        const sent = await sendToWorker(id, message);
+        return NextResponse.json({ success: sent });
+
+      case "complete":
+        completeWorker(id);
+        return NextResponse.json({ success: true });
+
+      case "fail":
+        failWorker(id);
+        return NextResponse.json({ success: true });
+
+      default:
+        return NextResponse.json(
+          { error: "Invalid action. Use: send, complete, or fail" },
+          { status: 400 }
+        );
+    }
+  } catch (error) {
+    console.error("Failed to perform worker action:", error);
+    return NextResponse.json(
+      { error: "Failed to perform worker action" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/orchestrate/workers/[id] - Kill worker
+export async function DELETE(request: Request, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const { searchParams } = new URL(request.url);
+    const cleanupWorktree = searchParams.get("cleanup") === "true";
+
+    await killWorker(id, cleanupWorktree);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Failed to kill worker:", error);
+    return NextResponse.json(
+      { error: "Failed to kill worker" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/orchestrate/workers/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { getWorkers, getWorkersSummary } from "@/lib/orchestration";
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const conductorId = searchParams.get("conductorId");
+    const summaryOnly = searchParams.get("summary") === "true";
+
+    if (!conductorId) {
+      return NextResponse.json(
+        { error: "Missing conductorId parameter" },
+        { status: 400 }
+      );
+    }
+
+    if (summaryOnly) {
+      const summary = await getWorkersSummary(conductorId);
+      return NextResponse.json({ summary });
+    }
+
+    const workers = await getWorkers(conductorId);
+    return NextResponse.json({ workers });
+  } catch (error) {
+    console.error("Failed to get workers:", error);
+    return NextResponse.json(
+      { error: "Failed to get workers" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/[id]/detect/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getProject, detectDevServers } from "@/lib/projects";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// GET /api/projects/[id]/detect - Detect available dev servers for a project
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const project = await getProject(id);
+
+    if (!project) {
+      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+    }
+
+    const detected = await detectDevServers(project.working_directory);
+    return NextResponse.json({ detected });
+  } catch (error) {
+    console.error("Error detecting dev servers:", error);
+    return NextResponse.json(
+      { error: "Failed to detect dev servers" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/[id]/dev-servers/[dsId]/route.ts

@@ -0,0 +1,66 @@
+import { NextRequest, NextResponse } from "next/server";
+import { updateProjectDevServer, deleteProjectDevServer } from "@/lib/projects";
+import { queries, type ProjectDevServer } from "@/lib/db";
+
+interface RouteParams {
+  params: Promise<{ id: string; dsId: string }>;
+}
+
+// PATCH /api/projects/[id]/dev-servers/[dsId] - Update a dev server config
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { dsId } = await params;
+
+    const existing = await queries.getProjectDevServer(dsId);
+    if (!existing) {
+      return NextResponse.json(
+        { error: "Dev server config not found" },
+        { status: 404 }
+      );
+    }
+
+    const body = await request.json();
+    const { name, type, command, port, portEnvVar, sortOrder } = body;
+
+    const devServer = await updateProjectDevServer(dsId, {
+      name,
+      type,
+      command,
+      port,
+      portEnvVar,
+      sortOrder,
+    });
+
+    return NextResponse.json({ devServer });
+  } catch (error) {
+    console.error("Error updating dev server config:", error);
+    return NextResponse.json(
+      { error: "Failed to update dev server config" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/projects/[id]/dev-servers/[dsId] - Delete a dev server config
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { dsId } = await params;
+
+    const existing = await queries.getProjectDevServer(dsId);
+    if (!existing) {
+      return NextResponse.json(
+        { error: "Dev server config not found" },
+        { status: 404 }
+      );
+    }
+
+    await deleteProjectDevServer(dsId);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error deleting dev server config:", error);
+    return NextResponse.json(
+      { error: "Failed to delete dev server config" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/[id]/dev-servers/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getProject, addProjectDevServer } from "@/lib/projects";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// POST /api/projects/[id]/dev-servers - Add a dev server config to a project
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const project = await getProject(id);
+
+    if (!project) {
+      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+    }
+
+    if (project.is_uncategorized) {
+      return NextResponse.json(
+        { error: "Cannot add dev servers to Uncategorized project" },
+        { status: 400 }
+      );
+    }
+
+    const body = await request.json();
+    const { name, type, command, port, portEnvVar } = body;
+
+    if (!name || !type || !command) {
+      return NextResponse.json(
+        { error: "Name, type, and command are required" },
+        { status: 400 }
+      );
+    }
+
+    const devServer = await addProjectDevServer(id, {
+      name,
+      type,
+      command,
+      port,
+      portEnvVar,
+    });
+
+    return NextResponse.json({ devServer }, { status: 201 });
+  } catch (error) {
+    console.error("Error adding dev server config:", error);
+    return NextResponse.json(
+      { error: "Failed to add dev server config" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/[id]/repositories/[repoId]/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  updateProjectRepository,
+  deleteProjectRepository,
+} from "@/lib/projects";
+import { queries, type ProjectRepository } from "@/lib/db";
+
+interface RouteParams {
+  params: Promise<{ id: string; repoId: string }>;
+}
+
+// PATCH /api/projects/[id]/repositories/[repoId] - Update a repository
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { repoId } = await params;
+
+    const existing = await queries.getProjectRepository(repoId);
+    if (!existing) {
+      return NextResponse.json(
+        { error: "Repository not found" },
+        { status: 404 }
+      );
+    }
+
+    const body = await request.json();
+    const { name, path, isPrimary, sortOrder } = body;
+
+    const repository = await updateProjectRepository(repoId, {
+      name,
+      path,
+      isPrimary,
+      sortOrder,
+    });
+
+    return NextResponse.json({ repository });
+  } catch (error) {
+    console.error("Error updating repository:", error);
+    return NextResponse.json(
+      { error: "Failed to update repository" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/projects/[id]/repositories/[repoId] - Delete a repository
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { repoId } = await params;
+
+    const existing = await queries.getProjectRepository(repoId);
+    if (!existing) {
+      return NextResponse.json(
+        { error: "Repository not found" },
+        { status: 404 }
+      );
+    }
+
+    await deleteProjectRepository(repoId);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error deleting repository:", error);
+    return NextResponse.json(
+      { error: "Failed to delete repository" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/[id]/repositories/route.ts

@@ -0,0 +1,74 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getProject,
+  getProjectRepositories,
+  addProjectRepository,
+} from "@/lib/projects";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// GET /api/projects/[id]/repositories - List repositories for a project
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const project = await getProject(id);
+
+    if (!project) {
+      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+    }
+
+    const repositories = await getProjectRepositories(id);
+    return NextResponse.json({ repositories });
+  } catch (error) {
+    console.error("Error fetching repositories:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch repositories" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/projects/[id]/repositories - Add a repository to a project
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const project = await getProject(id);
+
+    if (!project) {
+      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+    }
+
+    if (project.is_uncategorized) {
+      return NextResponse.json(
+        { error: "Cannot add repositories to Uncategorized project" },
+        { status: 400 }
+      );
+    }
+
+    const body = await request.json();
+    const { name, path, isPrimary } = body;
+
+    if (!name || !path) {
+      return NextResponse.json(
+        { error: "Name and path are required" },
+        { status: 400 }
+      );
+    }
+
+    const repository = await addProjectRepository(id, {
+      name,
+      path,
+      isPrimary,
+    });
+
+    return NextResponse.json({ repository }, { status: 201 });
+  } catch (error) {
+    console.error("Error adding repository:", error);
+    return NextResponse.json(
+      { error: "Failed to add repository" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,108 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getProjectWithDevServers,
+  updateProject,
+  deleteProject,
+  toggleProjectExpanded,
+} from "@/lib/projects";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+// GET /api/projects/[id] - Get a single project with dev servers
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const project = await getProjectWithDevServers(id);
+
+    if (!project) {
+      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ project });
+  } catch (error) {
+    console.error("Error getting project:", error);
+    return NextResponse.json(
+      { error: "Failed to get project" },
+      { status: 500 }
+    );
+  }
+}
+
+// PATCH /api/projects/[id] - Update a project
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const {
+      name,
+      workingDirectory,
+      agentType,
+      defaultModel,
+      initialPrompt,
+      expanded,
+    } = body;
+
+    // Handle expanded toggle separately
+    if (typeof expanded === "boolean") {
+      await toggleProjectExpanded(id, expanded);
+    }
+
+    // Update other fields if provided
+    if (
+      name ||
+      workingDirectory ||
+      agentType ||
+      defaultModel ||
+      initialPrompt !== undefined
+    ) {
+      const project = await updateProject(id, {
+        name,
+        working_directory: workingDirectory,
+        agent_type: agentType,
+        default_model: defaultModel,
+        initial_prompt: initialPrompt,
+      });
+
+      if (!project) {
+        return NextResponse.json(
+          { error: "Project not found or cannot be modified" },
+          { status: 404 }
+        );
+      }
+    }
+
+    const updated = await getProjectWithDevServers(id);
+    return NextResponse.json({ project: updated });
+  } catch (error) {
+    console.error("Error updating project:", error);
+    return NextResponse.json(
+      { error: "Failed to update project" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/projects/[id] - Delete a project
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { id } = await params;
+    const deleted = await deleteProject(id);
+
+    if (!deleted) {
+      return NextResponse.json(
+        { error: "Project not found or cannot be deleted" },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error deleting project:", error);
+    return NextResponse.json(
+      { error: "Failed to delete project" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/detect/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { detectDevServers, validateWorkingDirectory } from "@/lib/projects";
+
+// POST /api/projects/detect - Detect available dev servers in a directory
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { workingDirectory } = body;
+
+    if (!workingDirectory) {
+      return NextResponse.json(
+        { error: "Working directory is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!validateWorkingDirectory(workingDirectory)) {
+      return NextResponse.json(
+        { error: "Working directory does not exist" },
+        { status: 400 }
+      );
+    }
+
+    const detected = await detectDevServers(workingDirectory);
+    return NextResponse.json({ detected });
+  } catch (error) {
+    console.error("Error detecting dev servers:", error);
+    return NextResponse.json(
+      { error: "Failed to detect dev servers" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/projects/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getAllProjectsWithDevServers,
+  createProject,
+  validateWorkingDirectory,
+} from "@/lib/projects";
+
+// GET /api/projects - List all projects with dev server configs
+export async function GET() {
+  try {
+    const projects = await getAllProjectsWithDevServers();
+    return NextResponse.json({ projects });
+  } catch (error) {
+    console.error("Error getting projects:", error);
+    return NextResponse.json(
+      { error: "Failed to get projects" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/projects - Create a new project
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { name, workingDirectory, agentType, defaultModel, devServers } =
+      body;
+
+    if (!name || !workingDirectory) {
+      return NextResponse.json(
+        { error: "Name and working directory are required" },
+        { status: 400 }
+      );
+    }
+
+    if (!validateWorkingDirectory(workingDirectory)) {
+      return NextResponse.json(
+        { error: "Working directory does not exist" },
+        { status: 400 }
+      );
+    }
+
+    const project = await createProject({
+      name,
+      workingDirectory,
+      agentType,
+      defaultModel,
+      devServers,
+    });
+
+    return NextResponse.json({ project }, { status: 201 });
+  } catch (error) {
+    console.error("Error creating project:", error);
+    return NextResponse.json(
+      { error: "Failed to create project" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/sessions/[id]/claude-session/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { getDb } from "@/lib/db";
+
+const execAsync = promisify(exec);
+
+// GET: Check tmux environment for Claude session ID
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const tmuxSession = `claude-${id}`;
+
+  try {
+    // Check tmux environment for CLAUDE_SESSION_ID
+    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=", "");
+      if (sessionId && sessionId !== "null") {
+        // Update database with the session ID
+        getDb()
+          .prepare(
+            "UPDATE sessions SET claude_session_id = ?, updated_at = datetime('now') WHERE id = ?"
+          )
+          .run(sessionId, id);
+
+        return NextResponse.json({ claude_session_id: sessionId });
+      }
+    }
+
+    return NextResponse.json({ claude_session_id: null });
+  } catch (error) {
+    console.error("Error getting Claude session ID:", error);
+    return NextResponse.json({ claude_session_id: null });
+  }
+}