teleportation-cli 1.0.0 → 1.0.2

package/lib/cli/remote-commands.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+/**
+ * CLI Commands for Remote Session Management
+ *
+ * Provides command-line interface for:
+ * - Starting remote sessions
+ * - Listing and querying sessions
+ * - Viewing logs
+ * - Pulling results
+ * - Session control (stop, resume, destroy)
+ */
+
+import { RemoteOrchestrator } from '../remote/orchestrator.js';
+import { RemoteSessionManager } from '../remote/session-manager.js';
+import { ProviderFactory } from '../remote/providers/provider-factory.js';
+import { VaultClient } from '../remote/vault-client.js';
+import { LivePortClient } from '../remote/liveport-client.js';
+import { CodeSync } from '../remote/code-sync.js';
+import { randomUUID } from 'crypto';
+
+async function loadSavedRelayCredentials() {
+  try {
+    const { CredentialManager } = await import('../auth/credentials.js');
+    const manager = new CredentialManager();
+    const creds = await manager.load();
+
+    return {
+      relayApiUrl: creds?.relayApiUrl || '',
+      relayApiKey: creds?.relayApiKey || creds?.apiKey || '',
+      githubToken: creds?.githubToken || '',
+    };
+  } catch (error) {
+    if (process.env.TELEPORTATION_DEBUG === 'true') {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[remote] Failed to load saved credentials: ${message}`);
+    }
+    return {
+      relayApiUrl: '',
+      relayApiKey: '',
+      githubToken: '',
+    };
+  }
+}
+
+/**
+ * Color helpers for terminal output
+ */
+const c = {
+  red: (text) => `\x1b[0;31m${text}\x1b[0m`,
+  green: (text) => `\x1b[0;32m${text}\x1b[0m`,
+  yellow: (text) => `\x1b[1;33m${text}\x1b[0m`,
+  blue: (text) => `\x1b[0;34m${text}\x1b[0m`,
+  cyan: (text) => `\x1b[0;36m${text}\x1b[0m`,
+  purple: (text) => `\x1b[0;35m${text}\x1b[0m`
+};
+
+/**
+ * Format uptime from milliseconds to human-readable string
+ * @private
+ */
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+function createStubVaultClient() {
+  return {
+    apiUrl: process.env.MECH_VAULT_URL || process.env.VAULT_API_URL || 'https://vault.mechdna.net/api',
+    apiKey: process.env.MECH_API_KEY,
+    appId: process.env.MECH_APP_ID,
+  };
+}
+
+function createStubLivePortClient() {
+  return {
+    apiKey: process.env.LIVEPORT_API_KEY,
+    apiUrl: process.env.LIVEPORT_API_URL || 'https://api.liveport.dev/v1',
+  };
+}
+
+function getProviderForSession(session, deps = {}) {
+  if (deps.provider) return deps.provider;
+
+  const vaultClient = deps.vaultClient || createStubVaultClient();
+  const livePortClient = deps.livePortClient || createStubLivePortClient();
+
+  const providerFactory = deps.providerFactory || new ProviderFactory({
+    vaultClient,
+    livePortClient,
+    flyApiToken: process.env.FLY_API_TOKEN,
+    daytonaApiKey: process.env.DAYTONA_API_KEY,
+  });
+
+  return providerFactory.createProvider(session.provider);
+}
+
+/**
+ * Start a new remote session
+ *
+ * @param {Object} args - Command arguments
+ * @param {string} args.task - Task description
+ * @param {string} [args.branch] - Git branch name
+ * @param {string} [args.provider] - Provider type (fly or daytona)
+ * @param {boolean} [args.noPr] - Skip PR creation on completion
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<Object>} Session information
+ */
+export async function commandRemoteStart(args, deps = {}) {
+  const { task, branch, provider: providerOverride, noPr } = args;
+
+  // Validate required arguments
+  if (!task) {
+    throw new Error('Task description is required. Use --task "description"');
+  }
+
+  console.log(c.cyan('\nStarting remote session...'));
+  console.log(`Task: ${task}`);
+  if (branch) console.log(`Branch: ${branch}`);
+  if (providerOverride) console.log(`Provider: ${providerOverride}`);
+
+  try {
+    // Initialize dependencies (use injected for testing, or create real ones)
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    // Only create real clients if not in test mode (deps not provided)
+    let vaultClient, livePortClient, providerFactory, codeSync;
+
+    if (deps.orchestrator && deps.providerFactory) {
+      // Test mode: use all injected dependencies
+      vaultClient = deps.vaultClient;
+      livePortClient = deps.livePortClient;
+      providerFactory = deps.providerFactory;
+      codeSync = deps.codeSync;
+    } else {
+      // Production mode: create real clients
+      vaultClient = new VaultClient({
+        apiUrl: process.env.MECH_VAULT_URL || process.env.VAULT_API_URL || 'https://vault.mechdna.net/api',
+        apiKey: process.env.MECH_API_KEY,
+        appId: process.env.MECH_APP_ID
+      });
+      livePortClient = new LivePortClient({
+        apiKey: process.env.LIVEPORT_API_KEY,
+        apiUrl: process.env.LIVEPORT_API_URL || 'https://api.liveport.dev/v1'
+      });
+      providerFactory = new ProviderFactory({
+        vaultClient,
+        livePortClient,
+        flyApiToken: process.env.FLY_API_TOKEN,
+        daytonaApiKey: process.env.DAYTONA_API_KEY
+      });
+    }
+
+    // Select provider
+    const selectedProvider = providerFactory.selectAndCreate(task, {
+      provider: providerOverride
+    });
+
+    const providerType = providerOverride || providerFactory.selectProvider(task);
+    console.log(c.blue(`\nSelected provider: ${providerType}`));
+
+    // Generate session ID
+    const sessionId = `remote-${randomUUID().slice(0, 8)}`;
+
+    // Resolve relay credentials (prefer env vars; fallback to saved credentials)
+    const savedCreds = await loadSavedRelayCredentials();
+    const relayApiUrl = process.env.RELAY_API_URL || savedCreds.relayApiUrl;
+    const relayApiKey = process.env.RELAY_API_KEY || savedCreds.relayApiKey;
+
+    const githubToken = process.env.GITHUB_TOKEN || savedCreds.githubToken;
+
+    if (!relayApiUrl) {
+      throw new Error('Missing RELAY_API_URL. Set RELAY_API_URL or run `teleportation login --api-key ...`');
+    }
+    if (!relayApiKey) {
+      throw new Error('Missing RELAY_API_KEY. Set RELAY_API_KEY or run `teleportation login --api-key ...`');
+    }
+    if (!githubToken) {
+      throw new Error('Missing GitHub credentials. Set GITHUB_TOKEN or run `teleportation github connect --token ...`');
+    }
+
+    const repoPath = process.cwd();
+
+    // Create orchestrator (use injected or create real one)
+    if (!codeSync && !deps.orchestrator) {
+      codeSync = new CodeSync({
+        repoPath,
+        sessionId
+      });
+    }
+
+    const orchestrator = deps.orchestrator || new RemoteOrchestrator({
+      sessionId,
+      repoPath,
+      vaultClient,
+      livePortClient,
+      provider: selectedProvider
+    });
+
+    // Capture local state and secrets
+    console.log(c.yellow('\n→ Capturing local state...'));
+    const localState = await codeSync.captureLocalState();
+
+    // Start session
+    console.log(c.yellow('→ Provisioning remote machine...'));
+    await orchestrator.startSession({
+      task,
+      branch: branch || localState.branch,
+      repoUrl: localState.remoteUrl,
+      relayApiUrl,
+      relayApiKey,
+      githubToken,
+      mechApiKey: process.env.MECH_API_KEY
+    });
+
+    // Register session
+    const session = await sessionManager.registerSession({
+      id: sessionId,
+      provider: providerType,
+      machineId: orchestrator.machineId,
+      branch: localState.branch,
+      metadata: {
+        task,
+        tunnelUrl: orchestrator.tunnelUrl,
+        noPr,
+        startedAt: Date.now()
+      }
+    });
+
+    // Display results
+    console.log(c.green('\n✓ Remote session started successfully!\n'));
+    console.log(`Session ID:    ${c.cyan(sessionId)}`);
+    console.log(`Provider:      ${c.cyan(providerType)}`);
+    console.log(`Machine ID:    ${c.cyan(orchestrator.machineId)}`);
+    console.log(`Tunnel URL:    ${c.cyan(orchestrator.tunnelUrl)}`);
+    console.log(`Branch:        ${c.cyan(localState.branch)}`);
+    console.log(`\nTimeline:      ${c.cyan(`https://app.teleportation.dev/sessions/${sessionId}`)}`);
+
+    console.log(c.yellow('\n→ Remote AI agent is now working on your task'));
+    console.log(c.yellow('→ Approve actions from your mobile device'));
+    console.log(c.yellow(`→ Check status with: teleportation remote status ${sessionId}`));
+
+    return {
+      sessionId,
+      tunnelUrl: orchestrator.tunnelUrl,
+      machineId: orchestrator.machineId,
+      provider: providerType,
+      session
+    };
+  } catch (error) {
+    console.error(c.red(`\n✗ Failed to start remote session: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * List remote sessions
+ *
+ * @param {Object} args - Command arguments
+ * @param {string} [args.status] - Filter by status (running, paused, completed, failed)
+ * @param {string} [args.provider] - Filter by provider (fly, daytona)
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<Array>} List of sessions
+ */
+export async function commandRemoteList(args, deps = {}) {
+  const { status, provider } = args;
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const filters = {};
+    if (status) filters.status = status;
+    if (provider) filters.provider = provider;
+
+    const sessions = await sessionManager.listSessions(filters);
+
+    if (sessions.length === 0) {
+      console.log('No remote sessions found.');
+      return [];
+    }
+
+    console.log(c.cyan('\nRemote Sessions:\n'));
+    console.log(
+      'SESSION ID'.padEnd(20),
+      'PROVIDER'.padEnd(12),
+      'STATUS'.padEnd(12),
+      'BRANCH'.padEnd(25),
+      'UPTIME'
+    );
+    console.log('-'.repeat(95));
+
+    for (const session of sessions) {
+      const uptime = formatUptime(Date.now() - session.createdAt);
+      const statusColor = session.status === 'running' ? c.green :
+                         session.status === 'paused' ? c.yellow :
+                         session.status === 'completed' ? c.blue :
+                         c.red;
+
+      console.log(
+        session.id.padEnd(20),
+        session.provider.padEnd(12),
+        statusColor(session.status.padEnd(12)),
+        session.branch.padEnd(25),
+        uptime
+      );
+    }
+
+    console.log(`\n${c.cyan(`Total: ${sessions.length} session(s)`)}`);
+
+    return sessions;
+  } catch (error) {
+    console.error(c.red(`Failed to list sessions: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Show detailed status of a remote session
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<Object>} Session status details
+ */
+export async function commandRemoteStatus(sessionId, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.cyan('\nSession Status:\n'));
+    console.log(`Session ID:    ${session.id}`);
+    console.log(`Provider:      ${session.provider}`);
+    console.log(`Status:        ${c.green(session.status)}`);
+    console.log(`Branch:        ${session.branch}`);
+    console.log(`Machine ID:    ${session.machineId}`);
+
+    if (session.metadata.tunnelUrl) {
+      console.log(`Tunnel URL:    ${c.cyan(session.metadata.tunnelUrl)}`);
+    }
+
+    console.log(`\nCreated:       ${new Date(session.createdAt).toLocaleString()}`);
+    console.log(`Last Active:   ${new Date(session.lastActiveAt).toLocaleString()}`);
+    console.log(`Uptime:        ${formatUptime(Date.now() - session.createdAt)}`);
+
+    if (session.metadata.task) {
+      console.log(`\nTask:          ${session.metadata.task}`);
+    }
+
+    console.log(`\nTimeline:      ${c.cyan(`https://app.teleportation.dev/sessions/${sessionId}`)}`);
+
+    // Get machine status from orchestrator if available, otherwise query provider
+    let status = null;
+    if (deps.orchestrator) {
+      status = await deps.orchestrator.getStatus();
+    } else {
+      const provider = getProviderForSession(session, deps);
+      status = { machine: await provider.getMachineStatus(session.machineId) };
+    }
+
+    if (status?.machine) {
+      console.log(c.cyan('\nMachine Status:'));
+      console.log(`  State:       ${status.machine.state || status.machine.status || 'unknown'}`);
+      if (status.machine.cpu !== undefined) {
+        console.log(`  CPU:         ${status.machine.cpu}`);
+      }
+      if (status.machine.memory !== undefined) {
+        console.log(`  Memory:      ${status.machine.memory} MB`);
+      }
+    }
+
+    return {
+      session,
+      status
+    };
+  } catch (error) {
+    console.error(c.red(`Failed to get session status: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Stream logs from a remote session
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} options - Log options
+ * @param {boolean} [options.follow] - Follow log output
+ * @param {number} [options.tail] - Number of lines to show from end
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<Array>} Log entries
+ */
+export async function commandRemoteLogs(sessionId, options = {}, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.cyan(`\nLogs for session: ${sessionId}\n`));
+
+    const provider = getProviderForSession(session, deps);
+    const response = await provider.getLogs(session.machineId, options);
+
+    const entries = Array.isArray(response)
+      ? response
+      : (response && typeof response === 'object' && Array.isArray(response.logs))
+        ? response.logs
+        : [];
+
+    for (const entry of entries) {
+      if (entry && typeof entry === 'object' && entry.timestamp && entry.message) {
+        const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+        console.log(`${c.cyan(timestamp)} ${entry.message}`);
+      } else {
+        console.log(String(entry));
+      }
+    }
+
+    return entries;
+  } catch (error) {
+    console.error(c.red(`Failed to retrieve logs: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Pull results from a remote session
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<Object>} Pull result
+ */
+export async function commandRemotePull(sessionId, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.cyan(`\nPulling results from session: ${sessionId}\n`));
+
+    // Initialize CodeSync
+    const codeSync = deps.codeSync || new CodeSync({
+      repoPath: process.cwd(),
+      sessionId
+    });
+
+    // Check for conflicts
+    console.log(c.yellow('→ Checking for conflicts...'));
+    const conflicts = await codeSync.detectConflicts();
+
+    if (conflicts.hasConflicts) {
+      console.log(c.red('\n✗ Conflicts detected:'));
+      console.log(`  Conflicting files: ${conflicts.conflictingFiles.join(', ')}`);
+      throw new Error('Conflicts detected. Resolve conflicts before pulling.');
+    }
+
+    // Show diff summary
+    console.log(c.yellow('→ Fetching changes...'));
+    const diff = await codeSync.getDiffSummary();
+
+    console.log(c.cyan('\nChanges:'));
+    console.log(`  Behind remote: ${diff.behind} commit(s)`);
+    console.log(`  Files changed: ${diff.files.length}`);
+
+    if (diff.files.length > 0) {
+      console.log('\n  Modified files:');
+      diff.files.slice(0, 10).forEach(file => {
+        console.log(`    - ${file}`);
+      });
+      if (diff.files.length > 10) {
+        console.log(`    ... and ${diff.files.length - 10} more`);
+      }
+    }
+
+    // Pull changes
+    console.log(c.yellow('\n→ Pulling changes...'));
+    const result = await codeSync.pullFromRemote({
+      strategy: 'merge',
+      stashLocal: true
+    });
+
+    if (result.success) {
+      console.log(c.green('\n✓ Successfully pulled changes from remote session'));
+      console.log(`  Commit: ${result.commit}`);
+    } else {
+      console.log(c.red('\n✗ Failed to pull changes'));
+    }
+
+    return result;
+  } catch (error) {
+    console.error(c.red(`Failed to pull results: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Stop a remote session (pause)
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<void>}
+ */
+export async function commandRemoteStop(sessionId, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.yellow(`\nStopping session: ${sessionId}...`));
+
+    if (deps.orchestrator) {
+      await deps.orchestrator.stopSession();
+    } else {
+      const provider = getProviderForSession(session, deps);
+      await provider.stopMachine(session.machineId);
+    }
+
+    // Update session status
+    await sessionManager.updateSession(sessionId, {
+      status: 'paused'
+    });
+
+    console.log(c.green('✓ Session stopped (paused)'));
+  } catch (error) {
+    console.error(c.red(`Failed to stop session: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Resume a paused remote session
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<void>}
+ */
+export async function commandRemoteResume(sessionId, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.yellow(`\nResuming session: ${sessionId}...`));
+
+    const provider = getProviderForSession(session, deps);
+    await provider.startMachine(session.machineId);
+
+    // Update session status
+    await sessionManager.updateSession(sessionId, {
+      status: 'running'
+    });
+
+    console.log(c.green('✓ Session resumed'));
+  } catch (error) {
+    console.error(c.red(`Failed to resume session: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Destroy a remote session and cleanup all resources
+ *
+ * @param {string} sessionId - Session ID
+ * @param {Object} [deps] - Injected dependencies (for testing)
+ * @returns {Promise<void>}
+ */
+export async function commandRemoteDestroy(sessionId, deps = {}) {
+  if (!sessionId) {
+    throw new Error('Session ID is required');
+  }
+
+  // Require confirmation for destructive action
+  if (!deps.confirm) {
+    throw new Error('Confirmation required. Use --confirm to destroy session.');
+  }
+
+  try {
+    const sessionManager = deps.sessionManager || new RemoteSessionManager();
+
+    const session = await sessionManager.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    console.log(c.red(`\nDestroying session: ${sessionId}...`));
+    console.log(c.yellow('This will delete the remote machine and all resources.'));
+
+    if (deps.orchestrator) {
+      await deps.orchestrator.destroySession();
+    } else {
+      const provider = getProviderForSession(session, deps);
+      await provider.destroyMachine(session.machineId);
+    }
+
+    // Unregister session
+    await sessionManager.unregisterSession(sessionId);
+
+    console.log(c.green('✓ Session destroyed'));
+    console.log(c.cyan('All remote resources have been cleaned up.'));
+  } catch (error) {
+    console.error(c.red(`Failed to destroy session: ${error.message}`));
+    throw error;
+  }
+}