teleportation-cli 1.1.5 → 1.2.1

package/.claude/hooks/user_prompt_submit.mjs

@@ -46,6 +46,10 @@ const fetchJson = async (url, opts) => {
 
   const { session_id, prompt } = input;
 
+  // Detect message source
+  const isAutonomousTask = env.TELEPORTATION_TASK_MODE === 'true' || !!env.TELEPORTATION_PARENT_SESSION_ID;
+  const source = isAutonomousTask ? 'autonomous_task' : 'cli_interactive';
+
   // Clear away mode only on actual user activity (prompt submit), not on tool attempts.
   // Also support /away and /back here in case they are handled as prompts.
   if (session_id && prompt && typeof prompt === 'string') {
@@ -53,8 +57,15 @@ const fetchJson = async (url, opts) => {
     const lowered = trimmed.toLowerCase();
 
     let desiredAway = null;
-    if (lowered === '/away' || lowered === 'teleportation away') desiredAway = true;
-    else if (lowered === '/back' || lowered === 'teleportation back') desiredAway = false;
+    // Support multiple command formats: /away, teleportation away, teleport away, teleporation away (typo)
+    if (lowered === '/away' ||
+        lowered === 'teleportation away' ||
+        lowered === 'teleport away' ||
+        lowered === 'teleporation away') desiredAway = true;
+    else if (lowered === '/back' ||
+             lowered === 'teleportation back' ||
+             lowered === 'teleport back' ||
+             lowered === 'teleporation back') desiredAway = false;
     else if (trimmed.length > 0) desiredAway = false;
 
     if (desiredAway !== null) {
@@ -66,13 +77,21 @@ const fetchJson = async (url, opts) => {
         const RELAY_API_KEY = env.RELAY_API_KEY || config.relayApiKey || '';
 
         if (RELAY_API_URL && RELAY_API_KEY) {
+          // When user types locally, signal they're back and set location to 'local'
+          // This helps the daemon know to stop auto-continuing after approvals
+          const patchBody = { is_away: desiredAway };
+          if (desiredAway === false) {
+            // User is active locally - mark location as 'local'
+            patchBody.last_approval_location = 'local';
+          }
+
           await fetchJson(`${RELAY_API_URL}/api/sessions/${session_id}/daemon-state`, {
             method: 'PATCH',
             headers: {
               'Content-Type': 'application/json',
               'Authorization': `Bearer ${RELAY_API_KEY}`
             },
-            body: JSON.stringify({ is_away: desiredAway })
+            body: JSON.stringify(patchBody)
           });
           
           // Log away_mode_changed event to timeline (only for explicit /away or /back commands)
@@ -89,6 +108,7 @@ const fetchJson = async (url, opts) => {
                 body: JSON.stringify({
                   session_id,
                   type: 'away_mode_changed',
+                  source,
                   data: {
                     is_away: desiredAway,
                     source: 'user_prompt',
@@ -150,6 +170,7 @@ const fetchJson = async (url, opts) => {
             body: JSON.stringify({
               session_id,
               type: 'model_change_requested',
+              source,
               data: {
                 command: prompt,
                 timestamp: Date.now()
@@ -200,10 +221,12 @@ const fetchJson = async (url, opts) => {
             body: JSON.stringify({
               session_id,
               type: 'user_message',
+              source,
               data: {
                 prompt: truncatedPrompt,
                 full_length: trimmed.length,
                 truncated: trimmed.length > MAX_PROMPT_LENGTH,
+                source: 'cli',
                 timestamp: Date.now()
               }
             })

package/lib/cli/daemon-commands.js

@@ -3,7 +3,7 @@
  * Handles away mode, back mode, and daemon status commands
  */
 
-import { checkDaemonStatus, startDaemon, stopDaemon } from '../daemon/pid-manager.js';
+import { checkDaemonStatus, startDaemon, stopDaemon } from '../daemon/lifecycle.js';
 
 // Color helpers
 const c = {

package/lib/cli/teleport-commands.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+/**
+ * CLI Commands for Session Teleportation
+ *
+ * Provides command-line interface for:
+ * - Teleporting local sessions to cloud environments
+ * - Checking teleport status
+ * - Stopping teleports
+ * - Listing active teleports
+ */
+
+import { TeleportManager, TeleportMode, TeleportStatus } from '../teleport/manager.js';
+import { ProviderFactory } from '../remote/providers/provider-factory.js';
+import { getSupportedCoders } from '../teleport/exporters/index.js';
+
+/**
+ * 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`,
+  dim: (text) => `\x1b[2m${text}\x1b[0m`,
+};
+
+/**
+ * Load saved relay credentials
+ */
+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') {
+      console.error(`[teleport] Failed to load saved credentials: ${error.message}`);
+    }
+    return {
+      relayApiUrl: '',
+      relayApiKey: '',
+      githubToken: '',
+    };
+  }
+}
+
+/**
+ * Create provider factory with environment variables
+ */
+function createProviderFactory() {
+  return new ProviderFactory({
+    vaultClient: {
+      apiUrl: process.env.MECH_VAULT_URL || 'https://vault.mechdna.net/api',
+      apiKey: process.env.MECH_API_KEY,
+      appId: process.env.MECH_APP_ID,
+    },
+    livePortClient: {
+      apiKey: process.env.LIVEPORT_API_KEY,
+      apiUrl: process.env.LIVEPORT_API_URL || 'https://api.liveport.dev/v1',
+    },
+    flyApiToken: process.env.FLY_API_TOKEN,
+    daytonaApiKey: process.env.DAYTONA_API_KEY,
+    spritesApiKey: process.env.SPRITES_API_KEY,
+  });
+}
+
+/**
+ * Create TeleportManager instance
+ */
+async function createTeleportManager() {
+  const savedCreds = await loadSavedRelayCredentials();
+
+  const relayApiUrl = process.env.RELAY_API_URL || savedCreds.relayApiUrl || 'https://api.teleportation.dev';
+  const relayApiKey = process.env.RELAY_API_KEY || savedCreds.relayApiKey;
+
+  if (!relayApiKey) {
+    throw new Error('No relay API key found. Run "teleportation login" first.');
+  }
+
+  const providerFactory = createProviderFactory();
+
+  return new TeleportManager({
+    providerFactory,
+    relayApiUrl,
+    relayApiKey,
+  });
+}
+
+/**
+ * Format status with color
+ */
+function formatStatus(status) {
+  const statusColors = {
+    [TeleportStatus.PENDING]: c.dim,
+    [TeleportStatus.CAPTURING]: c.yellow,
+    [TeleportStatus.UPLOADING]: c.yellow,
+    [TeleportStatus.PROVISIONING]: c.yellow,
+    [TeleportStatus.EXPORTING]: c.yellow,
+    [TeleportStatus.RESUMING]: c.yellow,
+    [TeleportStatus.RUNNING]: c.green,
+    [TeleportStatus.COMPLETED]: c.blue,
+    [TeleportStatus.FAILED]: c.red,
+  };
+
+  const colorFn = statusColors[status] || c.dim;
+  return colorFn(status);
+}
+
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+/**
+ * Start a teleport session
+ *
+ * @param {Object} options
+ * @param {string} options.sessionId - Local session ID (or generates one)
+ * @param {string} [options.task] - Task description
+ * @param {string} [options.cwd] - Working directory
+ * @param {string} [options.provider] - Force specific provider
+ * @param {string} [options.targetCoder] - Target CLI (claude-code, gemini-cli)
+ * @param {string} [options.mode] - Teleport mode (pause, fork)
+ */
+export async function commandTeleportStart(options = {}) {
+  console.log(c.purple('\nTeleporting Session to Cloud...\n'));
+
+  const {
+    sessionId = `local-${Date.now()}`,
+    task,
+    cwd = process.cwd(),
+    provider,
+    targetCoder = 'claude-code',
+    mode = 'pause',
+  } = options;
+
+  // Validate target coder
+  const supportedCoders = getSupportedCoders();
+  if (!supportedCoders.includes(targetCoder)) {
+    console.log(c.red(`❌ Unsupported coder: ${targetCoder}`));
+    console.log(c.cyan(`Supported coders: ${supportedCoders.join(', ')}\n`));
+    process.exit(1);
+  }
+
+  // Validate mode
+  if (!Object.values(TeleportMode).includes(mode)) {
+    console.log(c.red(`❌ Invalid mode: ${mode}`));
+    console.log(c.cyan(`Valid modes: ${Object.values(TeleportMode).join(', ')}\n`));
+    process.exit(1);
+  }
+
+  try {
+    const manager = await createTeleportManager();
+
+    // Progress callback
+    const onProgress = (event) => {
+      const statusIcon = {
+        [TeleportStatus.CAPTURING]: '📷',
+        [TeleportStatus.UPLOADING]: '⬆️',
+        [TeleportStatus.PROVISIONING]: '🚀',
+        [TeleportStatus.EXPORTING]: '📦',
+        [TeleportStatus.RESUMING]: '▶️',
+        [TeleportStatus.RUNNING]: '✅',
+      };
+      const icon = statusIcon[event.status] || '⏳';
+      console.log(`  ${icon} ${event.status}`);
+    };
+
+    console.log(c.yellow('Session Details:'));
+    console.log(`  Session ID: ${c.cyan(sessionId)}`);
+    console.log(`  Working Dir: ${c.dim(cwd)}`);
+    console.log(`  Target CLI: ${c.cyan(targetCoder)}`);
+    console.log(`  Mode: ${c.cyan(mode)}`);
+    if (task) console.log(`  Task: ${task}`);
+    if (provider) console.log(`  Provider: ${c.cyan(provider)}`);
+    console.log('');
+
+    console.log(c.yellow('Progress:'));
+
+    const result = await manager.initiateTeleport(sessionId, {
+      task,
+      cwd,
+      provider,
+      targetCoder,
+      mode,
+      onProgress,
+    });
+
+    console.log('');
+    console.log(c.green('✅ Teleport Started Successfully!\n'));
+
+    console.log(c.yellow('Teleport Details:'));
+    console.log(`  Teleport ID: ${c.cyan(result.teleportId)}`);
+    console.log(`  Provider: ${c.cyan(result.provider)}`);
+    console.log(`  Machine ID: ${c.dim(result.machineId)}`);
+    if (result.spriteUrl) {
+      console.log(`  Sprite URL: ${c.blue(result.spriteUrl)}`);
+    }
+    if (result.tunnelUrl) {
+      console.log(`  Tunnel URL: ${c.blue(result.tunnelUrl)}`);
+    }
+    console.log(`  Timeline: ${c.blue(result.timelineUrl)}`);
+    console.log('');
+
+    if (mode === TeleportMode.PAUSE) {
+      console.log(c.yellow('⏸️  Local session paused. Work continues on cloud.\n'));
+    } else {
+      console.log(c.yellow('🔀 Fork mode: Local session continues in parallel.\n'));
+    }
+
+    return result;
+  } catch (error) {
+    console.log(c.red(`\n❌ Teleport failed: ${error.message}\n`));
+    if (process.env.TELEPORTATION_DEBUG === 'true') {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Get teleport status
+ *
+ * @param {string} teleportId - Teleport ID
+ */
+export async function commandTeleportStatus(teleportId) {
+  if (!teleportId) {
+    console.log(c.red('❌ Teleport ID is required\n'));
+    process.exit(1);
+  }
+
+  try {
+    const manager = await createTeleportManager();
+    const state = manager.getTeleportStatus(teleportId);
+
+    if (!state) {
+      console.log(c.red(`❌ Teleport not found: ${teleportId}\n`));
+      process.exit(1);
+    }
+
+    console.log(c.purple(`\nTeleport Status: ${teleportId}\n`));
+
+    console.log(c.yellow('Status:'));
+    console.log(`  Status: ${formatStatus(state.status)}`);
+    console.log(`  Session ID: ${c.cyan(state.sessionId)}`);
+    console.log(`  Mode: ${c.cyan(state.mode)}`);
+    console.log(`  Target CLI: ${c.cyan(state.targetCoder)}`);
+
+    if (state.provider) {
+      console.log(`  Provider: ${c.cyan(state.provider)}`);
+    }
+    if (state.machineId) {
+      console.log(`  Machine ID: ${c.dim(state.machineId)}`);
+    }
+
+    console.log('');
+    console.log(c.yellow('Timestamps:'));
+    console.log(`  Created: ${c.dim(state.createdAt)}`);
+    if (state.updatedAt) {
+      console.log(`  Updated: ${c.dim(state.updatedAt)}`);
+    }
+    if (state.completedAt) {
+      console.log(`  Completed: ${c.dim(state.completedAt)}`);
+    }
+
+    if (state.task) {
+      console.log('');
+      console.log(c.yellow('Task:'));
+      console.log(`  ${state.task}`);
+    }
+
+    if (state.error) {
+      console.log('');
+      console.log(c.red('Error:'));
+      console.log(`  ${state.error}`);
+    }
+
+    // Get commit stats if available
+    const commitStats = manager.getCommitStats(teleportId);
+    if (commitStats) {
+      console.log('');
+      console.log(c.yellow('Git Commits:'));
+      console.log(`  Total Commits: ${c.cyan(commitStats.commitCount)}`);
+      console.log(`  Auto-Commit Active: ${commitStats.isRunning ? c.green('Yes') : c.dim('No')}`);
+      if (commitStats.lastCommitAt) {
+        console.log(`  Last Commit: ${c.dim(commitStats.lastCommitAt)}`);
+      }
+    }
+
+    console.log('');
+
+    return state;
+  } catch (error) {
+    console.log(c.red(`\n❌ Failed to get status: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * List active teleports
+ *
+ * @param {Object} [options]
+ * @param {string} [options.status] - Filter by status
+ */
+export async function commandTeleportList(options = {}) {
+  console.log(c.purple('\nActive Teleports\n'));
+
+  try {
+    const manager = await createTeleportManager();
+    let teleports = manager.listActiveTeleports();
+
+    // Filter by status if specified
+    if (options.status) {
+      teleports = teleports.filter(t => t.status === options.status);
+    }
+
+    if (teleports.length === 0) {
+      console.log(c.dim('No active teleports found.\n'));
+      console.log(c.cyan('Start a teleport with: teleportation teleport start --task "your task"\n'));
+      return;
+    }
+
+    // Table header
+    console.log(c.dim('─'.repeat(80)));
+    console.log(
+      c.yellow('ID'.padEnd(20)) +
+      c.yellow('Status'.padEnd(15)) +
+      c.yellow('Provider'.padEnd(12)) +
+      c.yellow('CLI'.padEnd(15)) +
+      c.yellow('Age')
+    );
+    console.log(c.dim('─'.repeat(80)));
+
+    for (const t of teleports) {
+      const age = formatDuration(Date.now() - new Date(t.createdAt).getTime());
+      console.log(
+        t.teleportId.substring(0, 18).padEnd(20) +
+        formatStatus(t.status).padEnd(15 + 10) + // Extra for ANSI codes
+        (t.provider || '-').padEnd(12) +
+        t.targetCoder.padEnd(15) +
+        c.dim(age)
+      );
+    }
+
+    console.log(c.dim('─'.repeat(80)));
+    console.log(c.dim(`\nTotal: ${teleports.length} teleport(s)\n`));
+
+    return teleports;
+  } catch (error) {
+    console.log(c.red(`\n❌ Failed to list teleports: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Stop a teleport session
+ *
+ * @param {string} teleportId - Teleport ID
+ * @param {Object} [options]
+ * @param {boolean} [options.createPR] - Create PR with results
+ * @param {string} [options.baseBranch] - Base branch for PR
+ */
+export async function commandTeleportStop(teleportId, options = {}) {
+  if (!teleportId) {
+    console.log(c.red('❌ Teleport ID is required\n'));
+    process.exit(1);
+  }
+
+  console.log(c.yellow(`\nStopping teleport: ${teleportId}\n`));
+
+  try {
+    const manager = await createTeleportManager();
+
+    const result = await manager.stopTeleport(teleportId, {
+      success: true,
+      createPR: options.createPR,
+      baseBranch: options.baseBranch,
+    });
+
+    if (!result.success) {
+      console.log(c.red(`❌ Failed to stop teleport: ${result.error}\n`));
+      process.exit(1);
+    }
+
+    console.log(c.green('✅ Teleport stopped successfully!\n'));
+
+    if (result.delivery) {
+      console.log(c.yellow('Results Delivered:'));
+      console.log(`  Strategy: ${c.cyan(result.delivery.strategy)}`);
+      if (result.delivery.prUrl) {
+        console.log(`  PR: ${c.blue(result.delivery.prUrl)}`);
+      }
+      if (result.delivery.branch) {
+        console.log(`  Branch: ${c.cyan(result.delivery.branch)}`);
+      }
+      console.log('');
+    }
+
+    if (result.deliveryError) {
+      console.log(c.yellow('⚠️  Delivery issue:'));
+      console.log(`  ${c.dim(result.deliveryError)}\n`);
+    }
+
+    return result;
+  } catch (error) {
+    console.log(c.red(`\n❌ Failed to stop teleport: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Show help for teleport commands
+ */
+export function commandTeleportHelp() {
+  console.log(c.purple('\nSession Teleportation Commands\n'));
+  console.log(c.cyan('Transfer local coding sessions to cloud environments\n'));
+
+  console.log(c.yellow('Commands:'));
+  console.log('  ' + c.green('teleport start') + '              Start teleporting current session');
+  console.log('  ' + c.green('teleport status <id>') + '        Get teleport status');
+  console.log('  ' + c.green('teleport list') + '               List active teleports');
+  console.log('  ' + c.green('teleport stop <id>') + '          Stop a teleport session\n');
+
+  console.log(c.yellow('Start Options:'));
+  console.log('  ' + c.green('--task "description"') + '        Task for the cloud session');
+  console.log('  ' + c.green('--cwd /path') + '                 Working directory (default: current)');
+  console.log('  ' + c.green('--provider sprites|daytona') + ' Force specific cloud provider');
+  console.log('  ' + c.green('--target-coder cli') + '          Target CLI (claude-code, gemini-cli)');
+  console.log('  ' + c.green('--mode pause|fork') + '           Teleport mode\n');
+
+  console.log(c.yellow('Stop Options:'));
+  console.log('  ' + c.green('--create-pr') + '                 Create PR with results');
+  console.log('  ' + c.green('--base-branch main') + '          Base branch for PR\n');
+
+  console.log(c.yellow('Modes:'));
+  console.log('  ' + c.cyan('pause') + '  Pause local session, continue on cloud (default)');
+  console.log('  ' + c.cyan('fork') + '   Fork: local continues, cloud runs in parallel\n');
+
+  console.log(c.purple('Examples:'));
+  console.log('  teleportation teleport start --task "Implement feature X"');
+  console.log('  teleportation teleport start --target-coder gemini-cli --mode fork');
+  console.log('  teleportation teleport status tel_abc123xyz');
+  console.log('  teleportation teleport stop tel_abc123xyz --create-pr');
+  console.log('');
+}
+
+export default {
+  commandTeleportStart,
+  commandTeleportStatus,
+  commandTeleportList,
+  commandTeleportStop,
+  commandTeleportHelp,
+};

package/lib/daemon/daemon-v2.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Teleportation Daemon v2
+ * 
+ * Powered by @derivativelabs/agent-process.
+ * Decomposed into modular services.
+ */
+
+import { createAgent } from '@derivativelabs/agent-process';
+import { HeartbeatService } from '@derivativelabs/agent-process/services';
+import { createDaemonState } from './state.js';
+import { SessionService, QueueService, PollingService } from './services/index.js';
+import { CredentialManager } from '../auth/credentials.js';
+
+async function main() {
+  console.log('[daemon-v2] Starting up...');
+
+  // 1. Configuration
+  const config = {
+    port: parseInt(process.env.TELEPORTATION_DAEMON_PORT || '3050', 10),
+    relayApiUrl: process.env.RELAY_API_URL || 'https://api.teleportation.dev',
+    relayApiKey: process.env.RELAY_API_KEY || '',
+    pollIntervalMs: parseInt(process.env.DAEMON_POLL_INTERVAL_MS || '5000', 10),
+    cleanupIntervalMs: 60 * 60 * 1000, // 1 hour
+    idleCheckIntervalMs: 300000, // 5 min
+    idleTimeoutMs: 1800000, // 30 min
+  };
+
+  // 2. Load credentials if not in environment
+  if (!config.relayApiKey) {
+    try {
+      const credManager = new CredentialManager();
+      const creds = await credManager.load();
+      if (creds && creds.apiKey) {
+        config.relayApiKey = creds.apiKey;
+        config.relayApiUrl = creds.relayUrl || config.relayApiUrl;
+      }
+    } catch (e) {
+      console.warn('[daemon-v2] Failed to load credentials:', e.message);
+    }
+  }
+
+  // 3. Shared State
+  const state = createDaemonState();
+
+  // 4. Services
+  const sessionService = new SessionService(state, config);
+  const queueService = new QueueService(state, config);
+  const pollingService = new PollingService(state, config);
+
+  // 5. Agent
+  const agent = createAgent({
+    name: 'teleportation-daemon',
+    port: config.port,
+    services: [
+      // Custom Services
+      sessionService,
+      queueService,
+      pollingService,
+
+      // Interval-based services using built-in HeartbeatService
+      new HeartbeatService({
+        name: 'relay-polling',
+        interval: config.pollIntervalMs,
+        handler: () => pollingService.poll()
+      }),
+      new HeartbeatService({
+        name: 'queue-processor',
+        interval: 1000, // Process queue every second
+        handler: () => queueService.processNext()
+      }),
+      new HeartbeatService({
+        name: 'session-cleanup',
+        interval: 60000, // Every minute
+        handler: () => {
+          const now = Date.now();
+          const timeout = 240000; // 4 minutes
+          for (const [id, lastActivity] of state.sessionActivity) {
+            if (now - lastActivity > timeout) {
+              state.sessions.delete(id);
+              state.sessionActivity.delete(id);
+              console.log(`[daemon-v2] Cleaned up stale session ${id}`);
+            }
+          }
+        }
+      })
+    ]
+  });
+
+  // 6. Start
+  try {
+    await agent.start();
+    console.log('[daemon-v2] Ready');
+  } catch (error) {
+    console.error('[daemon-v2] Failed to start:', error);
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('[daemon-v2] Critical error:', err);
+  process.exit(1);
+});