@ekkos/cli 0.2.10 → 0.2.12

package/dist/commands/setup-remote.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * ekkos setup-remote - One-command setup for remote terminal access
+ *
+ * This command does everything automatically:
+ * 1. Checks if user is logged in (prompts login if not)
+ * 2. Generates unique device ID and fingerprint
+ * 3. Opens browser for device pairing approval
+ * 4. Installs background agent as system service
+ * 5. Starts agent immediately
+ * 6. Verifies connection to cloud relay
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupRemote = setupRemote;
+const chalk_1 = __importDefault(require("chalk"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const open_1 = __importDefault(require("open"));
+const state_1 = require("../utils/state");
+const init_1 = require("./init");
+const PLATFORM_URL = process.env.PLATFORM_URL || 'https://platform.ekkos.dev';
+const MEMORY_API_URL = process.env.MEMORY_API_URL || 'https://mcp.ekkos.dev';
+const POLLING_INTERVAL = 2000; // 2 seconds
+const POLLING_TIMEOUT = 600000; // 10 minutes
+/**
+ * Get or create device info
+ */
+function getOrCreateDeviceInfo() {
+    const deviceFilePath = path.join(state_1.EKKOS_DIR, 'device.json');
+    // Check if device already registered
+    if (fs.existsSync(deviceFilePath)) {
+        const existing = JSON.parse(fs.readFileSync(deviceFilePath, 'utf-8'));
+        if (existing.deviceId) {
+            return existing;
+        }
+    }
+    // Generate new device ID
+    const deviceId = crypto.randomUUID();
+    // Get device name from hostname or system info
+    let deviceName = os.hostname();
+    if (os.platform() === 'darwin') {
+        try {
+            const computerName = (0, child_process_1.execSync)('scutil --get ComputerName', { encoding: 'utf-8' }).trim();
+            if (computerName)
+                deviceName = computerName;
+        }
+        catch {
+            // Fall back to hostname
+        }
+    }
+    const deviceInfo = {
+        deviceId,
+        deviceName,
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+        cliVersion: '0.2.8', // TODO: Get from package.json
+    };
+    // Save device info
+    if (!fs.existsSync(state_1.EKKOS_DIR)) {
+        fs.mkdirSync(state_1.EKKOS_DIR, { recursive: true });
+    }
+    fs.writeFileSync(deviceFilePath, JSON.stringify(deviceInfo, null, 2));
+    return deviceInfo;
+}
+/**
+ * Request device pairing code from server
+ */
+async function requestPairingCode(deviceInfo, authToken) {
+    const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/pair`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            deviceId: deviceInfo.deviceId,
+            deviceName: deviceInfo.deviceName,
+            hostname: deviceInfo.hostname,
+            platform: deviceInfo.platform,
+            arch: deviceInfo.arch,
+            fingerprint: deviceInfo,
+        }),
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+        const errorMessage = typeof errorData === 'string'
+            ? errorData
+            : errorData.error || errorData.message || JSON.stringify(errorData);
+        throw new Error(errorMessage || `Failed to request pairing code: ${response.status}`);
+    }
+    return response.json();
+}
+/**
+ * Poll for pairing approval
+ */
+async function pollForApproval(deviceCode, authToken) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < POLLING_TIMEOUT) {
+        const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/pair/${deviceCode}`, {
+            headers: {
+                'Authorization': `Bearer ${authToken}`,
+            },
+        });
+        if (response.status === 200) {
+            const data = await response.json();
+            if (data.status === 'approved') {
+                return { approved: true, deviceToken: data.deviceToken };
+            }
+        }
+        else if (response.status === 403) {
+            // Denied
+            return { approved: false };
+        }
+        else if (response.status === 410) {
+            // Expired
+            throw new Error('Pairing code expired');
+        }
+        // Wait before next poll
+        await new Promise(resolve => setTimeout(resolve, POLLING_INTERVAL));
+        process.stdout.write('.');
+    }
+    throw new Error('Pairing timeout');
+}
+/**
+ * Install agent as system service
+ */
+async function installService(verbose) {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        await installMacOSService(verbose);
+    }
+    else if (platform === 'win32') {
+        await installWindowsService(verbose);
+    }
+    else if (platform === 'linux') {
+        await installLinuxService(verbose);
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Install macOS launchd service
+ */
+async function installMacOSService(verbose) {
+    const plistName = 'dev.ekkos.agent';
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${plistName}.plist`);
+    // Find node path
+    const nodePath = process.execPath;
+    // Find ekkos CLI path (assuming it's in node_modules/.bin or globally installed)
+    let ekkosPath;
+    try {
+        ekkosPath = (0, child_process_1.execSync)('which ekkos', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // Fall back to npx
+        ekkosPath = 'npx @ekkos/cli';
+    }
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${plistName}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${ekkosPath.includes('npx') ? ekkosPath.split(' ')[0] : ekkosPath}</string>
+        ${ekkosPath.includes('npx') ? '<string>@ekkos/cli</string>' : ''}
+        <string>agent</string>
+        <string>daemon</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardErrorPath</key>
+    <string>${path.join(state_1.EKKOS_DIR, 'agent.err.log')}</string>
+    <key>StandardOutPath</key>
+    <string>${path.join(state_1.EKKOS_DIR, 'agent.out.log')}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+    </dict>
+</dict>
+</plist>`;
+    // Ensure directory exists
+    const launchAgentsDir = path.dirname(plistPath);
+    if (!fs.existsSync(launchAgentsDir)) {
+        fs.mkdirSync(launchAgentsDir, { recursive: true });
+    }
+    // Write plist
+    fs.writeFileSync(plistPath, plistContent);
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  Created: ${plistPath}`));
+    }
+    // Unload if already loaded
+    try {
+        (0, child_process_1.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: 'utf-8' });
+    }
+    catch {
+        // Ignore if not loaded
+    }
+    // Load the service
+    (0, child_process_1.execSync)(`launchctl load "${plistPath}"`, { encoding: 'utf-8' });
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  Loaded: ${plistName}`));
+    }
+}
+/**
+ * Install Windows service
+ */
+async function installWindowsService(verbose) {
+    // Windows uses a scheduled task that runs at login
+    const taskName = 'ekkOS Agent';
+    // Find ekkos CLI path
+    let ekkosPath;
+    try {
+        ekkosPath = (0, child_process_1.execSync)('where ekkos', { encoding: 'utf-8' }).trim().split('\n')[0];
+    }
+    catch {
+        // Fall back to npx
+        ekkosPath = 'npx';
+    }
+    // Create scheduled task
+    const command = ekkosPath.includes('npx')
+        ? `npx @ekkos/cli agent daemon`
+        : `"${ekkosPath}" agent daemon`;
+    try {
+        // Delete existing task
+        (0, child_process_1.execSync)(`schtasks /delete /tn "${taskName}" /f 2>nul`, { encoding: 'utf-8' });
+    }
+    catch {
+        // Ignore if doesn't exist
+    }
+    // Create task that runs at login
+    (0, child_process_1.execSync)(`schtasks /create /tn "${taskName}" /tr "${command}" /sc onlogon /rl limited`, { encoding: 'utf-8' });
+    // Start the task now
+    (0, child_process_1.execSync)(`schtasks /run /tn "${taskName}"`, { encoding: 'utf-8' });
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  Created scheduled task: ${taskName}`));
+    }
+}
+/**
+ * Install Linux systemd service
+ */
+async function installLinuxService(verbose) {
+    const serviceName = 'ekkos-agent';
+    const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    const servicePath = path.join(serviceDir, `${serviceName}.service`);
+    // Find ekkos CLI path
+    let ekkosPath;
+    try {
+        ekkosPath = (0, child_process_1.execSync)('which ekkos', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        ekkosPath = 'npx @ekkos/cli';
+    }
+    const serviceContent = `[Unit]
+Description=ekkOS Remote Terminal Agent
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${ekkosPath} agent daemon
+Restart=always
+RestartSec=10
+StandardOutput=append:${path.join(state_1.EKKOS_DIR, 'agent.out.log')}
+StandardError=append:${path.join(state_1.EKKOS_DIR, 'agent.err.log')}
+
+[Install]
+WantedBy=default.target
+`;
+    // Ensure directory exists
+    if (!fs.existsSync(serviceDir)) {
+        fs.mkdirSync(serviceDir, { recursive: true });
+    }
+    // Write service file
+    fs.writeFileSync(servicePath, serviceContent);
+    // Reload systemd and enable service
+    (0, child_process_1.execSync)('systemctl --user daemon-reload', { encoding: 'utf-8' });
+    (0, child_process_1.execSync)(`systemctl --user enable ${serviceName}`, { encoding: 'utf-8' });
+    (0, child_process_1.execSync)(`systemctl --user restart ${serviceName}`, { encoding: 'utf-8' });
+    if (verbose) {
+        console.log(chalk_1.default.gray(`  Created: ${servicePath}`));
+        console.log(chalk_1.default.gray(`  Enabled and started: ${serviceName}`));
+    }
+}
+/**
+ * Verify agent is connected
+ */
+async function verifyConnection(deviceInfo, authToken) {
+    // Wait a bit for agent to start
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    // Check device status
+    const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/devices/${(await (0, state_1.getState)())?.userId}`, {
+        headers: {
+            'Authorization': `Bearer ${authToken}`,
+        },
+    });
+    if (!response.ok) {
+        return false;
+    }
+    const data = await response.json();
+    const device = data.devices?.find((d) => d.deviceId === deviceInfo.deviceId);
+    return device?.online === true;
+}
+/**
+ * Main setup command
+ */
+async function setupRemote(options = {}) {
+    const verbose = options.verbose || false;
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('  🔧 ekkOS Remote Setup'));
+    console.log('');
+    // Step 1: Check if logged in
+    let authToken = (0, state_1.getAuthToken)();
+    if (!authToken) {
+        console.log(chalk_1.default.yellow('  You need to log in first.'));
+        console.log('');
+        await (0, init_1.init)({ ide: 'claude' });
+        authToken = (0, state_1.getAuthToken)();
+        if (!authToken) {
+            console.log(chalk_1.default.red('  Failed to authenticate. Please run `ekkos init` first.'));
+            process.exit(1);
+        }
+    }
+    const state = (0, state_1.getState)();
+    console.log(chalk_1.default.green(`  ✓ Logged in as ${state?.userEmail || 'unknown'}`));
+    // Step 2: Get or create device info
+    const deviceInfo = getOrCreateDeviceInfo();
+    console.log(chalk_1.default.green(`  ✓ Device: ${deviceInfo.deviceName} (${deviceInfo.arch})`));
+    // Step 3: Check if already paired
+    const deviceFilePath = path.join(state_1.EKKOS_DIR, 'device.json');
+    const deviceData = JSON.parse(fs.readFileSync(deviceFilePath, 'utf-8'));
+    if (deviceData.deviceToken && !options.force) {
+        console.log(chalk_1.default.green('  ✓ Device already paired'));
+    }
+    else {
+        // Request pairing code
+        console.log('');
+        console.log(chalk_1.default.cyan('  Requesting pairing code...'));
+        let pairingResponse;
+        try {
+            pairingResponse = await requestPairingCode(deviceInfo, authToken);
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(`  Error: ${err.message}`));
+            process.exit(1);
+        }
+        // Open browser for approval
+        const verificationUrl = pairingResponse.verificationUrl || `${PLATFORM_URL}/verify/${pairingResponse.userCode}`;
+        console.log('');
+        console.log(chalk_1.default.white(`  Verification code: ${chalk_1.default.bold.yellow(pairingResponse.userCode)}`));
+        console.log(chalk_1.default.gray(`  Opening browser to approve...`));
+        console.log('');
+        try {
+            await (0, open_1.default)(verificationUrl);
+        }
+        catch {
+            console.log(chalk_1.default.yellow(`  Could not open browser. Please visit:`));
+            console.log(chalk_1.default.cyan(`  ${verificationUrl}`));
+        }
+        // Poll for approval
+        console.log(chalk_1.default.gray('  Waiting for approval'));
+        process.stdout.write('  ');
+        try {
+            const result = await pollForApproval(pairingResponse.deviceCode, authToken);
+            console.log('');
+            if (!result.approved) {
+                console.log(chalk_1.default.red('  Pairing was denied.'));
+                process.exit(1);
+            }
+            // Save device token
+            deviceData.deviceToken = result.deviceToken;
+            deviceData.pairedAt = new Date().toISOString();
+            fs.writeFileSync(deviceFilePath, JSON.stringify(deviceData, null, 2));
+            console.log(chalk_1.default.green('  ✓ Device paired'));
+        }
+        catch (err) {
+            console.log('');
+            console.log(chalk_1.default.red(`  Error: ${err.message}`));
+            process.exit(1);
+        }
+    }
+    // Step 4: Install service (unless skipped)
+    if (!options.skipService) {
+        console.log(chalk_1.default.cyan('  Installing agent service...'));
+        try {
+            await installService(verbose);
+            console.log(chalk_1.default.green('  ✓ Agent installed and running'));
+        }
+        catch (err) {
+            console.log(chalk_1.default.yellow(`  Warning: Could not install service: ${err.message}`));
+            console.log(chalk_1.default.gray('  You can start the agent manually with: ekkos agent start'));
+        }
+    }
+    // Step 5: Verify connection
+    console.log(chalk_1.default.cyan('  Verifying connection...'));
+    const connected = await verifyConnection(deviceInfo, authToken);
+    if (connected) {
+        console.log(chalk_1.default.green('  ✓ Connected to ekkOS cloud'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  ⚠ Agent not connected yet (may take a moment)'));
+    }
+    // Success message
+    console.log('');
+    console.log(chalk_1.default.green.bold('  🎉 Setup complete!'));
+    console.log('');
+    console.log(chalk_1.default.white('  Access your terminal from anywhere at:'));
+    console.log(chalk_1.default.cyan(`    ${PLATFORM_URL}/dashboard/terminal`));
+    console.log('');
+    console.log(chalk_1.default.gray(`  Your device will appear as "${deviceInfo.deviceName}" in the device list.`));
+    console.log(chalk_1.default.gray('  The agent runs in background and auto-starts on boot.'));
+    console.log('');
+    console.log(chalk_1.default.dim('  How it works:'));
+    console.log(chalk_1.default.dim('  • Claude Code runs on THIS machine (uses your subscription)'));
+    console.log(chalk_1.default.dim('  • ekkOS provides secure relay to access it from any browser'));
+    console.log(chalk_1.default.dim('  • Your code/files stay local - only terminal I/O is relayed'));
+    console.log(chalk_1.default.dim('  • ekkOS learns from every session - faster, smarter, better over time'));
+    console.log('');
+    console.log(chalk_1.default.gray('  Commands:'));
+    console.log(chalk_1.default.gray('    ekkos agent status   - Check agent status'));
+    console.log(chalk_1.default.gray('    ekkos agent stop     - Stop agent temporarily'));
+    console.log(chalk_1.default.gray('    ekkos agent uninstall - Remove agent completely'));
+    console.log('');
+}

package/dist/index.js

@@ -12,6 +12,8 @@ const run_1 = require("./commands/run");
 const doctor_1 = require("./commands/doctor");
 const stream_1 = require("./commands/stream");
 const hooks_1 = require("./commands/hooks");
+const setup_remote_1 = require("./commands/setup-remote");
+const agent_1 = require("./commands/agent");
 const state_1 = require("./utils/state");
 const chalk_1 = __importDefault(require("chalk"));
 commander_1.program
@@ -47,6 +49,7 @@ commander_1.program
     .option('-b, --bypass', 'Enable bypass permissions mode (dangerously skip all permission checks)')
     .option('-v, --verbose', 'Show debug output')
     .option('-d, --doctor', 'Run diagnostics before starting')
+    .option('-r, --research', 'Auto-run research agent on startup (scans arXiv for new AI papers)')
     .option('--no-inject', 'Monitor-only mode (detect context wall but print instructions instead of auto-inject)')
     .action((options) => {
     (0, run_1.run)({
@@ -54,7 +57,8 @@ commander_1.program
         bypass: options.bypass,
         verbose: options.verbose,
         doctor: options.doctor,
-        noInject: options.noInject
+        noInject: options.noInject,
+        research: options.research
     });
 });
 // Doctor command - check system prerequisites
@@ -178,4 +182,74 @@ commander_1.program
         key: options.key
     });
 });
+// ============================================================================
+// REMOTE TERMINAL COMMANDS
+// ============================================================================
+// Setup remote - one-command setup for remote terminal access
+commander_1.program
+    .command('setup-remote')
+    .description('Set up remote terminal access (run Claude on your PC from anywhere)')
+    .option('-f, --force', 'Force re-pairing even if already paired')
+    .option('--skip-service', 'Skip installing background service')
+    .option('-v, --verbose', 'Show detailed output')
+    .action((options) => {
+    (0, setup_remote_1.setupRemote)({
+        force: options.force,
+        skipService: options.skipService,
+        verbose: options.verbose,
+    });
+});
+// Agent command - manage the background agent
+const agentCmd = commander_1.program
+    .command('agent')
+    .description('Manage the remote terminal agent');
+agentCmd
+    .command('daemon')
+    .description('Run the agent daemon (used by system service)')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentDaemon)({ verbose: options.verbose });
+});
+agentCmd
+    .command('start')
+    .description('Start the agent service')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentStart)({ verbose: options.verbose });
+});
+agentCmd
+    .command('stop')
+    .description('Stop the agent service')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentStop)({ verbose: options.verbose });
+});
+agentCmd
+    .command('restart')
+    .description('Restart the agent service')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentRestart)({ verbose: options.verbose });
+});
+agentCmd
+    .command('status')
+    .description('Check agent status and connection')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentStatus)({ verbose: options.verbose });
+});
+agentCmd
+    .command('uninstall')
+    .description('Remove the agent service and unpair device')
+    .option('-v, --verbose', 'Show verbose output')
+    .action((options) => {
+    (0, agent_1.agentUninstall)({ verbose: options.verbose });
+});
+agentCmd
+    .command('logs')
+    .description('Show agent logs')
+    .option('-f, --follow', 'Follow log output (like tail -f)')
+    .action((options) => {
+    (0, agent_1.agentLogs)({ follow: options.follow });
+});
 commander_1.program.parse();

package/dist/utils/state.d.ts

@@ -17,6 +17,8 @@ export interface EkkosState {
     turnNumber: number;
     lastUpdated: string;
     projectPath: string;
+    userId?: string;
+    userEmail?: string;
 }
 export interface EkkosConfig {
     hookApiKey?: string;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {
     "ekkos": "dist/index.js",
+    "cli": "dist/index.js",
     "ekkos-capture": "dist/cache/capture.js"
   },
   "scripts": {

package/templates/ekkos-manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://ekkos.dev/schemas/manifest-v1.json",
   "manifestVersion": "1.0.0",
-  "generatedAt": "2026-01-19T16:26:13.076Z",
+  "generatedAt": "2026-01-21T08:07:39.857Z",
   "platforms": {
     "darwin": {
       "configDir": "~/.ekkos",