@atercates/claude-deck 0.2.4 → 0.2.6

package/components/TmuxSessions.tsx

@@ -1,132 +0,0 @@
-"use client";
-
-import { useState, useEffect, useCallback } from "react";
-import { Button } from "./ui/button";
-import { Badge } from "./ui/badge";
-import { RefreshCw, Terminal, MonitorUp } from "lucide-react";
-import { cn } from "@/lib/utils";
-
-interface TmuxSession {
-  name: string;
-  windows: number;
-  created: string;
-  attached: boolean;
-}
-
-interface TmuxSessionsProps {
-  onAttach: (sessionName: string) => void;
-}
-
-export function TmuxSessions({ onAttach }: TmuxSessionsProps) {
-  const [sessions, setSessions] = useState<TmuxSession[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchSessions = useCallback(async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      const res = await fetch("/api/exec", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          command:
-            "tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_created}|#{session_attached}' 2>/dev/null || echo ''",
-        }),
-      });
-      const data = await res.json();
-
-      if (data.success && data.output.trim()) {
-        const parsed = data.output
-          .trim()
-          .split("\n")
-          .filter((line: string) => line.includes("|"))
-          .map((line: string) => {
-            const [name, windows, created, attached] = line.split("|");
-            return {
-              name,
-              windows: parseInt(windows),
-              created: new Date(parseInt(created) * 1000).toLocaleString(),
-              attached: attached === "1",
-            };
-          });
-        setSessions(parsed);
-      } else {
-        setSessions([]);
-      }
-    } catch (err) {
-      console.error("Failed to fetch tmux sessions:", err);
-      setError("Failed to load");
-      setSessions([]);
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  useEffect(() => {
-    fetchSessions();
-    // Refresh every 30 seconds
-    const interval = setInterval(fetchSessions, 30000);
-    return () => clearInterval(interval);
-  }, [fetchSessions]);
-
-  if (sessions.length === 0 && !loading && !error) {
-    return null; // Don't show section if no tmux sessions
-  }
-
-  return (
-    <div className="border-border border-b">
-      <div className="flex items-center justify-between px-4 py-2">
-        <div className="flex items-center gap-2">
-          <Terminal className="text-muted-foreground h-4 w-4" />
-          <span className="text-muted-foreground text-xs font-medium tracking-wider uppercase">
-            Tmux Sessions
-          </span>
-        </div>
-        <Button
-          variant="ghost"
-          size="icon-sm"
-          onClick={fetchSessions}
-          disabled={loading}
-          className="h-6 w-6"
-        >
-          <RefreshCw className={cn("h-3 w-3", loading && "animate-spin")} />
-        </Button>
-      </div>
-
-      <div className="space-y-1 px-4 pb-3">
-        {error && <p className="text-destructive text-xs">{error}</p>}
-        {sessions.map((session) => (
-          <button
-            key={session.name}
-            onClick={() => onAttach(session.name)}
-            className={cn(
-              "flex w-full items-center justify-between rounded-md p-2 text-left transition-colors",
-              "hover:bg-primary/10 border",
-              session.attached
-                ? "border-primary/50 bg-primary/5"
-                : "border-transparent"
-            )}
-          >
-            <div className="flex min-w-0 items-center gap-2">
-              <MonitorUp className="text-primary h-4 w-4 flex-shrink-0" />
-              <span className="truncate text-sm font-medium">
-                {session.name}
-              </span>
-            </div>
-            <div className="flex flex-shrink-0 items-center gap-2">
-              <span className="text-muted-foreground text-xs">
-                {session.windows}w
-              </span>
-              {session.attached && (
-                <Badge variant="success" className="px-1 py-0 text-[10px]">
-                  attached
-                </Badge>
-              )}
-            </div>
-          </button>
-        ))}
-      </div>
-    </div>
-  );
-}

package/data/groups/index.ts

@@ -1 +0,0 @@
-export { useToggleGroup, useCreateGroup, useDeleteGroup } from "./mutations";

package/data/groups/mutations.ts

@@ -1,95 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { sessionKeys } from "../sessions/keys";
-
-export function useToggleGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      path,
-      expanded,
-    }: {
-      path: string;
-      expanded: boolean;
-    }) => {
-      const res = await fetch(`/api/groups/${encodeURIComponent(path)}`, {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ expanded }),
-      });
-      if (!res.ok) throw new Error("Failed to toggle group");
-      return res.json();
-    },
-    onMutate: async ({ path, expanded }) => {
-      await queryClient.cancelQueries({ queryKey: sessionKeys.list() });
-      const previous = queryClient.getQueryData(sessionKeys.list());
-      queryClient.setQueryData(
-        sessionKeys.list(),
-        (
-          old:
-            | {
-                sessions: unknown[];
-                groups: Array<{ path: string; expanded: boolean }>;
-              }
-            | undefined
-        ) =>
-          old
-            ? {
-                ...old,
-                groups: old.groups.map((g) =>
-                  g.path === path ? { ...g, expanded } : g
-                ),
-              }
-            : old
-      );
-      return { previous };
-    },
-    onError: (_, __, context) => {
-      if (context?.previous) {
-        queryClient.setQueryData(sessionKeys.list(), context.previous);
-      }
-    },
-  });
-}
-
-export function useCreateGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      name,
-      parentPath,
-    }: {
-      name: string;
-      parentPath?: string;
-    }) => {
-      const res = await fetch("/api/groups", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name, parentPath }),
-      });
-      if (!res.ok) throw new Error("Failed to create group");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}
-
-export function useDeleteGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (path: string) => {
-      const res = await fetch(`/api/groups/${encodeURIComponent(path)}`, {
-        method: "DELETE",
-      });
-      if (!res.ok) throw new Error("Failed to delete group");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}

package/hooks/useGroups.ts

@@ -1,37 +0,0 @@
-import { useCallback } from "react";
-import { useToggleGroup, useCreateGroup, useDeleteGroup } from "@/data/groups";
-
-export function useGroups() {
-  const toggleMutation = useToggleGroup();
-  const createMutation = useCreateGroup();
-  const deleteMutation = useDeleteGroup();
-
-  const toggleGroup = useCallback(
-    async (path: string, expanded: boolean) => {
-      await toggleMutation.mutateAsync({ path, expanded });
-    },
-    [toggleMutation]
-  );
-
-  const createGroup = useCallback(
-    async (name: string, parentPath?: string) => {
-      await createMutation.mutateAsync({ name, parentPath });
-    },
-    [createMutation]
-  );
-
-  const deleteGroup = useCallback(
-    async (path: string) => {
-      if (!confirm("Delete this group? Sessions will be moved to parent."))
-        return;
-      await deleteMutation.mutateAsync(path);
-    },
-    [deleteMutation]
-  );
-
-  return {
-    toggleGroup,
-    createGroup,
-    deleteGroup,
-  };
-}

package/hooks/useKeybarVisibility.ts

@@ -1,42 +0,0 @@
-"use client";
-
-import { useState, useCallback, useEffect } from "react";
-
-const STORAGE_KEY = "agentOS-keybar-visible";
-
-/**
- * Hook to manage mobile keybar visibility with localStorage persistence.
- * Default: hidden on mobile to maximize terminal space.
- */
-export function useKeybarVisibility() {
-  const [isVisible, setIsVisible] = useState(false);
-
-  // Load persisted state on mount
-  useEffect(() => {
-    if (typeof window === "undefined") return;
-    const stored = localStorage.getItem(STORAGE_KEY);
-    if (stored === "true") {
-      setIsVisible(true);
-    }
-  }, []);
-
-  const toggle = useCallback(() => {
-    setIsVisible((prev) => {
-      const next = !prev;
-      localStorage.setItem(STORAGE_KEY, String(next));
-      return next;
-    });
-  }, []);
-
-  const show = useCallback(() => {
-    setIsVisible(true);
-    localStorage.setItem(STORAGE_KEY, "true");
-  }, []);
-
-  const hide = useCallback(() => {
-    setIsVisible(false);
-    localStorage.setItem(STORAGE_KEY, "false");
-  }, []);
-
-  return { isVisible, toggle, show, hide };
-}

package/lib/claude/process-manager.ts

@@ -1,278 +0,0 @@
-import { spawn, ChildProcess } from "child_process";
-import { WebSocket } from "ws";
-import { StreamParser } from "./stream-parser";
-import { queries } from "../db";
-import type { ClaudeSessionOptions, ClientEvent } from "./types";
-
-interface ManagedSession {
-  process: ChildProcess | null;
-  parser: StreamParser;
-  clients: Set<WebSocket>;
-  status: "idle" | "running" | "waiting" | "error";
-}
-
-export class ClaudeProcessManager {
-  private sessions: Map<string, ManagedSession> = new Map();
-
-  // Register a WebSocket client for a session
-  registerClient(sessionId: string, ws: WebSocket): void {
-    let session = this.sessions.get(sessionId);
-
-    if (!session) {
-      session = {
-        process: null,
-        parser: new StreamParser(sessionId),
-        clients: new Set(),
-        status: "idle",
-      };
-
-      // Set up parser event handlers
-      session.parser.on("event", (event: ClientEvent) => {
-        this.broadcastToSession(sessionId, event);
-        this.handleEvent(sessionId, event);
-      });
-
-      session.parser.on("parse_error", (error) => {
-        this.broadcastToSession(sessionId, {
-          type: "error",
-          sessionId,
-          timestamp: new Date().toISOString(),
-          data: { error: `Parse error: ${error.error}` },
-        });
-      });
-
-      this.sessions.set(sessionId, session);
-    }
-
-    session.clients.add(ws);
-
-    // Send current status
-    ws.send(
-      JSON.stringify({
-        type: "status",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { status: session.status },
-      })
-    );
-  }
-
-  // Unregister a WebSocket client
-  unregisterClient(sessionId: string, ws: WebSocket): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.clients.delete(ws);
-
-      // Clean up if no clients remain and process not running
-      if (session.clients.size === 0 && !session.process) {
-        this.sessions.delete(sessionId);
-      }
-    }
-  }
-
-  // Send a prompt to Claude
-  async sendPrompt(
-    sessionId: string,
-    prompt: string,
-    options: ClaudeSessionOptions = {}
-  ): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
-    }
-
-    if (session.process) {
-      throw new Error(`Session ${sessionId} already has a running process`);
-    }
-
-    // Build Claude CLI command
-    const args = ["-p", "--output-format", "stream-json", "--verbose"];
-
-    // Add model if specified
-    if (options.model) {
-      args.push("--model", options.model);
-    }
-
-    // Handle session continuity
-    const dbSession = await queries.getSession(sessionId);
-
-    if (dbSession?.claude_session_id) {
-      // Resume existing Claude session
-      args.push("--resume", dbSession.claude_session_id);
-    }
-
-    // Add system prompt if specified
-    if (options.systemPrompt) {
-      args.push("--system-prompt", options.systemPrompt);
-    }
-
-    // Add the prompt
-    args.push(prompt);
-
-    // Spawn Claude process
-    const cwd =
-      options.workingDirectory ||
-      dbSession?.working_directory?.replace("~", process.env.HOME || "") ||
-      process.env.HOME ||
-      "/";
-
-    console.log(`Spawning Claude for session ${sessionId}:`, args.join(" "));
-    console.log(`CWD: ${cwd}`);
-
-    // Reset parser for new conversation turn
-    session.parser = new StreamParser(sessionId);
-    session.parser.on("event", (event: ClientEvent) => {
-      console.log(
-        `Parser event [${sessionId}]:`,
-        event.type,
-        JSON.stringify(event.data).substring(0, 100)
-      );
-      this.broadcastToSession(sessionId, event);
-      this.handleEvent(sessionId, event);
-    });
-
-    // Find claude binary path
-    const claudePath =
-      process.env.HOME + "/.nvm/versions/node/v20.19.0/bin/claude";
-
-    const claudeProcess = spawn(claudePath, args, {
-      cwd,
-      env: {
-        ...process.env,
-        PATH: `/usr/local/bin:/opt/homebrew/bin:${process.env.PATH}`,
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    session.process = claudeProcess;
-    session.status = "running";
-    this.updateDbStatus(sessionId, "running");
-
-    this.broadcastToSession(sessionId, {
-      type: "status",
-      sessionId,
-      timestamp: new Date().toISOString(),
-      data: { status: "running" },
-    });
-
-    // Handle stdout (stream-json output)
-    claudeProcess.stdout?.on("data", (data: Buffer) => {
-      const text = data.toString();
-      console.log(`Claude stdout [${sessionId}]:`, text.substring(0, 200));
-      session.parser.write(text);
-    });
-
-    // Handle stderr (errors and other output)
-    claudeProcess.stderr?.on("data", (data: Buffer) => {
-      const text = data.toString();
-      console.error(`Claude stderr [${sessionId}]:`, text);
-    });
-
-    claudeProcess.on("error", (err) => {
-      console.error(`Claude spawn error [${sessionId}]:`, err);
-    });
-
-    // Handle process exit
-    claudeProcess.on("close", (code) => {
-      console.log(
-        `Claude process exited for session ${sessionId} with code ${code}`
-      );
-
-      session.parser.end();
-      session.process = null;
-      session.status = code === 0 ? "idle" : "error";
-
-      this.updateDbStatus(sessionId, session.status);
-
-      this.broadcastToSession(sessionId, {
-        type: "status",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { status: session.status, exitCode: code || 0 },
-      });
-    });
-
-    claudeProcess.on("error", (err) => {
-      console.error(`Claude process error for session ${sessionId}:`, err);
-
-      session.process = null;
-      session.status = "error";
-
-      this.updateDbStatus(sessionId, "error");
-
-      this.broadcastToSession(sessionId, {
-        type: "error",
-        sessionId,
-        timestamp: new Date().toISOString(),
-        data: { error: err.message },
-      });
-    });
-  }
-
-  // Cancel a running Claude process
-  cancelSession(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (session?.process) {
-      session.process.kill("SIGTERM");
-    }
-  }
-
-  // Get session status
-  getSessionStatus(
-    sessionId: string
-  ): "idle" | "running" | "waiting" | "error" | null {
-    return this.sessions.get(sessionId)?.status ?? null;
-  }
-
-  // Broadcast event to all clients of a session
-  private broadcastToSession(sessionId: string, event: ClientEvent): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      console.log(`No session found for broadcast: ${sessionId}`);
-      return;
-    }
-
-    console.log(
-      `Broadcasting to ${session.clients.size} clients for session ${sessionId}`
-    );
-    const message = JSON.stringify(event);
-    for (const client of session.clients) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(message);
-        console.log(`Sent message to client`);
-      } else {
-        console.log(`Client not open, state: ${client.readyState}`);
-      }
-    }
-  }
-
-  // Handle events for persistence
-  private handleEvent(sessionId: string, event: ClientEvent): void {
-    switch (event.type) {
-      case "init": {
-        // Store Claude's session ID for future --resume
-        const claudeSessionId = event.data.claudeSessionId;
-        if (claudeSessionId) {
-          queries.updateSessionClaudeId(claudeSessionId, sessionId);
-        }
-        break;
-      }
-
-      case "complete": {
-        // Update session timestamp
-        queries.updateSessionStatus("idle", sessionId);
-        break;
-      }
-
-      case "error": {
-        queries.updateSessionStatus("error", sessionId);
-        break;
-      }
-    }
-  }
-
-  // Update session status in database
-  private updateDbStatus(sessionId: string, status: string): void {
-    queries.updateSessionStatus(status, sessionId);
-  }
-}