@magpiecloud/mags 1.4.2 → 1.5.1

package/bin/mags.js

@@ -192,18 +192,37 @@ ${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
@@ -394,9 +413,11 @@ async function runJob(args) {
   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++) {
@@ -413,6 +434,14 @@ async function runJob(args) {
       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;
@@ -433,6 +462,32 @@ async function runJob(args) {
     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 = {
@@ -440,9 +495,11 @@ async function runJob(args) {
     type: 'inline',
     persistent
   };
-  if (workspace) payload.workspace_id = workspace;
+  // 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);
 
@@ -681,6 +738,220 @@ scripts on instant VMs directly from Claude.
   }
 }
 
+// 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');
@@ -811,7 +1082,7 @@ async function main() {
         break;
       case '--version':
       case '-v':
-        console.log('mags v1.4.2');
+        console.log('mags v1.5.1');
         process.exit(0);
         break;
       case 'new':
@@ -846,6 +1117,10 @@ async function main() {
         await requireAuth();
         await stopJob(args[1]);
         break;
+      case 'cron':
+        await requireAuth();
+        await cronCommand(args.slice(1));
+        break;
       case 'setup-claude':
         await setupClaude();
         break;

package/index.js

@@ -70,21 +70,38 @@ class Mags {
    * @param {string} options.name - Job name
    * @param {string} options.workspaceId - Persistent workspace ID
    * @param {boolean} options.persistent - Keep VM alive after script
+   * @param {boolean} options.ephemeral - No workspace/S3 sync (fastest)
    * @param {string} options.startupCommand - Command to run when waking from sleep
    * @param {object} options.environment - Environment variables
+   * @param {string[]} options.fileIds - File IDs from uploadFiles()
    * @returns {Promise<{requestId: string, status: string}>}
    */
   async run(script, options = {}) {
+    if (options.ephemeral && options.workspaceId) {
+      throw new Error('Cannot use ephemeral with workspaceId');
+    }
+    if (options.ephemeral && options.persistent) {
+      throw new Error('Cannot use ephemeral with persistent');
+    }
+
     const payload = {
       script,
       type: 'inline',
       name: options.name,
-      workspace_id: options.workspaceId,
       persistent: options.persistent || false,
       startup_command: options.startupCommand,
       environment: options.environment
     };
 
+    // Only set workspace_id if not ephemeral
+    if (!options.ephemeral) {
+      payload.workspace_id = options.workspaceId;
+    }
+
+    if (options.fileIds && options.fileIds.length > 0) {
+      payload.file_ids = options.fileIds;
+    }
+
     const response = await this._request('POST', '/api/v1/mags-jobs', payload);
     return {
       requestId: response.request_id,
@@ -173,6 +190,135 @@ class Mags {
 
     throw new Error(`Job ${requestId} timed out after ${timeout}ms`);
   }
+
+  /**
+   * Upload files for use in a job
+   * @param {string[]} filePaths - Array of local file paths
+   * @returns {Promise<string[]>} Array of file IDs
+   */
+  async uploadFiles(filePaths) {
+    const fs = require('fs');
+    const path = require('path');
+    const fileIds = [];
+
+    for (const filePath of filePaths) {
+      const fileName = path.basename(filePath);
+      const fileData = fs.readFileSync(filePath);
+      const boundary = '----MagsBoundary' + Date.now().toString(16);
+
+      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]);
+
+      const response = await this._multipartRequest('/api/v1/mags-files', body, boundary);
+      if (response.file_id) {
+        fileIds.push(response.file_id);
+      } else {
+        throw new Error(`Failed to upload file: ${fileName}`);
+      }
+    }
+
+    return fileIds;
+  }
+
+  _multipartRequest(apiPath, body, boundary) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(apiPath, this.apiUrl);
+      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 ${this.apiToken}`,
+          '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 {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve(data);
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.write(body);
+      req.end();
+    });
+  }
+
+  // Cron job methods
+
+  /**
+   * Create a cron job
+   * @param {object} options - Cron job options
+   * @param {string} options.name - Cron job name
+   * @param {string} options.cronExpression - Cron expression (e.g., "0 * * * *")
+   * @param {string} options.script - Script to execute
+   * @param {string} options.workspaceId - Workspace ID
+   * @param {boolean} options.persistent - Keep VM alive
+   * @returns {Promise<object>}
+   */
+  async cronCreate(options) {
+    const payload = {
+      name: options.name,
+      cron_expression: options.cronExpression,
+      script: options.script,
+      workspace_id: options.workspaceId,
+      persistent: options.persistent || false
+    };
+    return this._request('POST', '/api/v1/mags-cron', payload);
+  }
+
+  /**
+   * List cron jobs
+   * @returns {Promise<{cron_jobs: Array}>}
+   */
+  async cronList() {
+    return this._request('GET', '/api/v1/mags-cron');
+  }
+
+  /**
+   * Get a cron job
+   * @param {string} id - Cron job ID
+   * @returns {Promise<object>}
+   */
+  async cronGet(id) {
+    return this._request('GET', `/api/v1/mags-cron/${id}`);
+  }
+
+  /**
+   * Update a cron job
+   * @param {string} id - Cron job ID
+   * @param {object} updates - Fields to update
+   * @returns {Promise<object>}
+   */
+  async cronUpdate(id, updates) {
+    return this._request('PATCH', `/api/v1/mags-cron/${id}`, updates);
+  }
+
+  /**
+   * Delete a cron job
+   * @param {string} id - Cron job ID
+   * @returns {Promise<object>}
+   */
+  async cronDelete(id) {
+    return this._request('DELETE', `/api/v1/mags-cron/${id}`);
+  }
 }
 
 module.exports = Mags;

package/package.json

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