teleportation-cli 1.0.0

package/lib/cli/daemon-commands.js

@@ -0,0 +1,299 @@
+/**
+ * Daemon Management Commands
+ * Handles away mode, back mode, and daemon status commands
+ */
+
+import { checkDaemonStatus, startDaemon, stopDaemon } from '../daemon/pid-manager.js';
+
+// Color helpers
+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',
+};
+
+/**
+ * Get relay API configuration from environment
+ */
+function getRelayConfig() {
+  return {
+    url: process.env.RELAY_API_URL || '',
+    key: process.env.RELAY_API_KEY || '',
+  };
+}
+
+/**
+ * Update session daemon state via Relay API
+ */
+async function updateSessionDaemonState(sessionId, updates) {
+  const { url, key } = getRelayConfig();
+
+  if (!sessionId || !url || !key) {
+    return false;
+  }
+
+  try {
+    const res = await fetch(`${url}/api/sessions/${encodeURIComponent(sessionId)}/daemon-state`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${key}`,
+      },
+      body: JSON.stringify(updates),
+    });
+
+    if (!res.ok) {
+      console.error(`[daemon-commands] Failed to update daemon_state: HTTP ${res.status}`);
+      return false;
+    }
+
+    return true;
+  } catch (err) {
+    console.error(`[daemon-commands] Error updating daemon_state:`, err.message);
+    return false;
+  }
+}
+
+/**
+ * Get current session ID from environment or config
+ */
+function getSessionId() {
+  // Try environment variable first
+  if (process.env.TELEPORTATION_SESSION_ID) {
+    return process.env.TELEPORTATION_SESSION_ID;
+  }
+
+  // Could also check config file or other sources
+  // For now, we'll require it to be set
+  return null;
+}
+
+/**
+ * Command: teleportation away
+ * Mark session as away and start daemon
+ */
+export async function commandAway() {
+  console.log(c.yellow('🚀 Marking session as away and starting daemon...\n'));
+
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    console.log(c.red('❌ Error: TELEPORTATION_SESSION_ID not set\n'));
+    console.log(c.cyan('Set the environment variable or use: teleportation away --session <id>\n'));
+    process.exit(1);
+  }
+
+  try {
+    // Update session daemon state
+    const updated = await updateSessionDaemonState(sessionId, {
+      is_away: true,
+      status: 'running',
+      started_reason: 'cli_away',
+    });
+
+    if (!updated) {
+      console.log(c.yellow('⚠️  Warning: Could not update session state via Relay API\n'));
+      console.log(c.cyan('Continuing with local daemon start...\n'));
+    } else {
+      console.log(c.green('✅ Session marked as away in Relay API\n'));
+    }
+
+    // Start daemon
+    const status = await checkDaemonStatus();
+    if (status.running) {
+      console.log(c.yellow('⚠️  Daemon already running (PID: ' + status.pid + ')\n'));
+    } else {
+      const result = await startDaemon();
+      if (result.success) {
+        console.log(c.green('✅ Daemon started (PID: ' + result.pid + ')\n'));
+      } else {
+        console.log(c.red('❌ Failed to start daemon: ' + result.error + '\n'));
+        process.exit(1);
+      }
+    }
+
+    console.log(c.green('✅ Session marked as away. Daemon is running.\n'));
+    console.log(c.cyan('When you return, run: teleportation back\n'));
+  } catch (error) {
+    console.log(c.red('❌ Error: ' + error.message + '\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Command: teleportation back
+ * Mark session as back and stop daemon if no other sessions
+ */
+export async function commandBack() {
+  console.log(c.yellow('🔙 Marking session as back and stopping daemon...\n'));
+
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    console.log(c.red('❌ Error: TELEPORTATION_SESSION_ID not set\n'));
+    console.log(c.cyan('Set the environment variable or use: teleportation back --session <id>\n'));
+    process.exit(1);
+  }
+
+  try {
+    // Update session daemon state
+    const updated = await updateSessionDaemonState(sessionId, {
+      is_away: false,
+      status: 'stopped',
+      started_reason: null,
+    });
+
+    if (!updated) {
+      console.log(c.yellow('⚠️  Warning: Could not update session state via Relay API\n'));
+      console.log(c.cyan('Continuing with local daemon stop...\n'));
+    } else {
+      console.log(c.green('✅ Session marked as back in Relay API\n'));
+    }
+
+    // Check if other sessions still need daemon
+    const { url, key } = getRelayConfig();
+    let shouldStop = true;
+
+    if (url && key) {
+      try {
+        const res = await fetch(`${url}/api/sessions`, {
+          headers: { 'Authorization': `Bearer ${key}` },
+        });
+
+        if (res.ok) {
+          const sessions = await res.json();
+          const otherRunning = sessions.some(
+            (s) =>
+              s.session_id !== sessionId &&
+              s.daemon_state &&
+              s.daemon_state.status === 'running'
+          );
+
+          if (otherRunning) {
+            console.log(c.yellow('⚠️  Other sessions still have daemon running\n'));
+            shouldStop = false;
+          }
+        }
+      } catch (err) {
+        console.log(c.yellow('⚠️  Could not check other sessions\n'));
+        // Continue with stop anyway
+      }
+    }
+
+    if (shouldStop) {
+      const status = await checkDaemonStatus();
+      if (!status.running) {
+        console.log(c.yellow('⚠️  Daemon not running\n'));
+      } else {
+        const result = await stopDaemon();
+        if (result.success) {
+          console.log(c.green('✅ Daemon stopped\n'));
+        } else {
+          console.log(c.red('❌ Failed to stop daemon: ' + result.error + '\n'));
+          process.exit(1);
+        }
+      }
+    }
+
+    console.log(c.green('✅ Session marked as back.\n'));
+  } catch (error) {
+    console.log(c.red('❌ Error: ' + error.message + '\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Command: teleportation daemon-status
+ * Show detailed daemon status
+ */
+export async function commandDaemonStatus() {
+  console.log(c.cyan('\n📊 Daemon Status\n'));
+
+  const sessionId = getSessionId();
+
+  try {
+    // Check daemon process
+    const status = await checkDaemonStatus();
+
+    console.log(c.yellow('Process:'));
+    if (status.running) {
+      console.log(c.green(`  Status: Running`));
+      console.log(`  PID: ${status.pid}`);
+      console.log(`  Uptime: ${formatUptime(status.uptime)}`);
+    } else {
+      console.log(c.red(`  Status: Stopped`));
+    }
+
+    // Get session daemon state from Relay API
+    if (sessionId) {
+      const { url, key } = getRelayConfig();
+
+      if (url && key) {
+        try {
+          const res = await fetch(`${url}/api/sessions/${encodeURIComponent(sessionId)}`, {
+            headers: { 'Authorization': `Bearer ${key}` },
+          });
+
+          if (res.ok) {
+            const session = await res.json();
+            const daemonState = session.daemon_state;
+
+            if (daemonState) {
+              console.log(c.yellow('\nSession State:'));
+              console.log(`  Status: ${daemonState.status === 'running' ? c.green('Running') : c.red('Stopped')}`);
+              console.log(`  Away: ${daemonState.is_away ? c.yellow('Yes') : c.green('No')}`);
+
+              if (daemonState.started_at) {
+                const startedDate = new Date(daemonState.started_at);
+                console.log(`  Started: ${startedDate.toLocaleString()}`);
+              }
+
+              if (daemonState.started_reason) {
+                console.log(`  Started Reason: ${daemonState.started_reason}`);
+              }
+
+              if (daemonState.last_approval_location) {
+                console.log(`  Last Approval: ${daemonState.last_approval_location}`);
+              }
+
+              if (daemonState.stopped_reason) {
+                console.log(`  Stopped Reason: ${daemonState.stopped_reason}`);
+              }
+            }
+          }
+        } catch (err) {
+          console.log(c.yellow('\n⚠️  Could not fetch session state from Relay API\n'));
+        }
+      }
+    }
+
+    console.log();
+  } catch (error) {
+    console.log(c.red('❌ Error: ' + error.message + '\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Format uptime in human-readable format
+ */
+function formatUptime(seconds) {
+  if (!seconds) return 'unknown';
+
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+
+  return parts.join(' ');
+}
+
+export default {
+  commandAway,
+  commandBack,
+  commandDaemonStatus,
+};

package/lib/cli/index.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+/**
+ * CLI Commands Index
+ * Exports all snapshot/worktree/session commands for integration with teleportation-cli.cjs
+ */
+
+// Worktree commands - import for local use
+import {
+  commandWorktreeCreate,
+  commandWorktreeList,
+  commandWorktreeRemove,
+  commandWorktreeInfo,
+  commandWorktreeMerge,
+  commandWorktreePrune,
+  commandWorktreeUse
+} from './worktree-commands.js';
+
+// Snapshot commands - import for local use
+import {
+  commandSnapshotCreate,
+  commandSnapshotList,
+  commandSnapshotRestore,
+  commandSnapshotDiff,
+  commandSnapshotDelete,
+  commandSnapshotDeleteAll
+} from './snapshot-commands.js';
+
+// Session commands - import for local use
+import {
+  commandSessionList,
+  commandSessionInfo,
+  commandCheckConflicts,
+  commandSessionStats,
+  commandSessionPause,
+  commandSessionResume,
+  commandSessionComplete,
+  commandSessionCleanup
+} from './session-commands.js';
+
+// Re-export all commands
+export {
+  commandWorktreeCreate,
+  commandWorktreeList,
+  commandWorktreeRemove,
+  commandWorktreeInfo,
+  commandWorktreeMerge,
+  commandWorktreePrune,
+  commandWorktreeUse,
+  commandSnapshotCreate,
+  commandSnapshotList,
+  commandSnapshotRestore,
+  commandSnapshotDiff,
+  commandSnapshotDelete,
+  commandSnapshotDeleteAll,
+  commandSessionList,
+  commandSessionInfo,
+  commandCheckConflicts,
+  commandSessionStats,
+  commandSessionPause,
+  commandSessionResume,
+  commandSessionComplete,
+  commandSessionCleanup
+};
+
+// Re-export types
+export { SnapshotType } from '../snapshot/manager.js';
+
+/**
+ * Parse CLI arguments for worktree/snapshot commands
+ * @param {Array<string>} args - Command line arguments
+ * @returns {Object} Parsed arguments
+ */
+export function parseArgs(args) {
+  const parsed = {
+    command: null,
+    subcommand: null,
+    sessionId: null,
+    snapshotId: null,
+    branch: null,
+    agent: 'claude-code',
+    base: 'main',
+    target: 'main',
+    type: 'checkpoint',
+    message: '',
+    force: false,
+    keepSnapshot: true,
+    repoOnly: false,
+    status: null,
+    deleteAfter: false
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === 'worktree' || arg === 'snapshot' || arg === 'session') {
+      parsed.command = arg;
+    } else if (arg === 'create' || arg === 'list' || arg === 'remove' ||
+               arg === 'info' || arg === 'merge' || arg === 'prune' ||
+               arg === 'use' || arg === 'restore' || arg === 'diff' ||
+               arg === 'delete' || arg === 'delete-all' || arg === 'stats' ||
+               arg === 'pause' || arg === 'resume' || arg === 'complete' ||
+               arg === 'cleanup' || arg === 'check-conflicts') {
+      parsed.subcommand = arg;
+    } else if (arg === '--session-id' || arg === '-s') {
+      parsed.sessionId = args[++i];
+    } else if (arg === '--snapshot-id') {
+      parsed.snapshotId = args[++i];
+    } else if (arg === '--branch' || arg === '-b') {
+      parsed.branch = args[++i];
+    } else if (arg === '--agent' || arg === '-a') {
+      parsed.agent = args[++i];
+    } else if (arg === '--base') {
+      parsed.base = args[++i];
+    } else if (arg === '--target') {
+      parsed.target = args[++i];
+    } else if (arg === '--type' || arg === '-t') {
+      parsed.type = args[++i];
+    } else if (arg === '--message' || arg === '-m') {
+      parsed.message = args[++i];
+    } else if (arg === '--force' || arg === '-f') {
+      parsed.force = true;
+    } else if (arg === '--no-snapshot') {
+      parsed.keepSnapshot = false;
+    } else if (arg === '--repo-only') {
+      parsed.repoOnly = true;
+    } else if (arg === '--status') {
+      parsed.status = args[++i];
+    } else if (arg === '--delete-after') {
+      parsed.deleteAfter = true;
+    }
+
+    i++;
+  }
+
+  return parsed;
+}
+
+/**
+ * Route to the appropriate command handler
+ * @param {Object} parsed - Parsed arguments
+ * @returns {Promise<any>}
+ */
+export async function routeCommand(parsed) {
+  const { command, subcommand } = parsed;
+
+  if (command === 'worktree') {
+    switch (subcommand) {
+      case 'create':
+        return commandWorktreeCreate(parsed);
+      case 'list':
+        return commandWorktreeList();
+      case 'remove':
+        return commandWorktreeRemove(parsed);
+      case 'info':
+        return commandWorktreeInfo(parsed);
+      case 'merge':
+        return commandWorktreeMerge(parsed);
+      case 'prune':
+        return commandWorktreePrune();
+      case 'use':
+        return commandWorktreeUse(parsed);
+      default:
+        console.log('Unknown worktree subcommand. Available: create, list, remove, info, merge, prune, use');
+        return;
+    }
+  }
+
+  if (command === 'snapshot') {
+    switch (subcommand) {
+      case 'create':
+        return commandSnapshotCreate(parsed);
+      case 'list':
+        return commandSnapshotList(parsed);
+      case 'restore':
+        return commandSnapshotRestore(parsed);
+      case 'diff':
+        return commandSnapshotDiff(parsed);
+      case 'delete':
+        return commandSnapshotDelete(parsed);
+      case 'delete-all':
+        return commandSnapshotDeleteAll(parsed);
+      default:
+        console.log('Unknown snapshot subcommand. Available: create, list, restore, diff, delete, delete-all');
+        return;
+    }
+  }
+
+  if (command === 'session') {
+    switch (subcommand) {
+      case 'list':
+        return commandSessionList(parsed);
+      case 'info':
+        return commandSessionInfo(parsed);
+      case 'check-conflicts':
+        return commandCheckConflicts(parsed);
+      case 'stats':
+        return commandSessionStats();
+      case 'pause':
+        return commandSessionPause(parsed);
+      case 'resume':
+        return commandSessionResume(parsed);
+      case 'complete':
+        return commandSessionComplete(parsed);
+      case 'cleanup':
+        return commandSessionCleanup();
+      default:
+        console.log('Unknown session subcommand. Available: list, info, check-conflicts, stats, pause, resume, complete, cleanup');
+        return;
+    }
+  }
+
+  console.log('Unknown command. Available: worktree, snapshot, session');
+}
+
+/**
+ * Print help for worktree/snapshot/session commands
+ */
+export function printHelp() {
+  console.log(`
+Teleportation Worktree, Snapshot & Session Commands
+
+WORKTREE COMMANDS:
+  worktree create -s <session-id> -b <branch> [--agent <agent>] [--base <base-branch>]
+    Create a new worktree for isolated session development
+
+  worktree list
+    List all session worktrees
+
+  worktree remove -s <session-id> [--force] [--no-snapshot]
+    Remove a worktree (creates pre-destroy snapshot by default)
+
+  worktree info [-s <session-id>]
+    Show information about a worktree
+
+  worktree use -s <session-id>
+    Show path to switch to a worktree
+
+  worktree merge -s <session-id> [--target <branch>] [--delete-after]
+    Merge a worktree branch (manual process guidance)
+
+  worktree prune
+    Clean up stale worktree references
+
+SNAPSHOT COMMANDS:
+  snapshot create [-s <session-id>] [-t <type>] [-m <message>]
+    Create a snapshot (types: baseline, checkpoint, pre-merge, pre-commit, auto, pre-destroy)
+
+  snapshot list [-s <session-id>]
+    List all snapshots for a session
+
+  snapshot restore --snapshot-id <id> [--force]
+    Restore a previous snapshot
+
+  snapshot diff --snapshot-id <id>
+    Show diff between current state and snapshot
+
+  snapshot delete --snapshot-id <id> [--force]
+    Delete a snapshot
+
+  snapshot delete-all [-s <session-id>] [--force]
+    Delete all snapshots for a session
+
+SESSION COMMANDS:
+  session list [--status <status>] [--repo-only]
+    List all registered sessions
+
+  session info [-s <session-id>]
+    Show detailed session information
+
+  session check-conflicts [-s <session-id>]
+    Check for file conflicts with other active sessions
+
+  session stats
+    Show session statistics
+
+  session pause [-s <session-id>]
+    Pause a session
+
+  session resume [-s <session-id>]
+    Resume a paused session
+
+  session complete [-s <session-id>]
+    Mark a session as completed
+
+  session cleanup
+    Clean up stale sessions (inactive > 24h)
+
+OPTIONS:
+  -s, --session-id <id>    Session identifier
+  -b, --branch <name>      Branch name
+  -a, --agent <type>       Agent type (default: claude-code)
+  -t, --type <type>        Snapshot type
+  -m, --message <msg>      Snapshot message
+  -f, --force              Force operation
+  --base <branch>          Base branch for new worktree (default: main)
+  --target <branch>        Target branch for merge (default: main)
+  --no-snapshot            Skip creating snapshot before destructive ops
+  --repo-only              Only show sessions for current repository
+  --status <status>        Filter by status (active, paused, completed)
+  --delete-after           Delete worktree after merge
+`);
+}