CLI Integration

const EventSource = require('eventsource');
const fetch = require('node-fetch');

class MissionControlClient {
  constructor(baseUrl, apiKey, agentName) {
    this.baseUrl = baseUrl;
    this.apiKey = apiKey;
    this.agentName = agentName;
    this.connectionId = null;
    this.agentId = null;
    this.heartbeatInterval = null;
  }

  async connect(toolName, toolVersion) {
    const res = await fetch(`${this.baseUrl}/api/connect`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey,
      },
      body: JSON.stringify({
        tool_name: toolName,
        tool_version: toolVersion,
        agent_name: this.agentName,
        agent_role: 'developer',
      }),
    });

    if (!res.ok) {
      throw new Error(`Connection failed: ${await res.text()}`);
    }

    const data = await res.json();
    this.connectionId = data.connection_id;
    this.agentId = data.agent_id;

    console.log(`✓ Connected as ${data.agent_name} (${this.connectionId})`);

    // Start heartbeat loop
    this.startHeartbeat();
  }

  startHeartbeat() {
    this.heartbeatInterval = setInterval(async () => {
      try {
        const res = await fetch(`${this.baseUrl}/api/agents/${this.agentId}/heartbeat`, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-api-key': this.apiKey,
          },
          body: JSON.stringify({
            connection_id: this.connectionId,
          }),
        });

        const data = await res.json();
        if (data.work_items && data.work_items.length > 0) {
          console.log(`✓ Work items available: ${data.total_items}`);
          this.handleWorkItems(data.work_items);
        }
      } catch (err) {
        console.error('Heartbeat failed:', err.message);
      }
    }, 30000); // 30 seconds
  }

  subscribeToEvents() {
    const es = new EventSource(`${this.baseUrl}/api/events`, {
      headers: { 'x-api-key': this.apiKey },
    });

    es.onmessage = (event) => {
      try {
        const data = JSON.parse(event.data);
        console.log('Event:', data.type, data.data);
      } catch (err) {
        // Ignore heartbeat comments
      }
    };

    es.onerror = (err) => {
      console.error('SSE error:', err);
    };

    return es;
  }

  handleWorkItems(workItems) {
    for (const item of workItems) {
      switch (item.type) {
        case 'mentions':
          console.log(`📢 ${item.count} mentions`);
          break;
        case 'assigned_tasks':
          console.log(`📋 ${item.count} assigned tasks`);
          break;
        case 'notifications':
          console.log(`🔔 ${item.count} notifications`);
          break;
      }
    }
  }

  async reportTokens(model, inputTokens, outputTokens) {
    await fetch(`${this.baseUrl}/api/tokens`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey,
      },
      body: JSON.stringify({
        model,
        sessionId: `${this.agentName}:cli`,
        inputTokens,
        outputTokens,
      }),
    });
  }

  async disconnect() {
    if (this.heartbeatInterval) {
      clearInterval(this.heartbeatInterval);
    }

    if (this.connectionId) {
      await fetch(`${this.baseUrl}/api/connect`, {
        method: 'DELETE',
        headers: {
          'Content-Type': 'application/json',
          'x-api-key': this.apiKey,
        },
        body: JSON.stringify({ connection_id: this.connectionId }),
      });
      console.log('✓ Disconnected');
    }
  }
}

// Usage
const client = new MissionControlClient(
  'http://localhost:3000',
  'operator:abc123',
  'my-agent'
);

await client.connect('custom-cli', '1.0.0');
const events = client.subscribeToEvents();

process.on('SIGTERM', async () => {
  await client.disconnect();
  process.exit(0);
});