@magpiecloud/mags 1.8.13 → 1.8.15

package/nodejs/bin/mags.js

@@ -1,1146 +0,0 @@
-#!/usr/bin/env node
-
-const https = require('https');
-const http = require('http');
-const { URL } = require('url');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const readline = require('readline');
-const { exec, spawn } = require('child_process');
-
-// Config file path
-const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.mags');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const SSH_KEY_FILE = path.join(CONFIG_DIR, 'ssh_key');
-
-// Claude skill paths
-const CLAUDE_GLOBAL_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.claude', 'commands');
-const SKILL_URL = 'https://mags.run/mags.md';
-
-// Load saved config
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-    }
-  } catch (err) {
-    // Ignore errors
-  }
-  return {};
-}
-
-// Save config
-function saveConfig(config) {
-  try {
-    if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    }
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-
-// Configuration
-const config = loadConfig();
-const API_URL = process.env.MAGS_API_URL || config.api_url || 'https://api.magpiecloud.com';
-let API_TOKEN = process.env.MAGS_API_TOKEN || config.api_token || '';
-
-// Colors
-const colors = {
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
-  bold: '\x1b[1m',
-  reset: '\x1b[0m'
-};
-
-function log(color, msg) {
-  console.log(`${colors[color]}${msg}${colors.reset}`);
-}
-
-// Prompt for input
-function prompt(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-// Open URL in browser
-function openBrowser(url) {
-  const platform = process.platform;
-  let cmd;
-
-  if (platform === 'darwin') {
-    cmd = `open "${url}"`;
-  } else if (platform === 'win32') {
-    cmd = `start "${url}"`;
-  } else {
-    cmd = `xdg-open "${url}"`;
-  }
-
-  exec(cmd, (err) => {
-    if (err) {
-      log('yellow', `Could not open browser automatically.`);
-      log('cyan', `Please open this URL manually: ${url}`);
-    }
-  });
-}
-
-function request(method, path, body = null) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, API_URL);
-    const isHttps = url.protocol === 'https:';
-    const lib = isHttps ? https : http;
-
-    const options = {
-      hostname: url.hostname,
-      port: url.port || (isHttps ? 443 : 80),
-      path: url.pathname + url.search,
-      method,
-      headers: {
-        'Authorization': `Bearer ${API_TOKEN}`,
-        'Content-Type': 'application/json'
-      }
-    };
-
-    const req = lib.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          resolve(data);
-        }
-      });
-    });
-
-    req.on('error', reject);
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// Resolve job ID from name or ID
-async function resolveJobId(nameOrId) {
-  // If it looks like a UUID, use it directly
-  if (nameOrId.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)) {
-    return nameOrId;
-  }
-
-  // Otherwise, search by name/workspace
-  const resp = await request('GET', `/api/v1/mags-jobs?page=1&page_size=50`);
-  if (resp.jobs && resp.jobs.length > 0) {
-    // Try exact match on name first
-    let job = resp.jobs.find(j => j.name === nameOrId);
-    if (job) return job.request_id;
-
-    // Try workspace_id match
-    job = resp.jobs.find(j => j.workspace_id === nameOrId);
-    if (job) return job.request_id;
-
-    // Try partial name match (running/sleeping jobs only)
-    job = resp.jobs.find(j =>
-      (j.status === 'running' || j.status === 'sleeping') &&
-      (j.name && j.name.includes(nameOrId))
-    );
-    if (job) return job.request_id;
-  }
-
-  return nameOrId; // Return as-is, let API handle error
-}
-
-function usage() {
-  console.log(`
-${colors.cyan}${colors.bold}Mags CLI - Instant VM Execution${colors.reset}
-
-Usage: mags <command> [options] [script]
-
-${colors.bold}Commands:${colors.reset}
-  login                           Authenticate with Magpie
-  logout                          Remove saved credentials
-  whoami                          Show current authenticated user
-  new <name>                      Create a new persistent VM (returns ID only)
-  run [options] <script>          Execute a script on a microVM
-  ssh <name|id>                   Open SSH session to a running VM
-  status <name|id>                Get job status
-  logs <name|id>                  Get job logs
-  list                            List recent jobs
-  url <name|id> [port]            Enable URL access for a job
-  stop <name|id>                  Stop a running job
-  setup-claude                    Install Mags skill for Claude Code
-
-${colors.bold}Run Options:${colors.reset}
-  -w, --workspace <id>            Use persistent workspace (S3 sync)
-  -n, --name <name>               Set job name (for easier reference)
-  -p, --persistent                Keep VM alive after script completes
-  -e, --ephemeral                 No workspace/S3 sync (fastest execution)
-  -f, --file <path>               Upload file(s) to VM (repeatable)
-  --url                           Enable public URL access (requires -p)
-  --port <port>                   Port to expose for URL (default: 8080)
-  --startup-command <cmd>         Command to run when VM wakes from sleep
-
-${colors.bold}Cron Commands:${colors.reset}
-  cron add [options] <script>     Create a scheduled cron job
-  cron list                       List all cron jobs
-  cron remove <id>                Delete a cron job
-  cron enable <id>                Enable a cron job
-  cron disable <id>               Disable a cron job
-
-${colors.bold}Cron Options:${colors.reset}
-  --name <name>                   Cron job name (required)
-  --schedule <expr>               Cron expression (required, e.g. "0 * * * *")
-  -w, --workspace <id>            Workspace for cron jobs
-  -p, --persistent                Keep VM alive after cron script
-
-${colors.bold}Examples:${colors.reset}
-  mags login
-  mags new myvm                     # Create VM, get ID
-  mags ssh myvm                     # SSH by name
-  mags run 'echo Hello World'
-  mags run -e 'echo fast'           # Ephemeral (no S3 sync)
-  mags run -f script.py 'python3 script.py'  # Upload + run file
-  mags run -w myproject 'python3 script.py'
-  mags run -p --url 'python3 -m http.server 8080'
-  mags run -n webapp -w webapp -p --url --port 3000 'npm start'
-  mags cron add --name backup --schedule "0 0 * * *" 'tar czf backup.tar.gz data/'
-  mags cron list
-  mags status myvm
-  mags logs myvm
-  mags url myvm 8080
-  mags setup-claude                 # Install Claude Code skill
-`);
-  process.exit(1);
-}
-
-async function login() {
-  console.log(`
-${colors.cyan}${colors.bold}Mags Login${colors.reset}
-
-To authenticate, you need an API token from Magpie.
-`);
-
-  log('blue', 'Opening Mags to create an API token...');
-  console.log('');
-
-  const tokenUrl = 'https://mags.run/tokens';
-  openBrowser(tokenUrl);
-
-  await sleep(1000);
-
-  console.log(`${colors.gray}If the browser didn't open, visit:${colors.reset}`);
-  console.log(`${colors.cyan}${tokenUrl}${colors.reset}`);
-  console.log('');
-  console.log(`${colors.gray}1. Click "Create Token"${colors.reset}`);
-  console.log(`${colors.gray}2. Give it a name (e.g., "mags-cli")${colors.reset}`);
-  console.log(`${colors.gray}3. Copy the token and paste it below${colors.reset}`);
-  console.log('');
-
-  const token = await prompt(`${colors.bold}Paste your API token: ${colors.reset}`);
-
-  if (!token) {
-    log('red', 'No token provided. Login cancelled.');
-    process.exit(1);
-  }
-
-  // Validate token by making a test request
-  API_TOKEN = token;
-  log('blue', 'Verifying token...');
-
-  try {
-    const resp = await request('GET', '/api/v1/mags-jobs?page=1&page_size=1');
-
-    if (resp.error === 'unauthorized' || resp.error === 'Unauthorized') {
-      log('red', 'Invalid token. Please check and try again.');
-      process.exit(1);
-    }
-
-    // Save token
-    const newConfig = { ...config, api_token: token };
-    if (saveConfig(newConfig)) {
-      console.log('');
-      log('green', 'Login successful!');
-      log('gray', `Token saved to ${CONFIG_FILE}`);
-      console.log('');
-      log('cyan', 'You can now run mags commands. Try:');
-      console.log(`  ${colors.bold}mags new myvm${colors.reset}`);
-      console.log(`  ${colors.bold}mags ssh myvm${colors.reset}`);
-    } else {
-      log('yellow', 'Login successful, but could not save token to config file.');
-      log('yellow', 'You may need to login again next time.');
-    }
-  } catch (err) {
-    log('red', `Error validating token: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-async function logout() {
-  if (!config.api_token) {
-    log('yellow', 'You are not logged in.');
-    return;
-  }
-
-  const newConfig = { ...config };
-  delete newConfig.api_token;
-
-  if (saveConfig(newConfig)) {
-    log('green', 'Logged out successfully.');
-    log('gray', 'Token removed from config.');
-  } else {
-    log('red', 'Could not remove token from config file.');
-  }
-}
-
-async function whoami() {
-  if (!API_TOKEN) {
-    log('yellow', 'Not logged in.');
-    log('gray', 'Run `mags login` to authenticate.');
-    return;
-  }
-
-  log('blue', 'Checking authentication...');
-
-  try {
-    const resp = await request('GET', '/api/v1/mags-jobs?page=1&page_size=1');
-
-    if (resp.error === 'unauthorized' || resp.error === 'Unauthorized') {
-      log('red', 'Token is invalid or expired.');
-      log('gray', 'Run `mags login` to re-authenticate.');
-      return;
-    }
-
-    log('green', 'Authenticated');
-    if (process.env.MAGS_API_TOKEN) {
-      log('gray', 'Using token from MAGS_API_TOKEN environment variable');
-    } else {
-      log('gray', `Using token from ${CONFIG_FILE}`);
-    }
-  } catch (err) {
-    log('red', `Error: ${err.message}`);
-  }
-}
-
-async function requireAuth() {
-  if (API_TOKEN) return true;
-
-  console.log(`
-${colors.yellow}You are not logged in.${colors.reset}
-
-To use Mags, you need to authenticate first.
-`);
-
-  const answer = await prompt(`${colors.bold}Would you like to login now? (Y/n): ${colors.reset}`);
-
-  if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
-    log('gray', 'You can login later with: mags login');
-    process.exit(0);
-  }
-
-  await login();
-  return true;
-}
-
-// Create a new persistent VM
-async function newVM(name) {
-  if (!name) {
-    log('red', 'Error: Name required');
-    console.log(`\nUsage: mags new <name>\n`);
-    process.exit(1);
-  }
-
-  const payload = {
-    script: 'sleep infinity',
-    type: 'inline',
-    persistent: true,
-    name: name,
-    workspace_id: name,
-    startup_command: 'sleep infinity'
-  };
-
-  const response = await request('POST', '/api/v1/mags-jobs', payload);
-
-  if (!response.request_id) {
-    log('red', 'Failed to create VM:');
-    console.log(JSON.stringify(response, null, 2));
-    process.exit(1);
-  }
-
-  // Wait for VM to be ready
-  const maxAttempts = 60;
-  let attempt = 0;
-
-  while (attempt < maxAttempts) {
-    const status = await request('GET', `/api/v1/mags-jobs/${response.request_id}/status`);
-
-    if (status.status === 'running') {
-      // Just output the ID
-      console.log(response.request_id);
-      return;
-    } else if (status.status === 'error') {
-      log('red', `VM creation failed: ${status.error_message || 'Unknown error'}`);
-      process.exit(1);
-    }
-
-    await sleep(500);
-    attempt++;
-  }
-
-  log('yellow', 'VM creation timed out, but may still be starting');
-  console.log(response.request_id);
-}
-
-async function runJob(args) {
-  let script = '';
-  let workspace = '';
-  let name = '';
-  let persistent = false;
-  let ephemeral = false;
-  let enableUrl = false;
-  let port = 8080;
-  let startupCommand = '';
-  let fileArgs = [];
-
-  // Parse flags
-  for (let i = 0; i < args.length; i++) {
-    switch (args[i]) {
-      case '-w':
-      case '--workspace':
-        workspace = args[++i];
-        break;
-      case '-n':
-      case '--name':
-        name = args[++i];
-        break;
-      case '-p':
-      case '--persistent':
-        persistent = true;
-        break;
-      case '-e':
-      case '--ephemeral':
-        ephemeral = true;
-        break;
-      case '-f':
-      case '--file':
-        fileArgs.push(args[++i]);
-        break;
-      case '--url':
-        enableUrl = true;
-        break;
-      case '--port':
-        port = parseInt(args[++i]) || 8080;
-        break;
-      case '--startup-command':
-        startupCommand = args[++i];
-        break;
-      default:
-        script = args.slice(i).join(' ');
-        i = args.length;
-    }
-  }
-
-  if (!script) {
-    log('red', 'Error: No script provided');
-    usage();
-  }
-
-  // Validate flag combinations
-  if (ephemeral && workspace) {
-    log('red', 'Error: Cannot use --ephemeral with --workspace; ephemeral VMs have no persistent storage');
-    process.exit(1);
-  }
-  if (ephemeral && persistent) {
-    log('red', 'Error: Cannot use --ephemeral with --persistent; ephemeral VMs are destroyed after execution');
-    process.exit(1);
-  }
-
-  // Upload files if any
-  let fileIds = [];
-  if (fileArgs.length > 0) {
-    for (const filePath of fileArgs) {
-      log('blue', `Uploading ${filePath}...`);
-      const fileId = await uploadFile(filePath);
-      if (fileId) {
-        fileIds.push(fileId);
-        log('green', `Uploaded: ${filePath} (${fileId})`);
-      } else {
-        log('red', `Failed to upload: ${filePath}`);
-        process.exit(1);
-      }
-    }
-  }
-
-  log('blue', 'Submitting job...');
-
-  const payload = {
-    script,
-    type: 'inline',
-    persistent
-  };
-  // Only set workspace_id if not ephemeral
-  if (!ephemeral && workspace) payload.workspace_id = workspace;
-  if (name) payload.name = name;
-  if (startupCommand) payload.startup_command = startupCommand;
-  if (fileIds.length > 0) payload.file_ids = fileIds;
-
-  const response = await request('POST', '/api/v1/mags-jobs', payload);
-
-  if (!response.request_id) {
-    log('red', 'Failed to submit job:');
-    console.log(JSON.stringify(response, null, 2));
-    process.exit(1);
-  }
-
-  const requestId = response.request_id;
-  log('green', `Job submitted: ${requestId}`);
-  if (name) log('blue', `Name: ${name}`);
-  if (workspace) log('blue', `Workspace: ${workspace}`);
-  if (persistent) log('yellow', 'Persistent: VM will stay alive');
-
-  // Poll for completion
-  const maxAttempts = 120;
-  let attempt = 0;
-
-  while (attempt < maxAttempts) {
-    const status = await request('GET', `/api/v1/mags-jobs/${requestId}/status`);
-
-    if (status.status === 'completed') {
-      log('green', `Completed in ${status.script_duration_ms}ms`);
-      break;
-    } else if (status.status === 'running' && persistent) {
-      log('green', 'VM running');
-
-      if (enableUrl && status.subdomain) {
-        log('blue', `Enabling URL access on port ${port}...`);
-        const accessResp = await request('POST', `/api/v1/mags-jobs/${requestId}/access`, { port });
-        if (accessResp.success) {
-          log('green', `URL: https://${status.subdomain}.apps.magpiecloud.com`);
-        } else {
-          log('yellow', 'Warning: Could not enable URL access');
-        }
-      }
-      return;
-    } else if (status.status === 'error') {
-      log('red', 'Job failed');
-      console.log(JSON.stringify(status, null, 2));
-      process.exit(1);
-    }
-
-    process.stdout.write('.');
-    await sleep(1000);
-    attempt++;
-  }
-
-  console.log('');
-
-  // Get logs
-  log('cyan', 'Output:');
-  const logsResp = await request('GET', `/api/v1/mags-jobs/${requestId}/logs`);
-  if (logsResp.logs) {
-    logsResp.logs
-      .filter(l => l.source === 'stdout' || l.source === 'stderr')
-      .forEach(l => console.log(l.message));
-  }
-}
-
-async function enableUrlAccess(nameOrId, port = 8080) {
-  if (!nameOrId) {
-    log('red', 'Error: Job name or ID required');
-    usage();
-  }
-
-  const requestId = await resolveJobId(nameOrId);
-  log('blue', `Enabling URL access on port ${port}...`);
-
-  const accessResp = await request('POST', `/api/v1/mags-jobs/${requestId}/access`, { port });
-
-  if (accessResp.success) {
-    const status = await request('GET', `/api/v1/mags-jobs/${requestId}/status`);
-    if (status.subdomain) {
-      log('green', `URL enabled: https://${status.subdomain}.apps.magpiecloud.com`);
-    } else {
-      log('green', 'URL access enabled');
-    }
-  } else {
-    log('red', 'Failed to enable URL access');
-    console.log(JSON.stringify(accessResp, null, 2));
-    process.exit(1);
-  }
-}
-
-async function getStatus(nameOrId) {
-  if (!nameOrId) {
-    log('red', 'Error: Job name or ID required');
-    usage();
-  }
-  const requestId = await resolveJobId(nameOrId);
-  const status = await request('GET', `/api/v1/mags-jobs/${requestId}/status`);
-  console.log(JSON.stringify(status, null, 2));
-}
-
-async function getLogs(nameOrId) {
-  if (!nameOrId) {
-    log('red', 'Error: Job name or ID required');
-    usage();
-  }
-  const requestId = await resolveJobId(nameOrId);
-  const logsResp = await request('GET', `/api/v1/mags-jobs/${requestId}/logs`);
-  if (logsResp.logs) {
-    logsResp.logs.forEach(l => {
-      const levelColor = l.level === 'error' ? 'red' : l.level === 'warn' ? 'yellow' : 'gray';
-      console.log(`${colors[levelColor]}[${l.level}]${colors.reset} ${l.message}`);
-    });
-  }
-}
-
-async function listJobs() {
-  const resp = await request('GET', '/api/v1/mags-jobs?page=1&page_size=10');
-  if (resp.jobs && resp.jobs.length > 0) {
-    log('cyan', 'Recent Jobs:\n');
-    resp.jobs.forEach(job => {
-      const statusColor = job.status === 'completed' ? 'green'
-        : job.status === 'running' ? 'blue'
-        : job.status === 'error' ? 'red'
-        : 'yellow';
-      console.log(`${colors.gray}${job.request_id}${colors.reset}`);
-      console.log(`  Name: ${job.name || '-'}`);
-      console.log(`  Status: ${colors[statusColor]}${job.status}${colors.reset}`);
-      console.log(`  Workspace: ${job.workspace_id || '-'}`);
-      console.log(`  Duration: ${job.script_duration_ms ? job.script_duration_ms + 'ms' : '-'}`);
-      console.log(`  Created: ${job.created_at || '-'}`);
-      console.log('');
-    });
-  } else {
-    log('yellow', 'No jobs found');
-  }
-}
-
-async function stopJob(nameOrId) {
-  if (!nameOrId) {
-    log('red', 'Error: Job name or ID required');
-    usage();
-  }
-  const requestId = await resolveJobId(nameOrId);
-  log('blue', `Stopping job ${requestId}...`);
-  const resp = await request('POST', `/api/v1/mags-jobs/${requestId}/stop`);
-  if (resp.success) {
-    log('green', 'Job stopped');
-  } else {
-    log('red', 'Failed to stop job');
-    console.log(JSON.stringify(resp, null, 2));
-  }
-}
-
-// Download a file from URL
-function downloadFile(url) {
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(url);
-    const lib = urlObj.protocol === 'https:' ? https : http;
-
-    lib.get(url, (res) => {
-      // Handle redirects
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        downloadFile(res.headers.location).then(resolve).catch(reject);
-        return;
-      }
-
-      if (res.statusCode !== 200) {
-        reject(new Error(`Failed to download: HTTP ${res.statusCode}`));
-        return;
-      }
-
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => resolve(data));
-    }).on('error', reject);
-  });
-}
-
-async function setupClaude() {
-  console.log(`
-${colors.cyan}${colors.bold}Mags Claude Code Skill Setup${colors.reset}
-
-This will install the Mags skill for Claude Code, allowing you to run
-scripts on instant VMs directly from Claude.
-`);
-
-  // Ask where to install
-  console.log(`${colors.bold}Installation options:${colors.reset}`);
-  console.log(`  1. Global (all projects) - ~/.claude/commands/`);
-  console.log(`  2. Current project only - ./.claude/commands/`);
-  console.log('');
-
-  const choice = await prompt(`${colors.bold}Choose installation type [1/2]: ${colors.reset}`);
-
-  let targetDir;
-  if (choice === '2') {
-    targetDir = path.join(process.cwd(), '.claude', 'commands');
-    log('blue', 'Installing to current project...');
-  } else {
-    targetDir = CLAUDE_GLOBAL_DIR;
-    log('blue', 'Installing globally...');
-  }
-
-  // Create directory if it doesn't exist
-  try {
-    if (!fs.existsSync(targetDir)) {
-      fs.mkdirSync(targetDir, { recursive: true });
-    }
-  } catch (err) {
-    log('red', `Failed to create directory: ${err.message}`);
-    process.exit(1);
-  }
-
-  // Download skill file
-  log('blue', `Downloading skill from ${SKILL_URL}...`);
-
-  try {
-    const skillContent = await downloadFile(SKILL_URL);
-
-    const targetFile = path.join(targetDir, 'mags.md');
-    fs.writeFileSync(targetFile, skillContent);
-
-    console.log('');
-    log('green', 'Mags skill installed successfully!');
-    log('gray', `Location: ${targetFile}`);
-    console.log('');
-    log('cyan', 'Next steps:');
-    console.log(`  1. Make sure you're logged in: ${colors.bold}mags login${colors.reset}`);
-    console.log(`  2. In Claude Code, use: ${colors.bold}/mags <your request>${colors.reset}`);
-    console.log('');
-    log('cyan', 'Example prompts:');
-    console.log('  /mags run echo Hello World');
-    console.log('  /mags create a python environment with numpy');
-    console.log('  /mags run a flask server and give me the URL');
-
-  } catch (err) {
-    log('red', `Failed to download skill: ${err.message}`);
-    log('gray', `You can manually download from: ${SKILL_URL}`);
-    process.exit(1);
-  }
-}
-
-// Upload file via multipart form data
-async function uploadFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    log('red', `File not found: ${filePath}`);
-    return null;
-  }
-
-  const fileName = path.basename(filePath);
-  const fileData = fs.readFileSync(filePath);
-  const boundary = '----MagsBoundary' + Date.now().toString(16);
-
-  // Build multipart body
-  const parts = [];
-  parts.push(`--${boundary}\r\n`);
-  parts.push(`Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`);
-  parts.push(`Content-Type: application/octet-stream\r\n\r\n`);
-  const header = Buffer.from(parts.join(''));
-  const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
-  const body = Buffer.concat([header, fileData, footer]);
-
-  return new Promise((resolve, reject) => {
-    const url = new URL('/api/v1/mags-files', API_URL);
-    const isHttps = url.protocol === 'https:';
-    const lib = isHttps ? https : http;
-
-    const options = {
-      hostname: url.hostname,
-      port: url.port || (isHttps ? 443 : 80),
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${API_TOKEN}`,
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        'Content-Length': body.length
-      }
-    };
-
-    const req = lib.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const parsed = JSON.parse(data);
-          if (parsed.file_id) {
-            resolve(parsed.file_id);
-          } else {
-            resolve(null);
-          }
-        } catch {
-          resolve(null);
-        }
-      });
-    });
-
-    req.on('error', () => resolve(null));
-    req.write(body);
-    req.end();
-  });
-}
-
-// Cron job management
-async function cronCommand(args) {
-  if (args.length === 0) {
-    log('red', 'Error: Cron subcommand required (add, list, remove, enable, disable)');
-    usage();
-    return;
-  }
-
-  const subcommand = args[0];
-  const subArgs = args.slice(1);
-
-  switch (subcommand) {
-    case 'add':
-      await cronAdd(subArgs);
-      break;
-    case 'list':
-    case 'ls':
-      await cronList();
-      break;
-    case 'remove':
-    case 'rm':
-    case 'delete':
-      if (!subArgs[0]) {
-        log('red', 'Error: Cron job ID required');
-        process.exit(1);
-      }
-      await cronRemove(subArgs[0]);
-      break;
-    case 'enable':
-      if (!subArgs[0]) {
-        log('red', 'Error: Cron job ID required');
-        process.exit(1);
-      }
-      await cronToggle(subArgs[0], true);
-      break;
-    case 'disable':
-      if (!subArgs[0]) {
-        log('red', 'Error: Cron job ID required');
-        process.exit(1);
-      }
-      await cronToggle(subArgs[0], false);
-      break;
-    default:
-      log('red', `Unknown cron subcommand: ${subcommand}`);
-      usage();
-  }
-}
-
-async function cronAdd(args) {
-  let cronName = '';
-  let schedule = '';
-  let workspace = '';
-  let persistent = false;
-  let script = '';
-
-  for (let i = 0; i < args.length; i++) {
-    switch (args[i]) {
-      case '--name':
-        cronName = args[++i];
-        break;
-      case '--schedule':
-        schedule = args[++i];
-        break;
-      case '-w':
-      case '--workspace':
-        workspace = args[++i];
-        break;
-      case '-p':
-      case '--persistent':
-        persistent = true;
-        break;
-      default:
-        script = args.slice(i).join(' ');
-        i = args.length;
-    }
-  }
-
-  if (!cronName) {
-    log('red', 'Error: --name is required for cron jobs');
-    process.exit(1);
-  }
-  if (!schedule) {
-    log('red', 'Error: --schedule is required (e.g. "0 * * * *")');
-    process.exit(1);
-  }
-  if (!script) {
-    log('red', 'Error: Script is required');
-    process.exit(1);
-  }
-
-  const payload = {
-    name: cronName,
-    cron_expression: schedule,
-    script,
-    persistent
-  };
-  if (workspace) payload.workspace_id = workspace;
-
-  const resp = await request('POST', '/api/v1/mags-cron', payload);
-  if (resp.id) {
-    log('green', `Cron job created: ${resp.id}`);
-    log('blue', `Name: ${cronName}`);
-    log('blue', `Schedule: ${schedule}`);
-    if (resp.next_run_at) log('blue', `Next run: ${resp.next_run_at}`);
-  } else {
-    log('red', 'Failed to create cron job:');
-    console.log(JSON.stringify(resp, null, 2));
-    process.exit(1);
-  }
-}
-
-async function cronList() {
-  const resp = await request('GET', '/api/v1/mags-cron');
-  if (resp.cron_jobs && resp.cron_jobs.length > 0) {
-    log('cyan', 'Cron Jobs:\n');
-    resp.cron_jobs.forEach(cron => {
-      const statusColor = cron.enabled ? 'green' : 'yellow';
-      console.log(`${colors.gray}${cron.id}${colors.reset}`);
-      console.log(`  Name: ${cron.name}`);
-      console.log(`  Schedule: ${cron.cron_expression}`);
-      console.log(`  Enabled: ${colors[statusColor]}${cron.enabled}${colors.reset}`);
-      console.log(`  Workspace: ${cron.workspace_id || '-'}`);
-      console.log(`  Runs: ${cron.run_count || 0}`);
-      console.log(`  Last Run: ${cron.last_run_at || '-'}`);
-      console.log(`  Next Run: ${cron.next_run_at || '-'}`);
-      console.log(`  Last Status: ${cron.last_status || '-'}`);
-      console.log('');
-    });
-  } else {
-    log('yellow', 'No cron jobs found');
-  }
-}
-
-async function cronRemove(id) {
-  const resp = await request('DELETE', `/api/v1/mags-cron/${id}`);
-  if (resp.success) {
-    log('green', 'Cron job deleted');
-  } else {
-    log('red', 'Failed to delete cron job');
-    console.log(JSON.stringify(resp, null, 2));
-  }
-}
-
-async function cronToggle(id, enabled) {
-  const resp = await request('PATCH', `/api/v1/mags-cron/${id}`, { enabled });
-  if (resp.id) {
-    log('green', `Cron job ${enabled ? 'enabled' : 'disabled'}`);
-    if (resp.next_run_at) log('blue', `Next run: ${resp.next_run_at}`);
-  } else {
-    log('red', `Failed to ${enabled ? 'enable' : 'disable'} cron job`);
-    console.log(JSON.stringify(resp, null, 2));
-  }
-}
-
-async function sshToJob(nameOrId) {
-  if (!nameOrId) {
-    log('red', 'Error: Job name or ID required');
-    console.log(`\nUsage: mags ssh <name|id>\n`);
-    console.log('Examples:');
-    console.log('  mags ssh myvm');
-    console.log('  mags ssh 7bd12031-25ff-497f-b753-7ae73ce10317');
-    console.log('');
-    console.log('Get job names/IDs with: mags list');
-    process.exit(1);
-  }
-
-  // Resolve name to ID
-  const requestId = await resolveJobId(nameOrId);
-
-  // First check job status
-  log('blue', 'Checking job status...');
-  const status = await request('GET', `/api/v1/mags-jobs/${requestId}/status`);
-
-  if (status.error) {
-    log('red', `Error: ${status.error}`);
-    process.exit(1);
-  }
-
-  if (status.status !== 'running' && status.status !== 'sleeping') {
-    log('red', `Cannot SSH to job with status: ${status.status}`);
-    log('gray', 'Job must be running or sleeping (persistent)');
-    process.exit(1);
-  }
-
-  // Enable SSH access (port 22)
-  log('blue', 'Enabling SSH access...');
-  const accessResp = await request('POST', `/api/v1/mags-jobs/${requestId}/access`, { port: 22 });
-
-  if (!accessResp.success) {
-    log('red', 'Failed to enable SSH access');
-    if (accessResp.error) {
-      log('red', accessResp.error);
-    }
-    process.exit(1);
-  }
-
-  const sshHost = accessResp.ssh_host;
-  const sshPort = accessResp.ssh_port;
-  const sshKey = accessResp.ssh_private_key;
-
-  if (!sshHost || !sshPort) {
-    log('red', 'SSH access enabled but no connection details returned');
-    console.log(JSON.stringify(accessResp, null, 2));
-    process.exit(1);
-  }
-
-  log('green', `Connecting to ${sshHost}:${sshPort}...`);
-  console.log(`${colors.gray}(Use Ctrl+D or 'exit' to disconnect)${colors.reset}\n`);
-
-  // Build SSH arguments
-  const sshArgs = [
-    '-tt',  // Force TTY allocation even when stdin isn't a terminal
-    '-o', 'StrictHostKeyChecking=no',
-    '-o', 'UserKnownHostsFile=/dev/null',
-    '-o', 'LogLevel=ERROR',
-    '-p', sshPort.toString()
-  ];
-
-  // If API returned an SSH key, write it to a temp file and use it
-  let keyFile = null;
-  if (sshKey) {
-    keyFile = path.join(os.tmpdir(), `mags_ssh_${Date.now()}`);
-    fs.writeFileSync(keyFile, sshKey, { mode: 0o600 });
-    sshArgs.push('-i', keyFile);
-  }
-
-  sshArgs.push(`root@${sshHost}`);
-
-  const ssh = spawn('ssh', sshArgs, {
-    stdio: 'inherit'  // Inherit stdin/stdout/stderr for interactive session
-  });
-
-  ssh.on('error', (err) => {
-    if (keyFile) {
-      try { fs.unlinkSync(keyFile); } catch (e) {}
-    }
-    if (err.code === 'ENOENT') {
-      log('red', 'SSH client not found. Please install OpenSSH.');
-      log('gray', 'On macOS/Linux: ssh is usually pre-installed');
-      log('gray', 'On Windows: Install OpenSSH or use WSL');
-    } else {
-      log('red', `SSH error: ${err.message}`);
-    }
-    process.exit(1);
-  });
-
-  ssh.on('close', (code) => {
-    // Clean up temp key file
-    if (keyFile) {
-      try { fs.unlinkSync(keyFile); } catch (e) {}
-    }
-    if (code === 0) {
-      log('green', '\nSSH session ended');
-    } else {
-      log('yellow', `\nSSH session ended with code ${code}`);
-    }
-    process.exit(code || 0);
-  });
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  // Commands that don't require auth
-  const noAuthCommands = ['login', '--help', '-h', '--version', '-v'];
-
-  try {
-    switch (command) {
-      case 'login':
-        await login();
-        break;
-      case 'logout':
-        await logout();
-        break;
-      case 'whoami':
-        await whoami();
-        break;
-      case '--help':
-      case '-h':
-        usage();
-        break;
-      case '--version':
-      case '-v':
-        console.log('mags v1.5.1');
-        process.exit(0);
-        break;
-      case 'new':
-        await requireAuth();
-        await newVM(args[1]);
-        break;
-      case 'run':
-        await requireAuth();
-        await runJob(args.slice(1));
-        break;
-      case 'ssh':
-        await requireAuth();
-        await sshToJob(args[1]);
-        break;
-      case 'url':
-        await requireAuth();
-        await enableUrlAccess(args[1], parseInt(args[2]) || 8080);
-        break;
-      case 'status':
-        await requireAuth();
-        await getStatus(args[1]);
-        break;
-      case 'logs':
-        await requireAuth();
-        await getLogs(args[1]);
-        break;
-      case 'list':
-        await requireAuth();
-        await listJobs();
-        break;
-      case 'stop':
-        await requireAuth();
-        await stopJob(args[1]);
-        break;
-      case 'cron':
-        await requireAuth();
-        await cronCommand(args.slice(1));
-        break;
-      case 'setup-claude':
-        await setupClaude();
-        break;
-      default:
-        if (!command) {
-          // No command - check if logged in
-          if (!API_TOKEN) {
-            await requireAuth();
-          } else {
-            usage();
-          }
-        } else {
-          log('red', `Unknown command: ${command}`);
-          usage();
-        }
-    }
-  } catch (err) {
-    log('red', `Error: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-main();