@evident-ai/cli 3.1.1-dev.63072ee → 3.1.1-dev.698e558

package/README.md

@@ -94,6 +94,10 @@ Options:
 - `-c, --conversation <id>` — Process only this specific conversation.
 - `--idle-timeout <seconds>` — Exit after N seconds with no pending work (useful
   in CI to avoid polling indefinitely).
+- `--opencode-start-timeout <seconds>` — How long to wait for OpenCode to become
+  healthy when the runner starts it itself (default: `180`). On expiry the runner
+  warns and comes online anyway rather than failing. Env:
+  `EVIDENT_OPENCODE_START_TIMEOUT` (seconds).
 - `--json` — Output in JSON format (forces non-interactive mode).
 
 ## Global flags

package/dist/index.js

@@ -267,16 +267,28 @@ async function getToken() {
   }
   return null;
 }
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
 async function deleteToken(options = {}) {
   const keytar = await getKeytar();
+  const failures = [];
   if (keytar) {
     if (options.all) {
-      const all = await keytar.findCredentials(SERVICE_NAME).catch(() => []);
+      let accounts = [];
+      try {
+        accounts = await keytar.findCredentials(SERVICE_NAME);
+      } catch (err) {
+        failures.push({ type: "enumerate", error: toError(err) });
+      }
       await Promise.all(
-        all.map(
-          (entry) => keytar.deletePassword(SERVICE_NAME, entry.account).catch(() => {
-          })
-        )
+        accounts.map(async (entry) => {
+          try {
+            await keytar.deletePassword(SERVICE_NAME, entry.account);
+          } catch (err) {
+            failures.push({ type: "delete", account: entry.account, error: toError(err) });
+          }
+        })
       );
     } else {
       await keytar.deletePassword(SERVICE_NAME, keychainAccount());
@@ -287,6 +299,7 @@ async function deleteToken(options = {}) {
   } else {
     clearCredentials();
   }
+  return { failures };
 }
 
 // src/utils/ui.ts
@@ -404,8 +417,10 @@ async function deviceFlowLogin(options) {
 }
 async function tokenLogin() {
   console.log("Token login mode.");
-  console.log("Run `evident login` on a machine with a browser to get a token.");
-  console.log("Manage or revoke existing tokens under Settings \u2192 CLI tokens.");
+  console.log("Create a token under Settings \u2192 CLI tokens in the dashboard, then paste it below.");
+  console.log(
+    "(Alternatively, run `evident login` on a machine with a browser, or set EVIDENT_TOKEN for CI.)"
+  );
   blank();
   process.stdout.write("Paste token: ");
   const token = await new Promise((resolve3) => {
@@ -429,13 +444,22 @@ async function tokenLogin() {
     printError("No token provided.");
     process.exit(1);
   }
+  await validateAndStoreToken(token);
+}
+async function validateAndStoreToken(token) {
   const spinner = ora("Validating token...").start();
   try {
-    const result = await api.post("/auth/token/validate", { token });
+    const result = await api.get("/me", {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!result.user) {
+      throw new Error(
+        "This token is not a user login (e.g. a runner key). Paste a CLI token instead."
+      );
+    }
     await storeToken({
       token,
-      user: result.user,
-      expiresAt: result.expires_at
+      user: { email: result.user.email }
     });
     spinner.stop();
     printSuccess(`Logged in as ${chalk2.bold(result.user.email)}`);
@@ -455,9 +479,22 @@ async function login(options) {
 }
 
 // src/commands/logout.ts
+function describeFailure(failure) {
+  if (failure.type === "enumerate") {
+    return `could not list stored keychain entries (${failure.error.message})`;
+  }
+  return `${failure.account} (${failure.error.message})`;
+}
 async function logout(options = {}) {
   if (options.all) {
-    await deleteToken({ all: true });
+    const result = await deleteToken({ all: true });
+    if (result.failures.length > 0) {
+      printError(
+        `Failed to fully clear your keychain: ${result.failures.map(describeFailure).join("; ")}. Your local credentials file was cleared, but stale keychain entries may remain \u2014 run \`evident logout --all\` again, or remove them manually from your OS keychain / credential manager.`
+      );
+      process.exitCode = 1;
+      return;
+    }
     printSuccess("Logged out of all endpoints.");
     return;
   }
@@ -482,7 +519,9 @@ async function whoami() {
   blank();
   console.log(keyValue("Endpoint", apiUrl));
   console.log(keyValue("User", chalk3.bold(credentials2.user.email)));
-  console.log(keyValue("User ID", credentials2.user.id));
+  if (credentials2.user.id) {
+    console.log(keyValue("User ID", credentials2.user.id));
+  }
   if (credentials2.expiresAt) {
     const expiresAt = new Date(credentials2.expiresAt);
     const now = /* @__PURE__ */ new Date();
@@ -510,7 +549,10 @@ var TelemetryEventTypes = {
   AGENT_DISCONNECTED: "agent.disconnected",
   AGENT_MESSAGE_PROCESSING: "agent.message_processing",
   AGENT_MESSAGE_DONE: "agent.message_done",
-  AGENT_MESSAGE_FAILED: "agent.message_failed"
+  AGENT_MESSAGE_FAILED: "agent.message_failed",
+  // A `warn`/`error` runner-side log line forwarded server-side for
+  // observability (issue #916) — see `apps/cli/src/lib/runner-activity-telemetry.ts`.
+  RUNNER_ACTIVITY: "runner.activity"
 };
 
 // ../../packages/types/src/tunnel/index.ts
@@ -565,6 +607,13 @@ var isShuttingDown = false;
 var FLUSH_INTERVAL_MS = 5e3;
 var MAX_BUFFER_SIZE = 50;
 var FLUSH_TIMEOUT_MS = 3e3;
+var authProvider = null;
+function setTelemetryAuthProvider(provider) {
+  authProvider = provider;
+}
+var FLUSH_FAILURE_LOG_INTERVAL_MS = 6e4;
+var lastFlushFailureLoggedAt = 0;
+var suppressedFlushFailureCount = 0;
 function logEvent(eventType, options = {}) {
   const event = {
     event_type: eventType,
@@ -599,9 +648,16 @@ async function flushEvents() {
     flushTimeout = null;
   }
   try {
-    const credentials2 = await getToken();
-    if (!credentials2) {
-      return;
+    const providerContext = authProvider?.();
+    let authHeader;
+    if (providerContext?.authHeader) {
+      authHeader = providerContext.authHeader;
+    } else {
+      const credentials2 = await getToken();
+      if (!credentials2) {
+        return;
+      }
+      authHeader = `Bearer ${credentials2.token}`;
     }
     const apiUrl = getApiUrlConfig();
     const controller = new AbortController();
@@ -616,7 +672,7 @@ async function flushEvents() {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${credentials2.token}`
+          Authorization: authHeader
         },
         body: JSON.stringify(request),
         signal: controller.signal
@@ -628,8 +684,15 @@ async function flushEvents() {
       clearTimeout(timeout);
     }
   } catch (error2) {
-    if (process.env.DEBUG) {
-      console.error("Telemetry error:", error2);
+    const now = Date.now();
+    if (now - lastFlushFailureLoggedAt >= FLUSH_FAILURE_LOG_INTERVAL_MS) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      const suffix = suppressedFlushFailureCount > 0 ? ` (${suppressedFlushFailureCount} more suppressed in the last ${FLUSH_FAILURE_LOG_INTERVAL_MS / 1e3}s)` : "";
+      console.error(`Telemetry flush error: ${message}${suffix}`);
+      lastFlushFailureLoggedAt = now;
+      suppressedFlushFailureCount = 0;
+    } else {
+      suppressedFlushFailureCount++;
     }
   }
 }
@@ -698,6 +761,69 @@ var EventTypes = {
   DEPRECATED_AGENT_KEY_ENV_USED: "cli.deprecated_agent_key_env_used"
 };
 
+// src/lib/runner-activity-telemetry.ts
+var FORWARDED_LEVELS = /* @__PURE__ */ new Set(["warn", "error"]);
+var SEVERITY_BY_LEVEL = {
+  warn: "warning",
+  error: "error"
+};
+var MAX_MESSAGE_LENGTH = 500;
+var TRUNCATION_MARKER = "\u2026";
+function redact(message) {
+  return message.replace(/esk_[A-Za-z0-9_-]+/g, "esk_***").replace(/ct_[A-Za-z0-9_-]+/g, "ct_***").replace(/https?:\/\/\S+/g, "<url>");
+}
+function truncate(message) {
+  if (message.length <= MAX_MESSAGE_LENGTH) return message;
+  return message.slice(0, MAX_MESSAGE_LENGTH - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+}
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RATE_LIMIT_MAX_EVENTS = 30;
+var windowStartedAt = 0;
+var windowCount = 0;
+var windowDroppedCount = 0;
+function admitUnderRateLimit(now) {
+  if (now - windowStartedAt >= RATE_LIMIT_WINDOW_MS) {
+    if (windowDroppedCount > 0) {
+      console.error(
+        `[runner-activity-telemetry] rate cap reached: dropped ${windowDroppedCount} ${windowDroppedCount === 1 ? "entry" : "entries"} in the last ${RATE_LIMIT_WINDOW_MS / 1e3}s (cap ${RATE_LIMIT_MAX_EVENTS}/min)`
+      );
+    }
+    windowStartedAt = now;
+    windowCount = 0;
+    windowDroppedCount = 0;
+  }
+  if (windowCount >= RATE_LIMIT_MAX_EVENTS) {
+    windowDroppedCount++;
+    if (windowDroppedCount === 1) {
+      console.error(
+        `[runner-activity-telemetry] rate cap reached (${RATE_LIMIT_MAX_EVENTS} per ${RATE_LIMIT_WINDOW_MS / 1e3}s) \u2014 dropping further entries this window`
+      );
+    }
+    return false;
+  }
+  windowCount++;
+  return true;
+}
+function forwardRunnerActivity(entry, context) {
+  try {
+    if (!FORWARDED_LEVELS.has(entry.level)) return;
+    if (!context.agentId || !context.authHeader) return;
+    if (!admitUnderRateLimit(Date.now())) return;
+    const rawMessage = entry.error ?? entry.message ?? "";
+    const message = truncate(redact(rawMessage));
+    logEvent(TelemetryEventTypes.RUNNER_ACTIVITY, {
+      severity: SEVERITY_BY_LEVEL[entry.level],
+      message,
+      metadata: { source: "cli.run" },
+      agentId: context.agentId
+    });
+  } catch (err) {
+    console.error(
+      `[runner-activity-telemetry] failed to forward runner activity: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
 // src/lib/auth.ts
 async function getAuthCredentials() {
   const runnerKey = process.env.EVIDENT_RUNNER_KEY;
@@ -3178,7 +3304,12 @@ var ChannelDriver = class _ChannelDriver {
     const directory = await this.resolveOpenCodeDirectory();
     const sessionId = await createOpenCodeSession(this.port, directory);
     this.sessions.set(conversationId, sessionId);
-    await this.persistSession(conversationId, sessionId).catch(() => {
+    await this.persistSession(conversationId, sessionId).catch((err) => {
+      this.log({
+        level: "warn",
+        message: `Persisting the OpenCode session binding ${sessionId.slice(0, 8)} for conversation ${conversationId.slice(0, 8)} failed (best-effort, not retried) \u2014 the completion PATCH also carries opencode_session_id, so the binding is repaired when the turn finishes: ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conversationId
+      });
     });
     return sessionId;
   }
@@ -5212,10 +5343,16 @@ var ChannelDriver = class _ChannelDriver {
 import chalk5 from "chalk";
 import ora2 from "ora";
 import { select as select2 } from "@inquirer/prompts";
+var INTERACTIVE_START_TIMEOUT_MS = 3e4;
 async function ensureOpenCodeRunning(ctx) {
   const healthCheck = await checkOpenCodeHealth(ctx.port);
   if (healthCheck.healthy) {
-    return { port: ctx.port, process: null, version: healthCheck.version ?? null };
+    return {
+      port: ctx.port,
+      process: null,
+      version: healthCheck.version ?? null,
+      notReadyReason: null
+    };
   }
   const runningInstances = await findHealthyOpenCodeInstances();
   if (runningInstances.length > 0) {
@@ -5256,14 +5393,22 @@ async function ensureOpenCodeRunning(ctx) {
   if (!ctx.interactive) {
     ctx.log(`OpenCode is not running on port ${ctx.port}. Starting it automatically...`);
     const proc = await startOpenCode(ctx.port);
-    const health = await waitForOpenCodeHealth(ctx.port, 3e4);
+    const health = await waitForOpenCodeHealth(ctx.port, ctx.startTimeoutMs);
     if (!health.healthy) {
-      throw new Error(
-        `OpenCode failed to start on port ${ctx.port}. Install with: npm install -g opencode-ai`
-      );
+      return {
+        port: ctx.port,
+        process: proc,
+        version: null,
+        notReadyReason: `it did not become healthy within ${Math.round(ctx.startTimeoutMs / 1e3)}s`
+      };
     }
     ctx.log(`OpenCode started on port ${ctx.port}${health.version ? ` (v${health.version})` : ""}`);
-    return { port: ctx.port, process: proc, version: health.version ?? null };
+    return {
+      port: ctx.port,
+      process: proc,
+      version: health.version ?? null,
+      notReadyReason: null
+    };
   }
   let port = ctx.port;
   if (isPortInUse(port)) {
@@ -5316,15 +5461,15 @@ Port ${port} is already in use.`));
   if (action === "start") {
     const spinner = ora2("Starting OpenCode...").start();
     const proc = await startOpenCode(port);
-    const health = await waitForOpenCodeHealth(port, 3e4);
+    const health = await waitForOpenCodeHealth(port, INTERACTIVE_START_TIMEOUT_MS);
     if (!health.healthy) {
       spinner.fail("Failed to start OpenCode");
       throw new Error("OpenCode failed to start");
     }
     spinner.stop();
-    return { port, process: proc, version: health.version ?? null };
+    return { port, process: proc, version: health.version ?? null, notReadyReason: null };
   }
-  return { port, process: null, version: null };
+  return { port, process: null, version: null, notReadyReason: "you chose to continue without it" };
 }
 
 // src/commands/agent-lookup.ts
@@ -5521,6 +5666,35 @@ function resolveFileSyncDirectories(raw, homeDir) {
   }
   return directories;
 }
+var DEFAULT_OPENCODE_START_TIMEOUT_SECONDS = 180;
+var MAX_OPENCODE_START_TIMEOUT_SECONDS = 3600;
+var OPENCODE_START_TIMEOUT_ENV = "EVIDENT_OPENCODE_START_TIMEOUT";
+function resolveOpenCodeStartTimeoutMs(options, env = process.env) {
+  const defaultMs = DEFAULT_OPENCODE_START_TIMEOUT_SECONDS * 1e3;
+  let raw;
+  let source;
+  if (options.opencodeStartTimeout !== void 0) {
+    raw = options.opencodeStartTimeout;
+    source = "--opencode-start-timeout";
+  } else if (env[OPENCODE_START_TIMEOUT_ENV] !== void 0 && env[OPENCODE_START_TIMEOUT_ENV] !== "") {
+    raw = env[OPENCODE_START_TIMEOUT_ENV];
+    source = OPENCODE_START_TIMEOUT_ENV;
+  } else {
+    return { timeoutMs: defaultMs, warnings: [] };
+  }
+  const trimmed = raw.trim();
+  const seconds = Number(trimmed);
+  const isPositiveInteger = /^\d+$/.test(trimmed) && Number.isInteger(seconds) && seconds > 0;
+  if (!isPositiveInteger || seconds > MAX_OPENCODE_START_TIMEOUT_SECONDS) {
+    return {
+      timeoutMs: defaultMs,
+      warnings: [
+        `Ignoring invalid ${source} "${raw}": expected a positive integer number of seconds (at most ${MAX_OPENCODE_START_TIMEOUT_SECONDS}); using the default ${DEFAULT_OPENCODE_START_TIMEOUT_SECONDS}s`
+      ]
+    };
+  }
+  return { timeoutMs: seconds * 1e3, warnings: [] };
+}
 function meetsThreshold(state, level) {
   return LOG_LEVELS[level] >= LOG_LEVELS[state.logLevel];
 }
@@ -5542,6 +5716,10 @@ function log2(state, message, level = "info") {
 function logActivity(state, entry) {
   const level = entry.level ?? (entry.type === "error" ? "error" : "info");
   if (!meetsThreshold(state, level)) return;
+  forwardRunnerActivity(
+    { level, message: entry.message, error: entry.error },
+    { agentId: state.agentId, authHeader: state.authHeader }
+  );
   const fullEntry = {
     ...entry,
     level,
@@ -5896,6 +6074,7 @@ async function run(options) {
     sessionCleanupTimers: [],
     authHeader: ""
   };
+  setTelemetryAuthProvider(() => ({ authHeader: state.authHeader, agentId: state.agentId }));
   if (fileSyncDirectories.length > 0) {
     log2(state, `File sync enabled for: ${fileSyncDirectories.join(", ")}`);
   } else {
@@ -6084,40 +6263,52 @@ async function run(options) {
     } else {
       log2(state, "Not running in a MicroVM (MICROVM_ID unset) \u2014 nothing to report", "debug");
     }
+    const { timeoutMs: opencodeStartTimeoutMs, warnings: opencodeStartTimeoutWarnings } = resolveOpenCodeStartTimeoutMs(options, process.env);
+    for (const warning2 of opencodeStartTimeoutWarnings) {
+      logActivity(state, { type: "info", level: "warn", message: warning2 });
+    }
     const ocSpinner = interactive && !state.json ? ora3("Checking OpenCode...").start() : null;
     try {
       const oc = await ensureOpenCodeRunning({
         port: state.port,
         interactive: state.interactive,
         agentId: state.agentId,
-        log: (message) => log2(state, message)
+        log: (message) => log2(state, message),
+        startTimeoutMs: opencodeStartTimeoutMs
       });
       state.port = oc.port;
       state.opencodeProcess = oc.process;
       state.opencodeVersion = oc.version;
-      state.opencodeConnected = oc.process !== null || oc.version !== null;
+      state.opencodeConnected = oc.notReadyReason === null;
       const version2 = state.opencodeVersion ? ` (v${state.opencodeVersion})` : "";
       ocSpinner?.succeed(`OpenCode running on port ${state.port}${version2}`);
-      const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
-      if (versionWarning) {
-        log2(state, versionWarning, "warn");
-        if (state.interactive && !state.json) {
-          logActivity(state, { type: "info", level: "warn", message: versionWarning });
+      if (!state.interactive && oc.notReadyReason !== null) {
+        const message = `OpenCode is not ready on port ${state.port}: ${oc.notReadyReason}. The runner will still come online, but messages will fail until opencode answers \u2014 raise the wait with --opencode-start-timeout <seconds> (env ${OPENCODE_START_TIMEOUT_ENV}).`;
+        logActivity(state, { type: "info", level: "warn", message });
+      } else {
+        const versionWarning = buildOpenCodeVersionWarning(state.opencodeVersion);
+        if (versionWarning) {
+          log2(state, versionWarning, "warn");
+          if (state.interactive && !state.json) {
+            logActivity(state, { type: "info", level: "warn", message: versionWarning });
+          }
         }
-      }
-      const noProviderWarning = buildNoProviderWarning(await hasAnyConfiguredProvider(state.port));
-      if (noProviderWarning) {
-        log2(state, noProviderWarning, "warn");
-        if (state.interactive && !state.json) {
-          logActivity(state, { type: "info", level: "warn", message: noProviderWarning });
-          blank();
-          console.log(chalk6.yellow("\u26A0 No OpenCode model provider is configured."));
-          console.log(
-            chalk6.dim(
-              `Run ${chalk6.cyan("opencode auth login")} to set one up \u2014 messages will fail until then.`
-            )
-          );
-          blank();
+        const noProviderWarning = buildNoProviderWarning(
+          await hasAnyConfiguredProvider(state.port)
+        );
+        if (noProviderWarning) {
+          log2(state, noProviderWarning, "warn");
+          if (state.interactive && !state.json) {
+            logActivity(state, { type: "info", level: "warn", message: noProviderWarning });
+            blank();
+            console.log(chalk6.yellow("\u26A0 No OpenCode model provider is configured."));
+            console.log(
+              chalk6.dim(
+                `Run ${chalk6.cyan("opencode auth login")} to set one up \u2014 messages will fail until then.`
+              )
+            );
+            blank();
+          }
         }
       }
     } catch (error2) {
@@ -6324,7 +6515,10 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option(
   "--log-level <level>",
   "Log verbosity: debug | info | warn | error (default: info). Env: EVIDENT_LOG_LEVEL"
-).option("-v, --verbose", "Alias for --log-level debug (ignored if --log-level is set)").option("-c, --conversation <id>", "Process only this specific conversation").option("--idle-timeout <seconds>", "Exit after N seconds idle").option("--json", "Output in JSON format").option(
+).option("-v, --verbose", "Alias for --log-level debug (ignored if --log-level is set)").option("-c, --conversation <id>", "Process only this specific conversation").option("--idle-timeout <seconds>", "Exit after N seconds idle").option(
+  "--opencode-start-timeout <seconds>",
+  "Seconds to wait for OpenCode to become healthy when the runner starts it (default: 180). Env: EVIDENT_OPENCODE_START_TIMEOUT"
+).option("--json", "Output in JSON format").option(
   "--session-cleanup-max-age <duration>",
   "Delete OpenCode sessions idle longer than this (e.g. 7d, 24h). Enables cleanup. Env: EVIDENT_SESSION_CLEANUP_MAX_AGE"
 ).option(
@@ -6353,6 +6547,9 @@ program.command("run").description("Connect to Evident and process messages").op
       verbose: options.verbose,
       conversation: options.conversation,
       idleTimeout: options.idleTimeout ? parseInt(options.idleTimeout, 10) : void 0,
+      // Raw string — validation/precedence is single-sourced in run.ts's
+      // resolveOpenCodeStartTimeoutMs (flag > EVIDENT_OPENCODE_START_TIMEOUT > 180s default).
+      opencodeStartTimeout: options.opencodeStartTimeout,
       json: options.json,
       // Raw strings — the resolver in run.ts single-sources parsing (M1).
       sessionCleanupMaxAge: options.sessionCleanupMaxAge,