@atercates/claude-deck 0.2.3 → 0.2.5

package/lib/providers.ts

@@ -1,25 +1,9 @@
-import {
-  type ProviderId,
-  getProviderDefinition,
-  isValidProviderId,
-} from "./providers/registry";
+import type { ProviderId } from "./providers/registry";
 
 export type AgentType = ProviderId;
 
-export interface AgentProvider {
-  id: AgentType;
-  name: string;
-  description: string;
-  command: string;
-  supportsResume: boolean;
-  supportsFork: boolean;
-  buildFlags(options: BuildFlagsOptions): string[];
-  waitingPatterns: RegExp[];
-  runningPatterns: RegExp[];
-  idlePatterns: RegExp[];
-  getSessionId?: (projectPath: string) => string | null;
-  configDir: string;
-}
+export const CLAUDE_COMMAND = "claude";
+export const CLAUDE_AUTO_APPROVE_FLAG = "--dangerously-skip-permissions";
 
 export interface BuildFlagsOptions {
   sessionId?: string | null;
@@ -30,92 +14,27 @@ export interface BuildFlagsOptions {
   initialPrompt?: string;
 }
 
-const SPINNER_CHARS = /⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/;
-
-export const claudeProvider: AgentProvider = {
-  id: "claude",
-  name: "Claude Code",
-  description: "Anthropic's official CLI",
-  command: "claude",
-  configDir: "~/.claude",
-  supportsResume: true,
-  supportsFork: true,
-
-  buildFlags(options: BuildFlagsOptions): string[] {
-    const def = getProviderDefinition("claude");
-    const flags: string[] = [];
-
-    if (
-      (options.skipPermissions || options.autoApprove) &&
-      def.autoApproveFlag
-    ) {
-      flags.push(def.autoApproveFlag);
-    }
-
-    if (options.sessionId && def.resumeFlag) {
-      flags.push(`${def.resumeFlag} ${options.sessionId}`);
-    } else if (options.parentSessionId && def.resumeFlag) {
-      flags.push(`${def.resumeFlag} ${options.parentSessionId}`);
-      flags.push("--fork-session");
-    }
-
-    if (options.initialPrompt?.trim() && def.initialPromptFlag !== undefined) {
-      const prompt = options.initialPrompt.trim();
-      const escapedPrompt = prompt.replace(/'/g, "'\\''");
-      flags.push(`'${escapedPrompt}'`);
-    }
+export function buildClaudeFlags(options: BuildFlagsOptions): string[] {
+  const flags: string[] = [];
 
-    return flags;
-  },
+  if (options.skipPermissions || options.autoApprove) {
+    flags.push(CLAUDE_AUTO_APPROVE_FLAG);
+  }
 
-  waitingPatterns: [
-    /\[Y\/n\]/i,
-    /\[y\/N\]/i,
-    /Allow\?/i,
-    /Approve\?/i,
-    /Continue\?/i,
-    /Press Enter/i,
-    /waiting for/i,
-    /\(yes\/no\)/i,
-    /Do you want to/i,
-    /Esc to cancel/i,
-    />\s*1\.\s*Yes/,
-    /Yes, allow all/i,
-    /allow all edits/i,
-    /allow all commands/i,
-  ],
+  if (options.sessionId) {
+    flags.push("--resume", options.sessionId);
+  } else if (options.parentSessionId) {
+    flags.push("--resume", options.parentSessionId, "--fork-session");
+  }
 
-  runningPatterns: [
-    /thinking/i,
-    /Working/i,
-    /Reading/i,
-    /Writing/i,
-    /Searching/i,
-    /Running/i,
-    /Executing/i,
-    SPINNER_CHARS,
-  ],
+  if (options.initialPrompt?.trim()) {
+    const escapedPrompt = options.initialPrompt.trim().replace(/'/g, "'\\''");
+    flags.push(`'${escapedPrompt}'`);
+  }
 
-  idlePatterns: [/^>\s*$/m, /claude.*>\s*$/im, /✻\s*Sautéed/i, /✻\s*Done/i],
-};
-
-export const providers: Record<AgentType, AgentProvider> = {
-  claude: claudeProvider,
-};
-
-export function getProvider(agentType: AgentType): AgentProvider {
-  return providers[agentType] || claudeProvider;
-}
-
-export function getAllProviders(): AgentProvider[] {
-  return Object.values(providers);
+  return flags;
 }
 
 export function isValidAgentType(value: string): value is AgentType {
-  return isValidProviderId(value);
+  return value === "claude";
 }
-
-export {
-  getProviderDefinition,
-  getAllProviderDefinitions,
-} from "./providers/registry";

package/lib/status-monitor.ts

@@ -0,0 +1,303 @@
+/**
+ * Session status monitor — hook-based detection.
+ *
+ * Claude Code hooks write state files to ~/.claude-deck/session-states/.
+ * This module reads those files and pushes updates to the frontend via WebSocket.
+ *
+ * The only periodic work is `tmux list-sessions` every 3s to detect dead sessions.
+ * All state transitions are event-driven via Chokidar watching the state files dir.
+ */
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import {
+  getManagedSessionPattern,
+  getSessionIdFromName,
+  getProviderIdFromSessionName,
+} from "./providers/registry";
+import type { AgentType } from "./providers";
+import { broadcast } from "./claude/watcher";
+import { getDb } from "./db";
+import { STATES_DIR } from "./hooks/setup";
+import { getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
+
+const execAsync = promisify(exec);
+
+const TICK_INTERVAL_MS = 3000;
+const SESSION_NAME_CACHE_TTL = 10_000;
+const UUID_PATTERN = getManagedSessionPattern();
+
+// Cache for session metadata (name + cwd from SDK)
+const sessionMetaCache = new Map<
+  string,
+  { name: string; cwd: string | null; cachedAt: number }
+>();
+
+// --- Types ---
+
+export type SessionStatus = "running" | "waiting" | "idle" | "dead";
+
+interface StateFile {
+  status: "running" | "waiting" | "idle";
+  lastLine: string;
+  waitingContext?: string;
+  ts: number;
+}
+
+export interface SessionStatusSnapshot {
+  sessionName: string;
+  cwd: string | null;
+  status: SessionStatus;
+  lastLine: string;
+  waitingContext?: string;
+  claudeSessionId: string | null;
+  agentType: AgentType;
+}
+
+// --- State ---
+
+let currentSnapshot: Record<string, SessionStatusSnapshot> = {};
+let monitorTimer: ReturnType<typeof setInterval> | null = null;
+
+// --- State file reading ---
+
+function readStateFile(sessionId: string): StateFile | null {
+  try {
+    const filePath = path.join(STATES_DIR, `${sessionId}.json`);
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function listStateFiles(): Map<string, StateFile> {
+  const map = new Map<string, StateFile>();
+  try {
+    for (const file of fs.readdirSync(STATES_DIR)) {
+      if (!file.endsWith(".json")) continue;
+      const sessionId = file.replace(".json", "");
+      const state = readStateFile(sessionId);
+      if (state) map.set(sessionId, state);
+    }
+  } catch {
+    // dir may not exist yet
+  }
+  return map;
+}
+
+// --- tmux ---
+
+async function listTmuxSessions(): Promise<Map<string, string>> {
+  // Returns Map<sessionId, sessionName>
+  try {
+    const { stdout } = await execAsync(
+      "tmux list-sessions -F '#{session_name}' 2>/dev/null || echo \"\""
+    );
+    const map = new Map<string, string>();
+    for (const name of stdout.trim().split("\n")) {
+      if (!name || !UUID_PATTERN.test(name)) continue;
+      map.set(getSessionIdFromName(name), name);
+    }
+    return map;
+  } catch {
+    return new Map();
+  }
+}
+
+// --- Session metadata resolution ---
+
+async function resolveSessionMeta(
+  sessionId: string
+): Promise<{ name: string; cwd: string | null }> {
+  const cached = sessionMetaCache.get(sessionId);
+  if (cached && Date.now() - cached.cachedAt < SESSION_NAME_CACHE_TTL) {
+    return { name: cached.name, cwd: cached.cwd };
+  }
+
+  try {
+    const info = await getSessionInfo(sessionId);
+    if (info) {
+      const name = info.customTitle || info.summary || sessionId.slice(0, 8);
+      const cwd = info.cwd || null;
+      sessionMetaCache.set(sessionId, { name, cwd, cachedAt: Date.now() });
+      return { name, cwd };
+    }
+  } catch {
+    // SDK lookup failed — use short ID
+  }
+
+  const fallback = sessionId.slice(0, 8);
+  sessionMetaCache.set(sessionId, {
+    name: fallback,
+    cwd: null,
+    cachedAt: Date.now(),
+  });
+  return { name: fallback, cwd: null };
+}
+
+// --- Snapshot building ---
+
+async function buildSnapshot(
+  tmuxSessions: Map<string, string>,
+  stateFiles: Map<string, StateFile>
+): Promise<Record<string, SessionStatusSnapshot>> {
+  const snap: Record<string, SessionStatusSnapshot> = {};
+
+  const entries = await Promise.all(
+    [...tmuxSessions.entries()].map(async ([sessionId, tmuxName]) => {
+      const meta = await resolveSessionMeta(sessionId);
+      return { sessionId, tmuxName, ...meta };
+    })
+  );
+
+  for (const { sessionId, tmuxName, name, cwd } of entries) {
+    const agentType = getProviderIdFromSessionName(tmuxName) || "claude";
+    const state = stateFiles.get(sessionId);
+
+    snap[sessionId] = {
+      sessionName: name,
+      cwd,
+      status: state?.status || "idle",
+      lastLine: state?.lastLine || "",
+      ...(state?.status === "waiting" && state.waitingContext
+        ? { waitingContext: state.waitingContext }
+        : {}),
+      claudeSessionId: sessionId,
+      agentType,
+    };
+  }
+
+  // Filter out hidden sessions
+  try {
+    const db = getDb();
+    const hiddenRows = db
+      .prepare("SELECT item_id FROM hidden_items WHERE item_type = 'session'")
+      .all() as { item_id: string }[];
+    for (const { item_id } of hiddenRows) {
+      delete snap[item_id];
+    }
+  } catch {
+    // DB errors shouldn't break the monitor
+  }
+
+  return snap;
+}
+
+function snapshotChanged(
+  prev: Record<string, SessionStatusSnapshot>,
+  next: Record<string, SessionStatusSnapshot>
+): boolean {
+  const prevKeys = Object.keys(prev);
+  const nextKeys = Object.keys(next);
+  if (prevKeys.length !== nextKeys.length) return true;
+  for (const id of nextKeys) {
+    const p = prev[id];
+    const n = next[id];
+    if (
+      !p ||
+      p.status !== n.status ||
+      p.lastLine !== n.lastLine ||
+      p.sessionName !== n.sessionName
+    )
+      return true;
+  }
+  return false;
+}
+
+function updateDb(
+  prev: Record<string, SessionStatusSnapshot>,
+  next: Record<string, SessionStatusSnapshot>
+): void {
+  try {
+    const db = getDb();
+    for (const [id, snap] of Object.entries(next)) {
+      if (prev[id]?.status === snap.status) continue;
+      db.prepare(
+        "UPDATE sessions SET updated_at = datetime('now') WHERE id = ?"
+      ).run(id);
+      if (snap.claudeSessionId) {
+        db.prepare(
+          "UPDATE sessions SET claude_session_id = ? WHERE id = ? AND (claude_session_id IS NULL OR claude_session_id != ?)"
+        ).run(snap.claudeSessionId, id, snap.claudeSessionId);
+      }
+    }
+  } catch {
+    // DB errors shouldn't break the monitor
+  }
+}
+
+// --- Core tick (only for dead detection + state file sync) ---
+
+async function tick(): Promise<void> {
+  const tmuxSessions = await listTmuxSessions();
+  const stateFiles = listStateFiles();
+
+  // Clean up state files for sessions that no longer exist in tmux
+  for (const sessionId of stateFiles.keys()) {
+    if (!tmuxSessions.has(sessionId)) {
+      try {
+        fs.unlinkSync(path.join(STATES_DIR, `${sessionId}.json`));
+      } catch {
+        // ignore
+      }
+    }
+  }
+
+  const newSnapshot = await buildSnapshot(tmuxSessions, stateFiles);
+
+  if (snapshotChanged(currentSnapshot, newSnapshot)) {
+    updateDb(currentSnapshot, newSnapshot);
+    currentSnapshot = newSnapshot;
+    broadcast({ type: "session-statuses", statuses: newSnapshot });
+  }
+}
+
+// --- Public API ---
+
+export function getStatusSnapshot(): Record<string, SessionStatusSnapshot> {
+  return currentSnapshot;
+}
+
+export function acknowledge(_sessionName: string): void {
+  // With hook-based detection, acknowledge is a no-op.
+  // Status is determined by Claude Code's hook events, not by us.
+}
+
+/**
+ * Called by Chokidar when a state file in ~/.claude-deck/session-states/ changes.
+ * Triggers an immediate re-read and broadcast.
+ */
+export function onStateFileChange(): void {
+  tick().catch(console.error);
+}
+
+export function invalidateSessionName(sessionId: string): void {
+  sessionMetaCache.delete(sessionId);
+}
+
+export function startStatusMonitor(): void {
+  if (monitorTimer) return;
+
+  // Ensure states directory exists
+  fs.mkdirSync(STATES_DIR, { recursive: true });
+
+  // Initial tick
+  setTimeout(() => tick().catch(console.error), 500);
+
+  // Periodic fallback (catches tmux session death, missed events)
+  monitorTimer = setInterval(() => {
+    tick().catch(console.error);
+  }, TICK_INTERVAL_MS);
+
+  console.log("> Status monitor started (hook-based, 3s fallback tick)");
+}
+
+export function stopStatusMonitor(): void {
+  if (monitorTimer) {
+    clearInterval(monitorTimer);
+    monitorTimer = null;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atercates/claude-deck",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "claude-deck": "./scripts/claude-deck"

package/server.ts

@@ -5,6 +5,8 @@ import { WebSocketServer, WebSocket } from "ws";
 import * as pty from "node-pty";
 import { initDb } from "./lib/db";
 import { startWatcher, addUpdateClient } from "./lib/claude/watcher";
+import { startStatusMonitor } from "./lib/status-monitor";
+import { setupHooks } from "./lib/hooks/setup";
 import {
   validateSession,
   parseCookies,
@@ -13,7 +15,7 @@ import {
 } from "./lib/auth";
 
 const dev = process.env.NODE_ENV !== "production";
-const hostname = "0.0.0.0";
+const hostname = process.env.HOST || (dev ? "localhost" : "0.0.0.0");
 
 // Support: npm run dev -- -p 3012
 const pFlagIndex = process.argv.indexOf("-p");
@@ -166,7 +168,9 @@ app.prepare().then(async () => {
   await initDb();
   console.log("> Database initialized");
 
+  setupHooks();
   startWatcher();
+  startStatusMonitor();
 
   server.listen(port, () => {
     console.log(`> ClaudeDeck ready on http://${hostname}:${port}`);

package/app/api/groups/[...path]/route.ts

@@ -1,136 +0,0 @@
-import { NextResponse } from "next/server";
-import { queries, type Group } from "@/lib/db";
-
-// GET /api/groups/[...path] - Get a single group
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    const group = await queries.getGroup(path) as Group | undefined;
-
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    return NextResponse.json({
-      group: { ...group, expanded: Boolean(group.expanded) },
-    });
-  } catch (error) {
-    console.error("Error fetching group:", error);
-    return NextResponse.json(
-      { error: "Failed to fetch group" },
-      { status: 500 }
-    );
-  }
-}
-
-// PATCH /api/groups/[...path] - Update group (name, expanded, order)
-export async function PATCH(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    const body = await request.json();
-    const { name, expanded, sort_order } = body;
-
-    // Check if group exists
-    const group = await queries.getGroup(path) as Group | undefined;
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    // Protect default group from being renamed
-    if (path === "sessions" && name !== undefined && name !== "Sessions") {
-      return NextResponse.json(
-        { error: "Cannot rename the default group" },
-        { status: 400 }
-      );
-    }
-
-    // Update name
-    if (name !== undefined) {
-      await queries.updateGroupName(name, path);
-    }
-
-    // Update expanded state
-    if (expanded !== undefined) {
-      await queries.updateGroupExpanded(!!expanded, path);
-    }
-
-    // Update sort order
-    if (sort_order !== undefined) {
-      await queries.updateGroupOrder(sort_order, path);
-    }
-
-    const updatedGroup = await queries.getGroup(path) as Group;
-    return NextResponse.json({
-      group: { ...updatedGroup, expanded: Boolean(updatedGroup.expanded) },
-    });
-  } catch (error) {
-    console.error("Error updating group:", error);
-    return NextResponse.json(
-      { error: "Failed to update group" },
-      { status: 500 }
-    );
-  }
-}
-
-// DELETE /api/groups/[...path] - Delete group (moves sessions to parent or default)
-export async function DELETE(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    // Protect default group
-    if (path === "sessions") {
-      return NextResponse.json(
-        { error: "Cannot delete the default group" },
-        { status: 400 }
-      );
-    }
-
-    // Check if group exists
-    const group = await queries.getGroup(path) as Group | undefined;
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    // Find parent group or use default
-    const pathParts2 = path.split("/");
-    pathParts2.pop();
-    const parentPath =
-      pathParts2.length > 0 ? pathParts2.join("/") : "sessions";
-
-    // Move all sessions in this group to parent
-    await queries.moveSessionsToGroup(parentPath, path);
-
-    // Also move sessions from any subgroups
-    const allGroups = await queries.getAllGroups() as Group[];
-    const subgroups = allGroups.filter((g) => g.path.startsWith(path + "/"));
-    for (const subgroup of subgroups) {
-      await queries.moveSessionsToGroup(parentPath, subgroup.path);
-      await queries.deleteGroup(subgroup.path);
-    }
-
-    // Delete the group
-    await queries.deleteGroup(path);
-
-    return NextResponse.json({ success: true, movedTo: parentPath });
-  } catch (error) {
-    console.error("Error deleting group:", error);
-    return NextResponse.json(
-      { error: "Failed to delete group" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/groups/route.ts

@@ -1,93 +0,0 @@
-import { NextResponse } from "next/server";
-import { queries, type Group } from "@/lib/db";
-
-// GET /api/groups - List all groups
-export async function GET() {
-  try {
-    const groups = await queries.getAllGroups() as Group[];
-
-    // Convert expanded from 0/1 to boolean
-    const formattedGroups = groups.map((g) => ({
-      ...g,
-      expanded: Boolean(g.expanded),
-    }));
-
-    return NextResponse.json({ groups: formattedGroups });
-  } catch (error) {
-    console.error("Error fetching groups:", error);
-    return NextResponse.json(
-      { error: "Failed to fetch groups" },
-      { status: 500 }
-    );
-  }
-}
-
-// POST /api/groups - Create a new group
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const { name, parentPath } = body;
-
-    if (!name || typeof name !== "string") {
-      return NextResponse.json({ error: "Name is required" }, { status: 400 });
-    }
-
-    // Sanitize name to create path
-    const sanitizedName = name
-      .toLowerCase()
-      .replace(/[^a-z0-9-]/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "");
-
-    if (!sanitizedName) {
-      return NextResponse.json(
-        { error: "Invalid group name" },
-        { status: 400 }
-      );
-    }
-
-    // Build full path
-    const path = parentPath ? `${parentPath}/${sanitizedName}` : sanitizedName;
-
-    // Check if group already exists
-    const existing = await queries.getGroup(path) as Group | undefined;
-    if (existing) {
-      return NextResponse.json(
-        { error: "Group already exists", group: existing },
-        { status: 409 }
-      );
-    }
-
-    // If parent path specified, ensure parent exists
-    if (parentPath) {
-      const parent = await queries.getGroup(parentPath) as Group | undefined;
-      if (!parent) {
-        return NextResponse.json(
-          { error: "Parent group does not exist" },
-          { status: 400 }
-        );
-      }
-    }
-
-    // Get max sort order for new group
-    const groups = await queries.getAllGroups() as Group[];
-    const maxOrder = groups.reduce((max, g) => Math.max(max, g.sort_order), 0);
-
-    // Create the group
-    await queries.createGroup(path, name, maxOrder + 1);
-
-    const newGroup = await queries.getGroup(path) as Group;
-    return NextResponse.json(
-      {
-        group: { ...newGroup, expanded: Boolean(newGroup.expanded) },
-      },
-      { status: 201 }
-    );
-  } catch (error) {
-    console.error("Error creating group:", error);
-    return NextResponse.json(
-      { error: "Failed to create group" },
-      { status: 500 }
-    );
-  }
-}