@evident-ai/cli 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+import {
+  clearCredentials,
+  getApiUrlConfig,
+  getCredentials,
+  getTunnelUrlConfig,
+  setCredentials,
+  setEnvironment
+} from "./chunk-MWOWXSOP.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -8,79 +16,6 @@ import open from "open";
 import ora from "ora";
 import chalk2 from "chalk";
 
-// src/lib/config.ts
-import Conf from "conf";
-import { homedir } from "os";
-import { join } from "path";
-var environmentPresets = {
-  local: {
-    apiUrl: "http://localhost:3000/v1",
-    tunnelUrl: "ws://localhost:8787"
-  },
-  dev: {
-    apiUrl: "https://api.dev.evident.run/v1",
-    tunnelUrl: "wss://tunnel.dev.evident.run"
-  },
-  production: {
-    // Production URLs also have aliases: api.evident.run, tunnel.evident.run
-    apiUrl: "https://api.production.evident.run/v1",
-    tunnelUrl: "wss://tunnel.production.evident.run"
-  }
-};
-var defaults = environmentPresets.production;
-var currentEnvironment = "production";
-function setEnvironment(env) {
-  currentEnvironment = env;
-}
-function getEnvironment() {
-  const envVar = process.env.EVIDENT_ENV;
-  if (envVar && environmentPresets[envVar]) {
-    return envVar;
-  }
-  return currentEnvironment;
-}
-function getEnvConfig() {
-  return environmentPresets[getEnvironment()];
-}
-function getApiUrl() {
-  return process.env.EVIDENT_API_URL ?? getEnvConfig().apiUrl;
-}
-function getTunnelUrl() {
-  return process.env.EVIDENT_TUNNEL_URL ?? getEnvConfig().tunnelUrl;
-}
-var config = new Conf({
-  projectName: "evident",
-  projectSuffix: "",
-  defaults
-});
-var credentials = new Conf({
-  projectName: "evident",
-  projectSuffix: "",
-  configName: "credentials",
-  defaults: {}
-});
-function getApiUrlConfig() {
-  return getApiUrl();
-}
-function getTunnelUrlConfig() {
-  return getTunnelUrl();
-}
-function getCredentials() {
-  return {
-    token: credentials.get("token"),
-    user: credentials.get("user"),
-    expiresAt: credentials.get("expiresAt")
-  };
-}
-function setCredentials(creds) {
-  if (creds.token) credentials.set("token", creds.token);
-  if (creds.user) credentials.set("user", creds.user);
-  if (creds.expiresAt) credentials.set("expiresAt", creds.expiresAt);
-}
-function clearCredentials() {
-  credentials.clear();
-}
-
 // src/lib/api.ts
 var ApiClient = class {
   baseUrl;
@@ -188,15 +123,15 @@ async function getKeytar() {
     return null;
   }
 }
-async function storeToken(credentials2) {
+async function storeToken(credentials) {
   const keytar = await getKeytar();
   if (keytar) {
-    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(credentials2));
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(credentials));
   } else {
     setCredentials({
-      token: credentials2.token,
-      user: credentials2.user,
-      expiresAt: credentials2.expiresAt
+      token: credentials.token,
+      user: credentials.user,
+      expiresAt: credentials.expiresAt
     });
   }
 }
@@ -397,8 +332,8 @@ async function login(options) {
 
 // src/commands/logout.ts
 async function logout() {
-  const credentials2 = await getToken();
-  if (!credentials2) {
+  const credentials = await getToken();
+  if (!credentials) {
     printWarning("You are not logged in.");
     return;
   }
@@ -409,16 +344,16 @@ async function logout() {
 // src/commands/whoami.ts
 import chalk3 from "chalk";
 async function whoami() {
-  const credentials2 = await getToken();
-  if (!credentials2) {
+  const credentials = await getToken();
+  if (!credentials) {
     printError("Not logged in. Run the `login` command to authenticate.");
     process.exit(1);
   }
   blank();
-  console.log(keyValue("User", chalk3.bold(credentials2.user.email)));
-  console.log(keyValue("User ID", credentials2.user.id));
-  if (credentials2.expiresAt) {
-    const expiresAt = new Date(credentials2.expiresAt);
+  console.log(keyValue("User", chalk3.bold(credentials.user.email)));
+  console.log(keyValue("User ID", credentials.user.id));
+  if (credentials.expiresAt) {
+    const expiresAt = new Date(credentials.expiresAt);
     const now = /* @__PURE__ */ new Date();
     if (expiresAt < now) {
       console.log(keyValue("Status", chalk3.red("Token expired")));
@@ -436,33 +371,481 @@ async function whoami() {
 import WebSocket from "ws";
 import chalk4 from "chalk";
 import ora2 from "ora";
+import { execSync, spawn } from "child_process";
+import { select } from "@inquirer/prompts";
+
+// src/lib/telemetry.ts
+var CLI_VERSION = process.env.npm_package_version || "unknown";
+var eventBuffer = [];
+var flushTimeout = null;
+var isShuttingDown = false;
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_BUFFER_SIZE = 50;
+var FLUSH_TIMEOUT_MS = 3e3;
+function logEvent(eventType, options = {}) {
+  const event = {
+    event_type: eventType,
+    severity: options.severity || "info",
+    message: options.message,
+    metadata: options.metadata,
+    sandbox_id: options.sandboxId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  eventBuffer.push(event);
+  if (options.severity === "error" || eventBuffer.length >= MAX_BUFFER_SIZE) {
+    void flushEvents();
+  } else if (!flushTimeout && !isShuttingDown) {
+    flushTimeout = setTimeout(() => {
+      flushTimeout = null;
+      void flushEvents();
+    }, FLUSH_INTERVAL_MS);
+  }
+}
+var telemetry = {
+  debug: (eventType, message, metadata, sandboxId) => logEvent(eventType, { severity: "debug", message, metadata, sandboxId }),
+  info: (eventType, message, metadata, sandboxId) => logEvent(eventType, { severity: "info", message, metadata, sandboxId }),
+  warn: (eventType, message, metadata, sandboxId) => logEvent(eventType, { severity: "warning", message, metadata, sandboxId }),
+  error: (eventType, message, metadata, sandboxId) => logEvent(eventType, { severity: "error", message, metadata, sandboxId })
+};
+async function flushEvents() {
+  if (eventBuffer.length === 0) return;
+  const events = eventBuffer;
+  eventBuffer = [];
+  if (flushTimeout) {
+    clearTimeout(flushTimeout);
+    flushTimeout = null;
+  }
+  try {
+    const credentials = await getToken();
+    if (!credentials) {
+      return;
+    }
+    const apiUrl = getApiUrlConfig();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
+    try {
+      const response = await fetch(`${apiUrl}/telemetry/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${credentials.token}`
+        },
+        body: JSON.stringify({
+          events,
+          client_type: "cli",
+          client_version: CLI_VERSION
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        console.error(`Telemetry flush failed: ${response.status}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch (error2) {
+    if (process.env.DEBUG) {
+      console.error("Telemetry error:", error2);
+    }
+  }
+}
+async function shutdownTelemetry() {
+  isShuttingDown = true;
+  if (flushTimeout) {
+    clearTimeout(flushTimeout);
+    flushTimeout = null;
+  }
+  await flushEvents();
+}
+var EventTypes = {
+  // Tunnel lifecycle
+  TUNNEL_STARTING: "tunnel.starting",
+  TUNNEL_CONNECTED: "tunnel.connected",
+  TUNNEL_DISCONNECTED: "tunnel.disconnected",
+  TUNNEL_RECONNECTING: "tunnel.reconnecting",
+  TUNNEL_ERROR: "tunnel.error",
+  // OpenCode communication
+  OPENCODE_HEALTH_CHECK: "opencode.health_check",
+  OPENCODE_HEALTH_OK: "opencode.health_ok",
+  OPENCODE_HEALTH_FAILED: "opencode.health_failed",
+  OPENCODE_REQUEST_RECEIVED: "opencode.request_received",
+  OPENCODE_REQUEST_FORWARDED: "opencode.request_forwarded",
+  OPENCODE_RESPONSE_SENT: "opencode.response_sent",
+  OPENCODE_UNREACHABLE: "opencode.unreachable",
+  OPENCODE_ERROR: "opencode.error",
+  // Authentication
+  AUTH_LOGIN_STARTED: "auth.login_started",
+  AUTH_LOGIN_SUCCESS: "auth.login_success",
+  AUTH_LOGIN_FAILED: "auth.login_failed",
+  AUTH_LOGOUT: "auth.logout",
+  // CLI lifecycle
+  CLI_STARTED: "cli.started",
+  CLI_COMMAND: "cli.command",
+  CLI_ERROR: "cli.error"
+};
+
+// src/commands/tunnel.ts
 var MAX_RECONNECT_DELAY = 3e4;
 var BASE_RECONNECT_DELAY = 500;
-function getReconnectDelay(attempt) {
-  const exponentialDelay = BASE_RECONNECT_DELAY * Math.pow(2, attempt);
-  const jitter = Math.random() * 1e3;
-  return Math.min(exponentialDelay + jitter, MAX_RECONNECT_DELAY);
+var MAX_ACTIVITY_LOG_ENTRIES = 10;
+var CHUNK_THRESHOLD = 512 * 1024;
+var CHUNK_SIZE = 768 * 1024;
+var OPENCODE_PORT_RANGE = [4096, 4097, 4098, 4099, 4100];
+function getProcessCwd(pid) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      const output = execSync(`lsof -a -p ${pid} -d cwd -Fn 2>/dev/null`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const lines = output.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("n") && !line.startsWith("n ")) {
+          return line.slice(1);
+        }
+      }
+    } else if (platform === "linux") {
+      const output = execSync(`readlink /proc/${pid}/cwd 2>/dev/null`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (output) return output;
+    }
+  } catch {
+  }
+  return void 0;
 }
+function isPortInUse(port) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin" || platform === "linux") {
+      execSync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (!isPortInUse(port)) {
+      return port;
+    }
+  }
+  return null;
+}
+function findOpenCodeProcesses() {
+  const instances = [];
+  try {
+    const platform = process.platform;
+    if (platform === "darwin" || platform === "linux") {
+      let pids = [];
+      try {
+        const pgrepOutput = execSync('pgrep -f "opencode serve|opencode-serve"', {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        if (pgrepOutput) {
+          pids = pgrepOutput.split("\n").map((p) => parseInt(p.trim(), 10)).filter((p) => !isNaN(p));
+        }
+      } catch {
+        try {
+          const psOutput = execSync('ps aux | grep -E "opencode (serve|--port)" | grep -v grep', {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          if (psOutput) {
+            for (const line of psOutput.split("\n")) {
+              const parts = line.trim().split(/\s+/);
+              if (parts.length >= 2) {
+                const pid = parseInt(parts[1], 10);
+                if (!isNaN(pid)) pids.push(pid);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      for (const pid of pids) {
+        try {
+          const lsofOutput = execSync(`lsof -Pan -p ${pid} -i TCP -sTCP:LISTEN 2>/dev/null`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          for (const line of lsofOutput.split("\n")) {
+            const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+            if (portMatch) {
+              const port = parseInt(portMatch[1], 10);
+              if (!isNaN(port) && !instances.some((i) => i.port === port)) {
+                const cwd = getProcessCwd(pid);
+                instances.push({ pid, port, cwd });
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return instances;
+}
+async function scanPortsForOpenCode() {
+  const instances = [];
+  const checks = OPENCODE_PORT_RANGE.map(async (port) => {
+    const health = await checkOpenCodeHealth(port);
+    if (health.healthy) {
+      let pid = 0;
+      try {
+        const lsofOutput = execSync(`lsof -ti :${port} -sTCP:LISTEN 2>/dev/null`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        if (lsofOutput) {
+          pid = parseInt(lsofOutput.split("\n")[0], 10) || 0;
+        }
+      } catch {
+      }
+      const cwd = pid ? getProcessCwd(pid) : void 0;
+      return { pid, port, cwd, version: health.version };
+    }
+    return null;
+  });
+  const results = await Promise.all(checks);
+  for (const result of results) {
+    if (result) {
+      instances.push(result);
+    }
+  }
+  return instances;
+}
+async function checkOpenCodeHealth(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}/health`, {
+      signal: AbortSignal.timeout(2e3)
+      // 2 second timeout
+    });
+    if (!response.ok) {
+      return { healthy: false, error: `HTTP ${response.status}` };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { healthy: true, version: data.version };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
+    return { healthy: false, error: message };
+  }
+}
+async function findHealthyOpenCodeInstances() {
+  const processes = findOpenCodeProcesses();
+  const healthy = [];
+  for (const proc of processes) {
+    const health = await checkOpenCodeHealth(proc.port);
+    if (health.healthy) {
+      healthy.push({ ...proc, version: health.version });
+    }
+  }
+  if (healthy.length === 0) {
+    const scanned = await scanPortsForOpenCode();
+    return scanned;
+  }
+  return healthy;
+}
+function logActivity(state, entry) {
+  const fullEntry = {
+    ...entry,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+  state.activityLog.push(fullEntry);
+  if (state.activityLog.length > MAX_ACTIVITY_LOG_ENTRIES) {
+    state.activityLog.shift();
+  }
+  state.lastActivity = fullEntry.timestamp;
+}
+function formatActivityEntry(entry, _verbose) {
+  const time = entry.timestamp.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  switch (entry.type) {
+    case "request": {
+      const duration = entry.durationMs ? ` (${entry.durationMs}ms)` : "";
+      const status = entry.status ? ` \u2192 ${colorizeStatus(entry.status)}` : " ...";
+      return `  ${chalk4.dim(`[${time}]`)} ${chalk4.cyan("\u2190")} ${entry.method} ${entry.path}${status}${duration}`;
+    }
+    case "response": {
+      const duration = entry.durationMs ? ` (${entry.durationMs}ms)` : "";
+      return `  ${chalk4.dim(`[${time}]`)} ${chalk4.green("\u2192")} ${entry.method} ${entry.path} ${colorizeStatus(entry.status)}${duration}`;
+    }
+    case "error": {
+      const errorMsg = entry.error || "Unknown error";
+      const path = entry.path ? ` ${entry.method} ${entry.path}` : "";
+      return `  ${chalk4.dim(`[${time}]`)} ${chalk4.red("\u2717")}${path} - ${chalk4.red(errorMsg)}`;
+    }
+    case "info": {
+      return `  ${chalk4.dim(`[${time}]`)} ${chalk4.blue("\u25CF")} ${entry.message}`;
+    }
+    default:
+      return `  ${chalk4.dim(`[${time}]`)} ${entry.message || "Unknown"}`;
+  }
+}
+function colorizeStatus(status) {
+  if (status >= 200 && status < 300) {
+    return chalk4.green(status.toString());
+  } else if (status >= 300 && status < 400) {
+    return chalk4.yellow(status.toString());
+  } else if (status >= 400 && status < 500) {
+    return chalk4.red(status.toString());
+  } else if (status >= 500) {
+    return chalk4.bgRed.white(` ${status} `);
+  }
+  return status.toString();
+}
+var ANSI = {
+  saveCursor: "\x1B[s",
+  restoreCursor: "\x1B[u",
+  clearToEnd: "\x1B[J",
+  moveTo: (row) => `\x1B[${row};1H`,
+  moveUp: (n) => `\x1B[${n}A`
+};
+var STATUS_DISPLAY_HEIGHT = 20;
 function displayStatus(state) {
-  console.clear();
-  console.log(chalk4.bold("Evident Tunnel"));
-  console.log(chalk4.dim("\u2500".repeat(50)));
-  blank();
+  const lines = [];
+  lines.push(chalk4.bold("Evident Tunnel"));
+  lines.push(chalk4.dim("\u2500".repeat(60)));
+  lines.push("");
+  if (state.sandboxName) {
+    lines.push(`  Sandbox:    ${state.sandboxName}`);
+  }
+  lines.push(`  ID:         ${state.sandboxId ?? "Unknown"}`);
+  lines.push("");
   if (state.connected) {
-    console.log(`  ${chalk4.green("\u25CF")} Status:    ${chalk4.green("Online")}`);
-    console.log(`  Sandbox:    ${state.sandboxId ?? "Unknown"}`);
-    console.log(`  Last activity: ${state.lastActivity.toLocaleTimeString()}`);
+    lines.push(`  ${chalk4.green("\u25CF")} Tunnel:    ${chalk4.green("Connected to Evident")}`);
   } else {
-    console.log(`  ${chalk4.yellow("\u25CB")} Status:    ${chalk4.yellow("Reconnecting...")}`);
     if (state.reconnectAttempt > 0) {
-      console.log(`  Attempt:    ${state.reconnectAttempt}`);
+      lines.push(
+        `  ${chalk4.yellow("\u25CB")} Tunnel:    ${chalk4.yellow(`Reconnecting... (attempt ${state.reconnectAttempt})`)}`
+      );
+    } else {
+      lines.push(`  ${chalk4.yellow("\u25CB")} Tunnel:    ${chalk4.yellow("Connecting...")}`);
     }
   }
+  if (state.opencodeConnected) {
+    const version = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
+    lines.push(`  ${chalk4.green("\u25CF")} OpenCode:  ${chalk4.green(`Running${version}`)}`);
+  } else {
+    lines.push(`  ${chalk4.red("\u25CB")} OpenCode:  ${chalk4.red("Not connected")}`);
+  }
+  lines.push("");
+  if (state.activityLog.length > 0) {
+    lines.push(chalk4.bold("  Activity:"));
+    for (const entry of state.activityLog) {
+      lines.push(formatActivityEntry(entry, state.verbose));
+    }
+  } else {
+    lines.push(chalk4.dim("  No activity yet. Waiting for requests..."));
+  }
+  lines.push("");
+  lines.push(chalk4.dim("\u2500".repeat(60)));
+  if (state.verbose) {
+    lines.push(chalk4.dim("  Verbose mode: ON (request/response bodies will be logged)"));
+  }
+  lines.push(chalk4.dim("  Press Ctrl+C to disconnect"));
+  while (lines.length < STATUS_DISPLAY_HEIGHT) {
+    lines.push("");
+  }
+  if (!state.displayInitialized) {
+    console.log("");
+    console.log(chalk4.dim("\u2550".repeat(60)));
+    console.log("");
+    for (const line of lines) {
+      console.log(line);
+    }
+    state.displayInitialized = true;
+  } else {
+    process.stdout.write(ANSI.moveUp(STATUS_DISPLAY_HEIGHT + 3));
+    console.log(chalk4.dim("\u2550".repeat(60)));
+    console.log("");
+    for (const line of lines) {
+      process.stdout.write("\x1B[2K");
+      console.log(line);
+    }
+  }
+}
+function displayError(_state, error2, details) {
+  blank();
+  console.log(chalk4.bgRed.white.bold(" ERROR "));
+  console.log(chalk4.red(`  ${error2}`));
+  if (details) {
+    console.log(chalk4.dim(`  ${details}`));
+  }
   blank();
-  console.log(chalk4.dim("Press Ctrl+C to disconnect"));
 }
-async function forwardToOpenCode(port, request) {
+async function validateSandbox(token, sandboxId) {
+  const apiUrl = getApiUrlConfig();
+  try {
+    const response = await fetch(`${apiUrl}/sandboxes/${sandboxId}`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (response.status === 404) {
+      return { valid: false, error: "Sandbox not found" };
+    }
+    if (response.status === 401) {
+      return { valid: false, error: "Authentication failed. Please run `evident login` again." };
+    }
+    if (!response.ok) {
+      return { valid: false, error: `API error: ${response.status}` };
+    }
+    const sandbox = await response.json();
+    if (sandbox.sandbox_type !== "remote") {
+      return {
+        valid: false,
+        error: `Sandbox is type '${sandbox.sandbox_type}', must be 'remote' for tunnel connection`
+      };
+    }
+    return { valid: true, name: sandbox.name };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
+    return { valid: false, error: `Failed to validate sandbox: ${message}` };
+  }
+}
+async function forwardToOpenCode(port, request, requestId, state) {
   const url = `http://localhost:${port}${request.path}`;
+  const startTime = Date.now();
+  state.pendingRequests.set(requestId, {
+    startTime,
+    method: request.method,
+    path: request.path
+  });
+  logActivity(state, {
+    type: "request",
+    method: request.method,
+    path: request.path,
+    requestId
+  });
+  displayStatus(state);
+  if (state.verbose && request.body) {
+    console.log(chalk4.dim(`  Request body: ${JSON.stringify(request.body, null, 2)}`));
+  }
+  telemetry.debug(
+    EventTypes.OPENCODE_REQUEST_FORWARDED,
+    `Forwarding ${request.method} ${request.path}`,
+    {
+      method: request.method,
+      path: request.path,
+      port,
+      requestId
+    },
+    state.sandboxId ?? void 0
+  );
   try {
     const response = await fetch(url, {
       method: request.method,
@@ -474,26 +857,230 @@ async function forwardToOpenCode(port, request) {
     });
     let body;
     const contentType = response.headers.get("Content-Type");
-    if (contentType?.includes("application/json")) {
-      body = await response.json();
+    const text = await response.text();
+    if (!text || text.length === 0) {
+      body = null;
+    } else if (contentType?.includes("application/json")) {
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = text;
+      }
     } else {
-      body = await response.text();
+      body = text;
+    }
+    const durationMs = Date.now() - startTime;
+    state.pendingRequests.delete(requestId);
+    if (!state.opencodeConnected) {
+      state.opencodeConnected = true;
     }
+    const lastEntry = state.activityLog[state.activityLog.length - 1];
+    if (lastEntry && lastEntry.requestId === requestId) {
+      lastEntry.type = "response";
+      lastEntry.status = response.status;
+      lastEntry.durationMs = durationMs;
+    } else {
+      logActivity(state, {
+        type: "response",
+        method: request.method,
+        path: request.path,
+        status: response.status,
+        durationMs,
+        requestId
+      });
+    }
+    displayStatus(state);
+    if (state.verbose && body) {
+      const bodyStr = typeof body === "string" ? body : JSON.stringify(body, null, 2);
+      const truncated = bodyStr.length > 500 ? bodyStr.substring(0, 500) + "..." : bodyStr;
+      console.log(chalk4.dim(`  Response body: ${truncated}`));
+    }
+    telemetry.debug(
+      EventTypes.OPENCODE_RESPONSE_SENT,
+      `Response ${response.status}`,
+      {
+        status: response.status,
+        path: request.path,
+        durationMs,
+        requestId
+      },
+      state.sandboxId ?? void 0
+    );
     return {
       status: response.status,
       body
     };
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : "Unknown error";
+    const durationMs = Date.now() - startTime;
+    state.pendingRequests.delete(requestId);
+    state.opencodeConnected = false;
+    logActivity(state, {
+      type: "error",
+      method: request.method,
+      path: request.path,
+      error: `OpenCode unreachable: ${message}`,
+      durationMs,
+      requestId
+    });
+    displayStatus(state);
+    telemetry.error(
+      EventTypes.OPENCODE_UNREACHABLE,
+      `Failed to connect to OpenCode: ${message}`,
+      {
+        port,
+        path: request.path,
+        error: message,
+        requestId
+      },
+      state.sandboxId ?? void 0
+    );
     return {
       status: 502,
       body: { error: "Failed to connect to OpenCode", message }
     };
   }
 }
+async function subscribeToOpenCodeEvents(port, subscriptionId, ws, state) {
+  const url = `http://localhost:${port}/event`;
+  logActivity(state, {
+    type: "info",
+    message: `Starting event subscription ${subscriptionId.slice(0, 8)}`
+  });
+  displayStatus(state);
+  const abortController = new AbortController();
+  state.activeEventSubscriptions.set(subscriptionId, abortController);
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "text/event-stream" },
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to connect to OpenCode events: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        ws.send(JSON.stringify({ type: "event_end", id: subscriptionId }));
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          try {
+            const event = JSON.parse(line.slice(6));
+            ws.send(JSON.stringify({ type: "event", id: subscriptionId, event }));
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (error2) {
+    if (abortController.signal.aborted) {
+      return;
+    }
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
+    logActivity(state, {
+      type: "error",
+      error: `Event subscription failed: ${message}`
+    });
+    displayStatus(state);
+    ws.send(JSON.stringify({ type: "event_error", id: subscriptionId, error: message }));
+  } finally {
+    state.activeEventSubscriptions.delete(subscriptionId);
+  }
+}
+function cancelEventSubscription(subscriptionId, state) {
+  const controller = state.activeEventSubscriptions.get(subscriptionId);
+  if (controller) {
+    controller.abort();
+    state.activeEventSubscriptions.delete(subscriptionId);
+  }
+}
+function sendResponse(ws, requestId, response) {
+  const bodyStr = JSON.stringify(response.body ?? null);
+  const bodyBytes = Buffer.from(bodyStr, "utf-8");
+  if (bodyBytes.length < CHUNK_THRESHOLD) {
+    ws.send(
+      JSON.stringify({
+        type: "response",
+        id: requestId,
+        payload: response
+      })
+    );
+    return;
+  }
+  sendResponseAsChunks(ws, requestId, response, bodyBytes);
+}
+function sendResponseAsChunks(ws, requestId, response, bodyBytes) {
+  const chunks = splitIntoChunks(bodyBytes, CHUNK_SIZE);
+  ws.send(
+    JSON.stringify({
+      type: "response_start",
+      id: requestId,
+      total_chunks: chunks.length,
+      total_size: bodyBytes.length,
+      payload: {
+        status: response.status,
+        headers: response.headers
+      }
+    })
+  );
+  for (let i = 0; i < chunks.length; i++) {
+    ws.send(
+      JSON.stringify({
+        type: "response_chunk",
+        id: requestId,
+        chunk_index: i,
+        data: chunks[i].toString("base64")
+      })
+    );
+  }
+  ws.send(
+    JSON.stringify({
+      type: "response_end",
+      id: requestId
+    })
+  );
+}
+function splitIntoChunks(data, chunkSize) {
+  const chunks = [];
+  for (let i = 0; i < data.length; i += chunkSize) {
+    chunks.push(data.subarray(i, i + chunkSize));
+  }
+  return chunks;
+}
+function getReconnectDelay(attempt) {
+  const exponentialDelay = BASE_RECONNECT_DELAY * Math.pow(2, attempt);
+  const jitter = Math.random() * 1e3;
+  return Math.min(exponentialDelay + jitter, MAX_RECONNECT_DELAY);
+}
 async function connect(token, sandboxId, port, state) {
   const tunnelUrl = getTunnelUrlConfig();
-  const url = sandboxId ? `${tunnelUrl}/tunnel/${sandboxId}/connect` : `${tunnelUrl}/tunnel/default/connect`;
+  const url = `${tunnelUrl}/tunnel/${sandboxId}/connect`;
+  logActivity(state, {
+    type: "info",
+    message: "Connecting to tunnel relay..."
+  });
+  displayStatus(state);
+  telemetry.info(
+    EventTypes.TUNNEL_STARTING,
+    `Connecting to ${url}`,
+    {
+      sandboxId,
+      port,
+      tunnelUrl
+    },
+    sandboxId
+  );
   return new Promise((resolve, reject) => {
     const ws = new WebSocket(url, {
       headers: {
@@ -503,20 +1090,47 @@ async function connect(token, sandboxId, port, state) {
     ws.on("open", () => {
       state.connected = true;
       state.reconnectAttempt = 0;
-      state.lastActivity = /* @__PURE__ */ new Date();
+      logActivity(state, {
+        type: "info",
+        message: "WebSocket connection established"
+      });
       displayStatus(state);
     });
     ws.on("message", async (data) => {
       try {
         const message = JSON.parse(data.toString());
-        state.lastActivity = /* @__PURE__ */ new Date();
         switch (message.type) {
           case "connected":
-            state.sandboxId = message.sandbox_id ?? null;
+            state.sandboxId = message.sandbox_id ?? sandboxId;
+            logActivity(state, {
+              type: "info",
+              message: `Tunnel connected (sandbox: ${state.sandboxId})`
+            });
+            telemetry.info(
+              EventTypes.TUNNEL_CONNECTED,
+              `Tunnel connected`,
+              {
+                sandboxId: message.sandbox_id
+              },
+              message.sandbox_id
+            );
             displayStatus(state);
             break;
           case "error":
-            printError(`Tunnel error: ${message.message}`);
+            logActivity(state, {
+              type: "error",
+              error: message.message || "Unknown tunnel error"
+            });
+            telemetry.error(
+              EventTypes.TUNNEL_ERROR,
+              `Tunnel error: ${message.message}`,
+              {
+                code: message.code,
+                message: message.message
+              },
+              state.sandboxId ?? void 0
+            );
+            displayStatus(state);
             if (message.code === "unauthorized") {
               ws.close();
               reject(new Error("Unauthorized"));
@@ -527,81 +1141,440 @@ async function connect(token, sandboxId, port, state) {
             break;
           case "request":
             if (message.id && message.payload) {
-              const response = await forwardToOpenCode(port, message.payload);
-              ws.send(
-                JSON.stringify({
-                  type: "response",
-                  id: message.id,
-                  payload: response
-                })
+              telemetry.debug(
+                EventTypes.OPENCODE_REQUEST_RECEIVED,
+                `Request: ${message.payload.method} ${message.payload.path}`,
+                {
+                  requestId: message.id,
+                  method: message.payload.method,
+                  path: message.payload.path
+                },
+                state.sandboxId ?? void 0
               );
-              displayStatus(state);
+              const response = await forwardToOpenCode(port, message.payload, message.id, state);
+              sendResponse(ws, message.id, response);
+            }
+            break;
+          case "subscribe_events":
+            if (message.id) {
+              void subscribeToOpenCodeEvents(port, message.id, ws, state);
+            }
+            break;
+          case "unsubscribe_events":
+            if (message.id) {
+              cancelEventSubscription(message.id, state);
             }
             break;
         }
       } catch (error2) {
-        console.error("Failed to handle message:", error2);
+        const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
+        logActivity(state, {
+          type: "error",
+          error: `Failed to handle message: ${errorMessage}`
+        });
+        telemetry.error(
+          EventTypes.TUNNEL_ERROR,
+          `Failed to handle message: ${errorMessage}`,
+          {
+            error: errorMessage
+          },
+          state.sandboxId ?? void 0
+        );
+        displayStatus(state);
       }
     });
-    ws.on("close", () => {
+    ws.on("close", (code, reason) => {
       state.connected = false;
+      const reasonStr = reason.toString() || "No reason provided";
+      logActivity(state, {
+        type: "info",
+        message: `Disconnected (code: ${code}, reason: ${reasonStr})`
+      });
+      telemetry.info(
+        EventTypes.TUNNEL_DISCONNECTED,
+        "Tunnel disconnected",
+        {
+          sandboxId: state.sandboxId,
+          code,
+          reason: reasonStr
+        },
+        state.sandboxId ?? void 0
+      );
       displayStatus(state);
       resolve();
     });
     ws.on("error", (error2) => {
       state.connected = false;
+      logActivity(state, {
+        type: "error",
+        error: `Connection error: ${error2.message}`
+      });
+      telemetry.error(
+        EventTypes.TUNNEL_ERROR,
+        `Connection error: ${error2.message}`,
+        {
+          error: error2.message
+        },
+        state.sandboxId ?? void 0
+      );
       displayStatus(state);
-      console.error(chalk4.dim(`Connection error: ${error2.message}`));
     });
-    const cleanup = () => {
+    const cleanup = async () => {
+      process.removeAllListeners("SIGINT");
+      process.removeAllListeners("SIGTERM");
+      logActivity(state, {
+        type: "info",
+        message: "Shutting down..."
+      });
+      displayStatus(state);
+      telemetry.info(
+        EventTypes.TUNNEL_DISCONNECTED,
+        "Tunnel stopped by user",
+        {
+          sandboxId: state.sandboxId
+        },
+        state.sandboxId ?? void 0
+      );
+      await shutdownTelemetry();
       ws.close();
       process.exit(0);
     };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+    process.once("SIGINT", () => void cleanup());
+    process.once("SIGTERM", () => void cleanup());
   });
 }
 async function tunnel(options) {
-  const credentials2 = await getToken();
-  if (!credentials2) {
-    printError("Not logged in. Run the `login` command first.");
+  const verbose = options.verbose ?? false;
+  const credentials = await getToken();
+  if (!credentials) {
+    const cliName = (await import("./config-J7LPYFVS.js")).getCliName();
+    telemetry.error(EventTypes.CLI_ERROR, "Not logged in", { command: "tunnel" });
+    printError(`Not logged in. Run \`${cliName} login\` first.`);
     process.exit(1);
   }
   const port = options.port ?? 4096;
   const sandboxId = options.sandbox;
-  const spinner = ora2("Checking OpenCode connection...").start();
-  try {
-    const response = await fetch(`http://localhost:${port}/health`);
-    if (!response.ok) {
-      throw new Error("Health check failed");
-    }
-    spinner.succeed(`OpenCode detected on port ${port}`);
-  } catch {
-    spinner.warn(`Could not connect to OpenCode on port ${port}`);
-    printWarning("Make sure OpenCode is running before starting the tunnel.");
+  if (!sandboxId) {
+    const cliName = (await import("./config-J7LPYFVS.js")).getCliName();
+    printError("--sandbox <id> is required");
     blank();
+    console.log(chalk4.dim("To find your sandbox ID:"));
+    console.log(chalk4.dim("  1. Create a remote sandbox in the Evident web UI"));
+    console.log(chalk4.dim("  2. Copy the sandbox ID from the URL or settings"));
+    console.log(chalk4.dim(`  3. Run: ${cliName} tunnel --sandbox <id>`));
+    blank();
+    telemetry.error(EventTypes.CLI_ERROR, "Missing sandbox ID", { command: "tunnel" });
+    process.exit(1);
   }
   const state = {
     connected: false,
-    sandboxId: null,
+    opencodeConnected: false,
+    opencodeVersion: null,
+    sandboxId,
+    sandboxName: null,
     reconnectAttempt: 0,
-    lastActivity: /* @__PURE__ */ new Date()
+    lastActivity: /* @__PURE__ */ new Date(),
+    activityLog: [],
+    pendingRequests: /* @__PURE__ */ new Map(),
+    verbose,
+    displayInitialized: false,
+    activeEventSubscriptions: /* @__PURE__ */ new Map()
   };
+  telemetry.info(
+    EventTypes.CLI_COMMAND,
+    "Starting tunnel command",
+    {
+      command: "tunnel",
+      port,
+      sandboxId,
+      verbose
+    },
+    sandboxId
+  );
+  logActivity(state, {
+    type: "info",
+    message: `Starting tunnel (port: ${port}, verbose: ${verbose})`
+  });
+  logActivity(state, {
+    type: "info",
+    message: "Validating sandbox..."
+  });
+  const validateSpinner = ora2("Validating sandbox...").start();
+  const validation = await validateSandbox(credentials.token, sandboxId);
+  if (!validation.valid) {
+    validateSpinner.fail(`Sandbox validation failed: ${validation.error}`);
+    logActivity(state, {
+      type: "error",
+      error: `Sandbox validation failed: ${validation.error}`
+    });
+    telemetry.error(EventTypes.CLI_ERROR, `Sandbox validation failed: ${validation.error}`, {
+      command: "tunnel",
+      sandboxId
+    });
+    displayStatus(state);
+    process.exit(1);
+  }
+  state.sandboxName = validation.name ?? null;
+  validateSpinner.succeed(`Sandbox: ${validation.name || sandboxId}`);
+  logActivity(state, {
+    type: "info",
+    message: `Sandbox validated: ${validation.name || sandboxId}`
+  });
+  logActivity(state, {
+    type: "info",
+    message: `Checking OpenCode on port ${port}...`
+  });
+  const opencodeSpinner = ora2("Checking OpenCode connection...").start();
+  const healthCheck = await checkOpenCodeHealth(port);
+  if (healthCheck.healthy) {
+    state.opencodeConnected = true;
+    state.opencodeVersion = healthCheck.version ?? null;
+    const version = healthCheck.version ? ` (v${healthCheck.version})` : "";
+    telemetry.info(
+      EventTypes.OPENCODE_HEALTH_OK,
+      `OpenCode healthy on port ${port}`,
+      {
+        port,
+        version: healthCheck.version
+      },
+      sandboxId
+    );
+    opencodeSpinner.succeed(`OpenCode running on port ${port}${version}`);
+    logActivity(state, {
+      type: "info",
+      message: `OpenCode running on port ${port}${version}`
+    });
+  } else {
+    telemetry.warn(
+      EventTypes.OPENCODE_HEALTH_FAILED,
+      `Could not connect to OpenCode: ${healthCheck.error}`,
+      {
+        port,
+        error: healthCheck.error
+      },
+      sandboxId
+    );
+    opencodeSpinner.warn(`Could not connect to OpenCode on port ${port}`);
+    logActivity(state, {
+      type: "error",
+      error: `OpenCode not reachable on port ${port}: ${healthCheck.error}`
+    });
+    const runningInstances = await findHealthyOpenCodeInstances();
+    if (runningInstances.length > 0) {
+      blank();
+      console.log(chalk4.yellow("Found OpenCode running on different port(s):"));
+      for (const instance of runningInstances) {
+        const ver = instance.version ? ` (v${instance.version})` : "";
+        const cwd = instance.cwd ? ` in ${instance.cwd}` : "";
+        console.log(chalk4.dim(`  \u2022 Port ${instance.port}${ver}${cwd}`));
+      }
+      blank();
+      if (runningInstances.length === 1) {
+        console.log(chalk4.yellow("Tip: Run with the correct port:"));
+        console.log(
+          chalk4.dim(
+            `  npx @evident-ai/cli@latest tunnel --sandbox ${sandboxId} --port ${runningInstances[0].port}`
+          )
+        );
+      } else {
+        console.log(chalk4.yellow("Tip: Specify which port to use:"));
+        console.log(
+          chalk4.dim(`  npx @evident-ai/cli@latest tunnel --sandbox ${sandboxId} --port <PORT>`)
+        );
+      }
+      blank();
+    } else {
+      blank();
+      const action = await select({
+        message: "OpenCode is not running. What would you like to do?",
+        choices: [
+          {
+            name: "Start OpenCode for me",
+            value: "start",
+            description: `Run 'opencode serve --port ${port}' in a new process`
+          },
+          {
+            name: "Show me the command to run",
+            value: "manual",
+            description: "Display instructions for starting OpenCode manually"
+          },
+          {
+            name: "Continue without OpenCode",
+            value: "continue",
+            description: "Connect the tunnel anyway (requests will fail until OpenCode starts)"
+          }
+        ]
+      });
+      if (action === "start") {
+        let actualPort = port;
+        if (isPortInUse(port)) {
+          console.log(chalk4.yellow(`
+Port ${port} is already in use by another process.`));
+          const alternativePort = findAvailablePort(port + 1);
+          if (alternativePort) {
+            const useAlternative = await select({
+              message: `Would you like to use port ${alternativePort} instead?`,
+              choices: [
+                { name: `Yes, use port ${alternativePort}`, value: "yes" },
+                { name: "No, I will free up the port manually", value: "no" }
+              ]
+            });
+            if (useAlternative === "yes") {
+              actualPort = alternativePort;
+            } else {
+              console.log(chalk4.dim(`
+Free up port ${port} and run the tunnel command again.`));
+              blank();
+              process.exit(1);
+            }
+          } else {
+            console.log(
+              chalk4.red(
+                `Could not find an available port. Please free up port ${port} and try again.`
+              )
+            );
+            blank();
+            process.exit(1);
+          }
+        }
+        const opencodeStartSpinner = ora2(`Starting OpenCode on port ${actualPort}...`).start();
+        try {
+          let command = "opencode";
+          let args = ["serve", "--port", actualPort.toString()];
+          try {
+            execSync("which opencode", { stdio: "ignore" });
+          } catch {
+            command = "npx";
+            args = ["opencode", "serve", "--port", actualPort.toString()];
+          }
+          const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+            cwd: process.cwd()
+            // Start in current working directory
+          });
+          child.unref();
+          const maxRetries = 10;
+          const retryDelayMs = 1e3;
+          let healthy = false;
+          let version;
+          for (let i = 0; i < maxRetries; i++) {
+            await sleep(retryDelayMs);
+            const retryHealth = await checkOpenCodeHealth(actualPort);
+            if (retryHealth.healthy) {
+              healthy = true;
+              version = retryHealth.version;
+              break;
+            }
+            opencodeStartSpinner.text = `Starting OpenCode on port ${actualPort}... (${i + 1}/${maxRetries})`;
+          }
+          if (healthy) {
+            state.opencodeConnected = true;
+            state.opencodeVersion = version ?? null;
+            const versionStr = version ? ` (v${version})` : "";
+            opencodeStartSpinner.succeed(`OpenCode started on port ${actualPort}${versionStr}`);
+            logActivity(state, {
+              type: "info",
+              message: `OpenCode started on port ${actualPort}${versionStr}`
+            });
+          } else {
+            opencodeStartSpinner.warn(
+              "OpenCode process started but not responding. Check if it started correctly."
+            );
+            logActivity(state, {
+              type: "info",
+              message: "OpenCode may still be starting..."
+            });
+            console.log(chalk4.dim("\nTip: Check for errors by running OpenCode manually:"));
+            console.log(chalk4.dim(`  opencode serve --port ${actualPort}`));
+            blank();
+          }
+        } catch (error2) {
+          const msg = error2 instanceof Error ? error2.message : "Unknown error";
+          opencodeStartSpinner.fail(`Failed to start OpenCode: ${msg}`);
+          logActivity(state, {
+            type: "error",
+            error: `Failed to start OpenCode: ${msg}`
+          });
+          console.log(chalk4.yellow("\nYou can try starting it manually:"));
+          console.log(chalk4.dim(`  opencode serve --port ${actualPort}`));
+          blank();
+        }
+      } else if (action === "manual") {
+        blank();
+        console.log(chalk4.yellow("To start OpenCode, run one of these commands:"));
+        blank();
+        console.log(chalk4.dim("  # Start OpenCode in your project directory:"));
+        console.log(chalk4.dim(`  opencode serve --port ${port}`));
+        blank();
+        console.log(chalk4.dim("  # Or if you have OpenCode installed globally:"));
+        console.log(chalk4.dim(`  npx opencode serve --port ${port}`));
+        blank();
+        console.log(
+          chalk4.dim("The tunnel will automatically forward requests once OpenCode is running.")
+        );
+        blank();
+      }
+    }
+  }
   while (true) {
     try {
-      await connect(credentials2.token, sandboxId, port, state);
+      await connect(credentials.token, sandboxId, port, state);
       state.reconnectAttempt++;
       const delay = getReconnectDelay(state.reconnectAttempt);
+      logActivity(state, {
+        type: "info",
+        message: `Reconnecting in ${Math.round(delay / 1e3)}s (attempt ${state.reconnectAttempt})...`
+      });
+      telemetry.info(
+        EventTypes.TUNNEL_RECONNECTING,
+        `Reconnecting (attempt ${state.reconnectAttempt})`,
+        {
+          attempt: state.reconnectAttempt,
+          delayMs: delay
+        },
+        state.sandboxId ?? void 0
+      );
       displayStatus(state);
       await sleep(delay);
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : "Unknown error";
       if (message === "Unauthorized") {
-        printError("Authentication failed. Please run the `login` command again.");
+        telemetry.error(
+          EventTypes.CLI_ERROR,
+          "Authentication failed",
+          {
+            command: "tunnel",
+            error: message
+          },
+          state.sandboxId ?? void 0
+        );
+        await shutdownTelemetry();
+        displayError(state, "Authentication failed", "Please run `evident login` again.");
         process.exit(1);
       }
+      logActivity(state, {
+        type: "error",
+        error: message
+      });
+      telemetry.error(
+        EventTypes.TUNNEL_ERROR,
+        `Tunnel error: ${message}`,
+        {
+          error: message,
+          attempt: state.reconnectAttempt
+        },
+        state.sandboxId ?? void 0
+      );
       state.reconnectAttempt++;
       const delay = getReconnectDelay(state.reconnectAttempt);
+      logActivity(state, {
+        type: "info",
+        message: `Reconnecting in ${Math.round(delay / 1e3)}s (attempt ${state.reconnectAttempt})...`
+      });
+      displayStatus(state);
       await sleep(delay);
     }
   }
@@ -618,10 +1591,11 @@ program.name("evident").description("Run OpenCode locally and connect it to Evid
 program.command("login").description("Authenticate with Evident").option("--token", "Use token-based authentication (for CI/CD)").option("--no-browser", "Do not open the browser automatically").action(login);
 program.command("logout").description("Remove stored credentials").action(logout);
 program.command("whoami").description("Show the currently logged in user").action(whoami);
-program.command("tunnel").description("Establish a tunnel to Evident for Local Mode").option("-s, --sandbox <id>", "Sandbox ID to connect to").option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").action((options) => {
+program.command("tunnel").description("Establish a tunnel to Evident for Local Mode").requiredOption("-s, --sandbox <id>", "Sandbox ID to connect to (required)").option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option("-v, --verbose", "Show detailed request/response information").action((options) => {
   tunnel({
     sandbox: options.sandbox,
-    port: parseInt(options.port, 10)
+    port: parseInt(options.port, 10),
+    verbose: options.verbose
   });
 });
 program.parse();