Events WebSocket

// The computer's id fills the /desktops/{instance_id} slot.
const instanceId = process.env.COMPUTER_ID;
const apiKey = process.env.ORGO_API_KEY;

// Step 1: Get the computer password
const res = await fetch(
  `https://www.orgo.ai/api/computers/${instanceId}/vnc-password`,
  { headers: { 'Authorization': `Bearer ${apiKey}` } }
);
const { password } = await res.json();

// Step 2: Connect to the events stream
const ws = new WebSocket(
  `wss://www.orgo.ai/desktops/${instanceId}/ws/events?token=${password}`
);

ws.onopen = () => {
  // Subscribe to the events you care about
  ws.send(JSON.stringify({
    type: 'subscribe',
    event_types: ['window_focus', 'clipboard', 'file_change', 'idle', 'active']
  }));
};

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);

  switch (msg.type) {
    case 'event':
      const { type, timestamp, data } = msg.event;
      console.log(`[${timestamp}] ${type}:`, data);

      // React to specific events
      if (type === 'window_focus') {
        console.log(`Focus moved to: ${data.window_name}`);
      }
      if (type === 'clipboard') {
        console.log(`Clipboard: ${data.content}${data.truncated ? '…' : ''}`);
      }
      if (type === 'idle') {
        console.log(`Desktop idle for ${data.idle_ms / 1000}s`);
      }
      break;

    case 'subscribed':
      console.log('Subscription confirmed');
      break;

    case 'error':
      console.error('Event error:', msg.message);
      break;
  }
};

// Later: add more subscriptions
ws.send(JSON.stringify({
  type: 'subscribe',
  event_types: ['process_start', 'process_stop']
}));

// Or unsubscribe from some
ws.send(JSON.stringify({
  type: 'unsubscribe',
  event_types: ['idle', 'active']
}));

import asyncio
import websockets
import json
import os
import requests

async def monitor_events(instance_id: str, api_key: str):
    # Step 1: Get the computer password
    res = requests.get(
        f"https://www.orgo.ai/api/computers/{instance_id}/vnc-password",
        headers={"Authorization": f"Bearer {api_key}"}
    )
    password = res.json()["password"]

    # Step 2: Connect to the events stream
    url = f"wss://www.orgo.ai/desktops/{instance_id}/ws/events?token={password}"

    async with websockets.connect(url) as ws:
        # Subscribe to events
        await ws.send(json.dumps({
            "type": "subscribe",
            "event_types": ["window_focus", "clipboard", "file_change"]
        }))

        # Listen for events
        async for message in ws:
            data = json.loads(message)

            if data["type"] == "event":
                event = data["event"]
                print(f"[{event['timestamp']}] {event['type']}: {event['data']}")

                if event["type"] == "file_change":
                    d = event["data"]
                    print(f"  {d['operation']} on {d['path']}")

            elif data["type"] == "subscribed":
                print("Subscribed successfully")

            elif data["type"] == "error":
                print(f"Error: {data['message']}")

# The computer's id fills the /desktops/{instance_id} slot.
asyncio.run(monitor_events(os.environ["COMPUTER_ID"], os.environ["ORGO_API_KEY"]))

interface DesktopEvent {
  type: string;
  timestamp: string;
  data: Record<string, unknown>;
}

interface EventMessage {
  type: 'event' | 'subscribed' | 'unsubscribed' | 'pong' | 'error';
  event?: DesktopEvent;
  message?: string;
}

class EventStream {
  private ws!: WebSocket;
  private handlers: Map<string, (event: DesktopEvent) => void> = new Map();

  static async connect(instanceId: string, apiKey: string) {
    const stream = new EventStream();

    // Get the computer password
    const res = await fetch(
      `https://www.orgo.ai/api/computers/${instanceId}/vnc-password`,
      { headers: { 'Authorization': `Bearer ${apiKey}` } }
    );
    const { password } = await res.json();

    // Connect
    stream.ws = new WebSocket(
      `wss://www.orgo.ai/desktops/${instanceId}/ws/events?token=${password}`
    );

    stream.ws.onmessage = (event) => {
      const msg: EventMessage = JSON.parse(event.data);
      if (msg.type === 'event' && msg.event) {
        const handler = stream.handlers.get(msg.event.type);
        handler?.(msg.event);
      }
    };

    return stream;
  }

  on(eventType: string, handler: (event: DesktopEvent) => void) {
    this.handlers.set(eventType, handler);

    // Auto-subscribe
    this.ws.send(JSON.stringify({
      type: 'subscribe',
      event_types: [eventType]
    }));

    return this;
  }

  off(eventType: string) {
    this.handlers.delete(eventType);
    this.ws.send(JSON.stringify({
      type: 'unsubscribe',
      event_types: [eventType]
    }));
    return this;
  }

  close() {
    this.ws.close();
  }
}

// Usage: the computer's id fills the /desktops/{instance_id} slot.
const events = await EventStream.connect(
  process.env.COMPUTER_ID!,
  process.env.ORGO_API_KEY!
);

events
  .on('window_focus', (e) => console.log('Window:', e.data.window_name))
  .on('clipboard', (e) => console.log('Clipboard:', e.data.content))
  .on('file_change', (e) => console.log('File:', e.data.operation, e.data.path))
  .on('idle', (e) => console.log('Idle for', Number(e.data.idle_ms) / 1000, 'seconds'));