@cmdctrl/claude-code 0.1.0

package/src/adapter/events.ts

@@ -0,0 +1,186 @@
+/**
+ * Types for Claude CLI stream-json output
+ */
+
+export interface StreamEvent {
+  type: 'system' | 'assistant' | 'result' | 'user';
+  subtype?: string;
+  session_id?: string;
+  message?: MessageContent;
+  result?: string;
+  permission_denials?: PermissionDenial[];
+}
+
+export interface MessageContent {
+  content: ContentBlock[];
+}
+
+export interface ContentBlock {
+  type: 'text' | 'tool_use' | 'tool_result' | 'thinking';
+  text?: string;
+  name?: string;
+  input?: unknown;
+  id?: string;
+}
+
+export interface PermissionDenial {
+  tool_name: string;
+  id: string;
+}
+
+export interface AskUserInput {
+  questions: Question[];
+}
+
+export interface Question {
+  question: string;
+  header?: string;
+  options: QuestionOption[];
+  multiSelect?: boolean;
+}
+
+export interface QuestionOption {
+  label: string;
+  description?: string;
+}
+
+export interface ProgressInfo {
+  action: string;
+  target: string;
+}
+
+/**
+ * Format raw stream output into human-readable string for verbose display
+ * Returns null if the event should be skipped
+ */
+export function formatVerboseOutput(line: string): string | null {
+  try {
+    const data = JSON.parse(line) as StreamEvent;
+
+    if (data.type === 'system' && data.subtype === 'init') {
+      return '● Task started';
+    }
+
+    if (data.type === 'assistant' && data.message?.content) {
+      // Check for text content first
+      const texts = data.message.content
+        .filter(c => c.type === 'text' && c.text)
+        .map(c => c.text!.substring(0, 100));
+      if (texts.length > 0) {
+        const joined = texts.join(' ');
+        const truncated = joined.length > 80 ? joined.substring(0, 80) + '...' : joined;
+        return `💬 ${truncated}`;
+      }
+
+      // Check for tool use
+      const tools = data.message.content.filter(c => c.type === 'tool_use');
+      if (tools.length > 0) {
+        const tool = tools[0];
+        const name = tool.name || 'unknown';
+        const input = tool.input as Record<string, unknown> | undefined;
+
+        switch (name) {
+          case 'Read': return `📖 Reading ${input?.file_path || 'file'}`;
+          case 'Write': return `✏️ Writing ${input?.file_path || 'file'}`;
+          case 'Edit': return `🔧 Editing ${input?.file_path || 'file'}`;
+          case 'Bash': {
+            const cmd = String(input?.command || '').substring(0, 60);
+            return `⚡ ${cmd}`;
+          }
+          case 'Glob': return `🔍 Searching: ${input?.pattern || ''}`;
+          case 'Grep': return `🔎 Grepping: ${input?.pattern || ''}`;
+          case 'Task': return `📋 Spawning agent`;
+          case 'TodoWrite': return `📝 Updating todos`;
+          case 'WebSearch': return `🌐 Searching: ${input?.query || ''}`;
+          case 'WebFetch': return `🌐 Fetching: ${input?.url || ''}`;
+          default: return `🔧 ${name}`;
+        }
+      }
+    }
+
+    if (data.type === 'result') {
+      // Check for permission denials
+      if (data.permission_denials?.length) {
+        const denial = data.permission_denials[0];
+        const toolName = denial.tool_name;
+        if (toolName === 'AskUserQuestion') {
+          return '❓ Waiting for your input';
+        } else {
+          return `⚠️ Permission required: ${toolName}`;
+        }
+      }
+      return '✓ Completed';
+    }
+
+    // Skip uninteresting events
+    return null;
+  } catch {
+    // Not JSON - show raw if short enough
+    const trimmed = line.trim();
+    if (trimmed && trimmed.length < 100) {
+      return trimmed;
+    }
+    return null;
+  }
+}
+
+/**
+ * Extract progress info from tool use
+ */
+export function extractProgressFromToolUse(
+  toolName: string,
+  input: unknown
+): ProgressInfo | null {
+  const inputObj = input as Record<string, unknown>;
+
+  switch (toolName) {
+    case 'Read':
+      return {
+        action: 'Reading',
+        target: (inputObj?.file_path as string) || 'file'
+      };
+    case 'Write':
+      return {
+        action: 'Writing',
+        target: (inputObj?.file_path as string) || 'file'
+      };
+    case 'Edit':
+      return {
+        action: 'Editing',
+        target: (inputObj?.file_path as string) || 'file'
+      };
+    case 'Bash':
+      const cmd = (inputObj?.command as string) || '';
+      return {
+        action: 'Running',
+        target: cmd.length > 30 ? cmd.substring(0, 30) + '...' : cmd
+      };
+    case 'Glob':
+      return {
+        action: 'Searching',
+        target: (inputObj?.pattern as string) || 'files'
+      };
+    case 'Grep':
+      return {
+        action: 'Searching',
+        target: (inputObj?.pattern as string) || 'pattern'
+      };
+    case 'WebSearch':
+      return {
+        action: 'Searching web',
+        target: (inputObj?.query as string) || ''
+      };
+    case 'WebFetch':
+      return {
+        action: 'Fetching',
+        target: (inputObj?.url as string) || 'URL'
+      };
+    case 'Task':
+      return {
+        action: 'Running agent',
+        target: (inputObj?.description as string) || ''
+      };
+    default:
+      return null;
+  }
+}

package/src/client/messages.ts

@@ -0,0 +1,193 @@
+/**
+ * Message types for daemon <-> server communication
+ */
+
+// Server -> Daemon messages
+
+export interface PingMessage {
+  type: 'ping';
+}
+
+export interface TaskStartMessage {
+  type: 'task_start';
+  task_id: string;
+  instruction: string;
+  project_path?: string;
+}
+
+export interface TaskResumeMessage {
+  type: 'task_resume';
+  task_id: string;
+  session_id: string;
+  message: string;
+  project_path?: string;
+}
+
+export interface TaskCancelMessage {
+  type: 'task_cancel';
+  task_id: string;
+}
+
+export interface GetMessagesMessage {
+  type: 'get_messages';
+  request_id: string;
+  session_id: string;
+  limit: number;
+  before_uuid?: string; // Cursor for backwards pagination (load older)
+  after_uuid?: string;  // Cursor for forwards pagination (load newer)
+}
+
+export interface WatchSessionMessage {
+  type: 'watch_session';
+  session_id: string;
+  file_path: string;
+}
+
+export interface UnwatchSessionMessage {
+  type: 'unwatch_session';
+  session_id: string;
+}
+
+export interface ContextRequestMessage {
+  type: 'context_request';
+  request_id: string;
+  session_id: string;
+  include: {
+    initial_prompt?: boolean;
+    recent_messages?: number;  // Number of recent messages to include
+    last_tool_use?: boolean;
+  };
+}
+
+export type ServerMessage =
+  | PingMessage
+  | TaskStartMessage
+  | TaskResumeMessage
+  | TaskCancelMessage
+  | GetMessagesMessage
+  | WatchSessionMessage
+  | UnwatchSessionMessage
+  | ContextRequestMessage;
+
+// Daemon -> Server messages
+
+export interface PongMessage {
+  type: 'pong';
+}
+
+export interface StatusMessage {
+  type: 'status';
+  running_tasks: string[];
+}
+
+export interface EventMessage {
+  type: 'event';
+  task_id: string;
+  event_type: string;
+  [key: string]: unknown;
+}
+
+export interface SessionInfo {
+  session_id: string;
+  slug: string;
+  title: string;
+  project: string;
+  project_name: string;
+  file_path: string;
+  last_message: string;
+  last_activity: string;
+  is_active: boolean;
+  message_count: number;
+}
+
+export interface ReportSessionsMessage {
+  type: 'report_sessions';
+  sessions: SessionInfo[];
+}
+
+export interface MessageEntry {
+  uuid: string;
+  role: 'USER' | 'AGENT' | 'SYSTEM';
+  content: string;
+  timestamp: string;
+}
+
+export interface MessagesResponseMessage {
+  type: 'messages';
+  request_id: string;
+  session_id: string;
+  messages: MessageEntry[];
+  has_more: boolean;
+  oldest_uuid?: string;
+  newest_uuid?: string;
+  error?: string;
+}
+
+export interface SessionActivityMessage {
+  type: 'session_activity';
+  session_id: string;
+  file_path: string;
+  last_message: string;
+  message_count: number;
+  is_completion: boolean;  // True when last message is from assistant (agent finished)
+  user_message_uuid?: string;  // UUID of the triggering user message (for positioning verbose output)
+  last_activity: string;  // ISO timestamp of the last message (not file mtime)
+}
+
+// Session status for dashboard summaries
+export type SessionStatus = 'working' | 'waiting_for_input' | 'completed' | 'errored' | 'stale';
+
+export interface SessionStatusMessage {
+  type: 'session_status';
+  session_id: string;
+  status: SessionStatus;
+  status_detail?: string;  // e.g., "Asked: Which database should I use?"
+  last_tool_use?: string;  // e.g., "Read file: schema.sql"
+  message_count: number;
+  elapsed_minutes: number;
+}
+
+export interface ContextResponseMessage {
+  type: 'context_response';
+  request_id: string;
+  session_id: string;
+  context: {
+    title: string;
+    project_path: string;
+    initial_prompt?: string;
+    recent_messages?: Array<{
+      role: 'USER' | 'AGENT';
+      content: string;
+    }>;
+    last_tool_use?: string;
+    message_count: number;
+    started_at?: string;
+    last_activity_at: string;
+    status: SessionStatus;
+    status_detail?: string;
+  };
+  error?: string;
+}
+
+export type DaemonMessage =
+  | PongMessage
+  | StatusMessage
+  | EventMessage
+  | ReportSessionsMessage
+  | MessagesResponseMessage
+  | SessionActivityMessage
+  | SessionStatusMessage
+  | ContextResponseMessage;
+
+// Event types sent from daemon to server
+export type EventType =
+  | 'SESSION_STARTED'  // Internal: triggers file watching (not sent to server)
+  | 'WAIT_FOR_USER'
+  | 'TASK_COMPLETE'
+  | 'OUTPUT'           // Legacy: verbose output from CLI stream (being phased out)
+  | 'PROGRESS'
+  | 'ERROR'
+  // New JSONL-based event types
+  | 'AGENT_RESPONSE'   // Assistant entry with text content
+  | 'VERBOSE'          // Tool use, thinking, tool result
+  | 'USER_MESSAGE';    // User message (for passive observers)