@cmdctrl/aider 0.1.0

package/src/client/messages.ts

@@ -0,0 +1,125 @@
+/**
+ * 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 GetMessagesMessage {
+  type: 'get_messages';
+  request_id: string;
+  session_id: string;
+  limit: number;
+  before_uuid?: string;
+  after_uuid?: string;
+}
+
+// Watch/unwatch are Claude Code specific (JSONL file watching)
+// Aider ignores these but we define them for type safety
+export interface WatchSessionMessage {
+  type: 'watch_session';
+  session_id: string;
+  file_path: string;
+}
+
+export interface UnwatchSessionMessage {
+  type: 'unwatch_session';
+  session_id: string;
+}
+
+export type ServerMessage =
+  | PingMessage
+  | TaskStartMessage
+  | TaskResumeMessage
+  | TaskCancelMessage
+  | GetMessagesMessage
+  | WatchSessionMessage
+  | UnwatchSessionMessage;
+
+// 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 interface SessionInfo {
+  session_id: string;
+  slug: string;
+  title: string;
+  project: string;
+  project_name: string;
+  file_path: string;
+  last_message: string;
+  last_activity: string;
+  is_active: boolean;
+  message_count: number;
+}
+
+export interface ReportSessionsMessage {
+  type: 'report_sessions';
+  sessions: SessionInfo[];
+}
+
+export interface MessageEntry {
+  uuid: string;
+  role: 'USER' | 'AGENT' | 'SYSTEM';
+  content: string;
+  timestamp: string;
+}
+
+export interface MessagesResponseMessage {
+  type: 'messages';
+  request_id: string;
+  session_id: string;
+  messages: MessageEntry[];
+  has_more: boolean;
+  oldest_uuid?: string;
+  newest_uuid?: string;
+  error?: string;
+}
+
+export type DaemonMessage = PongMessage | StatusMessage | EventMessage | ReportSessionsMessage | MessagesResponseMessage;
+
+// Event types sent from daemon to server
+export type EventType =
+  | 'WAIT_FOR_USER'
+  | 'TASK_COMPLETE'
+  | 'OUTPUT'
+  | 'PROGRESS'
+  | 'WARNING'
+  | 'ERROR';

package/src/client/websocket.ts

@@ -0,0 +1,317 @@
+import WebSocket from 'ws';
+import { URL } from 'url';
+import { CmdCtrlConfig, Credentials, writeCredentials } from '../config/config';
+import { AiderAdapter } from '../adapter/agentapi';
+import {
+  ServerMessage,
+  DaemonMessage,
+  TaskStartMessage,
+  TaskResumeMessage,
+  TaskCancelMessage,
+  GetMessagesMessage
+} from './messages';
+
+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: AiderAdapter;
+
+  constructor(config: CmdCtrlConfig, credentials: Credentials) {
+    this.config = config;
+    this.credentials = credentials;
+    this.adapter = new AiderAdapter(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}...`);
+
+      this.ws = new WebSocket(wsUrl, {
+        headers: {
+          Authorization: `Bearer ${this.credentials.refreshToken}`,
+          'X-Device-ID': this.config.deviceId,
+          'X-Agent-Type': 'aider'
+        }
+      });
+
+      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) {
+      const json = JSON.stringify(message);
+      if (message.type !== 'pong') {
+        console.log(`[WS OUT] ${message.type}:`, json.length > 200 ? json.substring(0, 200) + '...' : json);
+      }
+      this.ws.send(json);
+    }
+  }
+
+  /**
+   * 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(data: string): void {
+    try {
+      const msg = JSON.parse(data) as ServerMessage;
+
+      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 'get_messages':
+          this.handleGetMessages(msg as GetMessagesMessage);
+          break;
+
+        case 'watch_session':
+        case 'unwatch_session':
+          // Aider doesn't support file watching (Claude Code specific)
+          // Silently ignore these messages
+          break;
+
+        default:
+          console.log(`Unknown message type: ${(msg as { type: string }).type}`);
+      }
+    } catch (err) {
+      console.error('Failed to parse message:', err);
+    }
+  }
+
+  /**
+   * Handle task_start message
+   */
+  private async handleTaskStart(msg: TaskStartMessage): Promise<void> {
+    console.log(`Received task_start: ${msg.task_id}`);
+    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(`Received task_resume: ${msg.task_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(`Received task_cancel: ${msg.task_id}`);
+    await this.adapter.cancelTask(msg.task_id);
+  }
+
+  /**
+   * Handle get_messages request
+   * Fetches messages from AgentAPI's /messages endpoint
+   */
+  private async handleGetMessages(msg: GetMessagesMessage): Promise<void> {
+    console.log(`Received get_messages for session: ${msg.session_id}, after=${msg.after_uuid || 'none'}`);
+
+    // The session_id is the canonical ID like "dev-xxx:aider:PENDING-xxx"
+    // We need to find the task_id which matches this session
+    const taskId = msg.session_id;
+
+    const messages = await this.adapter.getMessages(taskId);
+
+    if (messages === null) {
+      // AgentAPI not running for this session
+      this.send({
+        type: 'messages',
+        request_id: msg.request_id,
+        session_id: msg.session_id,
+        messages: [],
+        has_more: false,
+        error: 'Session not active - AgentAPI not running'
+      });
+      return;
+    }
+
+    // Convert AgentAPI messages to our format
+    let formattedMessages = messages.map(m => ({
+      uuid: `aider-msg-${m.id}`,
+      role: m.role === 'agent' ? 'AGENT' as const : 'USER' as const,
+      content: m.content,
+      timestamp: m.time
+    }));
+
+    // Handle after_uuid for incremental fetches
+    if (msg.after_uuid) {
+      const afterIdx = formattedMessages.findIndex(m => m.uuid === msg.after_uuid);
+      if (afterIdx !== -1) {
+        formattedMessages = formattedMessages.slice(afterIdx + 1);
+      }
+    }
+
+    this.send({
+      type: 'messages',
+      request_id: msg.request_id,
+      session_id: msg.session_id,
+      messages: formattedMessages,
+      has_more: false,
+      newest_uuid: formattedMessages.length > 0 ? formattedMessages[formattedMessages.length - 1].uuid : undefined,
+    });
+  }
+
+  /**
+   * Schedule reconnection with exponential backoff
+   */
+  private scheduleReconnect(): void {
+    if (!this.shouldReconnect) {
+      return;
+    }
+
+    console.log(`Reconnecting in ${this.reconnectDelay}ms...`);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (err) {
+        console.error('Reconnection failed:', err);
+        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(() => {
+      this.sendStatus();
+    }, PING_INTERVAL);
+  }
+
+  /**
+   * Stop ping interval
+   */
+  private stopPingInterval(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+}

package/src/commands/register.ts

@@ -0,0 +1,201 @@
+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(/\/$/, '');
+  const deviceName = options.name || `${os.hostname()}-aider`;
+
+  // 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, delete ~/.cmdctrl-aider/config.json and ~/.cmdctrl-aider/credentials');
+    return;
+  }
+
+  console.log(`Registering Aider 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: 'aider'
+    });
+
+    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('Then enter this code:\n');
+  console.log(`  ${codeResponse.userCode}\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-aider start' to connect to the server.`);
+}

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-aider register" first.');
+    process.exit(1);
+  }
+
+  // Check if already running
+  if (isDaemonRunning()) {
+    console.error('Daemon is already running. Run "cmdctrl-aider stop" first.');
+    process.exit(1);
+  }
+
+  const config = readConfig()!;
+  const credentials = readCredentials()!;
+
+  console.log(`Starting CmdCtrl Aider 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);
+  }
+}