Checkpoints

interface Checkpoint {
  name: CheckpointName;        // Which step was completed
  completedAt: string;         // When it was completed (ISO timestamp)
  retryCount: number;          // How many retries it took
}

const CHECKPOINT_ORDER: CheckpointName[] = [
  "server_created",          // VPS server provisioned
  "ssh_key_uploaded",        // SSH key added to provider
  "ssh_connected",           // SSH connection established
  "swap_configured",         // Swap memory set up
  "system_updated",          // System packages updated
  "nvm_installed",           // Node Version Manager installed
  "node_installed",          // Node.js installed
  "pnpm_installed",          // pnpm package manager installed
  "chrome_installed",        // Google Chrome installed
  "openclaw_installed",      // OpenClaw package installed
  "openclaw_configured",     // OpenClaw configured
  "tailscale_installed",     // Tailscale VPN installed
  "tailscale_authenticated", // Tailscale authenticated
  "tailscale_configured",    // Tailscale serve configured
  "daemon_started",          // OpenClaw daemon started
  "completed",               // Deployment fully complete
];

function getLastCheckpoint(state: DeploymentState): CheckpointName | null {
  if (state.checkpoints.length === 0) {
    return null;
  }

  // Sort by order and return the last one
  const sorted = state.checkpoints
    .filter((cp) => CHECKPOINT_ORDER.includes(cp.name))
    .sort(
      (a, b) =>
        CHECKPOINT_ORDER.indexOf(a.name) - CHECKPOINT_ORDER.indexOf(b.name)
    );

  return sorted.length > 0 ? sorted[sorted.length - 1].name : null;
}

function getNextCheckpoint(state: DeploymentState): CheckpointName {
  const lastCheckpoint = getLastCheckpoint(state);

  if (!lastCheckpoint) {
    return CHECKPOINT_ORDER[0];  // Start from beginning
  }

  const currentIndex = CHECKPOINT_ORDER.indexOf(lastCheckpoint);
  if (currentIndex === -1 || currentIndex >= CHECKPOINT_ORDER.length - 1) {
    return "completed";
  }

  return CHECKPOINT_ORDER[currentIndex + 1];
}

while (retryCount < MAX_RETRIES) {
  try {
    await this.executeCheckpoint(checkpoint);
    markCheckpointComplete(this.deploymentName, checkpoint, retryCount);
    break;
  } catch (error) {
    retryCount++;
    // ... error handling and retry logic
    
    if (retryCount < MAX_RETRIES) {
      // Wait 5 seconds before retrying
      await new Promise((resolve) => setTimeout(resolve, 5000));
    } else {
      // Ask user to retry from beginning
      const shouldRetry = await this.onConfirm(
        `"${stepDescription}" failed after ${MAX_RETRIES} attempts.\n\n` +
        `Would you like to retry from the beginning?`
      );
      // ...
    }
  }
}

{
  "status": "configuring",
  "serverId": "12345678",
  "serverIp": "203.0.113.42",
  "checkpoints": [
    {
      "name": "server_created",
      "completedAt": "2025-01-15T10:32:00.000Z",
      "retryCount": 0
    },
    {
      "name": "ssh_connected",
      "completedAt": "2025-01-15T10:34:00.000Z",
      "retryCount": 1
    },
    {
      "name": "system_updated",
      "completedAt": "2025-01-15T10:36:00.000Z",
      "retryCount": 0
    }
  ],
  "updatedAt": "2025-01-15T10:36:00.000Z"
}

Deployment progress:
✅ server_created
✅ ssh_key_uploaded
✅ ssh_connected
❌ swap_configured (network timeout)

Deployment progress:
❌ server_created (rate limit, attempt 1)
⏳ Waiting 5 seconds...
❌ server_created (rate limit, attempt 2)
⏳ Waiting 5 seconds...
✅ server_created (success on attempt 3)

Deployment progress:
✅ server_created
✅ ssh_key_uploaded
✅ ssh_connected
✅ swap_configured
^C User interrupted

cat ~/.clawcontrol/deployments/<name>/state.json | jq '.checkpoints'

function resetToCheckpoint(
  deploymentName: string,
  checkpointName: CheckpointName
): DeploymentState {
  const state = readDeploymentState(deploymentName);
  const checkpointIndex = CHECKPOINT_ORDER.indexOf(checkpointName);

  // Keep only checkpoints before the target
  const newCheckpoints = state.checkpoints.filter((cp) => {
    const cpIndex = CHECKPOINT_ORDER.indexOf(cp.name);
    return cpIndex < checkpointIndex;
  });

  return updateDeploymentState(deploymentName, {
    checkpoints: newCheckpoints,
    status: newCheckpoints.length > 0 ? "configuring" : "initialized",
    lastError: undefined,
  });
}

interface DeploymentProgress {
  currentStep: CheckpointName;
  completedSteps: CheckpointName[];
  totalSteps: number;
  progress: number;          // Percentage (0-100)
  message: string;           // Human-readable status
}

[12/16] Installing Google Chrome...
[13/16] Installing OpenClaw...
[14/16] Configuring OpenClaw...