@cmdctrl/claude-code 0.1.0

package/src/commands/start.ts

@@ -0,0 +1,70 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  writePidFile,
+  isDaemonRunning
+} from '../config/config';
+import { DaemonClient } from '../client/websocket';
+
+interface StartOptions {
+  foreground?: boolean;
+}
+
+/**
+ * Start command - launch the daemon and connect to server
+ */
+export async function start(options: StartOptions): Promise<void> {
+  // Check registration
+  if (!isRegistered()) {
+    console.error('Device not registered. Run "cmdctrl-claude-code-daemon register" first.');
+    process.exit(1);
+  }
+
+  // Check if already running
+  if (isDaemonRunning()) {
+    console.error('Daemon is already running. Run "cmdctrl-claude-code-daemon stop" first.');
+    process.exit(1);
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials()!;
+
+  console.log(`Starting CmdCtrl daemon...`);
+  console.log(`Server: ${config.serverUrl}`);
+  console.log(`Device: ${config.deviceName} (${config.deviceId})`);
+
+  // Write PID file
+  writePidFile(process.pid);
+
+  // Create and start client
+  const client = new DaemonClient(config, credentials);
+
+  // Handle shutdown signals
+  const shutdown = async () => {
+    console.log('\nShutting down...');
+    await client.disconnect();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Connect and run
+  try {
+    await client.connect();
+    console.log('Connected to server.');
+
+    if (options.foreground) {
+      console.log('Running in foreground. Press Ctrl+C to stop.\n');
+    }
+
+    // Keep process alive - the WebSocket client handles events
+    await new Promise(() => {
+      // Never resolves - daemon runs until killed
+    });
+  } catch (err) {
+    console.error('Failed to start daemon:', err);
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,47 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  isDaemonRunning,
+  readPidFile
+} from '../config/config';
+
+/**
+ * Status command - check daemon and connection status
+ */
+export async function status(): Promise<void> {
+  console.log('CmdCtrl Daemon Status\n');
+
+  // Registration status
+  if (!isRegistered()) {
+    console.log('Registration: Not registered');
+    console.log('\nRun "cmdctrl-claude-code-daemon register" to register this device.');
+    return;
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials()!;
+
+  console.log('Registration: Registered');
+  console.log(`  Server: ${config.serverUrl}`);
+  console.log(`  Device: ${config.deviceName}`);
+  console.log(`  Device ID: ${config.deviceId}`);
+
+  // Token status
+  const tokenExpired = credentials.expiresAt < Date.now();
+  console.log(`\nToken: ${tokenExpired ? 'Expired' : 'Valid'}`);
+  if (!tokenExpired) {
+    const expiresIn = Math.round((credentials.expiresAt - Date.now()) / 1000 / 60);
+    console.log(`  Expires in: ${expiresIn} minutes`);
+  }
+
+  // Daemon status
+  const running = isDaemonRunning();
+  console.log(`\nDaemon: ${running ? 'Running' : 'Stopped'}`);
+  if (running) {
+    const pid = readPidFile();
+    console.log(`  PID: ${pid}`);
+  }
+
+  // TODO: Query daemon for actual connection status via local socket or HTTP
+}

package/src/commands/stop.ts

@@ -0,0 +1,58 @@
+import { isDaemonRunning, readPidFile, deletePidFile } from '../config/config';
+
+/**
+ * Stop command - stop the running daemon
+ */
+export async function stop(): Promise<void> {
+  if (!isDaemonRunning()) {
+    console.log('Daemon is not running.');
+    return;
+  }
+
+  const pid = readPidFile();
+  if (pid === null) {
+    console.log('No PID file found.');
+    return;
+  }
+
+  console.log(`Stopping daemon (PID ${pid})...`);
+
+  try {
+    // Send SIGTERM for graceful shutdown
+    process.kill(pid, 'SIGTERM');
+
+    // Wait for process to exit (up to 5 seconds)
+    let attempts = 0;
+    while (attempts < 50) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      try {
+        process.kill(pid, 0); // Check if still running
+        attempts++;
+      } catch {
+        // Process has exited
+        break;
+      }
+    }
+
+    // If still running after 5 seconds, force kill
+    try {
+      process.kill(pid, 0);
+      console.log('Daemon did not stop gracefully, sending SIGKILL...');
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Already dead, good
+    }
+
+    deletePidFile();
+    console.log('Daemon stopped.');
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
+      // Process doesn't exist
+      deletePidFile();
+      console.log('Daemon was not running (stale PID file removed).');
+    } else {
+      console.error('Failed to stop daemon:', err);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/unregister.ts

@@ -0,0 +1,30 @@
+import { readConfig, clearRegistration, isDaemonRunning } from '../config/config';
+
+/**
+ * Unregister command - removes local registration data
+ */
+export async function unregister(): Promise<void> {
+  const config = readConfig();
+
+  if (!config) {
+    console.log('Not registered.');
+    return;
+  }
+
+  // Check if daemon is running
+  if (isDaemonRunning()) {
+    console.error('Error: Daemon is currently running.');
+    console.error('Please stop the daemon first with: cmdctrl-claude-code stop');
+    process.exit(1);
+  }
+
+  console.log(`Unregistering device "${config.deviceName}" (${config.deviceId})...`);
+  console.log(`Server: ${config.serverUrl}`);
+
+  // Clear local registration data
+  clearRegistration();
+
+  console.log('\nLocal registration data cleared.');
+  console.log('Note: The device entry may still exist on the server.');
+  console.log('You can now register again with: cmdctrl-claude-code register -s <server-url>');
+}

package/src/config/config.ts

@@ -0,0 +1,163 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface CmdCtrlConfig {
+  serverUrl: string;
+  deviceId: string;
+  deviceName: string;
+}
+
+export interface Credentials {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number; // Unix timestamp
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.cmdctrl-claude-code');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials');
+const PID_FILE = path.join(CONFIG_DIR, 'daemon.pid');
+
+/**
+ * Ensure the config directory exists with proper permissions
+ */
+export function ensureConfigDir(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { mode: 0o700 });
+  }
+}
+
+/**
+ * Read the config file
+ */
+export function readConfig(): CmdCtrlConfig | null {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) {
+      return null;
+    }
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content) as CmdCtrlConfig;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the config file
+ */
+export function writeConfig(config: CmdCtrlConfig): void {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Read credentials (access/refresh tokens)
+ */
+export function readCredentials(): Credentials | null {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const content = fs.readFileSync(CREDENTIALS_FILE, 'utf-8');
+    return JSON.parse(content) as Credentials;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write credentials with restrictive permissions (600)
+ */
+export function writeCredentials(creds: Credentials): void {
+  ensureConfigDir();
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Delete credentials (for logout/revoke)
+ */
+export function deleteCredentials(): void {
+  if (fs.existsSync(CREDENTIALS_FILE)) {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  }
+}
+
+/**
+ * Delete config file
+ */
+export function deleteConfig(): void {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}
+
+/**
+ * Clear all registration data (config and credentials)
+ */
+export function clearRegistration(): void {
+  deleteConfig();
+  deleteCredentials();
+}
+
+/**
+ * Check if device is registered
+ */
+export function isRegistered(): boolean {
+  const config = readConfig();
+  const creds = readCredentials();
+  return config !== null && creds !== null && config.deviceId !== '';
+}
+
+/**
+ * Write daemon PID file
+ */
+export function writePidFile(pid: number): void {
+  ensureConfigDir();
+  fs.writeFileSync(PID_FILE, pid.toString(), { mode: 0o600 });
+}
+
+/**
+ * Read daemon PID
+ */
+export function readPidFile(): number | null {
+  try {
+    if (!fs.existsSync(PID_FILE)) {
+      return null;
+    }
+    const content = fs.readFileSync(PID_FILE, 'utf-8');
+    return parseInt(content, 10);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Delete PID file
+ */
+export function deletePidFile(): void {
+  if (fs.existsSync(PID_FILE)) {
+    fs.unlinkSync(PID_FILE);
+  }
+}
+
+/**
+ * Check if daemon is running
+ */
+export function isDaemonRunning(): boolean {
+  const pid = readPidFile();
+  if (pid === null) {
+    return false;
+  }
+  try {
+    // Signal 0 doesn't kill, just checks if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    // Process doesn't exist, clean up stale PID file
+    deletePidFile();
+    return false;
+  }
+}
+
+export { CONFIG_DIR, CONFIG_FILE, CREDENTIALS_FILE, PID_FILE };

package/src/handlers/context-handler.ts

@@ -0,0 +1,337 @@
+/**
+ * Context handler for extracting session context for dashboard summaries
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { findSessionFile } from '../message-reader';
+import { SessionStatus, ContextResponseMessage } from '../client/messages';
+
+interface JournalEntry {
+  type: string;
+  uuid?: string;
+  sessionId?: string;
+  timestamp?: string;
+  cwd?: string;
+  message?: {
+    role?: string;
+    content?: unknown;
+    stop_reason?: string;
+  };
+  // Tool use entries have different structure
+  name?: string;  // tool name for tool_use entries
+  input?: unknown;  // tool input
+}
+
+interface SessionContext {
+  title: string;
+  projectPath: string;
+  initialPrompt?: string;
+  recentMessages: Array<{ role: 'USER' | 'AGENT'; content: string }>;
+  lastToolUse?: string;
+  messageCount: number;
+  startedAt?: string;
+  lastActivityAt: string;
+  status: SessionStatus;
+  statusDetail?: string;
+}
+
+/**
+ * Extract readable text from message content (handles string or array of content blocks)
+ */
+function extractReadableText(content: unknown): string {
+  if (typeof content === 'string') {
+    return content.trim();
+  }
+
+  if (Array.isArray(content)) {
+    const textParts: string[] = [];
+    for (const block of content) {
+      if (typeof block === 'string') {
+        textParts.push(block);
+      } else if (block && typeof block === 'object') {
+        if (block.type === 'text' && typeof block.text === 'string') {
+          // Strip thinking tags
+          const text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>\s*/g, '').trim();
+          if (text) {
+            textParts.push(text);
+          }
+        }
+      }
+    }
+    return textParts.join(' ').trim();
+  }
+
+  if (content && typeof content === 'object' && 'text' in content) {
+    const text = (content as { text: unknown }).text;
+    if (typeof text === 'string') {
+      return text.trim();
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Detect if a message contains a question (agent asking user for input)
+ */
+function isQuestionToUser(content: string): { isQuestion: boolean; questionText?: string } {
+  // Common question patterns
+  const questionPatterns = [
+    /\?$/m,  // Ends with question mark
+    /^(should i|would you|do you|can you|shall i|which|what|how|where|when)/im,
+    /please (confirm|specify|provide|let me know|clarify)/i,
+    /waiting for (your|user) (input|response|confirmation)/i,
+  ];
+
+  for (const pattern of questionPatterns) {
+    if (pattern.test(content)) {
+      // Extract the first sentence/line that looks like a question
+      const lines = content.split('\n').filter(l => l.trim());
+      for (const line of lines) {
+        if (/\?$/.test(line.trim())) {
+          return { isQuestion: true, questionText: line.trim().slice(0, 100) };
+        }
+      }
+      return { isQuestion: true, questionText: content.slice(0, 100) };
+    }
+  }
+
+  return { isQuestion: false };
+}
+
+/**
+ * Extract context from a session JSONL file
+ */
+export function extractSessionContext(
+  sessionId: string,
+  options: {
+    includeInitialPrompt?: boolean;
+    recentMessagesCount?: number;
+    includeLastToolUse?: boolean;
+  } = {}
+): SessionContext | null {
+  const {
+    includeInitialPrompt = true,
+    recentMessagesCount = 10,
+    includeLastToolUse = true,
+  } = options;
+
+  const filePath = findSessionFile(sessionId);
+  if (!filePath) {
+    return null;
+  }
+
+  try {
+    const stat = fs.statSync(filePath);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    let title = '';
+    let projectPath = '';
+    let initialPrompt: string | undefined;
+    let lastToolUse: string | undefined;
+    let startedAt: string | undefined;
+    let lastActivityAt = stat.mtime.toISOString();
+    let status: SessionStatus = 'working';
+    let statusDetail: string | undefined;
+
+    const allMessages: Array<{ role: 'USER' | 'AGENT'; content: string; timestamp?: string }> = [];
+    let messageCount = 0;
+    let lastEntry: JournalEntry | null = null;
+    let lastAssistantContent = '';
+
+    for (const line of lines) {
+      try {
+        const entry: JournalEntry = JSON.parse(line);
+        lastEntry = entry;
+
+        // Extract metadata
+        if (entry.cwd && !projectPath) {
+          projectPath = entry.cwd;
+        }
+
+        if (entry.timestamp && !startedAt) {
+          startedAt = entry.timestamp;
+        }
+
+        if (entry.timestamp) {
+          lastActivityAt = entry.timestamp;
+        }
+
+        // Count and extract messages
+        if (entry.type === 'user' || entry.type === 'assistant') {
+          messageCount++;
+
+          const text = extractReadableText(entry.message?.content);
+          if (text) {
+            const role: 'USER' | 'AGENT' = entry.type === 'user' ? 'USER' : 'AGENT';
+            allMessages.push({ role, content: text, timestamp: entry.timestamp });
+
+            // Track first user message for initial prompt
+            if (entry.type === 'user' && !initialPrompt && includeInitialPrompt) {
+              initialPrompt = text;
+              // Generate title from first user message
+              const firstLine = text.split('\n')[0].trim();
+              title = firstLine.length > 50 ? firstLine.slice(0, 50) + '...' : firstLine;
+            }
+
+            // Track last assistant content for status detection
+            if (entry.type === 'assistant') {
+              lastAssistantContent = text;
+            }
+          }
+        }
+
+        // Track tool use
+        if (entry.type === 'tool_use' && includeLastToolUse && entry.name) {
+          // Format: "Read file: src/main.ts" or "Edit: src/main.ts"
+          let toolDesc = entry.name;
+          if (entry.input && typeof entry.input === 'object') {
+            const input = entry.input as Record<string, unknown>;
+            if (input.file_path) {
+              toolDesc = `${entry.name}: ${input.file_path}`;
+            } else if (input.path) {
+              toolDesc = `${entry.name}: ${input.path}`;
+            } else if (input.command) {
+              const cmd = String(input.command).slice(0, 50);
+              toolDesc = `${entry.name}: ${cmd}`;
+            }
+          }
+          lastToolUse = toolDesc;
+        }
+
+        // Also check for tool_use blocks within assistant messages
+        if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+          for (const block of entry.message.content as Array<{ type: string; name?: string; input?: unknown }>) {
+            if (block.type === 'tool_use' && block.name && includeLastToolUse) {
+              let toolDesc = block.name;
+              if (block.input && typeof block.input === 'object') {
+                const input = block.input as Record<string, unknown>;
+                if (input.file_path) {
+                  toolDesc = `${block.name}: ${input.file_path}`;
+                } else if (input.path) {
+                  toolDesc = `${block.name}: ${input.path}`;
+                } else if (input.command) {
+                  const cmd = String(input.command).slice(0, 50);
+                  toolDesc = `${block.name}: ${cmd}`;
+                }
+              }
+              lastToolUse = toolDesc;
+            }
+          }
+        }
+
+      } catch {
+        // Skip invalid JSON lines
+        continue;
+      }
+    }
+
+    // Determine status based on last entry
+    if (lastEntry) {
+      // Check if there's an error event
+      if (lastEntry.type === 'error') {
+        status = 'errored';
+        statusDetail = extractReadableText(lastEntry.message?.content) || 'Error occurred';
+      }
+      // Check if last message is from assistant with a question
+      else if (lastEntry.type === 'assistant' && lastAssistantContent) {
+        const { isQuestion, questionText } = isQuestionToUser(lastAssistantContent);
+        if (isQuestion) {
+          status = 'waiting_for_input';
+          statusDetail = questionText ? `Asked: ${questionText}` : 'Waiting for user input';
+        } else {
+          // Assistant responded without asking - could be completed or still working
+          const stopReason = lastEntry.message?.stop_reason;
+          if (stopReason === 'end_turn' || stopReason === null) {
+            // Check if it's a completion or still working based on tool use
+            const hasToolUse = Array.isArray(lastEntry.message?.content) &&
+              (lastEntry.message.content as Array<{ type: string }>).some(b => b.type === 'tool_use');
+            if (!hasToolUse && lastAssistantContent.length > 20) {
+              status = 'completed';
+              statusDetail = lastAssistantContent.slice(0, 100);
+            }
+          }
+        }
+      }
+      // Check for stale sessions (no activity in 30+ minutes)
+      const timeSinceActivity = Date.now() - stat.mtime.getTime();
+      if (timeSinceActivity > 30 * 60 * 1000 && status === 'working') {
+        status = 'stale';
+      }
+    }
+
+    // Get recent messages
+    const recentMessages = allMessages.slice(-recentMessagesCount).map(m => ({
+      role: m.role,
+      content: m.content.length > 500 ? m.content.slice(0, 500) + '...' : m.content,
+    }));
+
+    return {
+      title: title || sessionId.slice(0, 8),
+      projectPath: projectPath || path.dirname(filePath),
+      initialPrompt: includeInitialPrompt ? initialPrompt : undefined,
+      recentMessages,
+      lastToolUse: includeLastToolUse ? lastToolUse : undefined,
+      messageCount,
+      startedAt,
+      lastActivityAt,
+      status,
+      statusDetail,
+    };
+
+  } catch (err) {
+    console.error(`[ContextHandler] Failed to extract context for session ${sessionId}:`, err);
+    return null;
+  }
+}
+
+/**
+ * Build a context response message
+ */
+export function buildContextResponse(
+  requestId: string,
+  sessionId: string,
+  options: {
+    includeInitialPrompt?: boolean;
+    recentMessagesCount?: number;
+    includeLastToolUse?: boolean;
+  } = {}
+): ContextResponseMessage {
+  const context = extractSessionContext(sessionId, options);
+
+  if (!context) {
+    return {
+      type: 'context_response',
+      request_id: requestId,
+      session_id: sessionId,
+      context: {
+        title: '',
+        project_path: '',
+        message_count: 0,
+        last_activity_at: new Date().toISOString(),
+        status: 'stale',
+      },
+      error: `Session ${sessionId} not found`,
+    };
+  }
+
+  return {
+    type: 'context_response',
+    request_id: requestId,
+    session_id: sessionId,
+    context: {
+      title: context.title,
+      project_path: context.projectPath,
+      initial_prompt: context.initialPrompt,
+      recent_messages: context.recentMessages,
+      last_tool_use: context.lastToolUse,
+      message_count: context.messageCount,
+      started_at: context.startedAt,
+      last_activity_at: context.lastActivityAt,
+      status: context.status,
+      status_detail: context.statusDetail,
+    },
+  };
+}