@cmdctrl/cursor-cli 0.1.1 → 0.2.0

package/src/message-store.ts

@@ -0,0 +1,61 @@
+/**
+ * In-memory message store for Cursor CLI sessions.
+ *
+ * Cursor CLI manages its own sessions internally, but for CmdCtrl's
+ * get_messages protocol we need to track messages ourselves.
+ */
+
+import { randomUUID } from 'crypto';
+import type { MessageEntry } from '@cmdctrl/daemon-sdk';
+
+export class MessageStore {
+  private sessions: Map<string, MessageEntry[]> = new Map();
+
+  storeMessage(sessionId: string, role: 'USER' | 'AGENT' | 'SYSTEM', content: string): string {
+    const uuid = randomUUID();
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, []);
+    }
+    this.sessions.get(sessionId)!.push({
+      uuid,
+      role,
+      content,
+      timestamp: new Date().toISOString(),
+    });
+    return uuid;
+  }
+
+  getMessages(
+    sessionId: string,
+    limit: number,
+    beforeUuid?: string,
+    afterUuid?: string
+  ): {
+    messages: MessageEntry[];
+    hasMore: boolean;
+    oldestUuid?: string;
+    newestUuid?: string;
+  } {
+    let messages = this.sessions.get(sessionId) || [];
+
+    if (beforeUuid) {
+      const idx = messages.findIndex(m => m.uuid === beforeUuid);
+      if (idx > 0) messages = messages.slice(0, idx);
+    }
+
+    if (afterUuid) {
+      const idx = messages.findIndex(m => m.uuid === afterUuid);
+      if (idx >= 0) messages = messages.slice(idx + 1);
+    }
+
+    const hasMore = messages.length > limit;
+    const limited = messages.slice(-limit);
+
+    return {
+      messages: limited,
+      hasMore,
+      oldestUuid: limited[0]?.uuid,
+      newestUuid: limited[limited.length - 1]?.uuid,
+    };
+  }
+}

package/src/client/messages.ts

@@ -1,75 +0,0 @@
-/**
- * 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 VersionStatusMessage {
-  type: 'version_status';
-  status: 'current' | 'update_available' | 'update_required';
-  your_version: string;
-  min_version?: string;
-  recommended_version?: string;
-  latest_version?: string;
-  changelog_url?: string;
-  message?: string;
-}
-
-export type ServerMessage =
-  | PingMessage
-  | TaskStartMessage
-  | TaskResumeMessage
-  | TaskCancelMessage
-  | VersionStatusMessage;
-
-// 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 type DaemonMessage = PongMessage | StatusMessage | EventMessage;
-
-// Event types sent from daemon to server
-export type EventType =
-  | 'WAIT_FOR_USER'
-  | 'TASK_COMPLETE'
-  | 'OUTPUT'
-  | 'PROGRESS'
-  | 'ERROR';

package/src/client/websocket.ts

@@ -1,308 +0,0 @@
-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/config/config.ts

@@ -1,146 +0,0 @@
-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-cli');
-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);
-  }
-}
-
-/**
- * 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 };