@atercates/claude-deck 0.2.1

package/lib/dev-servers.ts

@@ -0,0 +1,509 @@
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+import fs from "fs";
+import path from "path";
+import { queries, type DevServer, type DevServerType, type DevServerStatus } from "./db";
+
+const execAsync = promisify(exec);
+
+const LOGS_DIR = path.join(process.env.HOME || "~", ".claude-deck", "logs");
+
+// Ensure logs directory exists
+if (!fs.existsSync(LOGS_DIR)) {
+  fs.mkdirSync(LOGS_DIR, { recursive: true });
+}
+
+export interface StartServerOptions {
+  projectId: string;
+  type: DevServerType;
+  name: string;
+  command: string;
+  workingDirectory: string;
+  ports?: number[];
+}
+
+export interface DetectedServer {
+  type: DevServerType;
+  name: string;
+  command: string;
+  ports: number[];
+}
+
+// Generate unique ID
+function generateId(): string {
+  return `ds_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// Get log file path for a server
+export function getLogPath(serverId: string): string {
+  return path.join(LOGS_DIR, `${serverId}.log`);
+}
+
+// Check if a process is running by PID
+async function isPidRunning(pid: number): Promise<boolean> {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Check if a port is in use
+async function isPortInUse(port: number): Promise<boolean> {
+  try {
+    const { stdout } = await execAsync(
+      `lsof -i :${port} -t 2>/dev/null || true`
+    );
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Get PID using a port
+async function getPidOnPort(port: number): Promise<number | null> {
+  try {
+    const { stdout } = await execAsync(
+      `lsof -i :${port} -t 2>/dev/null | head -1`
+    );
+    const pid = parseInt(stdout.trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+// Check Node.js server status
+async function checkNodeStatus(server: DevServer): Promise<DevServerStatus> {
+  if (server.pid) {
+    const running = await isPidRunning(server.pid);
+    if (running) return "running";
+  }
+
+  // Check if any of its ports are in use
+  const ports: number[] = JSON.parse(server.ports || "[]");
+  for (const port of ports) {
+    if (await isPortInUse(port)) {
+      // Port is in use, try to get the PID
+      const pid = await getPidOnPort(port);
+      if (pid) {
+        // Update PID in database
+        await queries.updateDevServerPid(pid, "running", server.id);
+        return "running";
+      }
+    }
+  }
+
+  return "stopped";
+}
+
+// Check Docker service status
+async function checkDockerStatus(server: DevServer): Promise<DevServerStatus> {
+  if (!server.container_id) return "stopped";
+
+  try {
+    const { stdout } = await execAsync(
+      `docker inspect -f '{{.State.Status}}' ${server.container_id} 2>/dev/null || echo ""`
+    );
+    const status = stdout.trim();
+    if (status === "running") return "running";
+    if (status === "starting" || status === "restarting") return "starting";
+    return "stopped";
+  } catch {
+    return "stopped";
+  }
+}
+
+// Get live status for a server
+export async function getServerStatus(
+  server: DevServer
+): Promise<DevServerStatus> {
+  if (server.type === "docker") {
+    return checkDockerStatus(server);
+  }
+  return checkNodeStatus(server);
+}
+
+// Get all servers with live status
+export async function getAllServers(): Promise<DevServer[]> {
+  const servers = await queries.getAllDevServers();
+
+  // Update status for each server
+  for (const server of servers) {
+    const liveStatus = await getServerStatus(server);
+    if (liveStatus !== server.status) {
+      await queries.updateDevServerStatus(liveStatus, server.id);
+      server.status = liveStatus;
+    }
+  }
+
+  return servers;
+}
+
+// Get servers for a project
+export async function getServersByProject(
+  projectId: string
+): Promise<DevServer[]> {
+  const servers = await queries.getDevServersByProject(projectId);
+
+  for (const server of servers) {
+    const liveStatus = await getServerStatus(server);
+    if (liveStatus !== server.status) {
+      await queries.updateDevServerStatus(liveStatus, server.id);
+      server.status = liveStatus;
+    }
+  }
+
+  return servers;
+}
+
+// Expand ~ to home directory
+function expandHome(filePath: string): string {
+  if (filePath.startsWith("~/")) {
+    return path.join(process.env.HOME || "", filePath.slice(2));
+  }
+  return filePath;
+}
+
+// Start a Node.js server
+async function spawnNodeServer(
+  id: string,
+  command: string,
+  workingDirectory: string,
+  ports: number[]
+): Promise<{ pid: number }> {
+  const logPath = getLogPath(id);
+  // Open log file for appending (get file descriptor for spawn)
+  const logFd = fs.openSync(logPath, "a");
+
+  // Expand ~ to absolute path - Node.js spawn doesn't handle tilde
+  const cwd = expandHome(workingDirectory);
+
+  // Build minimal env - only essentials for shell to work
+  // This lets Next.js/Vite/etc load .env.local without interference from parent process env
+  const env: Record<string, string | undefined> = {
+    PATH: process.env.PATH,
+    HOME: process.env.HOME,
+    USER: process.env.USER,
+    SHELL: process.env.SHELL,
+    TERM: process.env.TERM || "xterm-256color",
+    LANG: process.env.LANG || "en_US.UTF-8",
+  };
+
+  // Add port if specified
+  if (ports.length > 0) {
+    env.PORT = String(ports[0]);
+  }
+
+  const fullCommand = `cd "${cwd}" && ${command}`;
+
+  const child = spawn(fullCommand, [], {
+    cwd,
+    env: env as NodeJS.ProcessEnv,
+    shell: true,
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+  });
+
+  if (child.pid) child.unref();
+
+  // Close our reference to the fd - the child process has its own
+  fs.closeSync(logFd);
+
+  // Give it a moment to start
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  return { pid: child.pid || 0 };
+}
+
+// Start a Docker Compose service
+async function spawnDockerService(
+  command: string,
+  workingDirectory: string
+): Promise<{ containerId: string | null }> {
+  try {
+    // command is expected to be the service name
+    await execAsync(`docker compose up -d ${command}`, {
+      cwd: workingDirectory,
+    });
+
+    // Get container ID
+    const { stdout } = await execAsync(
+      `docker compose ps -q ${command} 2>/dev/null || echo ""`,
+      { cwd: workingDirectory }
+    );
+    const containerId = stdout.trim() || null;
+
+    return { containerId };
+  } catch (error) {
+    console.error("Failed to start Docker service:", error);
+    return { containerId: null };
+  }
+}
+
+// Start a server
+export async function startServer(
+  opts: StartServerOptions
+): Promise<DevServer> {
+  const id = generateId();
+  const ports = opts.ports || [];
+
+  // Create database record first
+  await queries.createDevServer(
+    id,
+    opts.projectId,
+    opts.type,
+    opts.name,
+    opts.command,
+    "starting",
+    null, // pid
+    null, // container_id
+    JSON.stringify(ports),
+    opts.workingDirectory
+  );
+
+  try {
+    if (opts.type === "docker") {
+      const { containerId } = await spawnDockerService(
+        opts.command,
+        opts.workingDirectory
+      );
+      await queries.updateDevServer("running", null, containerId, JSON.stringify(ports), id);
+    } else {
+      const { pid } = await spawnNodeServer(
+        id,
+        opts.command,
+        opts.workingDirectory,
+        ports
+      );
+      await queries.updateDevServer("running", pid, null, JSON.stringify(ports), id);
+    }
+  } catch (error) {
+    await queries.updateDevServerStatus("failed", id);
+    throw error;
+  }
+
+  return (await queries.getDevServer(id))!;
+}
+
+// Stop a server
+export async function stopServer(id: string): Promise<void> {
+  const server = await queries.getDevServer(id);
+  if (!server) return;
+
+  if (server.type === "docker") {
+    if (server.container_id) {
+      try {
+        await execAsync(`docker stop ${server.container_id}`);
+      } catch {
+        // Container may already be stopped
+      }
+    }
+  } else {
+    if (server.pid) {
+      try {
+        process.kill(server.pid, "SIGTERM");
+        // Give it time to gracefully shut down
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Force kill if still running
+        if (await isPidRunning(server.pid)) {
+          process.kill(server.pid, "SIGKILL");
+        }
+      } catch {
+        // Process may already be dead
+      }
+    }
+
+    // Also check ports and kill anything on them
+    const ports: number[] = JSON.parse(server.ports || "[]");
+    for (const port of ports) {
+      const pid = await getPidOnPort(port);
+      if (pid) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+          // Ignore
+        }
+      }
+    }
+  }
+
+  await queries.updateDevServerStatus("stopped", id);
+}
+
+// Restart a server
+export async function restartServer(id: string): Promise<DevServer> {
+  const server = await queries.getDevServer(id);
+  if (!server) throw new Error("Server not found");
+
+  await stopServer(id);
+
+  // Re-start with same config
+  if (server.type === "docker") {
+    const { containerId } = await spawnDockerService(
+      server.command,
+      server.working_directory
+    );
+    await queries.updateDevServer("running", null, containerId, server.ports, id);
+  } else {
+    const ports: number[] = JSON.parse(server.ports || "[]");
+    const { pid } = await spawnNodeServer(
+      id,
+      server.command,
+      server.working_directory,
+      ports
+    );
+    await queries.updateDevServer("running", pid, null, server.ports, id);
+  }
+
+  return (await queries.getDevServer(id))!;
+}
+
+// Remove a server (stop and delete)
+export async function removeServer(id: string): Promise<void> {
+  await stopServer(id);
+  await queries.deleteDevServer(id);
+
+  // Clean up log file
+  const logPath = getLogPath(id);
+  if (fs.existsSync(logPath)) {
+    fs.unlinkSync(logPath);
+  }
+}
+
+// Get logs for a server
+export async function getServerLogs(
+  id: string,
+  lines = 100
+): Promise<string[]> {
+  const server = await queries.getDevServer(id);
+  if (!server) return [];
+
+  if (server.type === "docker" && server.container_id) {
+    try {
+      const { stdout } = await execAsync(
+        `docker logs --tail ${lines} ${server.container_id} 2>&1`
+      );
+      return stdout.split("\n");
+    } catch {
+      return [];
+    }
+  }
+
+  // Node.js server - read log file
+  const logPath = getLogPath(id);
+  if (!fs.existsSync(logPath)) return [];
+
+  try {
+    const content = fs.readFileSync(logPath, "utf-8");
+    const allLines = content.split("\n");
+    return allLines.slice(-lines);
+  } catch {
+    return [];
+  }
+}
+
+// Detect available Node.js dev server in a directory
+export async function detectNodeServer(
+  workingDir: string
+): Promise<DetectedServer | null> {
+  const packageJsonPath = path.join(workingDir, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return null;
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const scripts = packageJson.scripts || {};
+
+    // Look for common dev server scripts
+    const devScripts = ["dev", "start", "serve", "develop"];
+    for (const script of devScripts) {
+      if (scripts[script]) {
+        // Try to detect port from script
+        const scriptContent = scripts[script];
+        let port = 3000; // default
+        const portMatch = scriptContent.match(/(?:port|PORT)[=\s]+(\d+)/i);
+        if (portMatch) {
+          port = parseInt(portMatch[1], 10);
+        }
+
+        return {
+          type: "node",
+          name: packageJson.name || path.basename(workingDir),
+          command: `npm run ${script}`,
+          ports: [port],
+        };
+      }
+    }
+  } catch {
+    // Ignore parse errors
+  }
+
+  return null;
+}
+
+// Detect Docker Compose services in a directory
+export async function detectDockerServices(
+  workingDir: string
+): Promise<DetectedServer[]> {
+  const composeFiles = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+  ];
+
+  for (const file of composeFiles) {
+    const composePath = path.join(workingDir, file);
+    if (fs.existsSync(composePath)) {
+      try {
+        const { stdout } = await execAsync(
+          `docker compose -f ${file} config --services 2>/dev/null || echo ""`,
+          { cwd: workingDir }
+        );
+        const services = stdout.trim().split("\n").filter(Boolean);
+
+        return services.map((service) => ({
+          type: "docker" as const,
+          name: service,
+          command: service,
+          ports: [], // Would need to parse compose file for ports
+        }));
+      } catch {
+        // Docker not available or compose file invalid
+      }
+    }
+  }
+
+  return [];
+}
+
+// Detect all available servers in a directory
+export async function detectServers(
+  workingDir: string
+): Promise<DetectedServer[]> {
+  const servers: DetectedServer[] = [];
+
+  const nodeServer = await detectNodeServer(workingDir);
+  if (nodeServer) {
+    servers.push(nodeServer);
+  }
+
+  const dockerServices = await detectDockerServices(workingDir);
+  servers.push(...dockerServices);
+
+  return servers;
+}
+
+// Clean up orphaned servers on startup
+export async function cleanupOrphanedServers(): Promise<void> {
+  const servers = await queries.getAllDevServers();
+
+  for (const server of servers) {
+    const liveStatus = await getServerStatus(server);
+    if (server.status === "running" && liveStatus === "stopped") {
+      // Server was running but is now dead
+      await queries.updateDevServerStatus("stopped", server.id);
+    }
+  }
+}

package/lib/diff-parser.ts

@@ -0,0 +1,221 @@
+/**
+ * Unified diff parser
+ * Parses git diff output into structured data
+ */
+
+export interface DiffLine {
+  type: "context" | "addition" | "deletion" | "header";
+  content: string;
+  oldLineNumber: number | null;
+  newLineNumber: number | null;
+}
+
+export interface DiffHunk {
+  header: string;
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  lines: DiffLine[];
+}
+
+export interface ParsedDiff {
+  oldFile: string;
+  newFile: string;
+  hunks: DiffHunk[];
+  additions: number;
+  deletions: number;
+  isBinary: boolean;
+  isNew: boolean;
+  isDeleted: boolean;
+  isRenamed: boolean;
+}
+
+/**
+ * Parse a unified diff string into structured data
+ */
+export function parseDiff(diffText: string): ParsedDiff {
+  const lines = diffText.split("\n");
+
+  let oldFile = "";
+  let newFile = "";
+  const hunks: DiffHunk[] = [];
+  let currentHunk: DiffHunk | null = null;
+  let additions = 0;
+  let deletions = 0;
+  let isBinary = false;
+  let isNew = false;
+  let isDeleted = false;
+  let isRenamed = false;
+
+  let oldLineNum = 0;
+  let newLineNum = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Binary file detection
+    if (line.startsWith("Binary files")) {
+      isBinary = true;
+      continue;
+    }
+
+    // Old file header
+    if (line.startsWith("--- ")) {
+      oldFile = line.slice(4);
+      if (oldFile === "/dev/null") {
+        isNew = true;
+      }
+      // Strip a/ prefix
+      if (oldFile.startsWith("a/")) {
+        oldFile = oldFile.slice(2);
+      }
+      continue;
+    }
+
+    // New file header
+    if (line.startsWith("+++ ")) {
+      newFile = line.slice(4);
+      if (newFile === "/dev/null") {
+        isDeleted = true;
+      }
+      // Strip b/ prefix
+      if (newFile.startsWith("b/")) {
+        newFile = newFile.slice(2);
+      }
+      continue;
+    }
+
+    // Rename detection
+    if (line.startsWith("rename from ") || line.startsWith("rename to ")) {
+      isRenamed = true;
+      continue;
+    }
+
+    // Hunk header: @@ -start,count +start,count @@
+    const hunkMatch = line.match(
+      /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/
+    );
+    if (hunkMatch) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+
+      const oldStart = parseInt(hunkMatch[1], 10);
+      const oldCount = hunkMatch[2] ? parseInt(hunkMatch[2], 10) : 1;
+      const newStart = parseInt(hunkMatch[3], 10);
+      const newCount = hunkMatch[4] ? parseInt(hunkMatch[4], 10) : 1;
+      const context = hunkMatch[5] || "";
+
+      currentHunk = {
+        header: line,
+        oldStart,
+        oldCount,
+        newStart,
+        newCount,
+        lines: [],
+      };
+
+      // Add header line with context (function name, etc.)
+      if (context.trim()) {
+        currentHunk.lines.push({
+          type: "header",
+          content: context.trim(),
+          oldLineNumber: null,
+          newLineNumber: null,
+        });
+      }
+
+      oldLineNum = oldStart;
+      newLineNum = newStart;
+      continue;
+    }
+
+    // Inside a hunk
+    if (currentHunk) {
+      if (line.startsWith("+")) {
+        currentHunk.lines.push({
+          type: "addition",
+          content: line.slice(1),
+          oldLineNumber: null,
+          newLineNumber: newLineNum,
+        });
+        newLineNum++;
+        additions++;
+      } else if (line.startsWith("-")) {
+        currentHunk.lines.push({
+          type: "deletion",
+          content: line.slice(1),
+          oldLineNumber: oldLineNum,
+          newLineNumber: null,
+        });
+        oldLineNum++;
+        deletions++;
+      } else if (line.startsWith(" ") || line === "") {
+        // Context line or empty
+        const content = line.startsWith(" ") ? line.slice(1) : line;
+        currentHunk.lines.push({
+          type: "context",
+          content,
+          oldLineNumber: oldLineNum,
+          newLineNumber: newLineNum,
+        });
+        oldLineNum++;
+        newLineNum++;
+      }
+      // Skip other lines like ""
+    }
+  }
+
+  // Don't forget the last hunk
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+
+  return {
+    oldFile,
+    newFile,
+    hunks,
+    additions,
+    deletions,
+    isBinary,
+    isNew,
+    isDeleted,
+    isRenamed,
+  };
+}
+
+/**
+ * Get a summary string for a diff
+ */
+export function getDiffSummary(diff: ParsedDiff): string {
+  if (diff.isBinary) {
+    return "Binary file";
+  }
+  if (diff.isNew) {
+    return `New file (+${diff.additions})`;
+  }
+  if (diff.isDeleted) {
+    return `Deleted (-${diff.deletions})`;
+  }
+  if (diff.isRenamed) {
+    return `Renamed (+${diff.additions}, -${diff.deletions})`;
+  }
+  return `+${diff.additions}, -${diff.deletions}`;
+}
+
+/**
+ * Get file name from diff (handles renames)
+ */
+export function getDiffFileName(diff: ParsedDiff): string {
+  if (diff.isNew) {
+    return diff.newFile;
+  }
+  if (diff.isDeleted) {
+    return diff.oldFile;
+  }
+  if (diff.isRenamed) {
+    return `${diff.oldFile} → ${diff.newFile}`;
+  }
+  return diff.newFile || diff.oldFile;
+}