@atercates/claude-deck 0.2.1

package/lib/notifications.ts

@@ -0,0 +1,219 @@
+// Notification utilities for ClaudeDeck
+
+export type NotificationEvent = "waiting" | "error" | "completed";
+
+export interface NotificationSettings {
+  enabled: boolean;
+  browserNotifications: boolean;
+  sound: boolean;
+  events: {
+    waiting: boolean;
+    error: boolean;
+    completed: boolean;
+  };
+}
+
+export const defaultSettings: NotificationSettings = {
+  enabled: true,
+  browserNotifications: true,
+  sound: true,
+  events: {
+    waiting: true,
+    error: true,
+    completed: false, // Off by default - can be noisy
+  },
+};
+
+const SETTINGS_KEY = "agentosNotificationSettings";
+
+export function loadSettings(): NotificationSettings {
+  if (typeof window === "undefined") return defaultSettings;
+  try {
+    const stored = localStorage.getItem(SETTINGS_KEY);
+    if (stored) {
+      return { ...defaultSettings, ...JSON.parse(stored) };
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return defaultSettings;
+}
+
+export function saveSettings(settings: NotificationSettings): void {
+  if (typeof window === "undefined") return;
+  localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+}
+
+export async function requestNotificationPermission(): Promise<boolean> {
+  if (typeof window === "undefined" || !("Notification" in window)) {
+    return false;
+  }
+
+  if (Notification.permission === "granted") {
+    return true;
+  }
+
+  if (Notification.permission === "denied") {
+    return false;
+  }
+
+  const permission = await Notification.requestPermission();
+  return permission === "granted";
+}
+
+export function canSendBrowserNotification(): boolean {
+  if (typeof window === "undefined" || !("Notification" in window)) {
+    return false;
+  }
+  return Notification.permission === "granted";
+}
+
+export function sendBrowserNotification(
+  title: string,
+  options?: NotificationOptions,
+  onClick?: () => void
+): Notification | null {
+  if (!canSendBrowserNotification()) return null;
+
+  // Only send if page is not focused
+  if (document.hasFocus()) return null;
+
+  const notification = new Notification(title, {
+    icon: "/favicon.ico",
+    badge: "/favicon.ico",
+    ...options,
+  });
+
+  // Auto-close after 5 seconds
+  setTimeout(() => notification.close(), 5000);
+
+  // Focus window and trigger callback when clicked
+  notification.onclick = () => {
+    window.focus();
+    notification.close();
+    onClick?.();
+  };
+
+  return notification;
+}
+
+// Audio notification
+let audioContext: AudioContext | null = null;
+
+export function playNotificationSound(
+  type: NotificationEvent = "waiting"
+): void {
+  if (typeof window === "undefined") return;
+
+  try {
+    if (!audioContext) {
+      audioContext = new AudioContext();
+    }
+
+    const oscillator = audioContext.createOscillator();
+    const gainNode = audioContext.createGain();
+
+    oscillator.connect(gainNode);
+    gainNode.connect(audioContext.destination);
+
+    // Different tones for different events
+    const frequencies: Record<NotificationEvent, number[]> = {
+      waiting: [800, 600], // Two-tone descending (needs attention)
+      error: [300, 200], // Low tones (error)
+      completed: [600, 800], // Two-tone ascending (success)
+    };
+
+    const freqs = frequencies[type];
+    const duration = 0.1;
+
+    gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);
+
+    freqs.forEach((freq, i) => {
+      const startTime = audioContext!.currentTime + i * duration;
+      oscillator.frequency.setValueAtTime(freq, startTime);
+    });
+
+    gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);
+    gainNode.gain.exponentialRampToValueAtTime(
+      0.01,
+      audioContext.currentTime + freqs.length * duration
+    );
+
+    oscillator.start(audioContext.currentTime);
+    oscillator.stop(audioContext.currentTime + freqs.length * duration);
+  } catch {
+    // Audio not available
+  }
+}
+
+// Tab title/badge management
+let originalTitle = "";
+let notificationCount = 0;
+let titleInterval: NodeJS.Timeout | null = null;
+
+export function setTabNotificationCount(count: number): void {
+  if (typeof window === "undefined") return;
+
+  if (!originalTitle) {
+    originalTitle = document.title.replace(/^\(\d+\)\s*/, "");
+  }
+
+  notificationCount = count;
+
+  if (count > 0) {
+    document.title = `(${count}) ${originalTitle}`;
+  } else {
+    document.title = originalTitle;
+  }
+}
+
+export function flashTabTitle(message: string): void {
+  if (typeof window === "undefined") return;
+
+  if (!originalTitle) {
+    originalTitle = document.title.replace(/^\(\d+\)\s*/, "");
+  }
+
+  // Clear existing flash
+  if (titleInterval) {
+    clearInterval(titleInterval);
+  }
+
+  let showMessage = true;
+  titleInterval = setInterval(() => {
+    if (document.hasFocus()) {
+      // Stop flashing when focused
+      if (titleInterval) clearInterval(titleInterval);
+      document.title =
+        notificationCount > 0
+          ? `(${notificationCount}) ${originalTitle}`
+          : originalTitle;
+      return;
+    }
+
+    document.title = showMessage ? message : originalTitle;
+    showMessage = !showMessage;
+  }, 1000);
+
+  // Stop after 30 seconds
+  setTimeout(() => {
+    if (titleInterval) {
+      clearInterval(titleInterval);
+      document.title =
+        notificationCount > 0
+          ? `(${notificationCount}) ${originalTitle}`
+          : originalTitle;
+    }
+  }, 30000);
+}
+
+export function clearTabNotifications(): void {
+  if (titleInterval) {
+    clearInterval(titleInterval);
+    titleInterval = null;
+  }
+  notificationCount = 0;
+  if (originalTitle) {
+    document.title = originalTitle;
+  }
+}

package/lib/orchestration.ts

@@ -0,0 +1,448 @@
+/**
+ * Orchestration System
+ *
+ * Allows a "conductor" session to spawn and manage worker sessions.
+ * Each worker gets its own git worktree for isolation.
+ */
+
+import { randomUUID } from "crypto";
+import { exec } from "child_process";
+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 { wrapWithBanner } from "./banner";
+import { runInBackground } from "./async-operations";
+
+const execAsync = promisify(exec);
+
+export interface SpawnWorkerOptions {
+  conductorSessionId: string;
+  task: string;
+  workingDirectory: string;
+  branchName?: string;
+  useWorktree?: boolean;
+  model?: string;
+  agentType?: AgentType;
+}
+
+export interface WorkerInfo {
+  id: string;
+  name: string;
+  task: string;
+  status:
+    | "pending"
+    | "running"
+    | "waiting"
+    | "idle"
+    | "completed"
+    | "failed"
+    | "dead";
+  worktreePath: string | null;
+  branchName: string | null;
+  createdAt: string;
+}
+
+/**
+ * Generate a unique branch name from a task description
+ */
+function taskToBranchName(task: string): string {
+  const base =
+    task
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, "")
+      .split(/\s+/)
+      .slice(0, 4)
+      .join("-")
+      .slice(0, 30) || "worker";
+
+  // Add short unique suffix to avoid conflicts
+  const suffix = Date.now().toString(36).slice(-4);
+  return `${base}-${suffix}`;
+}
+
+/**
+ * Generate a short session name from a task description
+ */
+function taskToSessionName(task: string): string {
+  // Take first 50 chars, trim to last complete word
+  const truncated = task.slice(0, 50);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > 20 ? truncated.slice(0, lastSpace) : truncated;
+}
+
+/**
+ * Spawn a new worker session
+ */
+export async function spawnWorker(
+  options: SpawnWorkerOptions
+): Promise<Session> {
+  const {
+    conductorSessionId,
+    task,
+    workingDirectory: rawWorkingDir,
+    branchName = taskToBranchName(task),
+    useWorktree = true,
+    model = "sonnet",
+    agentType = "claude",
+  } = options;
+
+  // Expand ~ to home directory
+  const workingDirectory = rawWorkingDir.replace(/^~/, process.env.HOME || "");
+
+  const sessionId = randomUUID();
+  const sessionName = taskToSessionName(task);
+  const provider = getProvider(agentType);
+
+  let worktreePath: string | null = null;
+  let actualWorkingDir = workingDirectory;
+
+  // Create worktree if requested
+  if (useWorktree) {
+    try {
+      const worktreeResult = await createWorktree({
+        projectPath: workingDirectory,
+        featureName: branchName,
+      });
+      worktreePath = worktreeResult.worktreePath;
+      actualWorkingDir = worktreePath;
+
+      // Set up environment in background (copy .env files, install deps)
+      const capturedWorktreePath = worktreePath;
+      const capturedSourcePath = workingDirectory;
+      runInBackground(async () => {
+        const result = await setupWorktree({
+          worktreePath: capturedWorktreePath,
+          sourcePath: capturedSourcePath,
+        });
+        console.log("Worker worktree setup completed:", {
+          worktreePath: capturedWorktreePath,
+          envFilesCopied: result.envFilesCopied,
+          stepsRun: result.steps.length,
+          success: result.success,
+        });
+      }, `setup-worker-worktree-${sessionId}`);
+    } catch (error) {
+      console.error("Failed to create worktree:", error);
+      // Fall back to same directory (no isolation)
+    }
+  }
+
+  // Create session in database
+  const tmuxName = `${provider.id}-${sessionId}`;
+  await queries.createWorkerSession(
+    sessionId,
+    sessionName,
+    tmuxName,
+    actualWorkingDir,
+    conductorSessionId,
+    task,
+    model,
+    "sessions", // group_path
+    agentType,
+    "uncategorized" // project_id
+  );
+
+  // Update worktree info if created
+  if (worktreePath) {
+    await queries.updateSessionWorktree(
+      worktreePath,
+      branchName,
+      "main", // base_branch
+      null, // dev_server_port
+      sessionId
+    );
+  }
+
+  // Create tmux session and start the agent
+  const tmuxSessionName = `${provider.id}-${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 flagsStr = flags.join(" ");
+
+  // Create tmux session with the agent and banner
+  const agentCmd = `${provider.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}"`;
+
+  try {
+    await execAsync(createCmd);
+
+    // Wait for Claude to be ready by checking for the input prompt
+    // Poll every 2 seconds for up to 30 seconds
+    const maxWaitMs = 30000;
+    const pollIntervalMs = 2000;
+    let waited = 0;
+    let ready = false;
+
+    console.log(
+      `[orchestration] Waiting for Claude to initialize in ${tmuxSessionName}...`
+    );
+
+    while (waited < maxWaitMs && !ready) {
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      waited += pollIntervalMs;
+
+      try {
+        const { stdout } = await execAsync(
+          `tmux capture-pane -t '${tmuxSessionName}' -p -S -10 2>/dev/null`
+        );
+        const content = stdout.toLowerCase();
+
+        // Check for trust/permissions prompt and auto-accept
+        // Claude shows "Ready to code here?" with "Yes, continue" option - just press Enter
+        if (
+          content.includes("ready to code here") ||
+          content.includes("yes, continue") ||
+          content.includes("need permission to work")
+        ) {
+          console.log(
+            `[orchestration] Trust prompt detected, pressing Enter to accept`
+          );
+          await execAsync(`tmux send-keys -t '${tmuxSessionName}' Enter`);
+          continue; // Keep waiting for the real prompt
+        }
+
+        // Look for Claude's ready state - the "? for shortcuts" line indicates fully loaded
+        const lines = stdout.trim().split("\n");
+        const lastFewLines = lines.slice(-3).join("\n");
+        if (
+          lastFewLines.includes("? for shortcuts") ||
+          lastFewLines.includes("?>")
+        ) {
+          ready = true;
+          console.log(`[orchestration] Claude ready after ${waited}ms`);
+        }
+      } catch {
+        // Session might not be ready yet
+      }
+    }
+
+    if (!ready) {
+      console.log(
+        `[orchestration] Timed out waiting for Claude, sending task anyway after ${waited}ms`
+      );
+    }
+
+    // Send the task as input, then press Enter
+    const escapedTask = task.replace(/'/g, "'\\''"); // Escape single quotes for shell
+    console.log(
+      `[orchestration] Sending task to ${tmuxSessionName}: "${task}"`
+    );
+    try {
+      await execAsync(
+        `tmux send-keys -t '${tmuxSessionName}' -l '${escapedTask}'`
+      );
+      await execAsync(`tmux send-keys -t '${tmuxSessionName}' Enter`);
+      console.log(
+        `[orchestration] Task sent successfully to ${tmuxSessionName}`
+      );
+    } catch (sendError) {
+      console.error(
+        `[orchestration] Failed to send task to ${tmuxSessionName}:`,
+        sendError
+      );
+    }
+
+    // Update worker status to running
+    await queries.updateWorkerStatus("running", sessionId);
+  } catch (error) {
+    console.error("Failed to start worker session:", error);
+    await queries.updateWorkerStatus("failed", sessionId);
+  }
+
+  return (await queries.getSession(sessionId))!;
+}
+
+/**
+ * Get all workers for a conductor session
+ */
+export async function getWorkers(
+  conductorSessionId: string
+): Promise<WorkerInfo[]> {
+  const workers = await queries.getWorkersByConductor(conductorSessionId);
+
+  // Get live status for each worker
+  const workerInfos: WorkerInfo[] = [];
+
+  for (const worker of workers) {
+    const provider = getProvider(worker.agent_type || "claude");
+    const tmuxSessionName = worker.tmux_name || `${provider.id}-${worker.id}`;
+
+    // Get live status from tmux
+    let liveStatus: string;
+    try {
+      liveStatus = await statusDetector.getStatus(tmuxSessionName);
+    } catch {
+      liveStatus = "dead";
+    }
+
+    // Combine DB status with live status
+    let status: WorkerInfo["status"];
+    if (
+      worker.worker_status === "completed" ||
+      worker.worker_status === "failed"
+    ) {
+      status = worker.worker_status;
+    } else if (liveStatus === "dead") {
+      status = "dead";
+    } else {
+      status = liveStatus as WorkerInfo["status"];
+    }
+
+    workerInfos.push({
+      id: worker.id,
+      name: worker.name,
+      task: worker.worker_task || "",
+      status,
+      worktreePath: worker.worktree_path,
+      branchName: worker.branch_name,
+      createdAt: worker.created_at,
+    });
+  }
+
+  return workerInfos;
+}
+
+/**
+ * Get recent output from a worker's terminal
+ */
+export async function getWorkerOutput(
+  workerId: string,
+  lines: number = 50
+): Promise<string> {
+  const session = await queries.getSession(workerId);
+  if (!session) {
+    throw new Error(`Worker ${workerId} not found`);
+  }
+
+  const provider = getProvider(session.agent_type || "claude");
+  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+
+  try {
+    const { stdout } = await execAsync(
+      `tmux capture-pane -t "${tmuxSessionName}" -p -S -${lines} 2>/dev/null || echo ""`
+    );
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Send a message/command to a worker
+ */
+export async function sendToWorker(
+  workerId: string,
+  message: string
+): Promise<boolean> {
+  const session = await queries.getSession(workerId);
+  if (!session) {
+    throw new Error(`Worker ${workerId} not found`);
+  }
+
+  const provider = getProvider(session.agent_type || "claude");
+  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+
+  try {
+    const escapedMessage = message.replace(/"/g, '\\"').replace(/\$/g, "\\$");
+    await execAsync(
+      `tmux send-keys -t "${tmuxSessionName}" "${escapedMessage}" Enter`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Mark a worker as completed
+ */
+export async function completeWorker(workerId: string): Promise<void> {
+  await queries.updateWorkerStatus("completed", workerId);
+}
+
+/**
+ * Mark a worker as failed
+ */
+export async function failWorker(workerId: string): Promise<void> {
+  await queries.updateWorkerStatus("failed", workerId);
+}
+
+/**
+ * Kill a worker session and optionally clean up its worktree
+ */
+export async function killWorker(
+  workerId: string,
+  cleanupWorktree: boolean = false
+): Promise<void> {
+  const session = await queries.getSession(workerId);
+  if (!session) {
+    return;
+  }
+
+  const provider = getProvider(session.agent_type || "claude");
+  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
+
+  // Kill tmux session
+  try {
+    await execAsync(
+      `tmux kill-session -t "${tmuxSessionName}" 2>/dev/null || true`
+    );
+  } catch {
+    // Ignore errors
+  }
+
+  // Clean up worktree if requested
+  // Note: This requires knowing the original project path, which we derive from git
+  if (cleanupWorktree && session.worktree_path) {
+    try {
+      // Get the main worktree (original project) from git
+      const { stdout } = await execAsync(
+        `git -C "${session.worktree_path}" worktree list --porcelain | head -1 | sed 's/worktree //'`
+      );
+      const projectPath = stdout.trim();
+      if (projectPath && projectPath !== session.worktree_path) {
+        await deleteWorktree(session.worktree_path, projectPath, true);
+      }
+    } catch (error) {
+      console.error("Failed to delete worktree:", error);
+      // Fallback: just remove the directory
+      try {
+        await execAsync(`rm -rf "${session.worktree_path}"`);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  await queries.updateWorkerStatus("failed", workerId);
+}
+
+/**
+ * Get a summary of all workers' statuses
+ */
+export async function getWorkersSummary(conductorSessionId: string): Promise<{
+  total: number;
+  pending: number;
+  running: number;
+  waiting: number;
+  completed: number;
+  failed: number;
+}> {
+  const workers = await getWorkers(conductorSessionId);
+
+  return {
+    total: workers.length,
+    pending: workers.filter((w) => w.status === "pending").length,
+    running: workers.filter((w) => w.status === "running").length,
+    waiting: workers.filter((w) => w.status === "waiting").length,
+    completed: workers.filter((w) => w.status === "completed").length,
+    failed: workers.filter((w) => w.status === "failed" || w.status === "dead")
+      .length,
+  };
+}