npm install ws

import { RexecClient } from '@pipeopshq/rexec';

const client = new RexecClient({
  baseURL: 'https://your-rexec-instance.com',
  token: 'your-api-token'
});

// Create a container
const container = await client.containers.create({
  image: 'ubuntu:24.04',
  name: 'my-sandbox'
});

console.log(`Created container: ${container.id}`);

// Connect to terminal
const terminal = await client.terminal.connect(container.id);

terminal.onData((data) => {
  console.log('Output:', data);
});

terminal.write('echo "Hello from Rexec!"\n');

// Clean up
await client.containers.delete(container.id);

import { RexecClient } from '@pipeopshq/rexec';

const client = new RexecClient({
  baseURL: 'https://your-rexec-instance.com',
  token: 'your-api-token'
});

const client = new RexecClient({
  baseURL: 'https://your-rexec-instance.com',
  token: 'your-api-token',
  fetch: customFetch // Use a custom fetch implementation
});

const containers = await client.containers.list();

for (const container of containers) {
  console.log(`${container.name}: ${container.status}`);
}

const container = await client.containers.get(containerId);
console.log(`Container ${container.name} is ${container.status}`);

const container = await client.containers.create({
  image: 'ubuntu:24.04',
  name: 'my-container',
  environment: {
    MY_VAR: 'value',
    DEBUG: 'true'
  },
  labels: {
    project: 'demo'
  }
});

console.log(`Created: ${container.id}`);

await client.containers.start(containerId);

await client.containers.stop(containerId);

await client.containers.delete(containerId);

const files = await client.files.list(containerId, '/home');

for (const file of files) {
  const icon = file.is_dir ? '📁' : '📄';
  console.log(`${icon} ${file.name}`);
}

const data = await client.files.download(containerId, '/home/file.txt');
const text = new TextDecoder().decode(data);
console.log('File contents:', text);

await client.files.mkdir(containerId, '/home/newdir');

const terminal = await client.terminal.connect(containerId, {
  cols: 120,
  rows: 40
});

terminal.onData((data) => {
  console.log(data.toString());
});

terminal.onClose(() => {
  console.log('Terminal closed');
});

terminal.onError((error) => {
  console.error('Terminal error:', error);
});

terminal.write('ls -la\n');

// Or send binary data
const encoder = new TextEncoder();
terminal.write(encoder.encode('echo hello\n'));

terminal.resize(150, 50);

terminal.close();

async function runScript(
  client: RexecClient,
  containerId: string,
  script: string
): Promise<string> {
  const terminal = await client.terminal.connect(containerId);
  
  return new Promise((resolve, reject) => {
    let output = '';
    
    terminal.onData((data) => {
      output += data.toString();
    });
    
    terminal.onClose(() => {
      resolve(output);
    });
    
    terminal.onError(reject);
    
    terminal.write(script + '\n');
    terminal.write('exit\n');
  });
}

const output = await runScript(
  client,
  container.id,
  'apt update && apt install -y nodejs'
);
console.log(output);

<script type="module">
import { RexecClient } from 'https://unpkg.com/@pipeopshq/rexec/dist/index.mjs';

const client = new RexecClient({
  baseURL: 'https://your-rexec-instance.com',
  token: 'your-api-token'
});

// List containers
const containers = await client.containers.list();
console.log(containers);
</script>

import { Terminal } from 'xterm';
import { RexecClient } from '@pipeopshq/rexec';

const xterm = new Terminal();
xterm.open(document.getElementById('terminal'));

const client = new RexecClient({
  baseURL: 'https://your-rexec-instance.com',
  token: 'your-api-token'
});

const container = await client.containers.create({ image: 'ubuntu:24.04' });
const rexecTerminal = await client.terminal.connect(container.id, {
  cols: xterm.cols,
  rows: xterm.rows
});

// Connect xterm to rexec terminal
rexecTerminal.onData((data) => {
  xterm.write(data);
});

xterm.onData((data) => {
  rexecTerminal.write(data);
});

xterm.onResize(({ cols, rows }) => {
  rexecTerminal.resize(cols, rows);
});

interface Container {
  id: string;
  name: string;
  image: string;
  status: 'running' | 'stopped' | 'creating' | 'error';
  created_at: string;
  started_at?: string;
  labels?: Record<string, string>;
  environment?: Record<string, string>;
}

interface FileInfo {
  name: string;
  path: string;
  size: number;
  mode: string;
  mod_time: string;
  is_dir: boolean;
}

interface TerminalOptions {
  cols?: number;
  rows?: number;
}

import { RexecClient, RexecError } from '@pipeopshq/rexec';

try {
  await client.containers.get('non-existent-id');
} catch (error) {
  if (error instanceof RexecError) {
    console.error(`API Error ${error.statusCode}: ${error.message}`);
  } else {
    console.error('Network error:', error);
  }
}