Terminal WebSocket

// COMPUTER_ID is the computer's UUID. INSTANCE_ID is its instance_id, which
// fills the /desktops/{instance_id} slot. Create computer returns both.
const computerId = process.env.COMPUTER_ID;
const instanceId = process.env.INSTANCE_ID;
const apiKey = process.env.ORGO_API_KEY;

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

// Step 2: Connect with the password as token
const ws = new WebSocket(
  `wss://www.orgo.ai/desktops/${instanceId}/ws/terminal?token=${password}&cols=80&rows=24`
);

ws.onopen = () => {
  console.log('Connected to terminal');
  // Example: run a command once the socket is open
  sendCommand('echo "Hello, World!"');
};

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

  switch (message.type) {
    case 'output':
      // Print the terminal output
      process.stdout.write(message.data);
      break;
    case 'error':
      console.error('Terminal error:', message.message);
      break;
    case 'exit':
      console.log('Shell exited with code:', message.code);
      break;
  }
};

ws.onclose = (e) => {
  if (e.code === 4008) console.log('Disconnected for inactivity. Reconnect to resume');
};

// Send a command
function sendCommand(command) {
  ws.send(JSON.stringify({
    type: 'input',
    data: command + '\r'  // \r for Enter key
  }));
}

// Resize terminal
function resizeTerminal(cols, rows) {
  ws.send(JSON.stringify({
    type: 'resize',
    cols,
    rows
  }));
}

import asyncio
import websockets
import json
import os
import requests

async def connect_terminal(computer_id: str, instance_id: str, api_key: str, cols: int = 80, rows: int = 24):
    # Step 1: Get the computer password. This endpoint takes the UUID.
    res = requests.get(
        f"https://www.orgo.ai/api/computers/{computer_id}/vnc-password",
        headers={"Authorization": f"Bearer {api_key}"}
    )
    password = res.json()["password"]

    # Step 2: Connect with the password as token. Adding &session=build gives a
    # shell that survives a reconnect.
    url = f"wss://www.orgo.ai/desktops/{instance_id}/ws/terminal?token={password}&cols={cols}&rows={rows}"

    async with websockets.connect(url) as ws:
        # Handle incoming messages
        async def receive_messages():
            async for message in ws:
                data = json.loads(message)

                if data["type"] == "output":
                    print(data["data"], end="", flush=True)
                elif data["type"] == "error":
                    print(f"Error: {data['message']}")
                elif data["type"] == "exit":
                    print(f"Shell exited with code: {data['code']}")
                    break

        # Send a command
        async def send_command(command: str):
            await ws.send(json.dumps({
                "type": "input",
                "data": command + "\r"
            }))

        # Start receiving messages in background
        receive_task = asyncio.create_task(receive_messages())

        # Send commands
        await send_command("echo 'Hello, World!'")
        await send_command("ls -la")

        # Wait for output
        await asyncio.sleep(2)
        receive_task.cancel()

# COMPUTER_ID is the UUID. INSTANCE_ID fills the /desktops/{instance_id} slot.
asyncio.run(connect_terminal(
    os.environ["COMPUTER_ID"], os.environ["INSTANCE_ID"], os.environ["ORGO_API_KEY"]
))

interface TerminalMessage {
  type: 'output' | 'error' | 'exit' | 'pong';
  data?: string;
  message?: string;
  code?: number;
}

class TerminalConnection {
  private ws!: WebSocket;

  static async connect(computerId: string, instanceId: string, apiKey: string, cols = 80, rows = 24) {
    const conn = new TerminalConnection();

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

    // Step 2: Connect with the password as token
    const url = `wss://www.orgo.ai/desktops/${instanceId}/ws/terminal?token=${password}&cols=${cols}&rows=${rows}`;
    conn.ws = new WebSocket(url);

    conn.ws.onmessage = (event) => {
      const message: TerminalMessage = JSON.parse(event.data);
      conn.handleMessage(message);
    };

    // Wait for the socket to open, so send() can be called right away
    await new Promise<void>((resolve, reject) => {
      conn.ws.onopen = () => resolve();
      conn.ws.onerror = () => reject(new Error('Terminal connection failed'));
    });

    return conn;
  }

  private handleMessage(message: TerminalMessage) {
    switch (message.type) {
      case 'output':
        console.log(message.data);
        break;
      case 'error':
        console.error('Error:', message.message);
        break;
      case 'exit':
        console.log('Exited with code:', message.code);
        break;
    }
  }

  send(data: string) {
    this.ws.send(JSON.stringify({ type: 'input', data }));
  }

  resize(cols: number, rows: number) {
    this.ws.send(JSON.stringify({ type: 'resize', cols, rows }));
  }

  ping() {
    this.ws.send(JSON.stringify({ type: 'ping' }));
  }

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

// COMPUTER_ID is the UUID. INSTANCE_ID fills the /desktops/{instance_id} slot.
const terminal = await TerminalConnection.connect(
  process.env.COMPUTER_ID!,
  process.env.INSTANCE_ID!,
  process.env.ORGO_API_KEY!
);
terminal.send('echo "Hello!"\r');