Examples

import { Cmdop } from '@cmdop/sdk';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
async function deploy(machines: string[], branch: string) {
  const script = `
    cd /app
    git fetch origin
    git checkout ${branch}
    git pull
    npm install
    npm run build
    pm2 restart all
  `;
 
  const results = await client.commands.execBatch(machines, script);
 
  for (const [machineId, result] of Object.entries(results)) {
    if (result.exitCode !== 0) {
      console.error(`Deploy failed on ${machineId}`);
      console.error(result.stderr);
    } else {
      console.log(`Deployed to ${machineId}`);
    }
  }
}
 
// Usage
deploy(['web-1', 'web-2', 'web-3'], 'main');

import { Cmdop } from '@cmdop/sdk';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
async function healthCheck() {
  const machines = await client.machines.list({ status: 'online' });
 
  for (const machine of machines) {
    const status = await client.machines.status(machine.id);
 
    if (status.cpu.usage > 90) {
      console.warn(`High CPU on ${machine.name}: ${status.cpu.usage}%`);
    }
 
    if (status.memory.used / status.memory.total > 0.9) {
      console.warn(`High memory on ${machine.name}`);
    }
 
    if (status.disk.used / status.disk.total > 0.85) {
      console.warn(`Low disk space on ${machine.name}`);
    }
  }
}
 
// Run every 5 minutes
setInterval(healthCheck, 5 * 60 * 1000);

import { Cmdop } from '@cmdop/sdk';
import fs from 'fs';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
async function aggregateLogs(machines: string[], logPath: string) {
  const output = fs.createWriteStream('aggregated.log');
 
  for (const machineId of machines) {
    const result = await client.commands.exec(
      machineId,
      `cat ${logPath} | tail -1000`
    );
 
    output.write(`\n=== ${machineId} ===\n`);
    output.write(result.stdout);
  }
 
  output.end();
}

import { Cmdop } from '@cmdop/sdk';
import fs from 'fs';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
async function syncFile(
  localPath: string,
  machineId: string,
  remotePath: string
) {
  const content = fs.readFileSync(localPath);
  await client.files.upload(machineId, remotePath, content);
  console.log(`Synced ${localPath} to ${machineId}:${remotePath}`);
}

import { CmdopProvider, useMachines, useRealtime } from '@cmdop/react';
 
function Dashboard() {
  const { machines } = useMachines();
 
  return (
    <div className="grid grid-cols-3 gap-4">
      {machines.map((machine) => (
        <MachineCard key={machine.id} machine={machine} />
      ))}
    </div>
  );
}
 
function MachineCard({ machine }) {
  const { metrics, status } = useRealtime(machine.id);
 
  return (
    <div className="border rounded p-4">
      <h3>{machine.name}</h3>
      <p>Status: {status}</p>
      <div className="mt-2">
        <div>CPU: {metrics?.cpu.usage}%</div>
        <div>Memory: {Math.round(metrics?.memory.used / 1024 / 1024)}MB</div>
      </div>
    </div>
  );
}
 
export default function App() {
  return (
    <CmdopProvider apiKey={process.env.NEXT_PUBLIC_CMDOP_API_KEY}>
      <Dashboard />
    </CmdopProvider>
  );
}

#!/usr/bin/env node
import { Cmdop } from '@cmdop/sdk';
import { program } from 'commander';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
program
  .command('list')
  .description('List all machines')
  .action(async () => {
    const machines = await client.machines.list();
    for (const m of machines) {
      console.log(`${m.name} (${m.status})`);
    }
  });
 
program
  .command('exec <machine> <command>')
  .description('Execute command')
  .action(async (machine, command) => {
    const result = await client.commands.exec(machine, command);
    console.log(result.stdout);
    if (result.stderr) console.error(result.stderr);
    process.exit(result.exitCode);
  });
 
program.parse();

// Next.js API Route
import { Cmdop, WebhookEvent } from '@cmdop/sdk';
 
const client = new Cmdop({ apiKey: process.env.CMDOP_API_KEY });
 
export async function POST(req: Request) {
  const event: WebhookEvent = await req.json();
 
  switch (event.type) {
    case 'machine.offline':
      // Send alert
      await sendSlackAlert(`Machine ${event.machine.name} went offline`);
      break;
 
    case 'command.failed':
      // Log failure
      console.error(`Command failed: ${event.command}`);
      break;
  }
 
  return Response.json({ ok: true });
}