@evident-ai/cli 0.1.6 → 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,6 +371,8 @@ 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";
@@ -479,8 +416,8 @@ async function flushEvents() {
     flushTimeout = null;
   }
   try {
-    const credentials2 = await getToken();
-    if (!credentials2) {
+    const credentials = await getToken();
+    if (!credentials) {
       return;
     }
     const apiUrl = getApiUrlConfig();
@@ -491,7 +428,7 @@ async function flushEvents() {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${credentials2.token}`
+          Authorization: `Bearer ${credentials.token}`
         },
         body: JSON.stringify({
           events,
@@ -551,6 +488,173 @@ var EventTypes = {
 var MAX_RECONNECT_DELAY = 3e4;
 var BASE_RECONNECT_DELAY = 500;
 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,
@@ -603,38 +707,76 @@ function colorizeStatus(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(60)));
-  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("Connected")}`);
-    console.log(`  Sandbox:    ${state.sandboxId ?? "Unknown"}`);
-    if (state.sandboxName) {
-      console.log(`  Name:       ${state.sandboxName}`);
-    }
+    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...")}`);
     }
   }
-  blank();
+  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) {
-    console.log(chalk4.bold("  Activity:"));
+    lines.push(chalk4.bold("  Activity:"));
     for (const entry of state.activityLog) {
-      console.log(formatActivityEntry(entry, state.verbose));
+      lines.push(formatActivityEntry(entry, state.verbose));
     }
   } else {
-    console.log(chalk4.dim("  No activity yet. Waiting for requests..."));
+    lines.push(chalk4.dim("  No activity yet. Waiting for requests..."));
   }
-  blank();
-  console.log(chalk4.dim("\u2500".repeat(60)));
+  lines.push("");
+  lines.push(chalk4.dim("\u2500".repeat(60)));
   if (state.verbose) {
-    console.log(chalk4.dim("  Verbose mode: ON (request/response bodies will be logged)"));
+    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);
+    }
   }
-  console.log(chalk4.dim("  Press Ctrl+C to disconnect"));
 }
 function displayError(_state, error2, details) {
   blank();
@@ -715,13 +857,23 @@ async function forwardToOpenCode(port, request, requestId, state) {
     });
     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";
@@ -762,6 +914,7 @@ async function forwardToOpenCode(port, request, requestId, state) {
     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,
@@ -788,6 +941,123 @@ async function forwardToOpenCode(port, request, requestId, state) {
     };
   }
 }
+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;
@@ -882,13 +1152,17 @@ async function connect(token, sandboxId, port, state) {
                 state.sandboxId ?? void 0
               );
               const response = await forwardToOpenCode(port, message.payload, message.id, state);
-              ws.send(
-                JSON.stringify({
-                  type: "response",
-                  id: message.id,
-                  payload: response
-                })
-              );
+              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;
         }
@@ -973,34 +1247,40 @@ async function connect(token, sandboxId, port, state) {
 }
 async function tunnel(options) {
   const verbose = options.verbose ?? false;
-  const credentials2 = await getToken();
-  if (!credentials2) {
+  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 `evident login` first.");
+    printError(`Not logged in. Run \`${cliName} login\` first.`);
     process.exit(1);
   }
   const port = options.port ?? 4096;
   const sandboxId = options.sandbox;
   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: evident tunnel --sandbox <id>"));
+    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,
+    opencodeConnected: false,
+    opencodeVersion: null,
     sandboxId,
     sandboxName: null,
     reconnectAttempt: 0,
     lastActivity: /* @__PURE__ */ new Date(),
     activityLog: [],
     pendingRequests: /* @__PURE__ */ new Map(),
-    verbose
+    verbose,
+    displayInitialized: false,
+    activeEventSubscriptions: /* @__PURE__ */ new Map()
   };
   telemetry.info(
     EventTypes.CLI_COMMAND,
@@ -1022,7 +1302,7 @@ async function tunnel(options) {
     message: "Validating sandbox..."
   });
   const validateSpinner = ora2("Validating sandbox...").start();
-  const validation = await validateSandbox(credentials2.token, sandboxId);
+  const validation = await validateSandbox(credentials.token, sandboxId);
   if (!validation.valid) {
     validateSpinner.fail(`Sandbox validation failed: ${validation.error}`);
     logActivity(state, {
@@ -1047,25 +1327,17 @@ async function tunnel(options) {
     message: `Checking OpenCode on port ${port}...`
   });
   const opencodeSpinner = ora2("Checking OpenCode connection...").start();
-  try {
-    telemetry.debug(
-      EventTypes.OPENCODE_HEALTH_CHECK,
-      `Checking OpenCode on port ${port}`,
-      { port },
-      sandboxId
-    );
-    const response = await fetch(`http://localhost:${port}/health`);
-    if (!response.ok) {
-      throw new Error(`Health check returned ${response.status}`);
-    }
-    const healthData = await response.json().catch(() => ({}));
-    const version = healthData.version ? ` (v${healthData.version})` : "";
+  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,
-        healthData
+        version: healthCheck.version
       },
       sandboxId
     );
@@ -1074,29 +1346,182 @@ async function tunnel(options) {
       type: "info",
       message: `OpenCode running on port ${port}${version}`
     });
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
+  } else {
     telemetry.warn(
       EventTypes.OPENCODE_HEALTH_FAILED,
-      `Could not connect to OpenCode: ${errorMessage}`,
+      `Could not connect to OpenCode: ${healthCheck.error}`,
       {
         port,
-        error: errorMessage
+        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}: ${errorMessage}`
+      error: `OpenCode not reachable on port ${port}: ${healthCheck.error}`
     });
-    printWarning("Make sure OpenCode is running before starting the tunnel:");
-    console.log(chalk4.dim(`  opencode serve --port ${port}`));
-    blank();
+    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, {