@atercates/claude-deck 0.2.1

package/server.ts

@@ -0,0 +1,155 @@
+import { createServer } from "http";
+import { parse } from "url";
+import next from "next";
+import { WebSocketServer, WebSocket } from "ws";
+import * as pty from "node-pty";
+import { initDb } from "./lib/db";
+import { startWatcher, addUpdateClient } from "./lib/claude/watcher";
+
+const dev = process.env.NODE_ENV !== "production";
+const hostname = "0.0.0.0";
+
+// Support: npm run dev -- -p 3012
+const pFlagIndex = process.argv.indexOf("-p");
+const portArg = pFlagIndex !== -1 ? process.argv[pFlagIndex + 1] : undefined;
+const port = parseInt(portArg || process.env.PORT || "3011", 10);
+
+const app = next({ dev, hostname, port });
+const handle = app.getRequestHandler();
+
+app.prepare().then(async () => {
+  const server = createServer(async (req, res) => {
+    try {
+      const parsedUrl = parse(req.url!, true);
+      await handle(req, res, parsedUrl);
+    } catch (err) {
+      console.error("Error occurred handling", req.url, err);
+      res.statusCode = 500;
+      res.end("internal server error");
+    }
+  });
+
+  const terminalWss = new WebSocketServer({ noServer: true });
+  const updatesWss = new WebSocketServer({ noServer: true });
+
+  server.on("upgrade", (request, socket, head) => {
+    const { pathname } = parse(request.url || "");
+
+    if (pathname === "/ws/terminal") {
+      terminalWss.handleUpgrade(request, socket, head, (ws) => {
+        terminalWss.emit("connection", ws, request);
+      });
+    } else if (pathname === "/ws/updates") {
+      updatesWss.handleUpgrade(request, socket, head, (ws) => {
+        setupHeartbeat(ws);
+        addUpdateClient(ws);
+      });
+    }
+  });
+
+  // Heartbeat: ping every 30s, kill if no pong in 10s
+  const HEARTBEAT_INTERVAL = 30000;
+  const HEARTBEAT_TIMEOUT = 10000;
+
+  function setupHeartbeat(ws: WebSocket) {
+    let alive = true;
+    ws.on("pong", () => {
+      alive = true;
+    });
+    const interval = setInterval(() => {
+      if (!alive) {
+        ws.terminate();
+        clearInterval(interval);
+        return;
+      }
+      alive = false;
+      ws.ping();
+    }, HEARTBEAT_INTERVAL);
+    ws.on("close", () => clearInterval(interval));
+  }
+
+  // Terminal connections
+  terminalWss.on("connection", (ws: WebSocket) => {
+    setupHeartbeat(ws);
+    let ptyProcess: pty.IPty;
+    try {
+      const shell = process.env.SHELL || "/bin/zsh";
+      // Use minimal env - only essentials for shell to work
+      // This lets Next.js/Vite/etc load .env.local without interference from parent process env
+      const minimalEnv: { [key: string]: string } = {
+        PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin",
+        HOME: process.env.HOME || "/",
+        USER: process.env.USER || "",
+        SHELL: shell,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        LANG: process.env.LANG || "en_US.UTF-8",
+      };
+
+      ptyProcess = pty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 24,
+        cwd: process.env.HOME || "/",
+        env: minimalEnv,
+      });
+    } catch (err) {
+      console.error("Failed to spawn pty:", err);
+      ws.send(
+        JSON.stringify({ type: "error", message: "Failed to start terminal" })
+      );
+      ws.close();
+      return;
+    }
+
+    ptyProcess.onData((data: string) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "output", data }));
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "exit", code: exitCode }));
+        ws.close();
+      }
+    });
+
+    ws.on("message", (message: Buffer) => {
+      try {
+        const msg = JSON.parse(message.toString());
+        switch (msg.type) {
+          case "input":
+            ptyProcess.write(msg.data);
+            break;
+          case "resize":
+            ptyProcess.resize(msg.cols, msg.rows);
+            break;
+          case "command":
+            ptyProcess.write(msg.data + "\r");
+            break;
+        }
+      } catch (err) {
+        console.error("Error parsing message:", err);
+      }
+    });
+
+    ws.on("close", () => {
+      ptyProcess.kill();
+    });
+
+    ws.on("error", (err) => {
+      console.error("WebSocket error:", err);
+      ptyProcess.kill();
+    });
+  });
+
+  await initDb();
+  console.log("> Database initialized");
+
+  startWatcher();
+
+  server.listen(port, () => {
+    console.log(`> ClaudeDeck ready on http://${hostname}:${port}`);
+  });
+});

package/stores/fileOpen.ts

@@ -0,0 +1,26 @@
+import { proxy } from "valtio";
+
+export interface FileOpenRequest {
+  path: string;
+  line: number;
+  timestamp: number;
+}
+
+export const fileOpenStore = proxy<{
+  request: FileOpenRequest | null;
+}>({
+  request: null,
+});
+
+export const fileOpenActions = {
+  requestOpen: (path: string, line: number) => {
+    fileOpenStore.request = {
+      path,
+      line,
+      timestamp: Date.now(),
+    };
+  },
+  clearRequest: () => {
+    fileOpenStore.request = null;
+  },
+};

package/stores/index.ts

@@ -0,0 +1 @@
+export { selectionStore, selectionActions } from "./sessionSelection";

package/stores/initialPrompt.ts

@@ -0,0 +1,24 @@
+/**
+ * Store for pending initial prompts to be sent when terminal becomes ready
+ * Uses a simple Map keyed by sessionId
+ */
+
+const pendingPrompts = new Map<string, string>();
+
+export function setPendingPrompt(sessionId: string, prompt: string): void {
+  if (prompt.trim()) {
+    pendingPrompts.set(sessionId, prompt.trim());
+  }
+}
+
+export function getPendingPrompt(sessionId: string): string | null {
+  return pendingPrompts.get(sessionId) || null;
+}
+
+export function clearPendingPrompt(sessionId: string): void {
+  pendingPrompts.delete(sessionId);
+}
+
+export function hasPendingPrompt(sessionId: string): boolean {
+  return pendingPrompts.has(sessionId);
+}

package/stores/sessionSelection.ts

@@ -0,0 +1,48 @@
+import { proxy } from "valtio";
+import { updateSelection } from "@/lib/rangeSelectionUtils";
+
+// Store state
+export const selectionStore = proxy({
+  selectedIds: new Set<string>(),
+  lastSelectedId: null as string | null,
+});
+
+// Actions - can be called from anywhere
+export const selectionActions = {
+  toggle: (
+    sessionId: string,
+    shiftKey = false,
+    allSessionIds: string[] = []
+  ) => {
+    const newSet = updateSelection(
+      selectionStore.selectedIds,
+      sessionId,
+      shiftKey,
+      selectionStore.lastSelectedId,
+      allSessionIds
+    );
+    selectionStore.selectedIds = newSet;
+    selectionStore.lastSelectedId = sessionId;
+  },
+
+  selectAll: (sessionIds: string[]) => {
+    selectionStore.selectedIds = new Set(sessionIds);
+  },
+
+  clear: () => {
+    selectionStore.selectedIds = new Set();
+    selectionStore.lastSelectedId = null;
+  },
+
+  isSelected: (sessionId: string) => {
+    return selectionStore.selectedIds.has(sessionId);
+  },
+
+  getCount: () => {
+    return selectionStore.selectedIds.size;
+  },
+
+  getSelectedIds: () => {
+    return Array.from(selectionStore.selectedIds);
+  },
+};