@atercates/claude-deck 0.2.3 → 0.2.5

package/lib/db/queries.ts

@@ -1,7 +1,6 @@
 import { getDb } from "./index";
 import type {
   Session,
-  Group,
   Project,
   ProjectDevServer,
   ProjectRepository,
@@ -39,14 +38,13 @@ export const queries = {
     parentSessionId: string | null,
     model: string | null,
     systemPrompt: string | null,
-    groupPath: string,
     agentType: string,
     autoApprove: boolean,
     projectId: string | null
   ) =>
     execute(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, parent_session_id, model, system_prompt, group_path, agent_type, auto_approve, project_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT INTO sessions (id, name, tmux_name, working_directory, parent_session_id, model, system_prompt, agent_type, auto_approve, project_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         id,
         name,
@@ -55,7 +53,6 @@ export const queries = {
         parentSessionId,
         model,
         systemPrompt,
-        groupPath,
         agentType,
         autoApprove ? 1 : 0,
         projectId,
@@ -68,12 +65,6 @@ export const queries = {
   getAllSessions: () =>
     query<Session>("SELECT * FROM sessions ORDER BY updated_at DESC"),
 
-  updateSessionStatus: (status: string, id: string) =>
-    execute(
-      "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE id = ?",
-      [status, id]
-    ),
-
   updateSessionClaudeId: (claudeSessionId: string, id: string) =>
     execute(
       "UPDATE sessions SET claude_session_id = ?, updated_at = datetime('now') WHERE id = ?",
@@ -112,24 +103,6 @@ export const queries = {
       [prUrl, prNumber, prStatus, id]
     ),
 
-  updateSessionGroup: (groupPath: string, id: string) =>
-    execute(
-      "UPDATE sessions SET group_path = ?, updated_at = datetime('now') WHERE id = ?",
-      [groupPath, id]
-    ),
-
-  getSessionsByGroup: (groupPath: string) =>
-    query<Session>(
-      "SELECT * FROM sessions WHERE group_path = ? ORDER BY updated_at DESC",
-      [groupPath]
-    ),
-
-  moveSessionsToGroup: (newGroupPath: string, oldGroupPath: string) =>
-    execute(
-      "UPDATE sessions SET group_path = ?, updated_at = datetime('now') WHERE group_path = ?",
-      [newGroupPath, oldGroupPath]
-    ),
-
   updateSessionProject: (projectId: string, id: string) =>
     execute(
       "UPDATE sessions SET project_id = ?, updated_at = datetime('now') WHERE id = ?",
@@ -162,13 +135,12 @@ export const queries = {
     conductorSessionId: string,
     workerTask: string,
     model: string | null,
-    groupPath: string,
     agentType: string,
     projectId: string | null
   ) =>
     execute(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, conductor_session_id, worker_task, worker_status, model, group_path, agent_type, project_id)
-       VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?)`,
+      `INSERT INTO sessions (id, name, tmux_name, working_directory, conductor_session_id, worker_task, worker_status, model, agent_type, project_id)
+       VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)`,
       [
         id,
         name,
@@ -177,43 +149,11 @@ export const queries = {
         conductorSessionId,
         workerTask,
         model,
-        groupPath,
         agentType,
         projectId,
       ]
     ),
 
-  getAllGroups: () =>
-    query<Group>("SELECT * FROM groups ORDER BY sort_order ASC, name ASC"),
-
-  getGroup: (path: string) =>
-    queryOne<Group>("SELECT * FROM groups WHERE path = ?", [path]),
-
-  createGroup: (path: string, name: string, sortOrder: number) =>
-    execute("INSERT INTO groups (path, name, sort_order) VALUES (?, ?, ?)", [
-      path,
-      name,
-      sortOrder,
-    ]),
-
-  updateGroupName: (name: string, path: string) =>
-    execute("UPDATE groups SET name = ? WHERE path = ?", [name, path]),
-
-  updateGroupExpanded: (expanded: boolean, path: string) =>
-    execute("UPDATE groups SET expanded = ? WHERE path = ?", [
-      expanded ? 1 : 0,
-      path,
-    ]),
-
-  updateGroupOrder: (sortOrder: number, path: string) =>
-    execute("UPDATE groups SET sort_order = ? WHERE path = ?", [
-      sortOrder,
-      path,
-    ]),
-
-  deleteGroup: (path: string) =>
-    execute("DELETE FROM groups WHERE path = ?", [path]),
-
   createProject: (
     id: string,
     name: string,

package/lib/db/types.ts

@@ -31,14 +31,6 @@ export interface Session {
   worker_status: "pending" | "running" | "completed" | "failed" | null;
 }
 
-export interface Group {
-  path: string;
-  name: string;
-  expanded: boolean;
-  sort_order: number;
-  created_at: string;
-}
-
 export interface Project {
   id: string;
   name: string;

package/lib/hooks/reporter.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * Claude Code hook reporter.
+ *
+ * Invoked by Claude Code hooks on state transitions. Reads JSON from stdin
+ * and writes a session state file to ~/.claude-deck/session-states/{session_id}.json.
+ *
+ * Installed to ~/.claude-deck/hooks/state-reporter by the setup module.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const STATES_DIR = path.join(os.homedir(), ".claude-deck", "session-states");
+
+interface HookInput {
+  session_id: string;
+  hook_event_name: string;
+  tool_name?: string;
+  tool_input?: unknown;
+  last_assistant_message?: string;
+  stop_hook_active?: boolean;
+  reason?: string;
+}
+
+interface StateFile {
+  status: "running" | "waiting" | "idle";
+  lastLine: string;
+  waitingContext?: string;
+  ts: number;
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => (data += chunk));
+    process.stdin.on("end", () => resolve(data));
+    // Safety timeout — don't hang if stdin never closes
+    setTimeout(() => resolve(data), 1000);
+  });
+}
+
+function getStatePath(sessionId: string): string {
+  return path.join(STATES_DIR, `${sessionId}.json`);
+}
+
+function writeState(sessionId: string, state: StateFile): void {
+  fs.mkdirSync(STATES_DIR, { recursive: true });
+  fs.writeFileSync(getStatePath(sessionId), JSON.stringify(state));
+}
+
+function deleteState(sessionId: string): void {
+  try {
+    fs.unlinkSync(getStatePath(sessionId));
+  } catch {
+    // file may not exist
+  }
+}
+
+async function main(): Promise<void> {
+  const raw = await readStdin();
+  if (!raw.trim()) return;
+
+  let input: HookInput;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  const { session_id, hook_event_name } = input;
+  if (!session_id) return;
+
+  switch (hook_event_name) {
+    case "SessionEnd":
+      deleteState(session_id);
+      break;
+
+    case "PermissionRequest":
+      writeState(session_id, {
+        status: "waiting",
+        lastLine: `Waiting: ${input.tool_name || "permission"}`,
+        waitingContext: input.tool_name
+          ? `Permission requested for ${input.tool_name}`
+          : "Permission requested",
+        ts: Date.now(),
+      });
+      break;
+
+    case "Stop":
+      // Only transition to idle if not in a stop-hook re-run loop
+      if (!input.stop_hook_active) {
+        writeState(session_id, {
+          status: "idle",
+          lastLine: input.last_assistant_message?.slice(0, 200) || "",
+          ts: Date.now(),
+        });
+      }
+      break;
+
+    default:
+      // UserPromptSubmit, SessionStart, PreToolUse, PostToolUse, PermissionDenied
+      writeState(session_id, {
+        status: "running",
+        lastLine: input.tool_name
+          ? `Running: ${input.tool_name}`
+          : "Running...",
+        ts: Date.now(),
+      });
+      break;
+  }
+}
+
+main().catch(() => process.exit(0));

package/lib/hooks/setup.ts

@@ -0,0 +1,164 @@
+/**
+ * Hooks setup module.
+ *
+ * Installs the state-reporter script to ~/.claude-deck/hooks/ and
+ * merges hook configuration into ~/.claude/settings.json idempotently.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const CLAUDE_DECK_DIR = path.join(os.homedir(), ".claude-deck");
+const HOOKS_DIR = path.join(CLAUDE_DECK_DIR, "hooks");
+const STATES_DIR = path.join(CLAUDE_DECK_DIR, "session-states");
+const REPORTER_PATH = path.join(HOOKS_DIR, "state-reporter");
+const SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+
+// Events we hook into and whether they run async
+const HOOK_EVENTS: Array<{ event: string; async: boolean }> = [
+  { event: "UserPromptSubmit", async: true },
+  { event: "PreToolUse", async: true },
+  { event: "PermissionRequest", async: false },
+  { event: "Elicitation", async: false },
+  { event: "Stop", async: true },
+  { event: "SessionStart", async: true },
+  { event: "SessionEnd", async: true },
+];
+
+// The reporter is a self-contained Node.js script (no tsx, no ESM, no deps)
+const REPORTER_SCRIPT = `#!/usr/bin/env node
+"use strict";
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var STATES_DIR = path.join(os.homedir(), ".claude-deck", "session-states");
+
+var data = "";
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", function(c) { data += c; });
+process.stdin.on("end", function() {
+  try {
+    var input = JSON.parse(data);
+    var id = input.session_id;
+    if (!id) return;
+    fs.mkdirSync(STATES_DIR, { recursive: true });
+    var fp = path.join(STATES_DIR, id + ".json");
+    var evt = input.hook_event_name;
+
+    if (evt === "SessionEnd") {
+      try { fs.unlinkSync(fp); } catch(e) {}
+      return;
+    }
+
+    var status = "running";
+    var lastLine = input.tool_name ? "Running: " + input.tool_name : "Running...";
+    var state = { status: status, lastLine: lastLine, ts: Date.now() };
+
+    if (evt === "SessionStart") {
+      state.status = "idle";
+      state.lastLine = "";
+    } else if (evt === "PermissionRequest" || evt === "Elicitation") {
+      state.status = "waiting";
+      state.lastLine = "Waiting: " + (input.tool_name || "input required");
+      state.waitingContext = input.tool_name
+        ? "Permission requested for " + input.tool_name
+        : "Input required";
+    } else if (evt === "Stop" && !input.stop_hook_active) {
+      state.status = "idle";
+      state.lastLine = (input.last_assistant_message || "").slice(0, 200);
+    }
+
+    fs.writeFileSync(fp, JSON.stringify(state));
+  } catch(e) {}
+});
+setTimeout(function() { process.exit(0); }, 2000);
+`;
+
+function installReporterScript(): void {
+  fs.mkdirSync(HOOKS_DIR, { recursive: true });
+  fs.mkdirSync(STATES_DIR, { recursive: true });
+  fs.writeFileSync(REPORTER_PATH, REPORTER_SCRIPT, { mode: 0o755 });
+}
+
+interface HookCommand {
+  type: "command";
+  command: string;
+  async?: boolean;
+}
+
+interface HookMatcher {
+  matcher?: string;
+  hooks: HookCommand[];
+}
+
+type SettingsHooks = Record<string, HookMatcher[]>;
+
+interface Settings {
+  hooks?: SettingsHooks;
+  [key: string]: unknown;
+}
+
+function isOurHook(hook: HookCommand): boolean {
+  return hook.command === REPORTER_PATH;
+}
+
+function mergeHooksIntoSettings(): void {
+  let settings: Settings = {};
+
+  try {
+    const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+    settings = JSON.parse(raw);
+  } catch {
+    // File doesn't exist or is invalid
+  }
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  let changed = false;
+
+  for (const { event, async: isAsync } of HOOK_EVENTS) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+
+    const eventHooks = settings.hooks[event];
+    const alreadyInstalled = eventHooks.some((matcher) =>
+      matcher.hooks?.some((h) => isOurHook(h))
+    );
+
+    if (!alreadyInstalled) {
+      const hookDef: HookCommand = {
+        type: "command",
+        command: REPORTER_PATH,
+      };
+      if (isAsync) {
+        hookDef.async = true;
+      }
+      eventHooks.push({ hooks: [hookDef] });
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+    console.log("> Hooks configured in ~/.claude/settings.json");
+  }
+}
+
+export function setupHooks(): void {
+  try {
+    installReporterScript();
+    mergeHooksIntoSettings();
+    console.log(
+      "> Hook reporter installed at ~/.claude-deck/hooks/state-reporter"
+    );
+  } catch (err) {
+    console.error("Failed to setup hooks:", err);
+  }
+}
+
+export { STATES_DIR };

package/lib/orchestration.ts

@@ -11,8 +11,9 @@ import { promisify } from "util";
 import { queries, type Session } from "./db";
 import { createWorktree, deleteWorktree } from "./worktrees";
 import { setupWorktree } from "./env-setup";
-import { type AgentType, getProvider } from "./providers";
-import { statusDetector } from "./status-detector";
+import { type AgentType, CLAUDE_COMMAND, buildClaudeFlags } from "./providers";
+import { getStatusSnapshot } from "./status-monitor";
+import { getSessionIdFromName } from "./providers/registry";
 import { wrapWithBanner } from "./banner";
 import { runInBackground } from "./async-operations";
 
@@ -94,7 +95,7 @@ export async function spawnWorker(
 
   const sessionId = randomUUID();
   const sessionName = taskToSessionName(task);
-  const provider = getProvider(agentType);
+  // Provider is always claude
 
   let worktreePath: string | null = null;
   let actualWorkingDir = workingDirectory;
@@ -131,7 +132,7 @@ export async function spawnWorker(
   }
 
   // Create session in database
-  const tmuxName = `${provider.id}-${sessionId}`;
+  const tmuxName = `claude-${sessionId}`;
   await queries.createWorkerSession(
     sessionId,
     sessionName,
@@ -140,7 +141,6 @@ export async function spawnWorker(
     conductorSessionId,
     task,
     model,
-    "sessions", // group_path
     agentType,
     "uncategorized" // project_id
   );
@@ -157,15 +157,15 @@ export async function spawnWorker(
   }
 
   // Create tmux session and start the agent
-  const tmuxSessionName = `${provider.id}-${sessionId}`;
+  const tmuxSessionName = `claude-${sessionId}`;
   const cwd = actualWorkingDir.replace("~", "$HOME");
 
   // Build the initial prompt command (workers use auto-approve by default for automation)
-  const flags = provider.buildFlags({ model, autoApprove: true });
+  const flags = buildClaudeFlags({ model, autoApprove: true });
   const flagsStr = flags.join(" ");
 
   // Create tmux session with the agent and banner
-  const agentCmd = `${provider.command} ${flagsStr}`;
+  const agentCmd = `${CLAUDE_COMMAND} ${flagsStr}`;
   const newSessionCmd = wrapWithBanner(agentCmd);
   const createCmd = `tmux set -g mouse on 2>/dev/null; tmux new-session -d -s "${tmuxSessionName}" -c "${cwd}" "${newSessionCmd}"`;
 
@@ -270,16 +270,12 @@ export async function getWorkers(
   const workerInfos: WorkerInfo[] = [];
 
   for (const worker of workers) {
-    const provider = getProvider(worker.agent_type || "claude");
-    const tmuxSessionName = worker.tmux_name || `${provider.id}-${worker.id}`;
+    const tmuxSessionName = worker.tmux_name || `claude-${worker.id}`;
 
-    // Get live status from tmux
-    let liveStatus: string;
-    try {
-      liveStatus = await statusDetector.getStatus(tmuxSessionName);
-    } catch {
-      liveStatus = "dead";
-    }
+    // Get live status from cached monitor snapshot
+    const sessionId = getSessionIdFromName(tmuxSessionName);
+    const snapshot = getStatusSnapshot();
+    const liveStatus = snapshot[sessionId]?.status || "dead";
 
     // Combine DB status with live status
     let status: WorkerInfo["status"];
@@ -320,8 +316,7 @@ export async function getWorkerOutput(
     throw new Error(`Worker ${workerId} not found`);
   }
 
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+  const tmuxSessionName = session.tmux_name || `claude-${workerId}`;
 
   try {
     const { stdout } = await execAsync(
@@ -345,8 +340,7 @@ export async function sendToWorker(
     throw new Error(`Worker ${workerId} not found`);
   }
 
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+  const tmuxSessionName = session.tmux_name || `claude-${workerId}`;
 
   try {
     const escapedMessage = message.replace(/"/g, '\\"').replace(/\$/g, "\\$");
@@ -385,8 +379,7 @@ export async function killWorker(
     return;
   }
 
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+  const tmuxSessionName = session.tmux_name || `claude-${workerId}`;
 
   // Kill tmux session
   try {

package/lib/providers/registry.ts

@@ -1,67 +1,13 @@
-export const PROVIDER_IDS = ["claude"] as const;
-
-export type ProviderId = (typeof PROVIDER_IDS)[number];
-
-export interface ProviderDefinition {
-  id: ProviderId;
-  name: string;
-  description: string;
-  cli: string;
-  configDir: string;
-  autoApproveFlag?: string;
-  supportsResume: boolean;
-  supportsFork: boolean;
-  resumeFlag?: string;
-  modelFlag?: string;
-  initialPromptFlag?: string;
-  defaultArgs?: string[];
-}
-
-export const PROVIDERS: ProviderDefinition[] = [
-  {
-    id: "claude",
-    name: "Claude Code",
-    description: "Anthropic's official CLI",
-    cli: "claude",
-    configDir: "~/.claude",
-    autoApproveFlag: "--dangerously-skip-permissions",
-    supportsResume: true,
-    supportsFork: true,
-    resumeFlag: "--resume",
-    initialPromptFlag: "",
-  },
-];
-
-export const PROVIDER_MAP = new Map<ProviderId, ProviderDefinition>(
-  PROVIDERS.map((provider) => [provider.id, provider])
-);
-
-export function getProviderDefinition(id: ProviderId): ProviderDefinition {
-  const provider = PROVIDER_MAP.get(id);
-  if (!provider) {
-    throw new Error(`Unknown provider: ${id}`);
-  }
-  return provider;
-}
-
-export function getAllProviderDefinitions(): ProviderDefinition[] {
-  return PROVIDERS;
-}
-
-export function isValidProviderId(value: string): value is ProviderId {
-  return PROVIDER_MAP.has(value as ProviderId);
-}
+export type ProviderId = "claude";
 
 export function getManagedSessionPattern(): RegExp {
-  return /^claude-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return /^claude-(new-)?[0-9a-z]{4,}/i;
 }
 
 export function getProviderIdFromSessionName(
   sessionName: string
 ): ProviderId | null {
-  if (sessionName.startsWith("claude-")) {
-    return "claude";
-  }
+  if (sessionName.startsWith("claude-")) return "claude";
   return null;
 }