@cmdctrl/cursor-cli 0.1.1

package/src/client/websocket.ts

@@ -0,0 +1,308 @@
+import WebSocket from 'ws';
+import { URL } from 'url';
+import { CmdCtrlConfig, Credentials } from '../config/config';
+import { CursorAdapter } from '../adapter/cursor-cli';
+import {
+  ServerMessage,
+  DaemonMessage,
+  TaskStartMessage,
+  TaskResumeMessage,
+  TaskCancelMessage,
+  VersionStatusMessage,
+} from './messages';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const MAX_RECONNECT_DELAY = 30000; // 30 seconds
+const INITIAL_RECONNECT_DELAY = 1000; // 1 second
+const PING_INTERVAL = 30000; // 30 seconds
+
+export class DaemonClient {
+  private ws: WebSocket | null = null;
+  private config: CmdCtrlConfig;
+  private credentials: Credentials;
+  private reconnectDelay = INITIAL_RECONNECT_DELAY;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private pingTimer: NodeJS.Timeout | null = null;
+  private shouldReconnect = true;
+  private adapter: CursorAdapter;
+
+  constructor(config: CmdCtrlConfig, credentials: Credentials) {
+    this.config = config;
+    this.credentials = credentials;
+    this.adapter = new CursorAdapter(this.sendEvent.bind(this));
+  }
+
+  /**
+   * Connect to the CmdCtrl server via WebSocket
+   */
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const serverUrl = new URL(this.config.serverUrl);
+      const wsProtocol = serverUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+      const wsUrl = `${wsProtocol}//${serverUrl.host}/ws/daemon`;
+
+      console.log(`Connecting to ${wsUrl}...`);
+
+      // Read version from package.json
+      let daemonVersion = 'unknown';
+      try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+        daemonVersion = pkg.version;
+      } catch {
+        try {
+          const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+          daemonVersion = pkg.version;
+        } catch { /* use default */ }
+      }
+
+      this.ws = new WebSocket(wsUrl, {
+        headers: {
+          Authorization: `Bearer ${this.credentials.accessToken}`,
+          'X-Device-ID': this.config.deviceId,
+          'X-Agent-Type': 'cursor_cli',
+          'X-Daemon-Version': daemonVersion,
+        }
+      });
+
+      this.ws.on('open', () => {
+        console.log('WebSocket connected');
+        this.reconnectDelay = INITIAL_RECONNECT_DELAY;
+        this.startPingInterval();
+        this.sendStatus();
+        resolve();
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleMessage(data.toString());
+      });
+
+      this.ws.on('close', (code, reason) => {
+        console.log(`WebSocket closed: ${code} ${reason}`);
+        this.stopPingInterval();
+        this.scheduleReconnect();
+      });
+
+      this.ws.on('error', (err) => {
+        console.error('WebSocket error:', err.message);
+        if (this.ws?.readyState === WebSocket.CONNECTING) {
+          reject(err);
+        }
+        // For established connections, the 'close' event usually follows 'error',
+        // but if the connection was killed abruptly, we may not get a clean close.
+        // Force close the socket to ensure 'close' event fires and triggers reconnect.
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.ws.terminate();
+        }
+      });
+    });
+  }
+
+  /**
+   * Disconnect from server
+   */
+  async disconnect(): Promise<void> {
+    this.shouldReconnect = false;
+
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    this.stopPingInterval();
+
+    // Stop all running tasks
+    await this.adapter.stopAll();
+
+    if (this.ws) {
+      this.ws.close(1000, 'Daemon shutting down');
+      this.ws = null;
+    }
+  }
+
+  /**
+   * Send a message to the server
+   */
+  private send(message: DaemonMessage): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+
+  /**
+   * Send an event for a task
+   */
+  private sendEvent(
+    taskId: string,
+    eventType: string,
+    data: Record<string, unknown>
+  ): void {
+    this.send({
+      type: 'event',
+      task_id: taskId,
+      event_type: eventType,
+      ...data
+    });
+  }
+
+  /**
+   * Send current status to server
+   */
+  private sendStatus(): void {
+    this.send({
+      type: 'status',
+      running_tasks: this.adapter.getRunningTasks()
+    });
+  }
+
+  /**
+   * Handle incoming message from server
+   */
+  private handleMessage(raw: string): void {
+    let msg: ServerMessage;
+    try {
+      msg = JSON.parse(raw) as ServerMessage;
+    } catch {
+      console.error('Failed to parse message:', raw);
+      return;
+    }
+
+    switch (msg.type) {
+      case 'ping':
+        this.send({ type: 'pong' });
+        break;
+
+      case 'task_start':
+        this.handleTaskStart(msg as TaskStartMessage);
+        break;
+
+      case 'task_resume':
+        this.handleTaskResume(msg as TaskResumeMessage);
+        break;
+
+      case 'task_cancel':
+        this.handleTaskCancel(msg as TaskCancelMessage);
+        break;
+
+      case 'version_status':
+        this.handleVersionStatus(msg as VersionStatusMessage);
+        break;
+
+      default:
+        console.warn('Unknown message type:', (msg as { type: string }).type);
+    }
+  }
+
+  /**
+   * Handle task_start message
+   */
+  private async handleTaskStart(msg: TaskStartMessage): Promise<void> {
+    console.log(`Starting task ${msg.task_id}: ${msg.instruction.substring(0, 50)}...`);
+
+    try {
+      await this.adapter.startTask(msg.task_id, msg.instruction, msg.project_path);
+    } catch (err) {
+      console.error(`Failed to start task ${msg.task_id}:`, err);
+      this.sendEvent(msg.task_id, 'ERROR', {
+        error: (err as Error).message
+      });
+    }
+  }
+
+  /**
+   * Handle task_resume message
+   */
+  private async handleTaskResume(msg: TaskResumeMessage): Promise<void> {
+    console.log(`Resuming task ${msg.task_id} with session ${msg.session_id}`);
+
+    try {
+      await this.adapter.resumeTask(msg.task_id, msg.session_id, msg.message, msg.project_path);
+    } catch (err) {
+      console.error(`Failed to resume task ${msg.task_id}:`, err);
+      this.sendEvent(msg.task_id, 'ERROR', {
+        error: (err as Error).message
+      });
+    }
+  }
+
+  /**
+   * Handle task_cancel message
+   */
+  private async handleTaskCancel(msg: TaskCancelMessage): Promise<void> {
+    console.log(`Cancelling task ${msg.task_id}`);
+    await this.adapter.cancelTask(msg.task_id);
+  }
+
+  /**
+   * Handle version_status message from server
+   */
+  private handleVersionStatus(msg: VersionStatusMessage): void {
+    if (msg.status === 'update_required') {
+      console.error(`\n✖ Daemon version ${msg.your_version} is no longer supported (minimum: ${msg.min_version})`);
+      console.error(`  Run: cmdctrl-cursor-cli update`);
+      if (msg.changelog_url) console.error(`  Changelog: ${msg.changelog_url}`);
+      if (msg.message) console.error(`  ${msg.message}`);
+      console.error('');
+      this.shouldReconnect = false;
+      process.exit(1);
+    } else if (msg.status === 'update_available') {
+      console.warn(`\n⚠ Update available: v${msg.latest_version} (you have v${msg.your_version})`);
+      console.warn(`  Run: cmdctrl-cursor-cli update`);
+      if (msg.changelog_url) console.warn(`  Changelog: ${msg.changelog_url}`);
+      console.warn('');
+    }
+  }
+
+  /**
+   * Schedule reconnection with exponential backoff
+   */
+  private scheduleReconnect(): void {
+    if (!this.shouldReconnect) {
+      return;
+    }
+
+    console.log(`Reconnecting in ${this.reconnectDelay / 1000}s...`);
+
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch {
+        // Increase delay with exponential backoff
+        this.reconnectDelay = Math.min(
+          this.reconnectDelay * 2,
+          MAX_RECONNECT_DELAY
+        );
+        this.scheduleReconnect();
+      }
+    }, this.reconnectDelay);
+  }
+
+  /**
+   * Start ping interval to keep connection alive
+   */
+  private startPingInterval(): void {
+    this.pingTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+      }
+    }, PING_INTERVAL);
+  }
+
+  /**
+   * Stop ping interval
+   */
+  private stopPingInterval(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+
+  /**
+   * Refresh access token using refresh token
+   */
+  async refreshToken(): Promise<boolean> {
+    console.log('Token refresh not yet implemented');
+    return false;
+  }
+}

package/src/commands/register.ts

@@ -0,0 +1,199 @@
+import * as os from 'os';
+import * as http from 'http';
+import * as https from 'https';
+import { URL } from 'url';
+import {
+  writeConfig,
+  writeCredentials,
+  readConfig,
+  isRegistered,
+  CmdCtrlConfig,
+  Credentials
+} from '../config/config';
+
+interface RegisterOptions {
+  server: string;
+  name?: string;
+}
+
+interface DeviceCodeResponse {
+  deviceCode: string;
+  userCode: string;
+  verificationUrl: string;
+  expiresIn: number;
+  interval: number;
+}
+
+interface TokenResponse {
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+  deviceId: string;
+}
+
+/**
+ * Make an HTTP(S) request
+ */
+function request(
+  url: string,
+  method: string,
+  body?: object
+): Promise<{ status: number; data: unknown }> {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const client = parsed.protocol === 'https:' ? https : http;
+
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      }
+    };
+
+    const req = client.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          const parsed = data ? JSON.parse(data) : {};
+          resolve({ status: res.statusCode || 0, data: parsed });
+        } catch {
+          resolve({ status: res.statusCode || 0, data: {} });
+        }
+      });
+    });
+
+    req.on('error', reject);
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+}
+
+/**
+ * Poll for token completion (after user verifies in browser)
+ */
+async function pollForToken(
+  serverUrl: string,
+  deviceCode: string,
+  interval: number,
+  expiresIn: number
+): Promise<TokenResponse | null> {
+  const startTime = Date.now();
+  const expiresAt = startTime + expiresIn * 1000;
+
+  while (Date.now() < expiresAt) {
+    await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+
+    try {
+      const response = await request(`${serverUrl}/api/devices/token`, 'POST', {
+        deviceCode
+      });
+
+      if (response.status === 200) {
+        return response.data as TokenResponse;
+      }
+
+      // 400 with "authorization_pending" means keep polling
+      const data = response.data as { error?: string };
+      if (response.status === 400 && data.error === 'authorization_pending') {
+        process.stdout.write('.');
+        continue;
+      }
+
+      // Other errors should stop polling
+      if (response.status >= 400) {
+        console.error('\nError polling for token:', data);
+        return null;
+      }
+    } catch (err) {
+      console.error('\nError polling for token:', err);
+      return null;
+    }
+  }
+
+  console.error('\nDevice code expired. Please try again.');
+  return null;
+}
+
+/**
+ * Register command - implements GitHub CLI style device auth flow
+ */
+export async function register(options: RegisterOptions): Promise<void> {
+  const serverUrl = options.server.replace(/\/$/, ''); // Remove trailing slash
+  const deviceName = options.name || `${os.hostname()}-cursor`;
+
+  // Check if already registered
+  if (isRegistered()) {
+    const config = readConfig();
+    console.log(`Already registered as "${config?.deviceName}" (${config?.deviceId})`);
+    console.log(`Server: ${config?.serverUrl}`);
+    console.log(`\nTo re-register, run: ${process.argv[1]} unregister`);
+    return;
+  }
+
+  console.log(`Registering Cursor CLI device "${deviceName}" with ${serverUrl}...\n`);
+
+  // Step 1: Request device code
+  let codeResponse: DeviceCodeResponse;
+  try {
+    const response = await request(`${serverUrl}/api/devices/code`, 'POST', {
+      deviceName,
+      hostname: os.hostname(),
+      agentType: 'cursor_cli'
+    });
+
+    if (response.status !== 200) {
+      console.error('Failed to get device code:', response.data);
+      process.exit(1);
+    }
+
+    codeResponse = response.data as DeviceCodeResponse;
+  } catch (err) {
+    console.error('Failed to connect to server:', err);
+    process.exit(1);
+  }
+
+  // Step 2: Display instructions to user
+  console.log('To complete registration, open this URL in your browser:\n');
+  console.log(`  ${codeResponse.verificationUrl}\n`);
+  console.log('Waiting for verification...');
+
+  // Step 3: Poll for completion
+  const tokenResponse = await pollForToken(
+    serverUrl,
+    codeResponse.deviceCode,
+    codeResponse.interval,
+    codeResponse.expiresIn
+  );
+
+  if (!tokenResponse) {
+    process.exit(1);
+  }
+
+  // Step 4: Save config and credentials
+  const config: CmdCtrlConfig = {
+    serverUrl,
+    deviceId: tokenResponse.deviceId,
+    deviceName
+  };
+
+  const credentials: Credentials = {
+    accessToken: tokenResponse.accessToken,
+    refreshToken: tokenResponse.refreshToken,
+    expiresAt: Date.now() + tokenResponse.expiresIn * 1000
+  };
+
+  writeConfig(config);
+  writeCredentials(credentials);
+
+  console.log('\n\nRegistration complete!');
+  console.log(`Device ID: ${tokenResponse.deviceId}`);
+  console.log(`\nRun 'cmdctrl-cursor-cli start' to connect to the server.`);
+}

package/src/commands/start.ts

@@ -0,0 +1,64 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  writePidFile,
+  isDaemonRunning
+} from '../config/config';
+import { DaemonClient } from '../client/websocket';
+
+interface StartOptions {
+  foreground?: boolean;
+}
+
+/**
+ * Start the daemon
+ */
+export async function start(options: StartOptions): Promise<void> {
+  // Check if registered
+  if (!isRegistered()) {
+    console.error('Device not registered. Run "cmdctrl-cursor-cli-daemon register" first.');
+    process.exit(1);
+  }
+
+  // Check if already running
+  if (isDaemonRunning()) {
+    console.error('Daemon is already running. Use "cmdctrl-cursor-cli-daemon stop" to stop it.');
+    process.exit(1);
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials()!;
+
+  console.log(`Starting Cursor CLI daemon for device "${config.deviceName}"...`);
+  console.log(`Server: ${config.serverUrl}`);
+
+  // Write PID file
+  writePidFile(process.pid);
+
+  // Create and connect client
+  const client = new DaemonClient(config, credentials);
+
+  // Handle shutdown signals
+  const shutdown = async (signal: string) => {
+    console.log(`\nReceived ${signal}, shutting down...`);
+    await client.disconnect();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  try {
+    await client.connect();
+    console.log('Cursor CLI daemon connected and ready for tasks.');
+
+    // In foreground mode, just keep running
+    if (options.foreground) {
+      console.log('Running in foreground. Press Ctrl+C to stop.');
+    }
+  } catch (err) {
+    console.error('Failed to connect:', err);
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,46 @@
+import {
+  readConfig,
+  readCredentials,
+  isRegistered,
+  isDaemonRunning,
+  readPidFile
+} from '../config/config';
+
+/**
+ * Show daemon status
+ */
+export async function status(): Promise<void> {
+  if (!isRegistered()) {
+    console.log('Status: Not registered');
+    console.log('\nRun "cmdctrl-cursor-cli-daemon register" to register this device.');
+    return;
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials();
+  const running = isDaemonRunning();
+  const pid = readPidFile();
+
+  console.log('Cursor CLI Daemon Status');
+  console.log('========================');
+  console.log(`Device Name: ${config.deviceName}`);
+  console.log(`Device ID:   ${config.deviceId}`);
+  console.log(`Server:      ${config.serverUrl}`);
+  console.log();
+  console.log(`Daemon:      ${running ? `Running (PID ${pid})` : 'Stopped'}`);
+
+  if (credentials) {
+    const expiresIn = credentials.expiresAt - Date.now();
+    const expired = expiresIn <= 0;
+    console.log(`Token:       ${expired ? 'Expired' : 'Valid'}`);
+    if (!expired) {
+      const hours = Math.floor(expiresIn / 1000 / 60 / 60);
+      const minutes = Math.floor((expiresIn / 1000 / 60) % 60);
+      console.log(`Expires in:  ${hours}h ${minutes}m`);
+    }
+  }
+
+  if (!running) {
+    console.log('\nRun "cmdctrl-cursor-cli-daemon start" to start the daemon.');
+  }
+}

package/src/commands/stop.ts

@@ -0,0 +1,47 @@
+import {
+  isDaemonRunning,
+  readPidFile,
+  deletePidFile
+} from '../config/config';
+
+/**
+ * Stop the daemon
+ */
+export async function stop(): Promise<void> {
+  if (!isDaemonRunning()) {
+    console.log('Daemon is not running.');
+    return;
+  }
+
+  const pid = readPidFile();
+  if (!pid) {
+    console.log('Could not find daemon PID.');
+    return;
+  }
+
+  console.log(`Stopping Cursor CLI daemon (PID ${pid})...`);
+
+  try {
+    // Send SIGTERM to gracefully shutdown
+    process.kill(pid, 'SIGTERM');
+
+    // Wait a bit for graceful shutdown
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Check if still running
+    try {
+      process.kill(pid, 0);
+      // Still running, send SIGKILL
+      console.log('Daemon not responding, force killing...');
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Process is gone
+    }
+
+    deletePidFile();
+    console.log('Daemon stopped.');
+  } catch (err) {
+    console.error('Failed to stop daemon:', err);
+    deletePidFile();
+  }
+}