@cmdctrl/cursor-cli 0.1.1 → 0.2.1

package/src/commands/register.ts

@@ -1,199 +1,57 @@
 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';
+import { ConfigManager, registerDevice } from '@cmdctrl/daemon-sdk';
+
+const configManager = new ConfigManager('cursor-cli');
 
 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 serverUrl = options.server.replace(/\/$/, '');
   const deviceName = options.name || `${os.hostname()}-cursor`;
 
-  // Check if already registered
-  if (isRegistered()) {
-    const config = readConfig();
+  if (configManager.isRegistered()) {
+    const config = configManager.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`);
+    console.log(`\nTo re-register, run: cmdctrl-cursor-cli 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(
+  const result = await registerDevice(
     serverUrl,
-    codeResponse.deviceCode,
-    codeResponse.interval,
-    codeResponse.expiresIn
+    deviceName,
+    os.hostname(),
+    'cursor_cli',
+    (url, _userCode) => {
+      console.log('To complete registration, open this URL in your browser:\n');
+      console.log(`  ${url}\n`);
+      console.log('Waiting for verification...');
+    }
   );
 
-  if (!tokenResponse) {
+  if (!result) {
+    console.error('\nDevice code expired. Please try again.');
     process.exit(1);
   }
 
-  // Step 4: Save config and credentials
-  const config: CmdCtrlConfig = {
+  configManager.writeConfig({
     serverUrl,
-    deviceId: tokenResponse.deviceId,
-    deviceName
-  };
-
-  const credentials: Credentials = {
-    accessToken: tokenResponse.accessToken,
-    refreshToken: tokenResponse.refreshToken,
-    expiresAt: Date.now() + tokenResponse.expiresIn * 1000
-  };
+    deviceId: result.deviceId,
+    deviceName,
+  });
 
-  writeConfig(config);
-  writeCredentials(credentials);
+  configManager.writeCredentials({
+    refreshToken: result.refreshToken,
+    accessToken: result.accessToken,
+    expiresAt: result.expiresIn ? Date.now() + result.expiresIn * 1000 : undefined,
+  });
 
   console.log('\n\nRegistration complete!');
-  console.log(`Device ID: ${tokenResponse.deviceId}`);
+  console.log(`Device ID: ${result.deviceId}`);
   console.log(`\nRun 'cmdctrl-cursor-cli start' to connect to the server.`);
 }

package/src/commands/start.ts

@@ -1,62 +1,153 @@
-import {
-  readConfig,
-  readCredentials,
-  isRegistered,
-  writePidFile,
-  isDaemonRunning
-} from '../config/config';
-import { DaemonClient } from '../client/websocket';
-
-interface StartOptions {
-  foreground?: boolean;
-}
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { DaemonClient, ConfigManager } from '@cmdctrl/daemon-sdk';
+import { CursorAdapter } from '../adapter/cursor-cli';
+import { MessageStore } from '../message-store';
+
+const configManager = new ConfigManager('cursor-cli');
 
-/**
- * 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.');
+export async function start(): Promise<void> {
+  if (!configManager.isRegistered()) {
+    console.error('Device not registered. Run "cmdctrl-cursor-cli 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.');
+  if (configManager.isDaemonRunning()) {
+    console.error('Daemon is already running. Run "cmdctrl-cursor-cli stop" first.');
     process.exit(1);
   }
 
-  const config = readConfig()!;
-  const credentials = readCredentials()!;
+  const config = configManager.readConfig()!;
+  const credentials = configManager.readCredentials()!;
+
+  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 */ }
+  }
+
+  console.log('Cursor CLI Daemon');
+  console.log(`  Server: ${config.serverUrl}`);
+  console.log(`  Device: ${config.deviceName} (${config.deviceId})`);
+  console.log(`  Version: ${daemonVersion}`);
+  console.log('');
+
+  configManager.writePidFile(process.pid);
 
-  console.log(`Starting Cursor CLI daemon for device "${config.deviceName}"...`);
-  console.log(`Server: ${config.serverUrl}`);
+  const messageStore = new MessageStore();
+  const pendingInstructions = new Map<string, string>();
+  const taskSessionMap = new Map<string, string>();
+
+  // Event callback wired into the DaemonClient below
+  let sendEvent: (taskId: string, eventType: string, data: Record<string, unknown>) => void;
+
+  const adapter = new CursorAdapter((taskId, eventType, data) => {
+    const sessionId = data.session_id as string | undefined;
+
+    // Store initial user message when session starts
+    if (eventType === 'SESSION_STARTED' && sessionId) {
+      const instruction = pendingInstructions.get(taskId);
+      if (instruction) {
+        messageStore.storeMessage(sessionId, 'USER', instruction);
+        pendingInstructions.delete(taskId);
+      }
+    }
+
+    // Store agent response on completion
+    if (eventType === 'TASK_COMPLETE' && data.result) {
+      const sid = (data.session_id as string) || taskSessionMap.get(taskId);
+      if (sid) {
+        messageStore.storeMessage(sid, 'AGENT', data.result as string);
+      }
+    }
 
-  // Write PID file
-  writePidFile(process.pid);
+    sendEvent(taskId, eventType, data);
+  });
 
-  // Create and connect client
-  const client = new DaemonClient(config, credentials);
+  const client = new DaemonClient({
+    serverUrl: config.serverUrl,
+    deviceId: config.deviceId,
+    agentType: 'cursor_cli',
+    token: credentials.refreshToken,
+    version: daemonVersion,
+  });
 
-  // Handle shutdown signals
-  const shutdown = async (signal: string) => {
-    console.log(`\nReceived ${signal}, shutting down...`);
+  // Wire up sendEvent to the client's internal method
+  sendEvent = (taskId, eventType, data) => {
+    // Use the client to send events — the SDK handles this via task handles,
+    // but since the adapter uses a callback pattern, we send raw events
+    (client as any).send({
+      type: 'event',
+      task_id: taskId,
+      event_type: eventType,
+      ...data,
+    });
+  };
+
+  client.onTaskStart(async (task) => {
+    pendingInstructions.set(task.taskId, task.instruction);
+    try {
+      await adapter.startTask(task.taskId, task.instruction, task.projectPath);
+    } catch (err: unknown) {
+      task.error(err instanceof Error ? err.message : 'Unknown error');
+    }
+  });
+
+  client.onTaskResume(async (task) => {
+    messageStore.storeMessage(task.sessionId, 'USER', task.message);
+    taskSessionMap.set(task.taskId, task.sessionId);
+    try {
+      await adapter.resumeTask(task.taskId, task.sessionId, task.message, task.projectPath);
+    } catch (err: unknown) {
+      task.error(err instanceof Error ? err.message : 'Unknown error');
+    }
+  });
+
+  client.onTaskCancel(async (taskId) => {
+    await adapter.cancelTask(taskId);
+  });
+
+  client.onGetMessages((req) => {
+    const result = messageStore.getMessages(
+      req.sessionId,
+      req.limit,
+      req.beforeUuid,
+      req.afterUuid
+    );
+    return {
+      messages: result.messages,
+      hasMore: result.hasMore,
+      oldestUuid: result.oldestUuid,
+      newestUuid: result.newestUuid,
+    };
+  });
+
+  client.onVersionStatus((msg) => {
+    if (msg.status === 'update_available') {
+      console.warn(`Update available: v${msg.latest_version} (you have v${msg.your_version})`);
+    }
+  });
+
+  const shutdown = async () => {
+    console.log('\nShutting down...');
+    await adapter.stopAll();
     await client.disconnect();
+    configManager.deletePidFile();
     process.exit(0);
   };
 
-  process.on('SIGINT', () => shutdown('SIGINT'));
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 
   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.');
-    }
+    console.log('Cursor CLI daemon running. Press Ctrl+C to stop.\n');
+    await new Promise(() => {});
   } catch (err) {
     console.error('Failed to connect:', err);
     process.exit(1);

package/src/commands/status.ts

@@ -1,46 +1,41 @@
-import {
-  readConfig,
-  readCredentials,
-  isRegistered,
-  isDaemonRunning,
-  readPidFile
-} from '../config/config';
+import { ConfigManager } from '@cmdctrl/daemon-sdk';
 
-/**
- * Show daemon status
- */
-export async function status(): Promise<void> {
-  if (!isRegistered()) {
+const configManager = new ConfigManager('cursor-cli');
+
+export function status(): void {
+  if (!configManager.isRegistered()) {
     console.log('Status: Not registered');
-    console.log('\nRun "cmdctrl-cursor-cli-daemon register" to register this device.');
+    console.log('\nRun "cmdctrl-cursor-cli register" to register this device.');
     return;
   }
 
-  const config = readConfig()!;
-  const credentials = readCredentials();
-  const running = isDaemonRunning();
-  const pid = readPidFile();
+  const config = configManager.readConfig()!;
+  const credentials = configManager.readCredentials();
 
   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) {
+  if (credentials?.expiresAt) {
     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 (expiresIn > 0) {
+      const hours = Math.floor(expiresIn / 3600000);
+      const minutes = Math.floor((expiresIn % 3600000) / 60000);
+      console.log(`Token:       Valid (expires in ${hours}h ${minutes}m)`);
+    } else {
+      console.log('Token:       Expired');
     }
+  } else {
+    console.log('Token:       Present');
   }
 
-  if (!running) {
-    console.log('\nRun "cmdctrl-cursor-cli-daemon start" to start the daemon.');
+  if (configManager.isDaemonRunning()) {
+    const pid = configManager.readPidFile();
+    console.log(`Daemon:      Running (PID ${pid})`);
+  } else {
+    console.log('Daemon:      Not running');
+    console.log('\nRun "cmdctrl-cursor-cli start" to start the daemon.');
   }
 }

package/src/commands/stop.ts

@@ -1,47 +1,36 @@
-import {
-  isDaemonRunning,
-  readPidFile,
-  deletePidFile
-} from '../config/config';
+import { ConfigManager } from '@cmdctrl/daemon-sdk';
 
-/**
- * Stop the daemon
- */
-export async function stop(): Promise<void> {
-  if (!isDaemonRunning()) {
+const configManager = new ConfigManager('cursor-cli');
+
+export function stop(): void {
+  if (!configManager.isDaemonRunning()) {
     console.log('Daemon is not running.');
     return;
   }
 
-  const pid = readPidFile();
-  if (!pid) {
-    console.log('Could not find daemon PID.');
+  const pid = configManager.readPidFile();
+  if (pid === null) {
+    console.log('No PID file found.');
     return;
   }
 
-  console.log(`Stopping Cursor CLI daemon (PID ${pid})...`);
-
   try {
-    // Send SIGTERM to gracefully shutdown
     process.kill(pid, 'SIGTERM');
+    console.log(`Sent SIGTERM to daemon (PID ${pid})`);
 
-    // 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.');
+    setTimeout(() => {
+      try {
+        process.kill(pid, 0);
+        console.log('Daemon still running, sending SIGKILL...');
+        process.kill(pid, 'SIGKILL');
+      } catch {
+        // Process is gone
+      }
+      configManager.deletePidFile();
+      console.log('Daemon stopped.');
+    }, 2000);
   } catch (err) {
     console.error('Failed to stop daemon:', err);
-    deletePidFile();
+    configManager.deletePidFile();
   }
 }

package/src/commands/unregister.ts

@@ -0,0 +1,43 @@
+import { ConfigManager } from '@cmdctrl/daemon-sdk';
+
+const configManager = new ConfigManager('cursor-cli');
+
+export async function unregister(): Promise<void> {
+  const config = configManager.readConfig();
+
+  if (!config) {
+    console.log('Not registered.');
+    return;
+  }
+
+  if (configManager.isDaemonRunning()) {
+    console.error('Error: Daemon is currently running.');
+    console.error('Please stop the daemon first with: cmdctrl-cursor-cli stop');
+    process.exit(1);
+  }
+
+  console.log(`Unregistering device "${config.deviceName}" (${config.deviceId})...`);
+
+  const credentials = configManager.readCredentials();
+  if (credentials) {
+    try {
+      const response = await fetch(`${config.serverUrl}/api/devices/${config.deviceId}`, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${credentials.refreshToken}` },
+      });
+      if (response.ok || response.status === 204) {
+        console.log('Device removed from server.');
+      } else if (response.status === 404) {
+        console.log('Device was already removed from server.');
+      } else {
+        console.warn(`Warning: Failed to remove device from server (HTTP ${response.status}).`);
+      }
+    } catch {
+      console.warn('Warning: Could not reach server to remove device.');
+    }
+  }
+
+  configManager.clearRegistration();
+  console.log('Local registration data cleared.');
+  console.log('You can now register again with: cmdctrl-cursor-cli register -s <server-url>');
+}

package/src/commands/update.ts

@@ -1,6 +1,10 @@
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { readFileSync } from 'fs';
 import { join } from 'path';
+import { ConfigManager } from '@cmdctrl/daemon-sdk';
+import { stop } from './stop';
+
+const configManager = new ConfigManager('cursor-cli');
 
 // Get the current version from package.json
 function getCurrentVersion(): string {
@@ -32,6 +36,7 @@ async function getLatestVersion(packageName: string): Promise<string | null> {
 export async function update(): Promise<void> {
   const packageName = '@cmdctrl/cursor-cli';
   const currentVersion = getCurrentVersion();
+  const wasRunning = configManager.isDaemonRunning();
 
   console.log(`Current version: ${currentVersion}`);
   console.log(`Checking for updates...`);
@@ -48,6 +53,14 @@ export async function update(): Promise<void> {
     return;
   }
 
+  // Stop daemon before updating so the old process doesn't hold stale code
+  if (wasRunning) {
+    console.log('Stopping daemon before update...');
+    stop();
+    // Wait for stop to complete (uses setTimeout internally)
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+  }
+
   console.log(`Updating ${packageName}: v${currentVersion} → v${latestVersion}`);
 
   try {
@@ -68,6 +81,14 @@ export async function update(): Promise<void> {
     console.log(`\nUpdate installed. Run 'cmdctrl-cursor-cli --version' to verify.`);
   }
 
-  console.log('\nIf the daemon is running, restart it:');
-  console.log('  cmdctrl-cursor-cli stop && cmdctrl-cursor-cli start');
+  // Restart daemon if it was running before update
+  if (wasRunning) {
+    console.log('Restarting daemon...');
+    const child = spawn('cmdctrl-cursor-cli', ['start'], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    console.log('Daemon restarted.');
+  }
 }