@cmdctrl/cursor-ide 0.1.0

package/src/commands/start.ts

@@ -0,0 +1,106 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  writePidFile,
+  isDaemonRunning,
+  cursorDbExists,
+} from '../config/config';
+import { DaemonClient } from '../client/websocket';
+import { getCDPClient } from '../adapter/cdp-client';
+
+interface StartOptions {
+  foreground?: boolean;
+}
+
+/**
+ * Start command - launch the daemon and connect to server
+ */
+export async function start(options: StartOptions): Promise<void> {
+  // Set up global error handlers to catch silent crashes
+  process.on('uncaughtException', (err) => {
+    console.error('[FATAL] Uncaught exception:', err);
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('[FATAL] Unhandled promise rejection:', reason);
+    console.error('Promise:', promise);
+    process.exit(1);
+  });
+
+  // Check registration
+  if (!isRegistered()) {
+    console.error('Device not registered. Run "cmdctrl-cursor-ide register" first.');
+    process.exit(1);
+  }
+
+  // Check if already running
+  if (isDaemonRunning()) {
+    console.error('Daemon is already running. Run "cmdctrl-cursor-ide stop" first.');
+    process.exit(1);
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials()!;
+
+  console.log(`Starting CmdCtrl Cursor IDE daemon...`);
+  console.log(`Server: ${config.serverUrl}`);
+  console.log(`Device: ${config.deviceName} (${config.deviceId})`);
+
+  // Check if Cursor database exists
+  if (!cursorDbExists()) {
+    console.warn('\nWarning: Cursor database not found.');
+    console.warn('Make sure Cursor has been run at least once.');
+  }
+
+  // Check CDP availability
+  const cdp = getCDPClient();
+  const cdpAvailable = await cdp.isAvailable();
+  if (!cdpAvailable) {
+    console.warn('\nWarning: Cursor CDP not available.');
+    console.warn('To enable message injection, start Cursor with:');
+    console.warn('  /Applications/Cursor.app/Contents/MacOS/Cursor --remote-debugging-port=9222');
+    console.warn('\nContinuing with observation-only mode...');
+  } else {
+    console.log('\nCDP: Connected to Cursor');
+    const title = await cdp.getWindowTitle();
+    if (title) {
+      console.log(`  Active project: ${title}`);
+    }
+  }
+
+  // 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 CmdCtrl server.');
+
+    if (options.foreground) {
+      console.log('Running in foreground. Press Ctrl+C to stop.\n');
+    }
+
+    // Keep process alive
+    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,83 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  isDaemonRunning,
+  readPidFile,
+  cursorDbExists,
+} from '../config/config';
+import { getCDPClient } from '../adapter/cdp-client';
+import { getCursorDB } from '../adapter/cursor-db';
+
+/**
+ * Status command - check daemon and CDP connection status
+ */
+export async function status(): Promise<void> {
+  console.log('CmdCtrl Cursor IDE Daemon Status\n');
+
+  // Registration status
+  if (!isRegistered()) {
+    console.log('Registration: Not registered');
+    console.log('\nRun "cmdctrl-cursor-ide 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}`);
+  }
+
+  // Cursor database status
+  const dbExists = cursorDbExists();
+  console.log(`\nCursor Database: ${dbExists ? 'Found' : 'Not found'}`);
+  if (dbExists) {
+    try {
+      const db = getCursorDB();
+      const composers = db.getComposers();
+      console.log(`  Sessions: ${composers.length}`);
+    } catch (err) {
+      console.log(`  Error reading database: ${(err as Error).message}`);
+    }
+  }
+
+  // CDP status
+  console.log('\nCDP (Chrome DevTools Protocol):');
+  try {
+    const cdp = getCDPClient();
+    const available = await cdp.isAvailable();
+    if (available) {
+      console.log('  Status: Available');
+      const title = await cdp.getWindowTitle();
+      if (title) {
+        console.log(`  Active project: ${title}`);
+      }
+      const composerOpen = await cdp.isComposerOpen();
+      console.log(`  Composer panel: ${composerOpen ? 'Open' : 'Closed'}`);
+    } else {
+      console.log('  Status: Not available');
+      console.log('  To enable, start Cursor with:');
+      console.log('    /Applications/Cursor.app/Contents/MacOS/Cursor --remote-debugging-port=9222');
+    }
+  } catch (err) {
+    console.log(`  Status: Error - ${(err as Error).message}`);
+  }
+}

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/config/config.ts

@@ -0,0 +1,167 @@
+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-cursor-ide');
+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');
+
+// Cursor data paths (macOS)
+export const CURSOR_GLOBAL_STORAGE = path.join(
+  os.homedir(),
+  'Library/Application Support/Cursor/User/globalStorage/state.vscdb'
+);
+export const CURSOR_WORKSPACE_STORAGE = path.join(
+  os.homedir(),
+  'Library/Application Support/Cursor/User/workspaceStorage'
+);
+
+// CDP default port
+export const CDP_PORT = 9222;
+export const CDP_URL = `http://localhost:${CDP_PORT}`;
+
+/**
+ * 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);
+  }
+}
+
+/**
+ * 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;
+  }
+}
+
+/**
+ * Check if Cursor global storage database exists
+ */
+export function cursorDbExists(): boolean {
+  return fs.existsSync(CURSOR_GLOBAL_STORAGE);
+}
+
+export { CONFIG_DIR, CONFIG_FILE, CREDENTIALS_FILE, PID_FILE };

package/src/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { register } from './commands/register';
+import { start } from './commands/start';
+import { status } from './commands/status';
+import { stop } from './commands/stop';
+
+const program = new Command();
+
+program
+  .name('cmdctrl-cursor-ide')
+  .description('Cursor IDE daemon - connects Cursor sessions to the CmdCtrl orchestration server')
+  .version('0.1.0');
+
+program
+  .command('register')
+  .description('Register this device with a CmdCtrl server')
+  .option('-s, --server <url>', 'CmdCtrl server URL', 'http://localhost:4000')
+  .option('-n, --name <name>', 'Device name (defaults to hostname-cursor)')
+  .action(register);
+
+program
+  .command('start')
+  .description('Start the daemon and connect to the CmdCtrl server')
+  .option('-f, --foreground', 'Run in foreground (don\'t daemonize)')
+  .action(start);
+
+program
+  .command('status')
+  .description('Check daemon and CDP connection status')
+  .action(status);
+
+program
+  .command('stop')
+  .description('Stop the running daemon')
+  .action(stop);
+
+program.parse();

package/src/session-discovery.ts

@@ -0,0 +1,115 @@
+import { getCursorDB, ComposerInfo } from './adapter/cursor-db';
+
+export interface ExternalSession {
+  session_id: string;
+  slug: string;
+  title: string;
+  project: string;
+  project_name: string;
+  file_path: string; // For Cursor, this is the DB path
+  last_message: string;
+  last_activity: string;
+  is_active: boolean;
+  message_count: number;
+}
+
+/**
+ * Discover Cursor IDE sessions from the SQLite database
+ * Returns sessions in a format compatible with CmdCtrl's external session API
+ */
+export function discoverSessions(excludeSessionIds: Set<string> = new Set()): ExternalSession[] {
+  const cursorDb = getCursorDB();
+  const composers = cursorDb.getComposers();
+  const sessions: ExternalSession[] = [];
+
+  const now = Date.now();
+  const ACTIVE_THRESHOLD = 30 * 1000; // 30 seconds
+
+  for (const composer of composers) {
+    // Skip excluded sessions (managed by CmdCtrl)
+    if (excludeSessionIds.has(composer.composerId)) {
+      continue;
+    }
+
+    // Use composer metadata directly for discovery (avoid expensive per-session queries)
+    // The detailed info (message count, last message preview) can be fetched on-demand
+    const lastActivity = new Date(composer.lastUpdatedAt).toISOString();
+    const isActive = (now - composer.lastUpdatedAt) < ACTIVE_THRESHOLD;
+
+    // Generate a slug from the composer name
+    const slug = generateSlug(composer.name);
+
+    // Use project path if available, otherwise empty (frontend can show device name)
+    const project = composer.projectPath || '';
+
+    sessions.push({
+      session_id: composer.composerId,
+      slug,
+      title: composer.name || 'Untitled',
+      project,
+      project_name: project ? project.split('/').pop() || 'cursor' : 'cursor',
+      file_path: 'state.vscdb', // Reference to SQLite
+      last_message: '', // Fetched on-demand when viewing session
+      last_activity: lastActivity,
+      is_active: isActive,
+      message_count: 0, // Fetched on-demand when viewing session
+    });
+  }
+
+  // Sort by last activity (newest first)
+  return sessions.sort((a, b) =>
+    new Date(b.last_activity).getTime() - new Date(a.last_activity).getTime()
+  );
+}
+
+/**
+ * Generate a URL-friendly slug from a title
+ */
+function generateSlug(title: string): string {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .substring(0, 50);
+}
+
+/**
+ * Get details for a specific session
+ */
+export function getSessionDetails(sessionId: string): ExternalSession | null {
+  const cursorDb = getCursorDB();
+  const composers = cursorDb.getComposers();
+  const composer = composers.find(c => c.composerId === sessionId);
+
+  if (!composer) {
+    return null;
+  }
+
+  const messageCount = cursorDb.getBubbleCount(sessionId);
+  const latestBubble = cursorDb.getLatestBubble(sessionId);
+  const lastMessage = latestBubble?.text?.substring(0, 100) || '';
+  const lastActivity = latestBubble?.createdAt || new Date(composer.lastUpdatedAt).toISOString();
+
+  const now = Date.now();
+  const ACTIVE_THRESHOLD = 30 * 1000;
+  const lastUpdateTime = latestBubble
+    ? new Date(latestBubble.createdAt).getTime()
+    : composer.lastUpdatedAt;
+  const isActive = (now - lastUpdateTime) < ACTIVE_THRESHOLD;
+
+  const project = composer.projectPath || '';
+
+  return {
+    session_id: composer.composerId,
+    slug: generateSlug(composer.name),
+    title: composer.name || 'Untitled',
+    project,
+    project_name: project ? project.split('/').pop() || 'cursor' : 'cursor',
+    file_path: 'state.vscdb',
+    last_message: lastMessage,
+    last_activity: lastActivity,
+    is_active: isActive,
+    message_count: messageCount,
+  };
+}