@atercates/claude-deck 0.2.3 → 0.2.4

package/app/api/sessions/status/acknowledge/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from "next/server";
+
+export async function POST() {
+  // With JSONL-based detection, acknowledge is a no-op.
+  // Status is determined by file content, not by a flag.
+  // The endpoint exists for API compatibility.
+  return NextResponse.json({ ok: true });
+}

package/app/api/sessions/status/route.ts

@@ -1,237 +1,6 @@
 import { NextResponse } from "next/server";
-import { exec } from "child_process";
-import { promisify } from "util";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { statusDetector, type SessionStatus } from "@/lib/status-detector";
-import type { AgentType } from "@/lib/providers";
-import {
-  getManagedSessionPattern,
-  getProviderIdFromSessionName,
-  getSessionIdFromName,
-} from "@/lib/providers/registry";
-import { getDb } from "@/lib/db";
-
-const execAsync = promisify(exec);
-
-interface SessionStatusResponse {
-  sessionName: string;
-  status: SessionStatus;
-  lastLine?: string;
-  claudeSessionId?: string | null;
-  agentType?: AgentType;
-}
-
-async function getTmuxSessions(): Promise<string[]> {
-  try {
-    const { stdout } = await execAsync(
-      "tmux list-sessions -F '#{session_name}' 2>/dev/null || true"
-    );
-    return stdout.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-async function getTmuxSessionCwd(sessionName: string): Promise<string | null> {
-  try {
-    const { stdout } = await execAsync(
-      `tmux display-message -t "${sessionName}" -p "#{pane_current_path}" 2>/dev/null || echo ""`
-    );
-    const cwd = stdout.trim();
-    return cwd || null;
-  } catch {
-    return null;
-  }
-}
-
-// Get Claude session ID from tmux environment variable
-async function getClaudeSessionIdFromEnv(
-  sessionName: string
-): Promise<string | null> {
-  try {
-    const { stdout } = await execAsync(
-      `tmux show-environment -t "${sessionName}" 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") {
-        return sessionId;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// Get Claude session ID by looking at session files on disk
-function getClaudeSessionIdFromFiles(projectPath: string): string | null {
-  const home = os.homedir();
-  const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(home, ".claude");
-  const projectDirName = projectPath.replace(/\//g, "-");
-  const projectDir = path.join(claudeDir, "projects", projectDirName);
-
-  if (!fs.existsSync(projectDir)) {
-    return null;
-  }
-
-  const uuidPattern =
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/;
-
-  try {
-    const files = fs.readdirSync(projectDir);
-    let mostRecent: string | null = null;
-    let mostRecentTime = 0;
-
-    for (const file of files) {
-      if (file.startsWith("agent-")) continue;
-      if (!uuidPattern.test(file)) continue;
-
-      const filePath = path.join(projectDir, file);
-      const stat = fs.statSync(filePath);
-
-      if (stat.mtimeMs > mostRecentTime) {
-        mostRecentTime = stat.mtimeMs;
-        mostRecent = file.replace(".jsonl", "");
-      }
-    }
-
-    if (mostRecent && Date.now() - mostRecentTime < 5 * 60 * 1000) {
-      return mostRecent;
-    }
-
-    const configFile = path.join(claudeDir, ".claude.json");
-    if (fs.existsSync(configFile)) {
-      try {
-        const config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
-        if (config.projects?.[projectPath]?.lastSessionId) {
-          return config.projects[projectPath].lastSessionId;
-        }
-      } catch {
-        // Ignore config parse errors
-      }
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-async function getClaudeSessionId(sessionName: string): Promise<string | null> {
-  const envId = await getClaudeSessionIdFromEnv(sessionName);
-  if (envId) {
-    return envId;
-  }
-
-  const cwd = await getTmuxSessionCwd(sessionName);
-  if (cwd) {
-    return getClaudeSessionIdFromFiles(cwd);
-  }
-
-  return null;
-}
-
-async function getLastLine(sessionName: string): Promise<string> {
-  try {
-    const { stdout } = await execAsync(
-      `tmux capture-pane -t "${sessionName}" -p -S -5 2>/dev/null || echo ""`
-    );
-    const lines = stdout.trim().split("\n").filter(Boolean);
-    return lines.pop() || "";
-  } catch {
-    return "";
-  }
-}
-
-// UUID pattern for claude-deck managed sessions (derived from registry)
-const UUID_PATTERN = getManagedSessionPattern();
-
-// Track previous statuses to detect changes
-const previousStatuses = new Map<string, SessionStatus>();
-
-function getAgentTypeFromSessionName(sessionName: string): AgentType {
-  return getProviderIdFromSessionName(sessionName) || "claude";
-}
+import { getStatusSnapshot } from "@/lib/status-monitor";
 
 export async function GET() {
-  try {
-    const sessions = await getTmuxSessions();
-
-    // Get status for claude-deck managed sessions
-    const managedSessions = sessions.filter((s) => UUID_PATTERN.test(s));
-
-    // Use the new status detector
-    const statusMap: Record<string, SessionStatusResponse> = {};
-
-    const db = getDb();
-    const sessionsToUpdate: string[] = [];
-
-    // Process all sessions in parallel for speed
-    const sessionPromises = managedSessions.map(async (sessionName) => {
-      const [status, claudeSessionId, lastLine] = await Promise.all([
-        statusDetector.getStatus(sessionName),
-        getClaudeSessionId(sessionName),
-        getLastLine(sessionName),
-      ]);
-      const id = getSessionIdFromName(sessionName);
-      const agentType = getAgentTypeFromSessionName(sessionName);
-
-      return { sessionName, id, status, claudeSessionId, lastLine, agentType };
-    });
-
-    const results = await Promise.all(sessionPromises);
-
-    for (const {
-      sessionName,
-      id,
-      status,
-      claudeSessionId,
-      lastLine,
-      agentType,
-    } of results) {
-      // Track status changes - update DB when session becomes active
-      const prevStatus = previousStatuses.get(id);
-      if (status === "running" || status === "waiting") {
-        if (prevStatus !== status) {
-          sessionsToUpdate.push(id);
-        }
-      }
-      previousStatuses.set(id, status);
-
-      statusMap[id] = {
-        sessionName,
-        status,
-        lastLine,
-        claudeSessionId,
-        agentType,
-      };
-    }
-
-    // Batch update sessions and claude_session_id
-    for (const id of sessionsToUpdate) {
-      db.prepare(
-        "UPDATE sessions SET updated_at = datetime('now') WHERE id = ?"
-      ).run(id);
-    }
-
-    for (const { id, claudeSessionId } of results) {
-      if (claudeSessionId) {
-        db.prepare(
-          "UPDATE sessions SET claude_session_id = ? WHERE id = ? AND (claude_session_id IS NULL OR claude_session_id != ?)"
-        ).run(claudeSessionId, id, claudeSessionId);
-      }
-    }
-
-    // Cleanup old trackers
-    statusDetector.cleanup();
-
-    return NextResponse.json({ statuses: statusMap });
-  } catch (error) {
-    console.error("Error getting session statuses:", error);
-    return NextResponse.json({ statuses: {} });
-  }
+  return NextResponse.json({ statuses: getStatusSnapshot() });
 }

package/app/page.tsx

@@ -296,6 +296,37 @@ function HomeContent() {
     [addTab, focusedPaneId, buildSessionCommand, runSessionInTerminal]
   );
 
+  // Attach to an already-running tmux session (non-destructive)
+  const attachToActiveTmux = useCallback(
+    (sessionId: string, tmuxSessionName: string) => {
+      const terminalInfo = getTerminalWithFallback();
+      if (!terminalInfo) return;
+
+      const { terminal, paneId } = terminalInfo;
+      const activeTab = getActiveTab(paneId);
+      const isInTmux = !!activeTab?.attachedTmux;
+
+      if (isInTmux) {
+        terminal.sendInput("\x02d");
+      }
+
+      setTimeout(
+        () => {
+          terminal.sendInput("\x03");
+          setTimeout(() => {
+            terminal.sendCommand(
+              `tmux attach -t ${tmuxSessionName} 2>/dev/null`
+            );
+            attachSession(paneId, sessionId, tmuxSessionName);
+            terminal.focus();
+          }, 50);
+        },
+        isInTmux ? 100 : 0
+      );
+    },
+    [getTerminalWithFallback, getActiveTab, attachSession]
+  );
+
   const resumeClaudeSession = useCallback(
     (
       claudeSessionId: string,
@@ -464,6 +495,7 @@ function HomeContent() {
         paneId={paneId}
         sessions={sessions}
         projects={projects}
+        sessionStatuses={sessionStatuses}
         onRegisterTerminal={registerTerminalRef}
         onMenuClick={isMobile ? () => setSidebarOpen(true) : undefined}
         onSelectSession={handleSelectSession}
@@ -473,6 +505,7 @@ function HomeContent() {
     [
       sessions,
       projects,
+      sessionStatuses,
       registerTerminalRef,
       isMobile,
       handleSelectSession,
@@ -586,6 +619,7 @@ function HomeContent() {
     updateSettings,
     requestPermission,
     attachToSession,
+    attachToActiveTmux,
     openSessionInNewTab,
     handleNewSessionInProject,
     handleOpenTerminal,

package/components/Pane/DesktopTabBar.tsx

@@ -21,6 +21,7 @@ import {
 } from "@/components/ui/tooltip";
 import { cn } from "@/lib/utils";
 import type { Session } from "@/lib/db";
+import type { SessionStatus } from "@/components/views/types";
 
 type ViewMode = "terminal" | "files" | "git" | "workers";
 
@@ -35,6 +36,7 @@ interface DesktopTabBarProps {
   activeTabId: string;
   session: Session | null | undefined;
   sessions: Session[];
+  sessionStatuses?: Record<string, SessionStatus>;
   viewMode: ViewMode;
   isFocused: boolean;
   isConductor: boolean;
@@ -63,6 +65,7 @@ export function DesktopTabBar({
   activeTabId,
   session,
   sessions,
+  sessionStatuses,
   viewMode,
   isFocused,
   isConductor,
@@ -103,34 +106,65 @@ export function DesktopTabBar({
     >
       {/* Tabs */}
       <div className="flex min-w-0 flex-1 items-center gap-0.5">
-        {tabs.map((tab) => (
-          <div
-            key={tab.id}
-            onClick={(e) => {
-              e.stopPropagation();
-              onTabSwitch(tab.id);
-            }}
-            className={cn(
-              "group flex cursor-pointer items-center gap-1.5 rounded-t-md px-3 py-1.5 text-xs transition-colors",
-              tab.id === activeTabId
-                ? "bg-background text-foreground"
-                : "text-muted-foreground hover:text-foreground/80 hover:bg-accent/50"
-            )}
-          >
-            <span className="max-w-[120px] truncate">{getTabName(tab)}</span>
-            {tabs.length > 1 && (
-              <button
-                onClick={(e) => {
-                  e.stopPropagation();
-                  onTabClose(tab.id);
-                }}
-                className="hover:text-foreground ml-1 opacity-0 group-hover:opacity-100"
-              >
-                <X className="h-3 w-3" />
-              </button>
-            )}
-          </div>
-        ))}
+        {tabs.map((tab) => {
+          const tabStatus = tab.sessionId
+            ? sessionStatuses?.[tab.sessionId]
+            : undefined;
+          return (
+            <Tooltip key={tab.id}>
+              <TooltipTrigger asChild>
+                <div
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    onTabSwitch(tab.id);
+                  }}
+                  className={cn(
+                    "group relative flex cursor-pointer items-center gap-1.5 rounded-t-md px-3 py-1.5 text-xs transition-colors",
+                    tab.id === activeTabId
+                      ? "bg-background text-foreground"
+                      : "text-muted-foreground hover:text-foreground/80 hover:bg-accent/50"
+                  )}
+                >
+                  {tabStatus &&
+                    tab.id !== activeTabId &&
+                    (tabStatus.status === "running" ||
+                      tabStatus.status === "waiting") && (
+                      <span
+                        className={cn(
+                          "absolute -top-0.5 -right-0.5 h-2 w-2 rounded-full",
+                          tabStatus.status === "running" &&
+                            "animate-pulse bg-green-500",
+                          tabStatus.status === "waiting" &&
+                            "animate-pulse bg-amber-500"
+                        )}
+                      />
+                    )}
+                  <span className="max-w-[120px] truncate">
+                    {getTabName(tab)}
+                  </span>
+                  {tabs.length > 1 && (
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        onTabClose(tab.id);
+                      }}
+                      className="hover:text-foreground ml-1 opacity-0 group-hover:opacity-100"
+                    >
+                      <X className="h-3 w-3" />
+                    </button>
+                  )}
+                </div>
+              </TooltipTrigger>
+              {tabStatus?.lastLine && tab.id !== activeTabId && (
+                <TooltipContent side="bottom" className="max-w-xs">
+                  <p className="truncate font-mono text-xs">
+                    {tabStatus.lastLine}
+                  </p>
+                </TooltipContent>
+              )}
+            </Tooltip>
+          );
+        })}
         <Tooltip>
           <TooltipTrigger asChild>
             <Button

package/components/Pane/index.tsx

@@ -43,10 +43,13 @@ const GitPanel = dynamic(
   { ssr: false, loading: () => <GitPanelSkeleton /> }
 );
 
+import type { SessionStatus } from "@/components/views/types";
+
 interface PaneProps {
   paneId: string;
   sessions: Session[];
   projects: Project[];
+  sessionStatuses?: Record<string, SessionStatus>;
   onRegisterTerminal: (
     paneId: string,
     tabId: string,
@@ -68,6 +71,7 @@ export const Pane = memo(function Pane({
   paneId,
   sessions,
   projects,
+  sessionStatuses,
   onRegisterTerminal,
   onMenuClick,
   onSelectSession,
@@ -318,6 +322,7 @@ export const Pane = memo(function Pane({
           activeTabId={paneData.activeTabId}
           session={session}
           sessions={sessions}
+          sessionStatuses={sessionStatuses}
           viewMode={viewMode}
           isFocused={isFocused}
           isConductor={isConductor}

package/components/QuickSwitcher.tsx

@@ -14,6 +14,7 @@ import { CodeSearchResults } from "@/components/CodeSearch/CodeSearchResults";
 import { useRipgrepAvailable } from "@/data/code-search";
 import { useClaudeProjectsQuery, useClaudeSessionsQuery } from "@/data/claude";
 import type { ClaudeProject } from "@/data/claude";
+import type { SessionStatus } from "@/components/views/types";
 
 interface QuickSwitcherProps {
   open: boolean;
@@ -27,6 +28,7 @@ interface QuickSwitcherProps {
   onSelectFile?: (file: string, line: number) => void;
   currentSessionId?: string;
   activeSessionWorkingDir?: string;
+  sessionStatuses?: Record<string, SessionStatus>;
 }
 
 interface FlatSession {
@@ -45,6 +47,7 @@ export function QuickSwitcher({
   onSelectFile,
   currentSessionId,
   activeSessionWorkingDir,
+  sessionStatuses,
 }: QuickSwitcherProps) {
   const [mode, setMode] = useState<"sessions" | "code">("sessions");
   const [query, setQuery] = useState("");
@@ -103,16 +106,46 @@ export function QuickSwitcher({
     // eslint-disable-next-line react-hooks/exhaustive-deps -- only re-run when .data changes, not entire query objects
   }, [s0.data, s1.data, s2.data, s3.data, topProjects]);
 
+  // Build a map of claudeSessionId -> status for quick lookup
+  const statusByClaudeId = useMemo(() => {
+    if (!sessionStatuses) return new Map<string, SessionStatus>();
+    const map = new Map<string, SessionStatus>();
+    for (const s of Object.values(sessionStatuses)) {
+      if (s.claudeSessionId) {
+        map.set(s.claudeSessionId, s);
+      }
+    }
+    return map;
+  }, [sessionStatuses]);
+
   const filteredSessions = useMemo(() => {
-    if (!query) return allSessions;
-    const q = query.toLowerCase();
-    return allSessions.filter(
-      (s) =>
-        s.summary.toLowerCase().includes(q) ||
-        s.projectDisplayName.toLowerCase().includes(q) ||
-        s.cwd.toLowerCase().includes(q)
-    );
-  }, [allSessions, query]);
+    let sessions = allSessions;
+    if (query) {
+      const q = query.toLowerCase();
+      sessions = sessions.filter(
+        (s) =>
+          s.summary.toLowerCase().includes(q) ||
+          s.projectDisplayName.toLowerCase().includes(q) ||
+          s.cwd.toLowerCase().includes(q)
+      );
+    }
+
+    // Sort: waiting first, then running, then by time
+    return [...sessions].sort((a, b) => {
+      const statusA = statusByClaudeId.get(a.sessionId)?.status;
+      const statusB = statusByClaudeId.get(b.sessionId)?.status;
+      const orderMap: Record<string, number> = {
+        waiting: 0,
+        running: 1,
+      };
+      const orderA = statusA && statusA in orderMap ? orderMap[statusA] : 2;
+      const orderB = statusB && statusB in orderMap ? orderMap[statusB] : 2;
+      if (orderA !== orderB) return orderA - orderB;
+      return (
+        new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
+      );
+    });
+  }, [allSessions, query, statusByClaudeId]);
 
   useEffect(() => {
     if (open) {
@@ -242,6 +275,7 @@ export function QuickSwitcher({
             ) : (
               filteredSessions.map((session, index) => {
                 const isCurrent = session.sessionId === currentSessionId;
+                const status = statusByClaudeId.get(session.sessionId);
                 return (
                   <button
                     key={session.sessionId}
@@ -259,11 +293,24 @@ export function QuickSwitcher({
                       index === selectedIndex
                         ? "bg-accent"
                         : "hover:bg-accent/50",
-                      isCurrent && "bg-primary/10"
+                      isCurrent && "bg-primary/10",
+                      status?.status === "waiting" && "bg-amber-500/5"
                     )}
                   >
-                    <div className="flex h-8 w-8 flex-shrink-0 items-center justify-center rounded-md bg-emerald-500/20 text-emerald-400">
+                    <div className="relative flex h-8 w-8 flex-shrink-0 items-center justify-center rounded-md bg-emerald-500/20 text-emerald-400">
                       <Terminal className="h-4 w-4" />
+                      {status && (
+                        <span
+                          className={cn(
+                            "border-background absolute -top-0.5 -right-0.5 h-2.5 w-2.5 rounded-full border-2",
+                            status.status === "running" &&
+                              "animate-pulse bg-green-500",
+                            status.status === "waiting" &&
+                              "animate-pulse bg-amber-500",
+                            status.status === "idle" && "bg-gray-400"
+                          )}
+                        />
+                      )}
                     </div>
                     <div className="min-w-0 flex-1">
                       <span className="block truncate text-sm font-medium">
@@ -272,6 +319,11 @@ export function QuickSwitcher({
                       <span className="text-muted-foreground block truncate text-xs">
                         {session.projectDisplayName}
                       </span>
+                      {status?.lastLine && (
+                        <span className="text-muted-foreground block truncate font-mono text-[10px]">
+                          {status.lastLine}
+                        </span>
+                      )}
                     </div>
                     <div className="text-muted-foreground flex flex-shrink-0 items-center gap-1 text-xs">
                       <Clock className="h-3 w-3" />