@atercates/claude-deck 0.2.14 → 0.2.16

package/scripts/lib/prerequisites.sh

@@ -388,6 +388,72 @@ install_ripgrep() {
     esac
 }
 
+check_cloudflared() {
+    if command -v cloudflared &> /dev/null; then
+        local cf_path=$(command -v cloudflared)
+        local cf_version=$(cloudflared --version 2>/dev/null | awk '{print $2}' || echo "unknown")
+        log_success "Found cloudflared $cf_version at $cf_path"
+        return 0
+    fi
+
+    source_node_managers
+
+    if command -v cloudflared &> /dev/null; then
+        local cf_path=$(command -v cloudflared)
+        local cf_version=$(cloudflared --version 2>/dev/null | awk '{print $2}' || echo "unknown")
+        log_success "Found cloudflared $cf_version at $cf_path"
+        return 0
+    fi
+
+    return 1
+}
+
+install_cloudflared() {
+    if command -v cloudflared &> /dev/null; then
+        return 0
+    fi
+
+    log_info "Installing cloudflared (Cloudflare Tunnel)..."
+
+    case "$OS" in
+        macos)
+            if ! groups | grep -q admin; then
+                log_info "Non-admin user - downloading pre-built cloudflared binary"
+                local arch
+                arch=$(uname -m)
+                local url
+                if [[ "$arch" == "arm64" ]]; then
+                    url="https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-arm64.tgz"
+                else
+                    url="https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz"
+                fi
+
+                mkdir -p "$HOME/.local/bin"
+                curl -fsSL "$url" | tar -xz -C "$HOME/.local/bin"
+                chmod +x "$HOME/.local/bin/cloudflared"
+                export PATH="$HOME/.local/bin:$PATH"
+                log_success "cloudflared installed to ~/.local/bin/cloudflared"
+            else
+                install_homebrew
+                brew install cloudflared
+            fi
+            ;;
+        debian)
+            curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null
+            echo "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/cloudflared.list
+            sudo apt-get update
+            sudo apt-get install -y cloudflared
+            ;;
+        redhat)
+            sudo rpm -i "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-x86_64.rpm" 2>/dev/null || true
+            ;;
+        *)
+            log_warn "Please install cloudflared manually: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/"
+            return 1
+            ;;
+    esac
+}
+
 check_and_install_prerequisites() {
     log_info "Checking prerequisites..."
 
@@ -415,30 +481,39 @@ check_and_install_prerequisites() {
 
     if [[ ${#missing[@]} -eq 0 ]]; then
         log_success "All prerequisites met"
-        return 0
-    fi
+    else
+        log_warn "Missing prerequisites: ${missing[*]}"
 
-    log_warn "Missing prerequisites: ${missing[*]}"
-
-    if is_interactive; then
-        if ! prompt_yn "Install missing prerequisites?"; then
-            log_error "Please install manually: ${missing[*]}"
-            exit 1
+        if is_interactive; then
+            if ! prompt_yn "Install missing prerequisites?"; then
+                log_error "Please install manually: ${missing[*]}"
+                exit 1
+            fi
         fi
-    fi
 
-    for dep in "${missing[@]}"; do
-        case "$dep" in
-            node) install_node ;;
-            git) install_git ;;
-            tmux) install_tmux ;;
-            ripgrep) install_ripgrep ;;
-        esac
-    done
+        for dep in "${missing[@]}"; do
+            case "$dep" in
+                node) install_node ;;
+                git) install_git ;;
+                tmux) install_tmux ;;
+                ripgrep) install_ripgrep ;;
+            esac
+        done
 
-    log_success "Prerequisites installed"
+        log_success "Prerequisites installed"
+    fi
 
     configure_tmux
+
+    # Optional: cloudflared for tunnel sharing
+    if ! check_cloudflared; then
+        log_info "cloudflared not found (optional - enables port sharing via Cloudflare Tunnel)"
+        if is_interactive; then
+            if prompt_yn "Install cloudflared for tunnel sharing?"; then
+                install_cloudflared
+            fi
+        fi
+    fi
 }
 
 configure_tmux() {

package/scripts/nginx-http.conf

@@ -0,0 +1,19 @@
+server {
+    listen 80;
+    server_name claudedeck.example.com;
+
+    location / {
+        proxy_pass http://127.0.0.1:3011;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        proxy_read_timeout 86400s;
+        proxy_send_timeout 86400s;
+    }
+}

package/server.ts

@@ -13,6 +13,7 @@ import {
   COOKIE_NAME,
   hasUsers,
 } from "./lib/auth";
+import { stopAllTunnels } from "./lib/tunnels";
 
 const dev = process.env.NODE_ENV !== "production";
 const hostname = process.env.HOST || (dev ? "localhost" : "0.0.0.0");
@@ -89,65 +90,86 @@ app.prepare().then(async () => {
     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;
-    }
+  // --- Persistent PTY pool ---
+  // PTYs survive WebSocket disconnects. Clients attach/reattach by ptyId.
+  interface PtyEntry {
+    process: pty.IPty;
+    ws: WebSocket | null;
+    buffer: string[];
+  }
+  const ptyPool = new Map<string, PtyEntry>();
+  const MAX_SCROLLBACK_BUFFER = 50000;
+
+  function spawnPty(): { id: string; entry: PtyEntry } {
+    const shell = process.env.SHELL || "/bin/zsh";
+    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",
+    };
+
+    const proc = pty.spawn(shell, [], {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd: process.env.HOME || "/",
+      env: minimalEnv,
+    });
+
+    const id = `pty_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+    const entry: PtyEntry = { process: proc, ws: null, buffer: [] };
 
-    ptyProcess.onData((data: string) => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: "output", data }));
+    proc.onData((data: string) => {
+      entry.buffer.push(data);
+      if (entry.buffer.length > MAX_SCROLLBACK_BUFFER) {
+        entry.buffer.splice(0, entry.buffer.length - MAX_SCROLLBACK_BUFFER);
+      }
+      if (entry.ws?.readyState === WebSocket.OPEN) {
+        entry.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();
+    proc.onExit(({ exitCode }) => {
+      if (entry.ws?.readyState === WebSocket.OPEN) {
+        entry.ws.send(JSON.stringify({ type: "exit", code: exitCode }));
       }
+      ptyPool.delete(id);
     });
 
+    ptyPool.set(id, entry);
+    return { id, entry };
+  }
+
+  function attachWsToPty(ws: WebSocket, entry: PtyEntry, _ptyId: string) {
+    // Detach previous WebSocket if any
+    if (entry.ws && entry.ws !== ws && entry.ws.readyState === WebSocket.OPEN) {
+      entry.ws.onclose = null;
+      entry.ws.onerror = null;
+      entry.ws.close(1000, "Replaced by new connection");
+    }
+    entry.ws = ws;
+
+    // Replay buffered output so the client sees prior terminal state
+    if (entry.buffer.length > 0) {
+      ws.send(JSON.stringify({ type: "output", data: entry.buffer.join("") }));
+    }
+
     ws.on("message", (message: Buffer) => {
       try {
         const msg = JSON.parse(message.toString());
         switch (msg.type) {
           case "input":
-            ptyProcess.write(msg.data);
+            entry.process.write(msg.data);
             break;
           case "resize":
-            ptyProcess.resize(msg.cols, msg.rows);
+            entry.process.resize(msg.cols, msg.rows);
             break;
           case "command":
-            ptyProcess.write(msg.data + "\r");
+            entry.process.write(msg.data + "\r");
             break;
         }
       } catch (err) {
@@ -156,13 +178,42 @@ app.prepare().then(async () => {
     });
 
     ws.on("close", () => {
-      ptyProcess.kill();
+      if (entry.ws === ws) entry.ws = null;
+      // PTY stays alive — no kill
     });
 
-    ws.on("error", (err) => {
-      console.error("WebSocket error:", err);
-      ptyProcess.kill();
+    ws.on("error", () => {
+      if (entry.ws === ws) entry.ws = null;
     });
+  }
+
+  // Terminal connections
+  terminalWss.on("connection", (ws: WebSocket, request) => {
+    setupHeartbeat(ws);
+
+    const { query } = parse(request.url || "", true);
+    const requestedPtyId = typeof query.ptyId === "string" ? query.ptyId : null;
+
+    // Try to reattach to existing PTY
+    if (requestedPtyId && ptyPool.has(requestedPtyId)) {
+      const entry = ptyPool.get(requestedPtyId)!;
+      ws.send(JSON.stringify({ type: "pty-id", ptyId: requestedPtyId }));
+      attachWsToPty(ws, entry, requestedPtyId);
+      return;
+    }
+
+    // Spawn new PTY
+    try {
+      const { id, entry } = spawnPty();
+      ws.send(JSON.stringify({ type: "pty-id", ptyId: id }));
+      attachWsToPty(ws, entry, id);
+    } catch (err) {
+      console.error("Failed to spawn pty:", err);
+      ws.send(
+        JSON.stringify({ type: "error", message: "Failed to start terminal" })
+      );
+      ws.close();
+    }
   });
 
   await initDb();
@@ -172,6 +223,13 @@ app.prepare().then(async () => {
   startWatcher();
   startStatusMonitor();
 
+  const shutdown = () => {
+    stopAllTunnels();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
   server.listen(port, () => {
     console.log(`> ClaudeDeck ready on http://${hostname}:${port}`);
   });

package/components/NewSessionDialog/AdvancedSettings.tsx

@@ -1,69 +0,0 @@
-import { ChevronRight } from "lucide-react";
-import { CLAUDE_AUTO_APPROVE_FLAG } from "@/lib/providers";
-
-interface AdvancedSettingsProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  useTmux: boolean;
-  onUseTmuxChange: (checked: boolean) => void;
-  skipPermissions: boolean;
-  onSkipPermissionsChange: (checked: boolean) => void;
-}
-
-export function AdvancedSettings({
-  open,
-  onOpenChange,
-  useTmux,
-  onUseTmuxChange,
-  skipPermissions,
-  onSkipPermissionsChange,
-}: AdvancedSettingsProps) {
-  return (
-    <div className="border-border rounded-lg border">
-      <button
-        type="button"
-        onClick={() => onOpenChange(!open)}
-        className="text-muted-foreground hover:text-foreground flex w-full items-center gap-2 px-3 py-2 text-sm transition-colors"
-      >
-        <ChevronRight
-          className={`h-4 w-4 transition-transform ${open ? "rotate-90" : ""}`}
-        />
-        Advanced Settings
-      </button>
-      {open && (
-        <div className="space-y-3 border-t px-3 py-3">
-          <div className="flex items-center gap-2">
-            <input
-              type="checkbox"
-              id="useTmux"
-              checked={useTmux}
-              onChange={(e) => onUseTmuxChange(e.target.checked)}
-              className="border-border bg-background accent-primary h-4 w-4 rounded"
-            />
-            <label htmlFor="useTmux" className="cursor-pointer text-sm">
-              Use tmux session
-              <span className="text-muted-foreground ml-1">
-                (enables detach/attach)
-              </span>
-            </label>
-          </div>
-          <div className="flex items-center gap-2">
-            <input
-              type="checkbox"
-              id="skipPermissions"
-              checked={skipPermissions}
-              onChange={(e) => onSkipPermissionsChange(e.target.checked)}
-              className="border-border bg-background accent-primary h-4 w-4 rounded"
-            />
-            <label htmlFor="skipPermissions" className="cursor-pointer text-sm">
-              Auto-approve tool calls
-              <span className="text-muted-foreground ml-1">
-                ({CLAUDE_AUTO_APPROVE_FLAG})
-              </span>
-            </label>
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}