@magpiecloud/mags 1.0.0 → 1.2.0

package/README.md

@@ -10,18 +10,47 @@ npm install -g @magpiecloud/mags
 
 ## Quick Start
 
-### 1. Set your API token
+### 1. Login to Magpie
 
 ```bash
-export MAGS_API_TOKEN="your-token-here"
+mags login
 ```
 
+This will open your browser to create an API token. Paste the token when prompted, and it will be saved for future use.
+
 ### 2. Run a script
 
 ```bash
 mags run 'echo Hello World'
 ```
 
+## Authentication
+
+The CLI supports multiple authentication methods:
+
+### Interactive Login (Recommended)
+
+```bash
+mags login
+```
+
+Opens the Magpie dashboard in your browser where you can create an API token. The token is saved to `~/.mags/config.json` and used automatically for all future commands.
+
+### Other Auth Commands
+
+```bash
+mags whoami    # Check current authentication status
+mags logout    # Remove saved credentials
+```
+
+### Environment Variable
+
+You can also set the token via environment variable (overrides saved config):
+
+```bash
+export MAGS_API_TOKEN="your-token-here"
+```
+
 ## CLI Commands
 
 ```bash

package/bin/mags.js

@@ -3,10 +3,44 @@
 const https = require('https');
 const http = require('http');
 const { URL } = require('url');
+const fs = require('fs');
+const path = require('path');
+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');
+
+// 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 API_URL = process.env.MAGS_API_URL || 'https://api.magpiecloud.com';
-const API_TOKEN = process.env.MAGS_API_TOKEN || '';
+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 = {
@@ -16,6 +50,7 @@ const colors = {
   blue: '\x1b[34m',
   cyan: '\x1b[36m',
   gray: '\x1b[90m',
+  bold: '\x1b[1m',
   reset: '\x1b[0m'
 };
 
@@ -23,6 +58,42 @@ 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);
@@ -64,34 +135,36 @@ function sleep(ms) {
 
 function usage() {
   console.log(`
-${colors.cyan}Mags CLI - Instant VM Execution${colors.reset}
+${colors.cyan}${colors.bold}Mags CLI - Instant VM Execution${colors.reset}
 
 Usage: mags <command> [options] [script]
 
-Commands:
+${colors.bold}Commands:${colors.reset}
+  login                           Authenticate with Magpie
+  logout                          Remove saved credentials
+  whoami                          Show current authenticated user
   run [options] <script>          Execute a script on a microVM
+  ssh <job-id>                    Open SSH session to a running VM
   status <job-id>                 Get job status
   logs <job-id>                   Get job logs
   list                            List recent jobs
   url <job-id> [port]             Enable URL access for a job
   stop <job-id>                   Stop a running job
 
-Run Options:
+${colors.bold}Run Options:${colors.reset}
   -w, --workspace <id>            Use persistent workspace (S3 sync)
   -p, --persistent                Keep VM alive after script completes
   --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
 
-Environment:
-  MAGS_API_TOKEN                  Your API token (required)
-  MAGS_API_URL                    API endpoint (default: https://api.magpiecloud.com)
-
-Examples:
+${colors.bold}Examples:${colors.reset}
+  mags login
   mags run 'echo Hello World'
   mags run -w myproject 'python3 script.py'
   mags run -p --url 'python3 -m http.server 8080'
   mags run -w webapp -p --url --port 3000 'npm start'
+  mags ssh abc123                   # SSH into a running VM
   mags status abc123
   mags logs abc123
   mags url abc123 8080
@@ -99,6 +172,133 @@ Examples:
   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 Magpie dashboard to create an API token...');
+  console.log('');
+
+  const tokenUrl = 'https://magpiecloud.com/api-keys';
+  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 run 'echo Hello World'${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;
+}
+
 async function runJob(args) {
   let script = '';
   let workspace = '';
@@ -294,53 +494,154 @@ async function stopJob(requestId) {
   }
 }
 
-async function main() {
-  const args = process.argv.slice(2);
+async function sshToJob(requestId) {
+  if (!requestId) {
+    log('red', 'Error: Job ID required');
+    console.log(`\nUsage: mags ssh <job-id>\n`);
+    console.log('Get job IDs with: mags list');
+    process.exit(1);
+  }
 
-  if (!API_TOKEN) {
-    log('red', 'Error: MAGS_API_TOKEN not set');
-    console.log('Set it via: export MAGS_API_TOKEN=your-token');
+  // 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;
+
+  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`);
+
+  // Spawn SSH process
+  const sshArgs = [
+    '-o', 'StrictHostKeyChecking=no',
+    '-o', 'UserKnownHostsFile=/dev/null',
+    '-o', 'LogLevel=ERROR',
+    '-p', sshPort.toString(),
+    `root@${sshHost}`
+  ];
+
+  const ssh = spawn('ssh', sshArgs, {
+    stdio: 'inherit'  // Inherit stdin/stdout/stderr for interactive session
+  });
+
+  ssh.on('error', (err) => {
+    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) => {
+    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.2.0');
+        process.exit(0);
+        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 '--help':
-      case '-h':
-      case '--version':
-      case '-v':
-        if (command === '--version' || command === '-v') {
-          console.log('mags v1.0.0');
-          process.exit(0);
-        }
-        usage();
-        break;
       default:
         if (!command) {
+          // No command - check if logged in
+          if (!API_TOKEN) {
+            await requireAuth();
+          } else {
+            usage();
+          }
+        } else {
+          log('red', `Unknown command: ${command}`);
           usage();
         }
-        log('red', `Unknown command: ${command}`);
-        usage();
     }
   } catch (err) {
     log('red', `Error: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpiecloud/mags",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Mags CLI - Execute scripts on Magpie's instant VM infrastructure",
   "main": "index.js",
   "bin": {