teleportation-cli 1.0.0 → 1.0.1

package/lib/remote/code-sync.js

@@ -0,0 +1,213 @@
+/**
+ * CodeSync
+ *
+ * Manages git state synchronization between local and remote machines:
+ * - Capture local state (branch, commit, uncommitted changes)
+ * - Sync code to remote machine
+ * - Pull changes from remote
+ * - Conflict detection
+ *
+ * Integrates with existing GitHandoff system from lib/handoff/git-handoff.js
+ */
+
+import { GitHandoff } from '../handoff/git-handoff.js';
+
+/**
+ * Local state structure
+ * @typedef {Object} LocalState
+ * @property {string} branch - Current branch name
+ * @property {string} commit - Current commit hash
+ * @property {string} remoteUrl - Remote repository URL
+ * @property {Array<string>} uncommittedChanges - List of uncommitted files
+ * @property {boolean} hasUncommitted - Whether there are uncommitted changes
+ * @property {number} timestamp - Capture timestamp
+ */
+
+/**
+ * CodeSync class
+ */
+export class CodeSync {
+  /**
+   * @param {Object} options
+   * @param {string} options.repoPath - Path to git repository
+   * @param {string} options.sessionId - Session identifier
+   * @param {Object} [options.gitHandoff] - GitHandoff instance (optional, will create if not provided)
+   */
+  constructor(options) {
+    const { repoPath, sessionId, gitHandoff } = options;
+
+    if (!repoPath) {
+      throw new Error('repoPath is required');
+    }
+
+    if (!sessionId) {
+      throw new Error('sessionId is required');
+    }
+
+    this.repoPath = repoPath;
+    this.sessionId = sessionId;
+
+    // Use provided GitHandoff or create new one
+    this.gitHandoff = gitHandoff || new GitHandoff({
+      repoPath,
+      sessionId,
+      branchPrefix: 'teleport/wip-'
+    });
+  }
+
+  /**
+   * Capture current local git state
+   * @returns {Promise<LocalState>}
+   */
+  async captureLocalState() {
+    // Verify git repository
+    const isRepo = await this.gitHandoff.isGitRepo();
+    if (!isRepo) {
+      throw new Error(`Not a git repository: ${this.repoPath}`);
+    }
+
+    // Get current state
+    const branch = await this.gitHandoff.getCurrentBranch();
+    const commit = await this.gitHandoff.getCurrentCommit();
+    const remoteUrl = await this.gitHandoff.getRemoteUrl();
+
+    if (!remoteUrl) {
+      throw new Error('No remote URL configured');
+    }
+
+    const hasUncommitted = await this.gitHandoff.hasUncommittedChanges();
+    const uncommittedChanges = hasUncommitted
+      ? await this.gitHandoff.getChangedFiles()
+      : [];
+
+    return {
+      branch,
+      commit,
+      remoteUrl,
+      uncommittedChanges,
+      hasUncommitted,
+      timestamp: Date.now()
+    };
+  }
+
+  /**
+   * Sync code to remote machine
+   * @param {Object} options
+   * @param {string} options.machineId - Remote machine ID
+   * @param {LocalState} [options.localState] - Pre-captured local state (optional)
+   * @returns {Promise<Object>}
+   */
+  async syncToRemote(options) {
+    const { machineId, localState: providedState } = options;
+
+    // Use provided state or capture fresh
+    const localState = providedState || await this.captureLocalState();
+
+    // If there are uncommitted changes, commit them as WIP
+    let wipCommit = null;
+    if (localState.hasUncommitted) {
+      const hasChanges = await this.gitHandoff.hasUncommittedChanges();
+      if (hasChanges) {
+        const result = await this.gitHandoff.commitWip(
+          `Remote sync for session ${this.sessionId}`
+        );
+        wipCommit = result.commit;
+      }
+    }
+
+    // Push to WIP branch
+    await this.gitHandoff.pushToWipBranch(true); // force push
+
+    return {
+      success: true,
+      sessionId: this.sessionId,
+      machineId,
+      branch: localState.branch,
+      commit: localState.commit,
+      wipCommit,
+      syncedAt: Date.now()
+    };
+  }
+
+  /**
+   * Pull changes from remote machine
+   * @param {Object} options
+   * @param {string} [options.strategy='merge'] - Sync strategy ('merge' or 'rebase')
+   * @param {boolean} [options.stashLocal=true] - Stash local changes before pulling
+   * @returns {Promise<Object>}
+   */
+  async pullFromRemote(options = {}) {
+    const { strategy = 'merge', stashLocal = true } = options;
+
+    // Fetch WIP branch
+    await this.gitHandoff.fetchWipBranch();
+
+    // Check if there are remote changes
+    const remoteCheck = await this.gitHandoff.checkRemoteChanges();
+    if (!remoteCheck.hasChanges) {
+      return {
+        success: true,
+        hasChanges: false,
+        commit: remoteCheck.localCommit
+      };
+    }
+
+    // Sync from remote
+    const result = await this.gitHandoff.syncFromRemote({
+      strategy,
+      stashLocal
+    });
+
+    return {
+      success: result.success,
+      hasChanges: true,
+      commit: result.commit,
+      conflicts: result.conflicts
+    };
+  }
+
+  /**
+   * Get diff summary between local and remote
+   * @returns {Promise<Object>}
+   */
+  async getDiffSummary() {
+    await this.gitHandoff.fetchWipBranch();
+    return this.gitHandoff.getDiffSummary();
+  }
+
+  /**
+   * Detect potential conflicts between local and remote
+   * @returns {Promise<Object>}
+   */
+  async detectConflicts() {
+    // Check remote changes
+    const remoteCheck = await this.gitHandoff.checkRemoteChanges();
+
+    // Check local uncommitted changes
+    const hasUncommitted = await this.gitHandoff.hasUncommittedChanges();
+    const localChanges = hasUncommitted
+      ? await this.gitHandoff.getChangedFiles()
+      : [];
+
+    // Get diff summary
+    const diff = await this.getDiffSummary();
+
+    // Determine if branches diverged
+    const diverged = diff.ahead > 0 && diff.behind > 0;
+
+    // Find conflicting files (overlap between remote changes and local uncommitted)
+    const conflictingFiles = localChanges.filter((file) =>
+      diff.files.includes(file)
+    );
+
+    return {
+      hasConflicts: conflictingFiles.length > 0 || (remoteCheck.hasChanges && hasUncommitted),
+      diverged,
+      conflictingFiles,
+      remoteChanges: diff.files,
+      localChanges
+    };
+  }
+}
+
+export default CodeSync;

package/lib/remote/init-script-robust.js

@@ -0,0 +1,187 @@
+/**
+ * Robust Init Script Generator
+ *
+ * Generates an init script with:
+ * - Network readiness checks
+ * - Detailed error logging
+ * - Retry logic for network calls
+ * - Step-by-step validation
+ */
+
+export function generateRobustInitScript(sessionConfig, ssh, tunnel, vaultClient, repoUrl, branch) {
+  const safeSessionId = escapeShellArg(sessionConfig.id);
+  const safeTask = escapeShellArg(sessionConfig.task || '');
+  const safePublicKey = escapeShellArg(ssh.publicKey);
+  const safeBranch = escapeShellArg(branch);
+  const safeRepoUrl = escapeShellArg(repoUrl);
+  const safeVaultUrl = escapeShellArg(vaultClient.apiUrl);
+  const safeVaultKey = escapeShellArg(vaultClient.apiKey);
+  const safeAppId = escapeShellArg(vaultClient.appId);
+  const namespace = sessionConfig.vaultNamespace;
+
+  return `
+set -e
+
+log_step() {
+  echo "=== [$1] $2 ==="
+}
+
+log_error() {
+  echo "❌ ERROR: $1" >&2
+}
+
+log_success() {
+  echo "✅ $1"
+}
+
+# Wait for network to be ready
+wait_for_network() {
+  log_step "0" "Waiting for network readiness"
+  local max_attempts=30
+  local attempt=1
+
+  while [ $attempt -le $max_attempts ]; do
+    if curl -fsSL --max-time 5 https://vault.mechdna.net/api/health >/dev/null 2>&1; then
+      log_success "Network is ready (attempt $attempt)"
+      return 0
+    fi
+    echo "Network not ready yet (attempt $attempt/$max_attempts)"
+    sleep 2
+    attempt=$((attempt + 1))
+  done
+
+  log_error "Network did not become ready after $max_attempts attempts"
+  return 1
+}
+
+# Retry a curl command with exponential backoff
+retry_curl() {
+  local max_attempts=3
+  local attempt=1
+  local wait_time=2
+
+  while [ $attempt -le $max_attempts ]; do
+    if "$@"; then
+      return 0
+    fi
+    local exit_code=$?
+
+    if [ $attempt -lt $max_attempts ]; then
+      echo "⚠️ Curl failed (exit $exit_code), retrying in $wait_time seconds (attempt $attempt/$max_attempts)"
+      sleep $wait_time
+      wait_time=$((wait_time * 2))
+      attempt=$((attempt + 1))
+    else
+      log_error "Curl failed after $max_attempts attempts (exit code: $exit_code)"
+      return $exit_code
+    fi
+  done
+}
+
+log_step "1" "Installing dependencies"
+apt-get update -qq && apt-get install -y -qq git openssh-server curl jq dnsutils
+log_success "Dependencies installed"
+
+log_step "2" "Checking DNS resolution"
+if nslookup vault.mechdna.net >/dev/null 2>&1; then
+  log_success "DNS resolution working"
+else
+  log_error "DNS resolution failed for vault.mechdna.net"
+  exit 1
+fi
+
+log_step "3" "Waiting for network connectivity"
+wait_for_network || exit 1
+
+log_step "4" "Setting up SSH"
+mkdir -p ~/.ssh
+echo ${safePublicKey} >> ~/.ssh/authorized_keys
+chmod 600 ~/.ssh/authorized_keys
+log_success "SSH configured"
+
+log_step "5" "Configuring environment variables"
+export VAULT_NAMESPACE="${namespace}"
+export MECH_VAULT_URL=${safeVaultUrl}
+export MECH_API_KEY=${safeVaultKey}
+export MECH_APP_ID=${safeAppId}
+export SESSION_ID=${safeSessionId}
+
+echo "VAULT_NAMESPACE=$VAULT_NAMESPACE"
+echo "MECH_VAULT_URL=$MECH_VAULT_URL"
+echo "SESSION_ID=$SESSION_ID"
+log_success "Environment configured"
+
+log_step "6" "Fetching secrets from Vault"
+ENV_FILE=/tmp/teleportation.env
+
+retry_curl curl -fsSL -X POST "$MECH_VAULT_URL/env-files/export" \
+  -H "Content-Type: application/json" \
+  -H "X-API-Key: $MECH_API_KEY" \
+  -H "X-App-ID: $MECH_APP_ID" \
+  -d "$(jq -n --arg namespace "$VAULT_NAMESPACE" --arg format 'env' '{namespace:$namespace,format:$format}')" \
+  -o "$ENV_FILE" || exit 1
+
+if [ ! -s "$ENV_FILE" ]; then
+  log_error "Vault env file is empty"
+  exit 1
+fi
+
+log_success "Secrets fetched ($(wc -l < "$ENV_FILE") lines)"
+
+log_step "7" "Loading environment variables"
+set +x
+set -a
+. "$ENV_FILE"
+set +a
+log_success "Environment loaded"
+
+log_step "8" "Configuring Git authentication"
+if [ -n "$GITHUB_TOKEN" ]; then
+  git config --global url."https://x-access-token:$GITHUB_TOKEN@github.com/".insteadOf "https://github.com/"
+  git config --global url."https://x-access-token:$GITHUB_TOKEN@github.com/".insteadOf "git@github.com:"
+  log_success "Git authentication configured"
+else
+  echo "⚠️ No GITHUB_TOKEN found, proceeding without authentication"
+fi
+
+log_step "9" "Cloning repository"
+git clone ${safeRepoUrl} /workspace || exit 1
+cd /workspace
+log_success "Repository cloned"
+
+log_step "10" "Checking out branch"
+git checkout ${safeBranch} || exit 1
+log_success "Branch checked out: ${safeBranch}"
+
+log_step "11" "Installing project dependencies"
+bun install || exit 1
+log_success "Dependencies installed"
+
+log_step "12" "Starting LivePort tunnel"
+${tunnel.tunnelCommand} &
+TUNNEL_PID=$!
+log_success "Tunnel started (PID: $TUNNEL_PID)"
+
+log_step "13" "Registering session with relay"
+retry_curl curl -fsSL -X POST "$RELAY_API_URL/api/sessions/register" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $RELAY_API_KEY" \
+  -d "$(jq -n --arg session_id \"$SESSION_ID\" '{session_id:$session_id,meta:{provider:"fly",remote:true}}')" \
+  >/dev/null || echo "⚠️ Session registration failed (non-fatal)"
+
+log_step "14" "Starting teleportation daemon"
+echo "Task: ${safeTask}"
+bun teleportation-cli.cjs daemon start --session-id ${safeSessionId} --task ${safeTask} || {
+  log_error "Daemon failed to start (exit code $?)"
+  exit 1
+}
+
+log_success "Initialization completed at $(date)"
+echo "=== Daemon is running, container will stay alive ==="
+tail -f /dev/null
+`.trim();
+}
+
+function escapeShellArg(str) {
+  return "'" + String(str || '').replace(/'/g, "'\\''") + "'";
+}