loki-mode 5.8.3 → 5.8.4

package/VERSION

@@ -1 +1 @@
-5.8.3
+5.8.4

package/autonomy/api-server.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+/**
+ * Loki Mode HTTP API Server (v1.0.0)
+ * Zero npm dependencies - uses only Node.js built-ins
+ *
+ * Usage:
+ *   node autonomy/api-server.js [--port 9898]
+ *   loki api start
+ *
+ * Endpoints:
+ *   GET  /health    - Health check
+ *   GET  /status    - Session status
+ *   GET  /events    - SSE stream
+ *   GET  /logs      - Recent log lines
+ *   POST /start     - Start session
+ *   POST /stop      - Stop session
+ *   POST /pause     - Pause session
+ *   POST /resume    - Resume session
+ */
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+// Configuration
+const PORT = parseInt(process.env.LOKI_API_PORT || process.argv[3] || '9898');
+const LOKI_DIR = process.env.LOKI_DIR || path.join(process.cwd(), '.loki');
+const STATE_DIR = path.join(LOKI_DIR, 'state');
+const LOG_DIR = path.join(LOKI_DIR, 'logs');
+
+// Find skill directory
+function findSkillDir() {
+    const candidates = [
+        path.join(process.env.HOME || '', '.claude/skills/loki-mode'),
+        path.dirname(__dirname),
+        process.cwd()
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(dir, 'SKILL.md')) &&
+            fs.existsSync(path.join(dir, 'autonomy/run.sh'))) {
+            return dir;
+        }
+    }
+    return process.cwd();
+}
+
+const SKILL_DIR = findSkillDir();
+const RUN_SH = path.join(SKILL_DIR, 'autonomy', 'run.sh');
+
+// Ensure directories exist
+fs.mkdirSync(STATE_DIR, { recursive: true });
+fs.mkdirSync(LOG_DIR, { recursive: true });
+
+// SSE clients for real-time updates
+const sseClients = new Set();
+
+// Utility: read file safely
+function readFile(filepath) {
+    try {
+        return fs.readFileSync(filepath, 'utf8').trim();
+    } catch {
+        return '';
+    }
+}
+
+// Utility: check if process is running
+function isRunning(pid) {
+    if (!pid) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+// Utility: get version
+function getVersion() {
+    const versionFile = path.join(SKILL_DIR, 'VERSION');
+    return readFile(versionFile) || 'unknown';
+}
+
+// Get current status
+function getStatus() {
+    const pidFile = path.join(LOKI_DIR, 'loki.pid');
+    const statusFile = path.join(LOKI_DIR, 'STATUS.txt');
+    const pauseFile = path.join(LOKI_DIR, 'PAUSE');
+    const stopFile = path.join(LOKI_DIR, 'STOP');
+
+    const pidStr = readFile(pidFile);
+    const pid = pidStr ? parseInt(pidStr) : null;
+    const running = isRunning(pid);
+
+    let state = 'stopped';
+    if (running) {
+        if (fs.existsSync(pauseFile)) {
+            state = 'paused';
+        } else if (fs.existsSync(stopFile)) {
+            state = 'stopping';
+        } else {
+            state = 'running';
+        }
+    }
+
+    // Read status text
+    const statusText = readFile(statusFile);
+
+    // Read orchestrator state if available
+    let currentPhase = '';
+    let currentTask = '';
+    const orchFile = path.join(STATE_DIR, 'orchestrator.json');
+    if (fs.existsSync(orchFile)) {
+        try {
+            const orch = JSON.parse(fs.readFileSync(orchFile, 'utf8'));
+            currentPhase = orch.currentPhase || '';
+            currentTask = orch.currentTask || '';
+        } catch {
+            // ignore parse errors
+        }
+    }
+
+    // Read queue stats
+    let pendingTasks = 0;
+    const queueFile = path.join(LOKI_DIR, 'queue', 'pending.json');
+    if (fs.existsSync(queueFile)) {
+        try {
+            const queue = JSON.parse(fs.readFileSync(queueFile, 'utf8'));
+            pendingTasks = queue.tasks?.length || 0;
+        } catch {
+            // ignore
+        }
+    }
+
+    return {
+        state,
+        pid,
+        statusText,
+        currentPhase,
+        currentTask,
+        pendingTasks,
+        provider: readFile(path.join(STATE_DIR, 'provider')) || 'claude',
+        version: getVersion(),
+        lokiDir: LOKI_DIR,
+        timestamp: new Date().toISOString()
+    };
+}
+
+// Broadcast to SSE clients
+function broadcast(event, data) {
+    const message = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const client of sseClients) {
+        try {
+            client.write(message);
+        } catch {
+            sseClients.delete(client);
+        }
+    }
+}
+
+// Parse JSON body
+function parseBody(req) {
+    return new Promise((resolve) => {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            } catch {
+                resolve({});
+            }
+        });
+    });
+}
+
+// Request handler
+async function handleRequest(req, res) {
+    const url = new URL(req.url, `http://localhost:${PORT}`);
+    const method = req.method;
+    const pathname = url.pathname;
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (method === 'OPTIONS') {
+        res.writeHead(204);
+        return res.end();
+    }
+
+    // JSON response helper
+    const json = (data, status = 200) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+
+    // Routes
+    if (method === 'GET' && pathname === '/health') {
+        return json({ status: 'ok', version: getVersion() });
+    }
+
+    if (method === 'GET' && pathname === '/status') {
+        return json(getStatus());
+    }
+
+    if (method === 'GET' && pathname === '/events') {
+        // Server-Sent Events
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+
+        // Send initial status
+        res.write(`data: ${JSON.stringify(getStatus())}\n\n`);
+
+        sseClients.add(res);
+
+        // Periodic updates every 2 seconds
+        const interval = setInterval(() => {
+            try {
+                res.write(`data: ${JSON.stringify(getStatus())}\n\n`);
+            } catch {
+                clearInterval(interval);
+                sseClients.delete(res);
+            }
+        }, 2000);
+
+        req.on('close', () => {
+            clearInterval(interval);
+            sseClients.delete(res);
+        });
+        return;
+    }
+
+    if (method === 'GET' && pathname === '/logs') {
+        const lines = parseInt(url.searchParams.get('lines')) || 50;
+        const logFile = path.join(LOG_DIR, 'session.log');
+
+        if (!fs.existsSync(logFile)) {
+            return json({ logs: [], total: 0 });
+        }
+
+        const content = fs.readFileSync(logFile, 'utf8');
+        const allLines = content.trim().split('\n').filter(l => l);
+        const logs = allLines.slice(-lines);
+        return json({ logs, total: allLines.length });
+    }
+
+    if (method === 'POST' && pathname === '/start') {
+        const body = await parseBody(req);
+        const prd = body.prd || '';
+        const provider = body.provider || 'claude';
+        const parallel = body.parallel || false;
+        const background = body.background !== false; // default true for API
+
+        // Check if already running
+        const status = getStatus();
+        if (status.state === 'running') {
+            return json({ error: 'Session already running', pid: status.pid }, 409);
+        }
+
+        if (!fs.existsSync(RUN_SH)) {
+            return json({ error: 'run.sh not found', path: RUN_SH }, 500);
+        }
+
+        // Build arguments
+        const args = ['--provider', provider];
+        if (parallel) args.push('--parallel');
+        if (background) args.push('--bg');
+        if (prd) args.push(prd);
+
+        const child = spawn(RUN_SH, args, {
+            detached: true,
+            stdio: 'ignore',
+            cwd: process.cwd()
+        });
+        child.unref();
+
+        // Save provider for status
+        fs.writeFileSync(path.join(STATE_DIR, 'provider'), provider);
+
+        // Broadcast update
+        setTimeout(() => broadcast('status', getStatus()), 500);
+
+        return json({
+            started: true,
+            pid: child.pid,
+            provider,
+            args
+        });
+    }
+
+    if (method === 'POST' && pathname === '/stop') {
+        const stopFile = path.join(LOKI_DIR, 'STOP');
+        const pidFile = path.join(LOKI_DIR, 'loki.pid');
+
+        // Touch STOP file (signals graceful shutdown)
+        fs.writeFileSync(stopFile, new Date().toISOString());
+
+        // Also try to kill process directly
+        const pidStr = readFile(pidFile);
+        if (pidStr) {
+            const pid = parseInt(pidStr);
+            if (isRunning(pid)) {
+                try {
+                    process.kill(pid, 'SIGTERM');
+                } catch {
+                    // ignore
+                }
+            }
+        }
+
+        broadcast('status', getStatus());
+        return json({ stopped: true });
+    }
+
+    if (method === 'POST' && pathname === '/pause') {
+        const pauseFile = path.join(LOKI_DIR, 'PAUSE');
+        fs.writeFileSync(pauseFile, new Date().toISOString());
+        broadcast('status', getStatus());
+        return json({ paused: true });
+    }
+
+    if (method === 'POST' && pathname === '/resume') {
+        const pauseFile = path.join(LOKI_DIR, 'PAUSE');
+        const stopFile = path.join(LOKI_DIR, 'STOP');
+
+        try { fs.unlinkSync(pauseFile); } catch {}
+        try { fs.unlinkSync(stopFile); } catch {}
+
+        broadcast('status', getStatus());
+        return json({ resumed: true });
+    }
+
+    // 404 for unknown routes
+    json({ error: 'not found', path: pathname }, 404);
+}
+
+// Start server
+const server = http.createServer(handleRequest);
+
+server.listen(PORT, () => {
+    console.log(`Loki Mode API v${getVersion()}`);
+    console.log(`Listening on http://localhost:${PORT}`);
+    console.log('');
+    console.log('Endpoints:');
+    console.log('  GET  /health  - Health check');
+    console.log('  GET  /status  - Session status');
+    console.log('  GET  /events  - SSE stream (real-time updates)');
+    console.log('  GET  /logs    - Recent log lines (?lines=50)');
+    console.log('  POST /start   - Start session');
+    console.log('  POST /stop    - Stop session');
+    console.log('  POST /pause   - Pause after current task');
+    console.log('  POST /resume  - Resume paused session');
+    console.log('');
+    console.log(`LOKI_DIR: ${LOKI_DIR}`);
+    console.log(`SKILL_DIR: ${SKILL_DIR}`);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+    console.log('Shutting down...');
+    server.close(() => process.exit(0));
+});
+
+process.on('SIGINT', () => {
+    console.log('\nShutting down...');
+    server.close(() => process.exit(0));
+});

package/autonomy/loki

@@ -26,6 +26,7 @@ YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 CYAN='\033[0;36m'
 BOLD='\033[1m'
+DIM='\033[2m'
 NC='\033[0m'
 
 # Resolve the script's real path (handles symlinks)
@@ -108,6 +109,7 @@ show_help() {
     echo "  status           Show current status"
     echo "  logs             Show recent log output"
     echo "  dashboard        Open dashboard in browser"
+    echo "  provider [cmd]   Manage AI provider (show|set|list|info)"
     echo "  serve            Start HTTP API server (alias for api start)"
     echo "  api [cmd]        HTTP API server (start|stop|status)"
     echo "  sandbox [cmd]    Docker sandbox (start|stop|status|logs|shell|build)"
@@ -204,6 +206,19 @@ cmd_start() {
         args+=("$prd_file")
     fi
 
+    # Load saved provider if not specified on command line
+    if [ -z "$provider" ]; then
+        if [ -f "$LOKI_DIR/state/provider" ]; then
+            provider=$(cat "$LOKI_DIR/state/provider" 2>/dev/null)
+            if [ -n "$provider" ]; then
+                args+=("--provider" "$provider")
+            fi
+        fi
+    fi
+
+    # Determine effective provider for display
+    local effective_provider="${provider:-${LOKI_PROVIDER:-claude}}"
+
     # Handle sandbox mode - delegate to sandbox.sh
     if [[ "${LOKI_SANDBOX_MODE:-}" == "true" ]]; then
         if [ ! -f "$SANDBOX_SH" ]; then
@@ -235,11 +250,15 @@ cmd_start() {
     fi
 
     # Show provider info
-    if [ -n "$provider" ]; then
-        echo -e "${GREEN}Starting Loki Mode with provider: $provider${NC}"
+    echo -e "${GREEN}Starting Loki Mode...${NC}"
+    echo -e "${CYAN}Provider:${NC} $effective_provider"
+    if [ -f "$LOKI_DIR/state/provider" ]; then
+        echo -e "${DIM}  (saved for this project - change with: loki provider set <name>)${NC}"
     else
-        echo -e "${GREEN}Starting Loki Mode...${NC}"
+        echo -e "${DIM}  (default - save for project with: loki provider set <name>)${NC}"
     fi
+    echo ""
+
     exec "$RUN_SH" "${args[@]}"
 }
 
@@ -294,6 +313,16 @@ cmd_status() {
     echo -e "${BOLD}Loki Mode Status${NC}"
     echo ""
 
+    # Show current provider
+    local saved_provider=""
+    if [ -f "$LOKI_DIR/state/provider" ]; then
+        saved_provider=$(cat "$LOKI_DIR/state/provider" 2>/dev/null)
+    fi
+    local current_provider="${saved_provider:-${LOKI_PROVIDER:-claude}}"
+    echo -e "${CYAN}Provider:${NC} $current_provider"
+    echo -e "${DIM}  Switch with: loki provider set <claude|codex|gemini>${NC}"
+    echo ""
+
     # Check status file
     if [ -f "$LOKI_DIR/STATUS.txt" ]; then
         echo -e "${CYAN}Current Status:${NC}"
@@ -328,6 +357,192 @@ cmd_status() {
     fi
 }
 
+# Provider management
+cmd_provider() {
+    local subcommand="${1:-show}"
+    shift || true
+
+    case "$subcommand" in
+        show|current)
+            cmd_provider_show
+            ;;
+        set)
+            cmd_provider_set "$@"
+            ;;
+        list)
+            cmd_provider_list
+            ;;
+        info)
+            cmd_provider_info "$@"
+            ;;
+        *)
+            echo -e "${BOLD}Loki Mode Provider Management${NC}"
+            echo ""
+            echo "Usage: loki provider <command>"
+            echo ""
+            echo "Commands:"
+            echo "  show     Show current provider (default)"
+            echo "  set      Set provider for this project"
+            echo "  list     List available providers"
+            echo "  info     Show provider details"
+            echo ""
+            echo "Examples:"
+            echo "  loki provider show"
+            echo "  loki provider set claude"
+            echo "  loki provider set codex"
+            echo "  loki provider list"
+            echo "  loki provider info gemini"
+            ;;
+    esac
+}
+
+cmd_provider_show() {
+    local saved_provider=""
+    if [ -f "$LOKI_DIR/state/provider" ]; then
+        saved_provider=$(cat "$LOKI_DIR/state/provider" 2>/dev/null)
+    fi
+
+    local current="${saved_provider:-${LOKI_PROVIDER:-claude}}"
+
+    echo -e "${BOLD}Current Provider${NC}"
+    echo ""
+    echo -e "${CYAN}Provider:${NC} $current"
+
+    if [ -n "$saved_provider" ]; then
+        echo -e "${DIM}(saved in .loki/state/provider)${NC}"
+    else
+        echo -e "${DIM}(default - not explicitly set)${NC}"
+    fi
+
+    echo ""
+    echo -e "Switch provider: ${CYAN}loki provider set <name>${NC}"
+    echo -e "Available:       ${CYAN}loki provider list${NC}"
+}
+
+cmd_provider_set() {
+    local new_provider="${1:-}"
+
+    if [ -z "$new_provider" ]; then
+        echo -e "${RED}Error: Provider name required${NC}"
+        echo "Usage: loki provider set <claude|codex|gemini>"
+        exit 1
+    fi
+
+    # Validate provider
+    case "$new_provider" in
+        claude|codex|gemini)
+            ;;
+        *)
+            echo -e "${RED}Error: Invalid provider '$new_provider'${NC}"
+            echo "Valid providers: claude, codex, gemini"
+            exit 1
+            ;;
+    esac
+
+    # Save provider
+    mkdir -p "$LOKI_DIR/state"
+    echo "$new_provider" > "$LOKI_DIR/state/provider"
+
+    echo -e "${GREEN}Provider set to: $new_provider${NC}"
+    echo ""
+    echo "This will be used for all future runs in this project."
+    echo "Override temporarily with: loki start --provider <name>"
+}
+
+cmd_provider_list() {
+    echo -e "${BOLD}Available Providers${NC}"
+    echo ""
+
+    local saved_provider=""
+    if [ -f "$LOKI_DIR/state/provider" ]; then
+        saved_provider=$(cat "$LOKI_DIR/state/provider" 2>/dev/null)
+    fi
+    local current="${saved_provider:-${LOKI_PROVIDER:-claude}}"
+
+    # Check which CLIs are installed
+    local claude_status="${RED}not installed${NC}"
+    local codex_status="${RED}not installed${NC}"
+    local gemini_status="${RED}not installed${NC}"
+
+    if command -v claude &> /dev/null; then
+        claude_status="${GREEN}installed${NC}"
+    fi
+    if command -v codex &> /dev/null; then
+        codex_status="${GREEN}installed${NC}"
+    fi
+    if command -v gemini &> /dev/null; then
+        gemini_status="${GREEN}installed${NC}"
+    fi
+
+    # Display providers
+    local marker=""
+    [ "$current" = "claude" ] && marker=" ${CYAN}(current)${NC}"
+    echo -e "  claude  - Claude Code (Anthropic)     $claude_status$marker"
+
+    marker=""
+    [ "$current" = "codex" ] && marker=" ${CYAN}(current)${NC}"
+    echo -e "  codex   - Codex CLI (OpenAI)          $codex_status$marker"
+
+    marker=""
+    [ "$current" = "gemini" ] && marker=" ${CYAN}(current)${NC}"
+    echo -e "  gemini  - Gemini CLI (Google)         $gemini_status$marker"
+
+    echo ""
+    echo -e "Set provider: ${CYAN}loki provider set <name>${NC}"
+}
+
+cmd_provider_info() {
+    local provider="${1:-${LOKI_PROVIDER:-claude}}"
+
+    echo -e "${BOLD}Provider: $provider${NC}"
+    echo ""
+
+    case "$provider" in
+        claude)
+            echo "Name:        Claude Code"
+            echo "Vendor:      Anthropic"
+            echo "CLI:         claude"
+            echo "Flag:        --dangerously-skip-permissions"
+            echo ""
+            echo "Features:"
+            echo "  - Full autonomous mode"
+            echo "  - Task tool for subagents"
+            echo "  - Parallel execution"
+            echo "  - MCP server support"
+            echo ""
+            echo "Status:      Full features"
+            ;;
+        codex)
+            echo "Name:        Codex CLI"
+            echo "Vendor:      OpenAI"
+            echo "CLI:         codex"
+            echo "Flag:        exec --dangerously-bypass-approvals-and-sandbox"
+            echo ""
+            echo "Features:"
+            echo "  - Autonomous mode"
+            echo "  - Sequential only (no subagents)"
+            echo ""
+            echo "Status:      Degraded mode"
+            ;;
+        gemini)
+            echo "Name:        Gemini CLI"
+            echo "Vendor:      Google"
+            echo "CLI:         gemini"
+            echo "Flag:        --yolo"
+            echo ""
+            echo "Features:"
+            echo "  - Autonomous mode"
+            echo "  - Sequential only (no subagents)"
+            echo ""
+            echo "Status:      Degraded mode"
+            ;;
+        *)
+            echo -e "${RED}Unknown provider: $provider${NC}"
+            exit 1
+            ;;
+    esac
+}
+
 # Open dashboard in browser
 cmd_dashboard() {
     local port=${LOKI_DASHBOARD_PORT:-57374}
@@ -771,6 +986,9 @@ main() {
         config)
             cmd_config "$@"
             ;;
+        provider)
+            cmd_provider "$@"
+            ;;
         version|--version|-v)
             cmd_version
             ;;

package/autonomy/run.sh

@@ -498,6 +498,11 @@ if [ -f "$PROVIDERS_DIR/loader.sh" ]; then
         echo "ERROR: Failed to load provider config: $LOKI_PROVIDER" >&2
         exit 1
     fi
+
+    # Save provider for future runs (if .loki dir exists or will be created)
+    if [ -d ".loki/state" ] || mkdir -p ".loki/state" 2>/dev/null; then
+        echo "$LOKI_PROVIDER" > ".loki/state/provider"
+    fi
 else
     # Fallback: Claude-only mode (backwards compatibility)
     PROVIDER_NAME="claude"

package/autonomy/serve.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+# shellcheck disable=SC2034  # Unused variables are for future use or exported
+# shellcheck disable=SC2155  # Declare and assign separately
+#===============================================================================
+# Loki Mode - API Server Launcher
+#
+# Usage:
+#   ./autonomy/serve.sh [OPTIONS]
+#   loki serve [OPTIONS]
+#
+# Options:
+#   --port, -p <port>   Port to listen on (default: 8420)
+#   --host, -h <host>   Host to bind to (default: localhost)
+#   --no-cors           Disable CORS
+#   --no-auth           Disable authentication
+#   --help              Show help message
+#
+# Environment Variables:
+#   LOKI_API_PORT       Port (default: 8420)
+#   LOKI_API_HOST       Host (default: localhost)
+#   LOKI_API_TOKEN      API token for remote access
+#===============================================================================
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+API_DIR="$PROJECT_DIR/api"
+
+# Default configuration
+PORT="${LOKI_API_PORT:-8420}"
+HOST="${LOKI_API_HOST:-localhost}"
+CORS="true"
+AUTH="true"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+BOLD='\033[1m'
+
+log_info() {
+    echo -e "${CYAN}[INFO]${NC} $*"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $*" >&2
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $*"
+}
+
+show_help() {
+    cat << EOF
+Loki Mode API Server
+
+Usage:
+  ./autonomy/serve.sh [OPTIONS]
+  loki serve [OPTIONS]
+
+Options:
+  --port, -p <port>   Port to listen on (default: 8420)
+  --host <host>       Host to bind to (default: localhost)
+  --no-cors           Disable CORS
+  --no-auth           Disable authentication
+  --generate-token    Generate a new API token
+  --help              Show this help message
+
+Environment Variables:
+  LOKI_API_PORT       Port (overridden by --port)
+  LOKI_API_HOST       Host (overridden by --host)
+  LOKI_API_TOKEN      API token for remote access
+  LOKI_DIR            Loki installation directory
+  LOKI_DEBUG          Enable debug output
+
+Examples:
+  # Start with defaults (localhost:8420)
+  loki serve
+
+  # Custom port
+  loki serve --port 9000
+
+  # Allow remote access (requires token)
+  export LOKI_API_TOKEN=\$(loki serve --generate-token)
+  loki serve --host 0.0.0.0
+
+  # Connect from another machine
+  curl -H "Authorization: Bearer \$TOKEN" http://server:8420/health
+
+EOF
+}
+
+generate_token() {
+    # Generate a secure random token
+    if command -v openssl &> /dev/null; then
+        openssl rand -hex 32
+    elif command -v python3 &> /dev/null; then
+        python3 -c "import secrets; print(secrets.token_hex(32))"
+    else
+        # Fallback to /dev/urandom
+        head -c 32 /dev/urandom | xxd -p -c 64
+    fi
+}
+
+check_deno() {
+    if ! command -v deno &> /dev/null; then
+        log_error "Deno is required but not installed."
+        echo ""
+        echo "Install Deno:"
+        echo "  curl -fsSL https://deno.land/install.sh | sh"
+        echo "  # or"
+        echo "  brew install deno"
+        echo ""
+        exit 1
+    fi
+}
+
+main() {
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --port|-p)
+                PORT="$2"
+                shift 2
+                ;;
+            --host)
+                HOST="$2"
+                shift 2
+                ;;
+            --no-cors)
+                CORS="false"
+                shift
+                ;;
+            --no-auth)
+                AUTH="false"
+                shift
+                ;;
+            --generate-token)
+                generate_token
+                exit 0
+                ;;
+            --help|-h)
+                show_help
+                exit 0
+                ;;
+            *)
+                log_error "Unknown option: $1"
+                show_help
+                exit 1
+                ;;
+        esac
+    done
+
+    # Check for Deno
+    check_deno
+
+    # Check API directory exists
+    if [ ! -f "$API_DIR/server.ts" ]; then
+        log_error "API server not found at: $API_DIR/server.ts"
+        exit 1
+    fi
+
+    # Display startup info
+    echo ""
+    echo -e "${BOLD}${BLUE}"
+    echo "  ██╗      ██████╗ ██╗  ██╗██╗     █████╗ ██████╗ ██╗"
+    echo "  ██║     ██╔═══██╗██║ ██╔╝██║    ██╔══██╗██╔══██╗██║"
+    echo "  ██║     ██║   ██║█████╔╝ ██║    ███████║██████╔╝██║"
+    echo "  ██║     ██║   ██║██╔═██╗ ██║    ██╔══██║██╔═══╝ ██║"
+    echo "  ███████╗╚██████╔╝██║  ██╗██║    ██║  ██║██║     ██║"
+    echo "  ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝    ╚═╝  ╚═╝╚═╝     ╚═╝"
+    echo -e "${NC}"
+    echo -e "  ${CYAN}HTTP/SSE API Server${NC}"
+    echo -e "  ${CYAN}Version: $(cat "$PROJECT_DIR/VERSION" 2>/dev/null || echo "dev")${NC}"
+    echo ""
+
+    # Build command arguments
+    local deno_args=(
+        "--allow-net"
+        "--allow-read"
+        "--allow-write"
+        "--allow-env"
+        "--allow-run"
+    )
+
+    local server_args=(
+        "--port" "$PORT"
+        "--host" "$HOST"
+    )
+
+    [ "$CORS" = "false" ] && server_args+=("--no-cors")
+    [ "$AUTH" = "false" ] && server_args+=("--no-auth")
+
+    # Export environment variables
+    export LOKI_DIR="$PROJECT_DIR"
+    export LOKI_VERSION="$(cat "$PROJECT_DIR/VERSION" 2>/dev/null || echo "dev")"
+
+    # Start the server
+    log_info "Starting API server..."
+    log_info "Deno version: $(deno --version | head -1)"
+    echo ""
+
+    exec deno run "${deno_args[@]}" "$API_DIR/server.ts" "${server_args[@]}"
+}
+
+main "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.8.3",
+  "version": "5.8.4",
   "description": "Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "claude",