@vm0/runner 2.8.0 → 2.8.2

package/index.js

@@ -866,8 +866,10 @@ var SSHClient = class {
   }
   /**
    * Execute a command on the remote VM
+   * @param command - The command to execute
+   * @param timeoutMs - Optional timeout in milliseconds (default: 300000ms = 5 minutes)
    */
-  async exec(command) {
+  async exec(command, timeoutMs) {
     const sshCmd = this.buildSSHCommand();
     const escapedCommand = command.replace(/'/g, "'\\''");
     const fullCmd = [...sshCmd, `'${escapedCommand}'`].join(" ");
@@ -875,8 +877,8 @@ var SSHClient = class {
       const { stdout, stderr } = await execAsync2(fullCmd, {
         maxBuffer: 50 * 1024 * 1024,
         // 50MB buffer
-        timeout: 3e5
-        // 5 minute timeout
+        timeout: timeoutMs ?? 3e5
+        // Default 5 minutes, customizable per call
       });
       return {
         exitCode: 0,
@@ -958,10 +960,11 @@ var SSHClient = class {
   }
   /**
    * Check if SSH connection is available
+   * Uses a short timeout (15s) to ensure waitUntilReachable() respects its outer timeout
    */
   async isReachable() {
     try {
-      const result = await this.exec("echo ok");
+      const result = await this.exec("echo ok", 15e3);
       return result.exitCode === 0 && result.stdout.trim() === "ok";
     } catch {
       return false;
@@ -5894,6 +5897,13 @@ var metricDataSchema = z8.object({
   disk_used: z8.number(),
   disk_total: z8.number()
 });
+var sandboxOperationSchema = z8.object({
+  ts: z8.string(),
+  action_type: z8.string(),
+  duration_ms: z8.number(),
+  success: z8.boolean(),
+  error: z8.string().optional()
+});
 var networkLogSchema = z8.object({
   timestamp: z8.string(),
   // Common fields (all modes)
@@ -5913,7 +5923,7 @@ var networkLogSchema = z8.object({
 var webhookTelemetryContract = c5.router({
   /**
    * POST /api/webhooks/agent/telemetry
-   * Receive telemetry data (system log, metrics, and network logs) from sandbox
+   * Receive telemetry data (system log, metrics, network logs, and sandbox operations) from sandbox
    */
   send: {
     method: "POST",
@@ -5922,7 +5932,8 @@ var webhookTelemetryContract = c5.router({
       runId: z8.string().min(1, "runId is required"),
       systemLog: z8.string().optional(),
       metrics: z8.array(metricDataSchema).optional(),
-      networkLogs: z8.array(networkLogSchema).optional()
+      networkLogs: z8.array(networkLogSchema).optional(),
+      sandboxOperations: z8.array(sandboxOperationSchema).optional()
     }),
     responses: {
       200: z8.object({
@@ -7121,6 +7132,10 @@ NETWORK_LOG_FILE = f"/tmp/vm0-network-{RUN_ID}.jsonl"
 TELEMETRY_LOG_POS_FILE = f"/tmp/vm0-telemetry-log-pos-{RUN_ID}.txt"
 TELEMETRY_METRICS_POS_FILE = f"/tmp/vm0-telemetry-metrics-pos-{RUN_ID}.txt"
 TELEMETRY_NETWORK_POS_FILE = f"/tmp/vm0-telemetry-network-pos-{RUN_ID}.txt"
+TELEMETRY_SANDBOX_OPS_POS_FILE = f"/tmp/vm0-telemetry-sandbox-ops-pos-{RUN_ID}.txt"
+
+# Sandbox operations log file (JSONL format)
+SANDBOX_OPS_LOG_FILE = f"/tmp/vm0-sandbox-ops-{RUN_ID}.jsonl"
 
 # Metrics collection configuration
 METRICS_INTERVAL = 5  # seconds
@@ -7134,6 +7149,36 @@ def validate_config() -> bool:
     if not WORKING_DIR:
         raise ValueError("VM0_WORKING_DIR is required but not set")
     return True
+
+def record_sandbox_op(
+    action_type: str,
+    duration_ms: int,
+    success: bool,
+    error: str = None
+) -> None:
+    """
+    Record a sandbox operation to JSONL file for telemetry upload.
+
+    Args:
+        action_type: Operation name (e.g., "init_total", "storage_download", "cli_execution")
+        duration_ms: Duration in milliseconds
+        success: Whether the operation succeeded
+        error: Optional error message if failed
+    """
+    from datetime import datetime, timezone
+    import json
+
+    entry = {
+        "ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",
+        "action_type": action_type,
+        "duration_ms": duration_ms,
+        "success": success,
+    }
+    if error:
+        entry["error"] = error
+
+    with open(SANDBOX_OPS_LOG_FILE, "a") as f:
+        f.write(json.dumps(entry) + "\\n")
 `;
 
 // ../../packages/core/src/sandbox/scripts/lib/log.py.ts
@@ -7572,10 +7617,11 @@ import hashlib
 import tarfile
 import tempfile
 import shutil
+import time
 from typing import Optional, Dict, Any, List
 from datetime import datetime
 
-from common import RUN_ID, STORAGE_PREPARE_URL, STORAGE_COMMIT_URL
+from common import RUN_ID, STORAGE_PREPARE_URL, STORAGE_COMMIT_URL, record_sandbox_op
 from log import log_info, log_warn, log_error, log_debug
 from http_client import http_post_json, http_put_presigned
 
@@ -7716,7 +7762,9 @@ def create_direct_upload_snapshot(
 
     # Step 1: Collect file metadata
     log_info("Computing file hashes...")
+    hash_start = time.time()
     files = collect_file_metadata(mount_path)
+    record_sandbox_op("artifact_hash_compute", int((time.time() - hash_start) * 1000), True)
     log_info(f"Found {len(files)} files")
 
     if not files:
@@ -7724,6 +7772,7 @@ def create_direct_upload_snapshot(
 
     # Step 2: Call prepare endpoint
     log_info("Calling prepare endpoint...")
+    prepare_start = time.time()
     prepare_payload = {
         "storageName": storage_name,
         "storageType": storage_type,
@@ -7735,12 +7784,15 @@ def create_direct_upload_snapshot(
     prepare_response = http_post_json(STORAGE_PREPARE_URL, prepare_payload)
     if not prepare_response:
         log_error("Failed to call prepare endpoint")
+        record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), False)
         return None
 
     version_id = prepare_response.get("versionId")
     if not version_id:
         log_error(f"Invalid prepare response: {prepare_response}")
+        record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), False)
         return None
+    record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), True)
 
     # Step 3: Check if version already exists (deduplication)
     # Still call commit to update HEAD pointer (fixes #649)
@@ -7783,10 +7835,13 @@ def create_direct_upload_snapshot(
     try:
         # Create archive
         log_info("Creating archive...")
+        archive_start = time.time()
         archive_path = os.path.join(temp_dir, "archive.tar.gz")
         if not create_archive(mount_path, archive_path):
             log_error("Failed to create archive")
+            record_sandbox_op("artifact_archive_create", int((time.time() - archive_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_archive_create", int((time.time() - archive_start) * 1000), True)
 
         # Create manifest
         log_info("Creating manifest...")
@@ -7797,12 +7852,14 @@ def create_direct_upload_snapshot(
 
         # Upload archive to S3
         log_info("Uploading archive to S3...")
+        s3_upload_start = time.time()
         if not http_put_presigned(
             archive_info["presignedUrl"],
             archive_path,
             "application/gzip"
         ):
             log_error("Failed to upload archive to S3")
+            record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), False)
             return None
 
         # Upload manifest to S3
@@ -7813,10 +7870,13 @@ def create_direct_upload_snapshot(
             "application/json"
         ):
             log_error("Failed to upload manifest to S3")
+            record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), True)
 
         # Step 6: Call commit endpoint
         log_info("Calling commit endpoint...")
+        commit_start = time.time()
         commit_payload = {
             "storageName": storage_name,
             "storageType": storage_type,
@@ -7831,11 +7891,14 @@ def create_direct_upload_snapshot(
         commit_response = http_post_json(STORAGE_COMMIT_URL, commit_payload)
         if not commit_response:
             log_error("Failed to call commit endpoint")
+            record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), False)
             return None
 
         if not commit_response.get("success"):
             log_error(f"Commit failed: {commit_response}")
+            record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), True)
 
         log_info(f"Direct upload snapshot created: {version_id[:8]}")
         return {"versionId": version_id}
@@ -7858,11 +7921,12 @@ import sys
 import json
 import tarfile
 import tempfile
+import time
 
 # Add lib to path for imports
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
-from common import validate_config
+from common import validate_config, record_sandbox_op
 from log import log_info, log_error
 from http_client import http_download
 
@@ -7942,13 +8006,21 @@ def main():
 
     log_info(f"Found {storage_count} storages, artifact: {has_artifact}")
 
+    # Track total download time
+    download_total_start = time.time()
+    download_success = True
+
     # Process storages
     for storage in storages:
         mount_path = storage.get("mountPath")
         archive_url = storage.get("archiveUrl")
 
         if archive_url and archive_url != "null":
-            download_storage(mount_path, archive_url)
+            storage_start = time.time()
+            success = download_storage(mount_path, archive_url)
+            record_sandbox_op("storage_download", int((time.time() - storage_start) * 1000), success)
+            if not success:
+                download_success = False
 
     # Process artifact
     if artifact:
@@ -7956,8 +8028,14 @@ def main():
         artifact_url = artifact.get("archiveUrl")
 
         if artifact_url and artifact_url != "null":
-            download_storage(artifact_mount, artifact_url)
-
+            artifact_start = time.time()
+            success = download_storage(artifact_mount, artifact_url)
+            record_sandbox_op("artifact_download", int((time.time() - artifact_start) * 1000), success)
+            if not success:
+                download_success = False
+
+    # Record total download time
+    record_sandbox_op("download_total", int((time.time() - download_total_start) * 1000), download_success)
     log_info("All storages downloaded successfully")
 
 
@@ -7974,12 +8052,14 @@ Uses direct S3 upload exclusively (no fallback to legacy methods).
 """
 import os
 import glob
+import time
 from typing import Optional, Dict, Any
 
 from common import (
     RUN_ID, CHECKPOINT_URL,
     SESSION_ID_FILE, SESSION_HISTORY_PATH_FILE,
-    ARTIFACT_DRIVER, ARTIFACT_MOUNT_PATH, ARTIFACT_VOLUME_NAME
+    ARTIFACT_DRIVER, ARTIFACT_MOUNT_PATH, ARTIFACT_VOLUME_NAME,
+    record_sandbox_op
 )
 from log import log_info, log_error
 from http_client import http_post_json
@@ -8035,19 +8115,27 @@ def create_checkpoint() -> bool:
     Returns:
         True on success, False on failure
     """
+    checkpoint_start = time.time()
     log_info("Creating checkpoint...")
 
     # Read session ID from temp file
+    session_id_start = time.time()
     if not os.path.exists(SESSION_ID_FILE):
         log_error("No session ID found, checkpoint creation failed")
+        record_sandbox_op("session_id_read", int((time.time() - session_id_start) * 1000), False, "Session ID file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     with open(SESSION_ID_FILE) as f:
         cli_agent_session_id = f.read().strip()
+    record_sandbox_op("session_id_read", int((time.time() - session_id_start) * 1000), True)
 
     # Read session history path from temp file
+    session_history_start = time.time()
     if not os.path.exists(SESSION_HISTORY_PATH_FILE):
         log_error("No session history path found, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history path file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     with open(SESSION_HISTORY_PATH_FILE) as f:
@@ -8058,6 +8146,8 @@ def create_checkpoint() -> bool:
         parts = session_history_path_raw.split(":", 2)
         if len(parts) != 3:
             log_error(f"Invalid Codex search marker format: {session_history_path_raw}")
+            record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Invalid Codex search marker")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
         sessions_dir = parts[1]
         codex_session_id = parts[2]
@@ -8065,6 +8155,8 @@ def create_checkpoint() -> bool:
         session_history_path = find_codex_session_file(sessions_dir, codex_session_id)
         if not session_history_path:
             log_error(f"Could not find Codex session file for {codex_session_id} in {sessions_dir}")
+            record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Codex session file not found")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
     else:
         session_history_path = session_history_path_raw
@@ -8072,6 +8164,8 @@ def create_checkpoint() -> bool:
     # Check if session history file exists
     if not os.path.exists(session_history_path):
         log_error(f"Session history file not found at {session_history_path}, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     # Read session history
@@ -8080,14 +8174,19 @@ def create_checkpoint() -> bool:
             cli_agent_session_history = f.read()
     except IOError as e:
         log_error(f"Failed to read session history: {e}")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, str(e))
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     if not cli_agent_session_history.strip():
         log_error("Session history is empty, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history empty")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     line_count = len(cli_agent_session_history.strip().split("\\n"))
     log_info(f"Session history loaded ({line_count} lines)")
+    record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), True)
 
     # CLI agent type (default to claude-code)
     cli_agent_type = os.environ.get("CLI_AGENT_TYPE", "claude-code")
@@ -8101,6 +8200,7 @@ def create_checkpoint() -> bool:
 
         if ARTIFACT_DRIVER != "vas":
             log_error(f"Unknown artifact driver: {ARTIFACT_DRIVER} (only 'vas' is supported)")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # VAS artifact: create snapshot using direct S3 upload (bypasses Vercel 4.5MB limit)
@@ -8117,12 +8217,14 @@ def create_checkpoint() -> bool:
 
         if not snapshot:
             log_error("Failed to create VAS snapshot for artifact")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # Extract versionId from snapshot response
         artifact_version = snapshot.get("versionId")
         if not artifact_version:
             log_error("Failed to extract versionId from snapshot")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # Build artifact snapshot JSON with new format (artifactName + artifactVersion)
@@ -8150,6 +8252,7 @@ def create_checkpoint() -> bool:
         checkpoint_payload["artifactSnapshot"] = artifact_snapshot
 
     # Call checkpoint API
+    api_call_start = time.time()
     result = http_post_json(CHECKPOINT_URL, checkpoint_payload)
 
     # Validate response contains checkpointId to confirm checkpoint was actually created
@@ -8157,9 +8260,13 @@ def create_checkpoint() -> bool:
     if result and result.get("checkpointId"):
         checkpoint_id = result.get("checkpointId")
         log_info(f"Checkpoint created successfully: {checkpoint_id}")
+        record_sandbox_op("checkpoint_api_call", int((time.time() - api_call_start) * 1000), True)
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), True)
         return True
     else:
         log_error(f"Checkpoint API returned invalid response: {result}")
+        record_sandbox_op("checkpoint_api_call", int((time.time() - api_call_start) * 1000), False, "Invalid API response")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 `;
 
@@ -8553,8 +8660,9 @@ from typing import List, Dict, Any
 
 from common import (
     RUN_ID, TELEMETRY_URL, TELEMETRY_INTERVAL,
-    SYSTEM_LOG_FILE, METRICS_LOG_FILE, NETWORK_LOG_FILE,
-    TELEMETRY_LOG_POS_FILE, TELEMETRY_METRICS_POS_FILE, TELEMETRY_NETWORK_POS_FILE
+    SYSTEM_LOG_FILE, METRICS_LOG_FILE, NETWORK_LOG_FILE, SANDBOX_OPS_LOG_FILE,
+    TELEMETRY_LOG_POS_FILE, TELEMETRY_METRICS_POS_FILE, TELEMETRY_NETWORK_POS_FILE,
+    TELEMETRY_SANDBOX_OPS_POS_FILE
 )
 from log import log_info, log_error, log_debug, log_warn
 from http_client import http_post_json
@@ -8657,6 +8765,19 @@ def read_network_logs_from_position(pos_file: str) -> tuple[List[Dict[str, Any]]
     return read_jsonl_from_position(NETWORK_LOG_FILE, pos_file)
 
 
+def read_sandbox_ops_from_position(pos_file: str) -> tuple[List[Dict[str, Any]], int]:
+    """
+    Read new sandbox operations from JSONL file starting from last position.
+
+    Args:
+        pos_file: Path to position tracking file
+
+    Returns:
+        Tuple of (sandbox operations list, new_position)
+    """
+    return read_jsonl_from_position(SANDBOX_OPS_LOG_FILE, pos_file)
+
+
 def upload_telemetry() -> bool:
     """
     Upload telemetry data to VM0 API.
@@ -8673,8 +8794,11 @@ def upload_telemetry() -> bool:
     # Read new network logs
     network_logs, network_pos = read_network_logs_from_position(TELEMETRY_NETWORK_POS_FILE)
 
+    # Read new sandbox operations
+    sandbox_ops, sandbox_ops_pos = read_sandbox_ops_from_position(TELEMETRY_SANDBOX_OPS_POS_FILE)
+
     # Skip if nothing new
-    if not system_log and not metrics and not network_logs:
+    if not system_log and not metrics and not network_logs and not sandbox_ops:
         log_debug("No new telemetry data to upload")
         return True
 
@@ -8688,10 +8812,11 @@ def upload_telemetry() -> bool:
         "runId": RUN_ID,
         "systemLog": masked_system_log,
         "metrics": metrics,  # Metrics don't contain secrets (just numbers)
-        "networkLogs": masked_network_logs
+        "networkLogs": masked_network_logs,
+        "sandboxOperations": sandbox_ops  # Sandbox ops don't contain secrets (just timing data)
     }
 
-    log_debug(f"Uploading telemetry: {len(system_log)} bytes log, {len(metrics)} metrics, {len(network_logs)} network logs")
+    log_debug(f"Uploading telemetry: {len(system_log)} bytes log, {len(metrics)} metrics, {len(network_logs)} network logs, {len(sandbox_ops)} sandbox ops")
 
     result = http_post_json(TELEMETRY_URL, payload, max_retries=1)
 
@@ -8700,6 +8825,7 @@ def upload_telemetry() -> bool:
         save_position(TELEMETRY_LOG_POS_FILE, log_pos)
         save_position(TELEMETRY_METRICS_POS_FILE, metrics_pos)
         save_position(TELEMETRY_NETWORK_POS_FILE, network_pos)
+        save_position(TELEMETRY_SANDBOX_OPS_POS_FILE, sandbox_ops_pos)
         log_debug(f"Telemetry uploaded successfully: {result.get('id', 'unknown')}")
         return True
     else:
@@ -8937,7 +9063,7 @@ sys.path.insert(0, "/usr/local/bin/vm0-agent/lib")
 from common import (
     WORKING_DIR, PROMPT, RESUME_SESSION_ID, COMPLETE_URL, RUN_ID,
     EVENT_ERROR_FLAG, HEARTBEAT_URL, HEARTBEAT_INTERVAL, AGENT_LOG_FILE,
-    CLI_AGENT_TYPE, OPENAI_MODEL, validate_config
+    CLI_AGENT_TYPE, OPENAI_MODEL, validate_config, record_sandbox_op
 )
 from log import log_info, log_error, log_warn
 from events import send_event
@@ -8973,10 +9099,14 @@ def _cleanup(exit_code: int, error_message: str):
 
     # Perform final telemetry upload before completion
     # This ensures all remaining data is captured
+    telemetry_start = time.time()
+    telemetry_success = True
     try:
         final_telemetry_upload()
     except Exception as e:
+        telemetry_success = False
         log_error(f"Final telemetry upload failed: {e}")
+    record_sandbox_op("final_telemetry_upload", int((time.time() - telemetry_start) * 1000), telemetry_success)
 
     # Always call complete API at the end
     # This sends vm0_result (on success) or vm0_error (on failure) and kills the sandbox
@@ -8989,13 +9119,17 @@ def _cleanup(exit_code: int, error_message: str):
     if error_message:
         complete_payload["error"] = error_message
 
+    complete_start = time.time()
+    complete_success = False
     try:
         if http_post_json(COMPLETE_URL, complete_payload):
             log_info("Complete API called successfully")
+            complete_success = True
         else:
             log_error("Failed to call complete API (sandbox may not be cleaned up)")
     except Exception as e:
         log_error(f"Complete API call failed: {e}")
+    record_sandbox_op("complete_api_call", int((time.time() - complete_start) * 1000), complete_success)
 
     # Stop heartbeat thread
     shutdown_event.set()
@@ -9027,25 +9161,36 @@ def _run() -> tuple[int, str]:
     log_info(f"Working directory: {WORKING_DIR}")
 
     # Start heartbeat thread
+    heartbeat_start = time.time()
     heartbeat_thread = threading.Thread(target=heartbeat_loop, daemon=True)
     heartbeat_thread.start()
     log_info("Heartbeat thread started")
+    record_sandbox_op("heartbeat_start", int((time.time() - heartbeat_start) * 1000), True)
 
     # Start metrics collector thread
+    metrics_start = time.time()
     start_metrics_collector(shutdown_event)
     log_info("Metrics collector thread started")
+    record_sandbox_op("metrics_collector_start", int((time.time() - metrics_start) * 1000), True)
 
     # Start telemetry upload thread
+    telemetry_start = time.time()
     start_telemetry_upload(shutdown_event)
     log_info("Telemetry upload thread started")
+    record_sandbox_op("telemetry_upload_start", int((time.time() - telemetry_start) * 1000), True)
 
     # Create and change to working directory - raises RuntimeError if fails
     # Directory may not exist if no artifact/storage was downloaded (e.g., first run)
+    working_dir_start = time.time()
+    working_dir_success = True
     try:
         os.makedirs(WORKING_DIR, exist_ok=True)
         os.chdir(WORKING_DIR)
     except OSError as e:
+        working_dir_success = False
+        record_sandbox_op("working_dir_setup", int((time.time() - working_dir_start) * 1000), False, str(e))
         raise RuntimeError(f"Failed to create/change to working directory: {WORKING_DIR} - {e}") from e
+    record_sandbox_op("working_dir_setup", int((time.time() - working_dir_start) * 1000), working_dir_success)
 
     # Set up Codex configuration if using Codex CLI
     # Claude Code uses ~/.claude by default (no configuration needed)
@@ -9058,6 +9203,8 @@ def _run() -> tuple[int, str]:
         log_info(f"Codex home directory: {codex_home}")
 
         # Login with API key via stdin (recommended method)
+        codex_login_start = time.time()
+        codex_login_success = False
         api_key = os.environ.get("OPENAI_API_KEY", "")
         if api_key:
             result = subprocess.run(
@@ -9068,13 +9215,16 @@ def _run() -> tuple[int, str]:
             )
             if result.returncode == 0:
                 log_info("Codex authenticated with API key")
+                codex_login_success = True
             else:
                 log_error(f"Codex login failed: {result.stderr}")
         else:
             log_error("OPENAI_API_KEY not set")
+        record_sandbox_op("codex_login", int((time.time() - codex_login_start) * 1000), codex_login_success)
 
-    init_duration = int(time.time() - init_start_time)
-    log_info(f"\u2713 Initialization complete ({init_duration}s)")
+    init_duration_ms = int((time.time() - init_start_time) * 1000)
+    record_sandbox_op("init_total", init_duration_ms, True)
+    log_info(f"\u2713 Initialization complete ({init_duration_ms // 1000}s)")
 
     # Lifecycle: Execution
     log_info("\u25B7 Execution")
@@ -9238,12 +9388,13 @@ def _run() -> tuple[int, str]:
         final_exit_code = 1
         error_message = "Some events failed to send"
 
-    # Log execution result
-    exec_duration = int(time.time() - exec_start_time)
+    # Log execution result and record metric
+    exec_duration_ms = int((time.time() - exec_start_time) * 1000)
+    record_sandbox_op("cli_execution", exec_duration_ms, agent_exit_code == 0)
     if agent_exit_code == 0 and final_exit_code == 0:
-        log_info(f"\u2713 Execution complete ({exec_duration}s)")
+        log_info(f"\u2713 Execution complete ({exec_duration_ms // 1000}s)")
     else:
-        log_info(f"\u2717 Execution failed ({exec_duration}s)")
+        log_info(f"\u2717 Execution failed ({exec_duration_ms // 1000}s)")
 
     # Handle completion
     if agent_exit_code == 0 and final_exit_code == 0:
@@ -11096,7 +11247,7 @@ var benchmarkCommand = new Command3("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "2.8.0" : "0.1.0";
+var version = true ? "2.8.2" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(statusCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/runner",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",