@magpiecloud/mags 1.8.13 → 1.8.15

package/deploy-page.sh

@@ -1,171 +0,0 @@
-#!/bin/bash
-# Deploy an HTML page to a public Mags URL
-# Usage: ./deploy-page.sh <html-file-or-content> [name]
-
-set -e
-
-MAGS_API_URL="${MAGS_API_URL:-https://api.magpiecloud.com}"
-MAGS_API_TOKEN="${MAGS_API_TOKEN:-}"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-# Load .env if exists
-if [ -f ".env" ]; then
-    export $(grep -v '^#' .env | xargs)
-fi
-
-if [ -z "$MAGS_API_TOKEN" ]; then
-    echo -e "${RED}Error: MAGS_API_TOKEN not set${NC}"
-    echo "Set it via: export MAGS_API_TOKEN=your-token"
-    exit 1
-fi
-
-usage() {
-    echo -e "${CYAN}Deploy HTML Page to Mags${NC}"
-    echo ""
-    echo "Usage: $0 <html-file-or-content> [name]"
-    echo ""
-    echo "Arguments:"
-    echo "  html-file-or-content  Path to HTML file, or HTML content directly"
-    echo "  name                  Optional name for the deployment (default: page)"
-    echo ""
-    echo "Examples:"
-    echo "  $0 index.html"
-    echo "  $0 index.html my-site"
-    echo "  $0 '<h1>Hello World</h1>'"
-    echo ""
-    echo "Environment:"
-    echo "  MAGS_API_TOKEN   Your API token (required)"
-    echo "  MAGS_API_URL     API URL (default: https://api.magpiecloud.com)"
-    exit 1
-}
-
-[ -z "$1" ] && usage
-
-INPUT="$1"
-NAME="${2:-page}"
-
-# Check if input is a file or raw HTML
-if [ -f "$INPUT" ]; then
-    echo -e "${BLUE}Reading HTML from file: $INPUT${NC}"
-    HTML_CONTENT=$(cat "$INPUT")
-else
-    echo -e "${BLUE}Using provided HTML content${NC}"
-    HTML_CONTENT="$INPUT"
-fi
-
-# Escape the HTML for JSON
-HTML_ESCAPED=$(echo "$HTML_CONTENT" | jq -Rs .)
-
-# Create the script that will serve the HTML
-SCRIPT=$(cat << 'SCRIPT_EOF'
-#!/bin/sh
-# Create the HTML file
-cat > /tmp/index.html << 'HTML_CONTENT_MARKER'
-__HTML_PLACEHOLDER__
-HTML_CONTENT_MARKER
-
-# Start Python HTTP server on port 8080
-cd /tmp
-echo "Server running on port 8080"
-python3 -m http.server 8080
-SCRIPT_EOF
-)
-
-# Replace placeholder with actual HTML
-SCRIPT=$(echo "$SCRIPT" | sed "s|__HTML_PLACEHOLDER__|$(echo "$HTML_CONTENT" | sed 's/|/\\|/g; s/&/\\&/g')|")
-
-echo -e "${BLUE}Deploying page...${NC}"
-
-# Submit the persistent job
-RESPONSE=$(curl -s -X POST "${MAGS_API_URL}/api/v1/mags-jobs" \
-    -H "Authorization: Bearer $MAGS_API_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d "$(jq -n --arg script "$SCRIPT" --arg name "$NAME" '{
-        script: $script,
-        type: "inline",
-        name: $name,
-        persistent: true
-    }')")
-
-REQUEST_ID=$(echo "$RESPONSE" | jq -r '.request_id // empty')
-
-if [ -z "$REQUEST_ID" ]; then
-    echo -e "${RED}Failed to deploy:${NC}"
-    echo "$RESPONSE" | jq .
-    exit 1
-fi
-
-echo -e "${GREEN}Deployment started: $REQUEST_ID${NC}"
-
-# Wait for job to be running
-echo -e "${BLUE}Waiting for VM to start...${NC}"
-MAX_ATTEMPTS=30
-ATTEMPT=0
-
-while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
-    STATUS_RESP=$(curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${REQUEST_ID}/status" \
-        -H "Authorization: Bearer $MAGS_API_TOKEN")
-
-    STATUS=$(echo "$STATUS_RESP" | jq -r '.status // "unknown"')
-    SUBDOMAIN=$(echo "$STATUS_RESP" | jq -r '.subdomain // empty')
-
-    if [ "$STATUS" = "error" ]; then
-        echo -e "${RED}Deployment failed!${NC}"
-        echo "$STATUS_RESP" | jq .
-        exit 1
-    fi
-
-    if [ "$STATUS" = "running" ]; then
-        echo -e " ${GREEN}VM running${NC}"
-        break
-    fi
-
-    printf "."
-    sleep 1
-    ATTEMPT=$((ATTEMPT + 1))
-done
-
-if [ "$STATUS" != "running" ]; then
-    echo -e "${RED}Timed out waiting for VM to start${NC}"
-    exit 1
-fi
-
-# Enable URL access
-echo -e "${BLUE}Enabling URL access...${NC}"
-ACCESS_RESP=$(curl -s -X POST "${MAGS_API_URL}/api/v1/mags-jobs/${REQUEST_ID}/access" \
-    -H "Authorization: Bearer $MAGS_API_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d '{"access_type": "url", "port": 8080}')
-
-URL=$(echo "$ACCESS_RESP" | jq -r '.url // empty')
-SUCCESS=$(echo "$ACCESS_RESP" | jq -r '.success // false')
-
-if [ "$SUCCESS" != "true" ] || [ -z "$URL" ]; then
-    echo -e "${YELLOW}Warning: Could not get URL from access endpoint${NC}"
-    echo "$ACCESS_RESP" | jq .
-    # Fallback: construct URL from subdomain
-    URL="https://${SUBDOMAIN}.apps.magpiecloud.com"
-fi
-
-echo ""
-echo -e "${GREEN}═══════════════════════════════════════════════════════════${NC}"
-echo -e "${GREEN}  Page Deployed Successfully!${NC}"
-echo -e "${GREEN}═══════════════════════════════════════════════════════════${NC}"
-echo ""
-echo -e "  ${CYAN}URL:${NC}        ${GREEN}${URL}${NC}"
-echo -e "  ${CYAN}Subdomain:${NC}  ${SUBDOMAIN}"
-echo -e "  ${CYAN}Request ID:${NC} ${REQUEST_ID}"
-echo ""
-echo -e "${YELLOW}Note: The VM will sleep after idle timeout and wake on next request.${NC}"
-echo ""
-echo "To check status:"
-echo "  curl -s -H 'Authorization: Bearer \$MAGS_API_TOKEN' \\"
-echo "    '${MAGS_API_URL}/api/v1/mags-jobs/${REQUEST_ID}/status' | jq ."
-echo ""

package/mags.sh

@@ -1,270 +0,0 @@
-#!/bin/bash
-# Mags CLI - Execute scripts on Magpie's instant VM infrastructure
-# Usage: ./mags.sh <command> [args]
-
-set -e
-
-# Configuration
-MAGS_API_URL="${MAGS_API_URL:-https://api.magpiecloud.com}"
-MAGS_API_TOKEN="${MAGS_API_TOKEN:-}"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-# Load .env if exists
-if [ -f ".env" ]; then
-    export $(grep -v '^#' .env | xargs)
-fi
-
-if [ -z "$MAGS_API_TOKEN" ]; then
-    echo -e "${RED}Error: MAGS_API_TOKEN not set${NC}"
-    echo "Set it via: export MAGS_API_TOKEN=your-token"
-    exit 1
-fi
-
-AUTH_HEADER="Authorization: Bearer $MAGS_API_TOKEN"
-
-usage() {
-    echo -e "${CYAN}Mags CLI - Instant VM Execution${NC}"
-    echo ""
-    echo "Usage: $0 <command> [args]"
-    echo ""
-    echo "Commands:"
-    echo "  run <script>              Execute a script"
-    echo "  run -w <workspace> <script>  Execute with persistent workspace"
-    echo "  run -p <script>           Run persistent VM (stays alive)"
-    echo "  run -p --url <script>     Run persistent VM with public URL"
-    echo "  status <id>               Get job status"
-    echo "  logs <id>                 Get job logs"
-    echo "  list                      List recent jobs"
-    echo "  url <id> [port]           Enable URL access for a job"
-    echo ""
-    echo "Examples:"
-    echo "  $0 run 'echo Hello World'"
-    echo "  $0 run -w myproject 'apk add python3 && python3 --version'"
-    echo "  $0 run -p --url 'python3 -m http.server 8080'"
-    echo "  $0 url abc123-job-id 8080"
-    echo "  $0 status abc123"
-    echo "  $0 logs abc123"
-    exit 1
-}
-
-# Submit a job and wait for completion
-run_job() {
-    local script=""
-    local workspace=""
-    local persistent="false"
-    local enable_url="false"
-    local port="8080"
-
-    # Parse flags
-    while [[ $# -gt 0 ]]; do
-        case "$1" in
-            -w|--workspace)
-                workspace="$2"
-                shift 2
-                ;;
-            -p|--persistent)
-                persistent="true"
-                shift
-                ;;
-            --url)
-                enable_url="true"
-                shift
-                ;;
-            --port)
-                port="$2"
-                shift 2
-                ;;
-            *)
-                script="$*"
-                break
-                ;;
-        esac
-    done
-
-    if [ -z "$script" ]; then
-        echo -e "${RED}Error: No script provided${NC}"
-        usage
-    fi
-
-    echo -e "${BLUE}Submitting job...${NC}"
-
-    # Build JSON payload
-    local json_payload
-    if [ -n "$workspace" ]; then
-        json_payload=$(jq -n \
-            --arg script "$script" \
-            --arg workspace "$workspace" \
-            --argjson persistent "$persistent" \
-            '{script: $script, type: "inline", workspace_id: $workspace, persistent: $persistent}')
-    else
-        json_payload=$(jq -n \
-            --arg script "$script" \
-            --argjson persistent "$persistent" \
-            '{script: $script, type: "inline", persistent: $persistent}')
-    fi
-
-    # Submit job
-    local response=$(curl -s -X POST "${MAGS_API_URL}/api/v1/mags-jobs" \
-        -H "$AUTH_HEADER" \
-        -H "Content-Type: application/json" \
-        -d "$json_payload")
-
-    local request_id=$(echo "$response" | jq -r '.request_id // empty')
-
-    if [ -z "$request_id" ]; then
-        echo -e "${RED}Failed to submit job:${NC}"
-        echo "$response" | jq .
-        exit 1
-    fi
-
-    echo -e "${GREEN}Job submitted: ${request_id}${NC}"
-    [ -n "$workspace" ] && echo -e "${BLUE}Workspace: ${workspace}${NC}"
-    [ "$persistent" = "true" ] && echo -e "${YELLOW}Persistent: VM will stay alive${NC}"
-
-    # Poll for completion
-    local max_attempts=60
-    local attempt=0
-    local status="pending"
-
-    while [ $attempt -lt $max_attempts ]; do
-        local status_resp=$(curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/status" \
-            -H "$AUTH_HEADER")
-
-        status=$(echo "$status_resp" | jq -r '.status // "unknown"')
-        local subdomain=$(echo "$status_resp" | jq -r '.subdomain // empty')
-
-        if [ "$status" = "completed" ]; then
-            local duration=$(echo "$status_resp" | jq -r '.script_duration_ms // 0')
-            echo -e "${GREEN}Completed in ${duration}ms${NC}"
-            break
-        elif [ "$status" = "running" ] && [ "$persistent" = "true" ]; then
-            echo -e "${GREEN}VM running${NC}"
-
-            # Enable URL access if requested
-            if [ "$enable_url" = "true" ] && [ -n "$subdomain" ]; then
-                echo -e "${BLUE}Enabling URL access on port ${port}...${NC}"
-                local access_resp=$(curl -s -X POST "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/access" \
-                    -H "$AUTH_HEADER" \
-                    -H "Content-Type: application/json" \
-                    -d "{\"port\": ${port}}")
-
-                local success=$(echo "$access_resp" | jq -r '.success // false')
-                if [ "$success" = "true" ]; then
-                    echo -e "${GREEN}URL: https://${subdomain}.apps.magpiecloud.com${NC}"
-                else
-                    echo -e "${YELLOW}Warning: Could not enable URL access${NC}"
-                    echo "$access_resp" | jq .
-                fi
-            elif [ -n "$subdomain" ]; then
-                echo -e "${CYAN}Subdomain: ${subdomain}${NC}"
-                echo -e "${CYAN}To enable URL: $0 url ${request_id} ${port}${NC}"
-            fi
-            exit 0
-        elif [ "$status" = "error" ]; then
-            echo -e "${RED}Job failed${NC}"
-            echo "$status_resp" | jq .
-            exit 1
-        fi
-
-        printf "."
-        sleep 1
-        attempt=$((attempt + 1))
-    done
-
-    echo ""
-
-    # Get logs
-    echo -e "${CYAN}Output:${NC}"
-    curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/logs" \
-        -H "$AUTH_HEADER" | jq -r '.logs[] | select(.source == "stdout" or .source == "stderr") | .message' 2>/dev/null || \
-    curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/logs" \
-        -H "$AUTH_HEADER" | jq -r '.logs[] | "[\(.level)] \(.message)"'
-}
-
-enable_url() {
-    local request_id="$1"
-    local port="${2:-8080}"
-
-    if [ -z "$request_id" ]; then
-        echo -e "${RED}Error: Job ID required${NC}"
-        usage
-    fi
-
-    echo -e "${BLUE}Enabling URL access on port ${port}...${NC}"
-
-    local access_resp=$(curl -s -X POST "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/access" \
-        -H "$AUTH_HEADER" \
-        -H "Content-Type: application/json" \
-        -d "{\"port\": ${port}}")
-
-    local success=$(echo "$access_resp" | jq -r '.success // false')
-
-    if [ "$success" = "true" ]; then
-        # Get subdomain from status
-        local status_resp=$(curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/status" \
-            -H "$AUTH_HEADER")
-        local subdomain=$(echo "$status_resp" | jq -r '.subdomain // empty')
-
-        if [ -n "$subdomain" ]; then
-            echo -e "${GREEN}URL enabled: https://${subdomain}.apps.magpiecloud.com${NC}"
-        else
-            echo -e "${GREEN}URL access enabled${NC}"
-        fi
-        echo "$access_resp" | jq .
-    else
-        echo -e "${RED}Failed to enable URL access${NC}"
-        echo "$access_resp" | jq .
-        exit 1
-    fi
-}
-
-get_status() {
-    local request_id="$1"
-    curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/status" \
-        -H "$AUTH_HEADER" | jq .
-}
-
-get_logs() {
-    local request_id="$1"
-    curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs/${request_id}/logs" \
-        -H "$AUTH_HEADER" | jq -r '.logs[] | "[\(.level)] \(.message)"'
-}
-
-list_jobs() {
-    echo -e "${CYAN}Recent Jobs:${NC}"
-    curl -s -X GET "${MAGS_API_URL}/api/v1/mags-jobs?page=1&page_size=10" \
-        -H "$AUTH_HEADER" | jq '.jobs[] | {request_id, name, status, workspace_id, script_duration_ms, created_at}'
-}
-
-# Main
-case "${1:-}" in
-    run)
-        shift
-        run_job "$@"
-        ;;
-    url)
-        shift
-        enable_url "$@"
-        ;;
-    status)
-        [ -z "$2" ] && usage
-        get_status "$2"
-        ;;
-    logs)
-        [ -z "$2" ] && usage
-        get_logs "$2"
-        ;;
-    list)
-        list_jobs
-        ;;
-    *)
-        usage
-        ;;
-esac

package/nodejs/README.md

@@ -1,197 +0,0 @@
-# @magpiecloud/mags
-
-Execute scripts instantly on Magpie's microVM infrastructure. VMs boot in <100ms from a warm pool.
-
-## Installation
-
-```bash
-npm install -g @magpiecloud/mags
-```
-
-## Quick Start
-
-### 1. Login to Magpie
-
-```bash
-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. Create a sandbox
-
-```bash
-mags new myproject              # Local disk only
-mags new myproject -p           # With S3 persistence
-mags ssh myproject
-```
-
-### 3. Or run a script
-
-```bash
-mags run 'echo Hello World'
-```
-
-## Authentication
-
-### 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
-# Create a sandbox (local disk)
-mags new myproject
-
-# Create with S3 persistence
-mags new myproject -p
-
-# SSH into it
-mags ssh myproject
-
-# Run a simple command
-mags run 'echo Hello'
-
-# With persistent workspace (S3 sync)
-mags run -w my-project 'apk add nodejs && node --version'
-
-# Persistent VM with public URL
-mags run -w webapp -p --url 'python3 -m http.server 8080'
-
-# With startup command (for auto-wake)
-mags run -w webapp -p --url --startup-command 'npm start' 'npm install && npm start'
-
-# Custom port
-mags run -w webapp -p --url --port 3000 'npm start'
-
-# Enable URL for existing job
-mags url <job-id>
-mags url <job-id> 8080
-
-# Other commands
-mags status <job-id>
-mags logs <job-id>
-mags list
-mags stop <job-id>
-
-# Install Claude Code skill
-mags setup-claude
-```
-
-## Claude Code Integration
-
-Install the Mags skill for Claude Code to run scripts directly from Claude:
-
-```bash
-mags setup-claude
-```
-
-This lets you use natural language commands like:
-- `/mags run echo Hello World`
-- `/mags create a python environment with numpy and pandas`
-- `/mags run a flask server and give me the public URL`
-
-See [mags.run/claude-skill.html](https://mags.run/claude-skill.html) for full documentation.
-
-## CLI Flags
-
-| Flag | Description | Default |
-|------|-------------|---------|
-| `-w, --workspace` | Workspace ID for persistent storage | auto |
-| `-p, --persistent` | Keep VM alive for URL/SSH access | false |
-| `--url` | Enable public URL access (requires -p) | false |
-| `--port` | Port to expose for URL access | 8080 |
-| `--startup-command` | Command when VM wakes from sleep | none |
-
-## SSH Access
-
-Connect to any running VM:
-
-```bash
-mags ssh myproject
-```
-
-Features:
-- Connects via secure proxy (`api.magpiecloud.com:PORT`)
-- Full PTY support for interactive terminals
-- Automatic SSH key management
-- Hostname: `mags-vm`
-
-## Workspaces & Persistence
-
-When using persistent mode (`-p`), your `/root` directory syncs to S3:
-- **Auto-sync**: Every 30 seconds while running
-- **On stop**: Full sync before VM terminates
-- **On wake**: Previous state restored
-
-Without `-p`, data lives on local disk only and is cleaned up when the VM is destroyed.
-
-## Node.js SDK
-
-```javascript
-const Mags = require('@magpiecloud/mags');
-
-const mags = new Mags({
-  apiToken: process.env.MAGS_API_TOKEN
-});
-
-// Run and wait for completion
-const result = await mags.runAndWait('echo Hello World');
-console.log(result.logs);
-
-// Run with workspace
-const { requestId } = await mags.run('python script.py', {
-  workspaceId: 'myproject',
-  persistent: true
-});
-
-// Get status
-const status = await mags.status(requestId);
-
-// Enable URL access
-await mags.enableUrl(requestId, 8080);
-
-// List jobs
-const jobs = await mags.list({ page: 1, pageSize: 10 });
-
-// Stop a job
-await mags.stop(requestId);
-```
-
-## Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `MAGS_API_TOKEN` | Your API token (required) | - |
-| `MAGS_API_URL` | API endpoint | https://api.magpiecloud.com |
-
-## Performance
-
-- **Warm start**: <100ms (VM from pool)
-- **Cold start**: ~4 seconds (new VM boot)
-- **Script overhead**: ~50ms
-- **Workspace sync**: Every 30 seconds
-
-## License
-
-MIT