@gleanwork/mcp-server-tester 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/cli/index.js

@@ -13,6 +13,7 @@ import { createRequire } from 'module';
 import os, { homedir, tmpdir, userInfo } from 'os';
 import { promisify } from 'util';
 import crypto, { randomUUID, createHash } from 'crypto';
+import { setTimeout as setTimeout$1 } from 'timers/promises';
 import { Command } from 'commander';
 import { render, useApp, useInput, Box, Text } from 'ink';
 import React, { useState, useEffect, useCallback, useRef } from 'react';
@@ -942,11 +943,11 @@ function isNodeDefaultFetch(fetch2) {
   return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
 }
 async function createSafeNodeFetch() {
-  const [{ createRequire: createRequire3 }, { lookup }] = await Promise.all([
+  const [{ createRequire: createRequire4 }, { lookup }] = await Promise.all([
     loadNodeModule("node:module"),
     loadNodeModule("node:dns")
   ]);
-  const { Agent, fetch: fetch2 } = createRequire3(getCurrentModulePath())(
+  const { Agent, fetch: fetch2 } = createRequire4(getCurrentModulePath())(
     "undici"
   );
   const dispatcher = new Agent({
@@ -2454,7 +2455,7 @@ function createProviderToolFactory({
   inputSchema
 }) {
   return ({
-    execute,
+    execute: execute2,
     outputSchema,
     needsApproval,
     toModelOutput,
@@ -2468,7 +2469,7 @@ function createProviderToolFactory({
     args,
     inputSchema,
     outputSchema,
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2483,7 +2484,7 @@ function createProviderToolFactoryWithOutputSchema({
   supportsDeferredResults
 }) {
   return ({
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2496,7 +2497,7 @@ function createProviderToolFactoryWithOutputSchema({
     args,
     inputSchema,
     outputSchema,
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2654,11 +2655,11 @@ function isAsyncIterable(obj) {
   return obj != null && typeof obj[Symbol.asyncIterator] === "function";
 }
 async function* executeTool({
-  execute,
+  execute: execute2,
   input,
   options
 }) {
-  const result = execute(input, options);
+  const result = execute2(input, options);
   if (isAsyncIterable(result)) {
     let lastOutput;
     for await (const output of result) {
@@ -3563,6 +3564,30 @@ var init_pythonRuntime = __esm({
     exec = promisify(execFile);
   }
 });
+
+// src/evals/cowork/driver.ts
+var COMPUTER_USE_TOKEN_FIELDS, CoworkDriverError, CoworkHitlBudgetError;
+var init_driver = __esm({
+  "src/evals/cowork/driver.ts"() {
+    init_esm_shims();
+    COMPUTER_USE_TOKEN_FIELDS = [
+      "input_tokens",
+      "output_tokens",
+      "cache_creation_input_tokens",
+      "cache_read_input_tokens"
+    ];
+    CoworkDriverError = class extends Error {
+      constructor(message, telemetry2) {
+        super(message);
+        this.telemetry = telemetry2;
+      }
+      kind = "failed";
+    };
+    CoworkHitlBudgetError = class extends CoworkDriverError {
+      kind = "hitl-budget-exhausted";
+    };
+  }
+});
 function resolveDriverPath(env) {
   const configuredRoot = env.MST_COWORK_DRIVER_ROOT;
   if (configuredRoot) {
@@ -3583,22 +3608,22 @@ async function runAnthropicComputerUseHitl(options) {
     "HITL check"
   );
 }
-async function runComputerUseDriver(query2, options, mode, label) {
+async function runComputerUseDriver(query2, options, mode, label2) {
   const env = {
     ...process.env,
     ...options.env,
     ...options.model ? { MST_COWORK_CUA_MODEL: options.model } : {}
   };
   if (options.deadlineAt <= Date.now())
-    throw new Error(`Computer Use ${label} deadline exceeded; not retrying.`);
+    throw new Error(`Computer Use ${label2} deadline exceeded; not retrying.`);
   const python = await ensureCoworkPython(env);
   const DRIVER_PATH = resolveDriverPath(env);
   const timeoutMs = options.deadlineAt - Date.now();
   if (timeoutMs <= 0)
-    throw new Error(`Computer Use ${label} deadline exceeded; not retrying.`);
+    throw new Error(`Computer Use ${label2} deadline exceeded; not retrying.`);
   const maxActions = options.maxActions ?? (mode === "hitl" ? 12 : 24);
   diagnostic(
-    `starting Computer Use ${label} (script=${DRIVER_PATH}, maxActions=${maxActions}, timeoutMs=${timeoutMs})`
+    `starting Computer Use ${label2} (script=${DRIVER_PATH}, maxActions=${maxActions}, timeoutMs=${timeoutMs})`
   );
   let stdout = "";
   try {
@@ -3616,7 +3641,7 @@ async function runComputerUseDriver(query2, options, mode, label) {
     const childError = error;
     stdout = String(childError.stdout ?? "");
     const reported = parseLastJsonLine(stdout);
-    const telemetry2 = parseTelemetry(reported?.telemetry, env, "partial");
+    const telemetry3 = parseTelemetry(reported?.telemetry, env, "partial");
     const details = error.killed === true ? "driver terminated before completion; not retrying" : "driver exited unsuccessfully; not retrying";
     if (mode === "hitl" && reported?.status === "failed" && typeof reported.error === "string" && /^Computer Use HITL check exceeded \d+ actions after attempting a visible prompt$/.test(
       reported.error
@@ -3626,47 +3651,47 @@ async function runComputerUseDriver(query2, options, mode, label) {
       );
       throw new ComputerUseHitlBudgetError(
         `HITL inspection reached its ${maxActions}-action budget.`,
-        telemetry2
+        telemetry3
       );
     }
-    diagnostic(`Computer Use ${label} failed: ${details}`);
+    diagnostic(`Computer Use ${label2} failed: ${details}`);
     throw new ComputerUseDriverError(
-      `Computer Use ${label} failed: ${details}`,
-      telemetry2
+      `Computer Use ${label2} failed: ${details}`,
+      telemetry3
     );
   }
   diagnostic(
-    `Computer Use ${label} exited successfully (stdoutBytes=${stdout.length})`
+    `Computer Use ${label2} exited successfully (stdoutBytes=${stdout.length})`
   );
   const record = parseLastJsonLine(stdout);
   const expectedStatus = mode === "submit" ? "submitted" : "hitl_checked";
   if (record?.status !== expectedStatus) {
     throw new ComputerUseDriverError(
-      `Computer Use ${label} did not reach ${expectedStatus}.`,
+      `Computer Use ${label2} did not reach ${expectedStatus}.`,
       parseTelemetry(record?.telemetry, env, "partial")
     );
   }
   if (!isCount(record.action_count) || !isSafeModel(record.model, env)) {
     throw new ComputerUseDriverError(
-      `Computer Use ${label} returned invalid result fields.`,
+      `Computer Use ${label2} returned invalid result fields.`,
       parseTelemetry(record.telemetry, env, "partial")
     );
   }
-  const telemetry = parseTelemetry(record.telemetry, env, "complete");
+  const telemetry2 = parseTelemetry(record.telemetry, env, "complete");
   const common = {
     action_count: record.action_count,
     model: record.model,
-    ...telemetry ? { telemetry } : {}
+    ...telemetry2 ? { telemetry: telemetry2 } : {}
   };
   diagnostic(
-    `Computer Use ${label} completed (actions=${common.action_count})`
+    `Computer Use ${label2} completed (actions=${common.action_count})`
   );
   if (mode === "hitl") return { status: "hitl_checked", ...common };
   const submission = asRecord(record.submission_action);
   if (submission?.action !== "key" || submission.text !== "enter") {
     throw new ComputerUseDriverError(
       "Computer Use submission returned an invalid submission boundary.",
-      telemetry ? { ...telemetry, accounting: "partial" } : void 0
+      telemetry2 ? { ...telemetry2, accounting: "partial" } : void 0
     );
   }
   return {
@@ -3726,7 +3751,7 @@ function parseTelemetry(value, env, accounting) {
   if (!usage || !coverage) return void 0;
   const safeUsage = {};
   const safeCoverage = {};
-  for (const field of TOKEN_FIELDS) {
+  for (const field of COMPUTER_USE_TOKEN_FIELDS) {
     const count = coverage[field];
     if (!isCount(count) || count > record.planner_response_count)
       return void 0;
@@ -3756,26 +3781,22 @@ function parseTelemetry(value, env, accounting) {
     cost: { status: "unavailable" }
   };
 }
-var execFileAsync, TOKEN_FIELDS, ComputerUseDriverError, ComputerUseHitlBudgetError;
+var execFileAsync, ComputerUseDriverError, ComputerUseHitlBudgetError;
 var init_anthropicComputerUse = __esm({
   "src/evals/cowork/anthropicComputerUse.ts"() {
     init_esm_shims();
     init_pythonRuntime();
+    init_driver();
     execFileAsync = promisify(execFile);
-    TOKEN_FIELDS = [
-      "input_tokens",
-      "output_tokens",
-      "cache_creation_input_tokens",
-      "cache_read_input_tokens"
-    ];
-    ComputerUseDriverError = class extends Error {
-      constructor(message, telemetry) {
-        super(message);
-        this.telemetry = telemetry;
+    ComputerUseDriverError = class extends CoworkDriverError {
+      constructor(message, telemetry2) {
+        super(message, telemetry2);
+        this.telemetry = telemetry2;
       }
     };
     ComputerUseHitlBudgetError = class extends ComputerUseDriverError {
       name = "ComputerUseHitlBudgetError";
+      kind = "hitl-budget-exhausted";
     };
   }
 });
@@ -5011,7 +5032,7 @@ async function prepareMacCoworkSession(options) {
     const { running: wasRunning } = await controller.state();
     await mkdir(lease, { mode: 448 });
     const receiptPath = join(lease, "session.json");
-    const receipt = Buffer.from(
+    const receipt2 = Buffer.from(
       JSON.stringify({
         version: 1,
         nonce: randomUUID(),
@@ -5024,7 +5045,7 @@ async function prepareMacCoworkSession(options) {
     let leaseInfo;
     try {
       leaseInfo = await lstat(lease);
-      await writeFile(receiptPath, receipt, { mode: 384, flag: "wx" });
+      await writeFile(receiptPath, receipt2, { mode: 384, flag: "wx" });
     } catch {
       try {
         await rmdir(lease);
@@ -5036,7 +5057,7 @@ async function prepareMacCoworkSession(options) {
     let installAttempted = false;
     const ownsLease = async () => {
       const current = await lstat(lease);
-      if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || current.uid !== process.getuid?.() || (current.mode & 63) !== 0 || !(await privateBytes(receiptPath)).equals(receipt))
+      if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || current.uid !== process.getuid?.() || (current.mode & 63) !== 0 || !(await privateBytes(receiptPath)).equals(receipt2))
         throw new Error(ERROR3);
       const names = await readdir(lease);
       if (names.length !== 1 || names[0] !== "session.json")
@@ -5088,7 +5109,7 @@ async function prepareMacCoworkSession(options) {
         } catch {
           const after = await lstat(lease);
           if (after.isDirectory() && after.dev === leaseInfo.dev && after.ino === leaseInfo.ino)
-            await writeFile(receiptPath, receipt, { mode: 384, flag: "wx" });
+            await writeFile(receiptPath, receipt2, { mode: 384, flag: "wx" });
           throw new Error(ERROR3);
         }
       } catch {
@@ -5193,16 +5214,16 @@ async function recoverMacCoworkSession() {
   if (!leaseInfo.isDirectory() || leaseInfo.isSymbolicLink() || leaseInfo.uid !== process.getuid?.() || leaseInfo.mode & 63)
     throw new Error("Recovery lease is not a private owned directory.");
   const bytes = await privateFile(receiptPath);
-  const receipt = Receipt.parse(JSON.parse(bytes.toString("utf8")));
-  if (receipt.profileDirectory !== profile)
+  const receipt2 = Receipt.parse(JSON.parse(bytes.toString("utf8")));
+  if (receipt2.profileDirectory !== profile)
     throw new Error("Recovery profile mismatch.");
-  assertStoppedOwner(receipt.pid);
+  assertStoppedOwner(receipt2.pid);
   await mkdir(gate, { mode: 448 });
   const verifyLease = async () => {
     const current = await lstat(lease);
     if (current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || !(await privateFile(receiptPath)).equals(bytes) || (await readdir(lease)).join() !== "session.json")
       throw new Error("Recovery lease changed; refusing cleanup.");
-    assertStoppedOwner(receipt.pid);
+    assertStoppedOwner(receipt2.pid);
   };
   try {
     await verifyLease();
@@ -5211,9 +5232,9 @@ async function recoverMacCoworkSession() {
       const journal = JSON.parse(
         (await privateFile(join(transaction, "journal.json"))).toString("utf8")
       );
-      if (journal.directory !== receipt.stagingDirectory)
+      if (journal.directory !== receipt2.stagingDirectory)
         throw new Error("Recovery staging mismatch.");
-    } else if (await exists3(receipt.stagingDirectory))
+    } else if (await exists3(receipt2.stagingDirectory))
       throw new Error(
         "Staging exists without its transaction; recovery refused."
       );
@@ -5223,10 +5244,10 @@ async function recoverMacCoworkSession() {
       throw new Error("Claude did not stop; recovery refused.");
     await verifyLease();
     if (hasTransaction) await restoreMacCoworkSettings(profile);
-    if (await exists3(transaction) || await exists3(receipt.stagingDirectory))
+    if (await exists3(transaction) || await exists3(receipt2.stagingDirectory))
       throw new Error("Recovery state remains; lease retained.");
-    if (receipt.wasRunning) await controller.start();
-    if ((await controller.state()).running !== receipt.wasRunning)
+    if (receipt2.wasRunning) await controller.start();
+    if ((await controller.state()).running !== receipt2.wasRunning)
       throw new Error(
         "Could not restore prior Claude running state; lease retained."
       );
@@ -5294,6 +5315,240 @@ var init_macos = __esm({
   }
 });
 
+// src/evals/cowork/linux.ts
+var linux_exports = {};
+__export(linux_exports, {
+  linuxCoworkPlatform: () => linuxCoworkPlatform
+});
+async function readSettings(file) {
+  const handle = await open$1(
+    file,
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const metadata2 = await handle.stat();
+    if (!metadata2.isFile() || metadata2.size > 1024 * 1024)
+      throw new Error("Invalid prepared settings file.");
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+function telemetry(started, actions, accounting) {
+  return {
+    driver: "linux-desktop",
+    accounting,
+    duration_ms: Math.max(0, Date.now() - started),
+    action_count: actions,
+    planner: { status: "not-applicable" },
+    cost: { status: "not-applicable" }
+  };
+}
+function receipt(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const r = parsed;
+    if (!["ready", "submitted", "hitl_checked", "failed"].includes(
+      String(r.status)
+    ) || typeof r.action_count !== "number" || !Number.isSafeInteger(r.action_count) || r.action_count < 0 || typeof r.duration_ms !== "number" || !Number.isFinite(r.duration_ms) || r.duration_ms < 0)
+      return void 0;
+    return {
+      status: r.status,
+      action_count: r.action_count,
+      duration_ms: r.duration_ms,
+      errorCode: typeof r.error === "string" && /^[a-z_]{1,64}$/.test(r.error) ? r.error : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function execute(mode, payload, options) {
+  const started = Date.now();
+  const remaining = options.deadlineAt - started;
+  if (remaining <= 0)
+    throw new CoworkDriverError(
+      "Linux desktop deadline exceeded; no action attempted."
+    );
+  const env = { ...process.env, ...options.env };
+  if (!env.DISPLAY || !env.DBUS_SESSION_BUS_ADDRESS)
+    throw new CoworkDriverError(
+      "Linux Cowork requires a prepared DISPLAY and D-Bus desktop session."
+    );
+  if (env.MST_COWORK_URL_OPENER !== void 0 && !isAbsolute(env.MST_COWORK_URL_OPENER))
+    throw new CoworkDriverError(
+      "MST_COWORK_URL_OPENER must be an absolute executable path."
+    );
+  const script = createRequire(
+    typeof __filename$1 === "string" ? __filename$1 : import.meta.url
+  ).resolve("@gleanwork/mcp-server-tester/cowork-linux-runtime");
+  const timeout = Math.min(remaining, mode === "submit" ? 6e4 : 1e4);
+  const driverTimeout = Math.max(
+    1,
+    Math.floor(timeout - Math.min(1e3, timeout / 10))
+  );
+  const result = await new Promise(
+    (resolve10) => {
+      const child = execFile(
+        env.MST_COWORK_PYTHON ?? "python3",
+        [
+          script,
+          "--mode",
+          mode,
+          "--timeout-ms",
+          String(driverTimeout),
+          "--max-actions",
+          String(options.maxActions ?? 24)
+        ],
+        {
+          timeout,
+          killSignal: "SIGKILL",
+          maxBuffer: 64 * 1024,
+          env: {
+            ...Object.fromEntries(
+              SESSION_ENV.flatMap((k) => env[k] ? [[k, env[k]]] : [])
+            ),
+            NO_AT_BRIDGE: "0"
+          }
+        },
+        (error, stdout) => resolve10({ failed: error !== null, stdout: String(stdout) })
+      );
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(JSON.stringify(payload));
+    }
+  );
+  const record = receipt(result.stdout);
+  const expected = mode === "probe" ? "ready" : mode === "submit" ? "submitted" : "hitl_checked";
+  if (result.failed || record?.status !== expected || record.action_count > (options.maxActions ?? 24))
+    throw new CoworkDriverError(
+      `Linux desktop ${mode} failed or its receipt was uncertain (${record?.errorCode ?? "missing_or_invalid_receipt"}); no retry attempted.`,
+      record ? telemetry(started, record.action_count, "partial") : void 0
+    );
+  return record;
+}
+var SESSION_ENV, linuxCoworkPlatform;
+var init_linux = __esm({
+  "src/evals/cowork/linux.ts"() {
+    init_esm_shims();
+    init_driver();
+    SESSION_ENV = [
+      "PATH",
+      "HOME",
+      "DISPLAY",
+      "XAUTHORITY",
+      "DBUS_SESSION_BUS_ADDRESS",
+      "AT_SPI_BUS_ADDRESS",
+      "XDG_RUNTIME_DIR",
+      "XDG_CONFIG_HOME",
+      "MST_COWORK_URL_OPENER",
+      "LANG",
+      "LC_ALL"
+    ];
+    linuxCoworkPlatform = {
+      dataDirectory: (options) => options.dataDir ?? join(
+        process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+        "Claude-3p",
+        "local-agent-mode-sessions"
+      ),
+      async prepare({ manifest, env, model }) {
+        const settingsFile = env.MST_COWORK_SETTINGS_FILE ?? "/etc/claude-desktop/managed-settings.json";
+        if (!isAbsolute(settingsFile))
+          throw new Error("Linux Cowork settings path must be absolute.");
+        try {
+          const settings = await readSettings(settingsFile);
+          const models = settings.inferenceModels;
+          if (model && !models?.some((m) => m.name === model))
+            throw new Error("model");
+          const expected = manifest.servers ?? [];
+          const actual = settings.managedMcpServers;
+          if (!Array.isArray(actual) || actual.length !== expected.length || settings.allowManagedMcpServersOnly !== true)
+            throw new Error("servers");
+          for (const [index, server] of expected.entries()) {
+            if (server.transport !== "http") throw new Error("transport");
+            const observed = actual.find(
+              (s) => s.name === (server.label ?? `server-${index + 1}`)
+            );
+            if (!observed || observed.transport !== "http" || observed.url !== server.serverUrl)
+              throw new Error("server");
+            if (observed.toolPolicy?.["*"] === "allow" && manifest.coworkSetup?.approveWriteTools !== true)
+              throw new Error("policy");
+          }
+        } catch {
+          throw new Error(
+            "Prepared Linux desktop settings do not match the eval model, MCP servers, or approval policy."
+          );
+        }
+        await execute(
+          "probe",
+          {},
+          { deadlineAt: Date.now() + 15e3, maxActions: 1, env }
+        );
+        return {
+          async dispose() {
+          }
+        };
+      },
+      async recover() {
+        throw new Error(
+          "Linux desktop recovery belongs to the runtime owner, not the MST driver."
+        );
+      },
+      async submit(query2, options) {
+        const started = Date.now();
+        const result = await execute("submit", { prompt: query2 }, options);
+        return {
+          status: "submitted",
+          action_count: result.action_count,
+          telemetry: telemetry(started, result.action_count, "complete")
+        };
+      },
+      async handleHitl(options) {
+        if (!options.isComplete)
+          throw new Error("Linux HITL requires a bound native completion check.");
+        const started = Date.now();
+        let actions = 0;
+        const budget = options.maxActions ?? 12;
+        try {
+          while (Date.now() < options.deadlineAt) {
+            if (await options.isComplete())
+              return {
+                status: "hitl_checked",
+                action_count: actions,
+                telemetry: telemetry(started, actions, "complete")
+              };
+            if (actions >= budget)
+              throw new CoworkHitlBudgetError(
+                "Linux HITL action budget exhausted.",
+                telemetry(started, actions, "partial")
+              );
+            const result = await execute(
+              "hitl",
+              { approveWriteTools: options.approveWriteTools === true },
+              { ...options, maxActions: budget - actions }
+            );
+            actions += result.action_count;
+            await setTimeout$1(
+              Math.min(500, Math.max(0, options.deadlineAt - Date.now()))
+            );
+          }
+        } catch (error) {
+          if (error instanceof CoworkHitlBudgetError) throw error;
+          const partialActions = error instanceof CoworkDriverError ? error.telemetry?.action_count ?? 0 : 0;
+          throw new CoworkDriverError(
+            "Linux HITL failed for the bound native session.",
+            telemetry(started, actions + partialActions, "partial")
+          );
+        }
+        throw new CoworkDriverError(
+          "Linux HITL deadline exceeded.",
+          telemetry(started, actions, "partial")
+        );
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
 
@@ -5308,12 +5563,12 @@ init_esm_shims();
 
 // src/cli/components/Spinner.tsx
 init_esm_shims();
-function Spinner({ label }) {
+function Spinner({ label: label2 }) {
   return /* @__PURE__ */ jsxs(Box, { children: [
     /* @__PURE__ */ jsx(Text, { color: "cyan", children: /* @__PURE__ */ jsx(InkSpinner, { type: "dots" }) }),
     /* @__PURE__ */ jsxs(Text, { children: [
       " ",
-      label
+      label2
     ] })
   ] });
 }
@@ -5375,7 +5630,7 @@ init_esm_shims();
 
 // package.json
 var package_default = {
-  version: "2.0.0-beta.2"};
+  version: "2.0.0-beta.4"};
 
 // src/cli/templates/index.ts
 function getPlaywrightConfigTemplate(answers) {
@@ -6107,8 +6362,56 @@ async function performClientCredentialsFlow(config) {
   };
 }
 
+// src/mcp/connectionDiagnostics.ts
+init_esm_shims();
+function classifyMCPConnectionFailure(error) {
+  if (typeof error !== "object" || error === null) return "connection_failed";
+  const details = error;
+  const status = details.response?.status ?? details.status ?? details.code;
+  if (typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599) {
+    return `http_${status}`;
+  }
+  const message = error instanceof Error ? error.message : "";
+  const httpStatus = /\b(?:HTTP|status(?: code)?|code:)\s*[:=(]?\s*([45]\d{2})\b/i.exec(
+    message
+  )?.[1];
+  if (httpStatus) return `http_${httpStatus}`;
+  for (const code of ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]) {
+    if (details.code === code || message.toUpperCase().includes(code)) {
+      return code.toLowerCase();
+    }
+  }
+  if (/timed out|timeout/i.test(message)) return "timeout";
+  if (/network|socket hang up|fetch failed/i.test(message))
+    return "network_error";
+  return "connection_failed";
+}
+var MCPHttpConnectionError = class extends Error {
+  constructor(streamableError, sseError, retryable, retryAfterMs) {
+    const streamableHttpFailure = classifyMCPConnectionFailure(streamableError);
+    const sseFailure = classifyMCPConnectionFailure(sseError);
+    super(
+      `MCP connection failed: streamableHttp=${streamableHttpFailure}; sse=${sseFailure}`
+    );
+    this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "MCPHttpConnectionError";
+    this.streamableHttpFailure = streamableHttpFailure;
+    this.sseFailure = sseFailure;
+  }
+  streamableHttpFailure;
+  sseFailure;
+};
+function formatMCPConnectionFailure(error) {
+  if (error instanceof MCPHttpConnectionError) {
+    return `MCP connection failed: streamableHttp=${error.streamableHttpFailure}; sse=${error.sseFailure}`;
+  }
+  return classifyMCPConnectionFailure(error);
+}
+
 // src/mcp/clientFactory.ts
 function getRetryAfterDelayMs(err) {
+  if (err instanceof MCPHttpConnectionError) return err.retryAfterMs;
   const response = err?.response;
   const retryAfter = response?.headers?.get?.("Retry-After");
   if (retryAfter) {
@@ -6127,6 +6430,7 @@ function isTransientNetworkError(err) {
   return msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("fetch failed");
 }
 function isRetryableError(err) {
+  if (err instanceof MCPHttpConnectionError) return err.retryable;
   return isTransientNetworkError(err) || isRateLimitError(err);
 }
 async function retryWithBackoff(fn, maxAttempts) {
@@ -6144,7 +6448,7 @@ async function retryWithBackoff(fn, maxAttempts) {
           attempt + 1,
           maxAttempts + 1,
           delayMs,
-          err.message
+          formatMCPConnectionFailure(err)
         );
         await new Promise((resolve10) => setTimeout(resolve10, delayMs));
       } else {
@@ -6301,15 +6605,24 @@ async function createMCPClientForConfig(config, options) {
       } catch (err) {
         debugHttp(
           "streamableHttp failed (%s), falling back to SSE",
-          err.message
+          formatMCPConnectionFailure(err)
         );
         debugClient("Streamable HTTP failed, falling back to SSE transport");
         debugHttp("Attempting transport: sse");
-        const sseTransport = new SSEClientTransport(url, {
-          requestInit,
-          ...options?.authProvider ? { authProvider: options.authProvider } : {}
-        });
-        await client.connect(sseTransport, connectOptions);
+        try {
+          const sseTransport = new SSEClientTransport(url, {
+            requestInit,
+            ...options?.authProvider ? { authProvider: options.authProvider } : {}
+          });
+          await client.connect(sseTransport, connectOptions);
+        } catch (sseError) {
+          throw new MCPHttpConnectionError(
+            err,
+            sseError,
+            isRetryableError(err) || isRetryableError(sseError),
+            getRetryAfterDelayMs(err) ?? getRetryAfterDelayMs(sseError)
+          );
+        }
         debugClient("Connected via SSE");
         debugHttp("Connection established via sse");
       }
@@ -7116,8 +7429,8 @@ ${errorText}`
       return;
     }
     try {
-      const open5 = await import('open');
-      await open5.default(url.toString());
+      const open6 = await import('open');
+      await open6.default(url.toString());
       debug2("Opened browser for authentication");
     } catch (error) {
       debug2("Failed to open browser:", error);
@@ -10565,14 +10878,97 @@ init_esm_shims();
 
 // src/evals/cowork/platform.ts
 init_esm_shims();
-async function getCoworkPlatform() {
-  if (process.platform === "darwin")
+async function getCoworkPlatform(provider) {
+  if (process.platform === "darwin" && provider === "anthropic-computer-use")
     return (await Promise.resolve().then(() => (init_macos(), macos_exports))).macCoworkPlatform;
+  if (process.platform === "linux" && provider === "linux-desktop")
+    return (await Promise.resolve().then(() => (init_linux(), linux_exports))).linuxCoworkPlatform;
   throw new Error(
-    `Cowork has no qualified ${process.platform} desktop adapter. The shared runner is portable; native execution is currently macOS-only.`
+    `Cowork driver ${provider} is not supported on ${process.platform}.`
   );
 }
 
+// src/evals/cowork/mcpReadiness.ts
+init_esm_shims();
+init_config();
+var PREFLIGHT_TIMEOUT_MS = 3e4;
+var CoworkMcpReadinessError = class extends Error {
+  servers;
+  constructor(servers) {
+    super(
+      `Cowork MCP preflight failed; no task was submitted. ${servers.map(
+        (server) => `${server.label}=${server.status}${server.error ? `(${server.error})` : ""}(${server.elapsedMs}ms)`
+      ).join(", ")}`
+    );
+    this.name = "CoworkMcpReadinessError";
+    this.servers = servers;
+  }
+};
+function label(server, index) {
+  return server.label ?? `server-${index + 1}`;
+}
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error("MCP preflight timed out")),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function resolveServer(server, env) {
+  if (!isHttpConfig(server)) return server;
+  const [coworkServer] = toCoworkServers([server]);
+  if (!coworkServer) throw new Error("Invalid Cowork MCP configuration.");
+  const headers = resolveCoworkMcpHeaders([coworkServer], env);
+  return {
+    ...server,
+    // Use the same validated runtime headers as Cowork setup.
+    auth: void 0,
+    headers: headers[coworkServer.label]
+  };
+}
+async function verifyCoworkMcpServers(servers, env) {
+  const results = await Promise.all(
+    servers.map(async (server, index) => {
+      const started = Date.now();
+      let client;
+      try {
+        client = await createMCPClientForConfig(resolveServer(server, env));
+        const tools = await withTimeout(
+          client.listTools(),
+          PREFLIGHT_TIMEOUT_MS
+        );
+        return {
+          label: label(server, index),
+          status: "connected",
+          toolCount: tools.tools.length,
+          elapsedMs: Date.now() - started
+        };
+      } catch (error) {
+        return {
+          label: label(server, index),
+          status: "failed",
+          elapsedMs: Date.now() - started,
+          error: formatMCPConnectionFailure(error)
+        };
+      } finally {
+        if (client) await closeMCPClient(client).catch(() => void 0);
+      }
+    })
+  );
+  if (results.some((result) => result.status !== "connected"))
+    throw new CoworkMcpReadinessError(results);
+  return results;
+}
+
 // src/evals/externalHost/builtins/anthropicClaude.ts
 init_esm_shims();
 
@@ -11155,7 +11551,7 @@ async function waitForClaudeMatch(options, requireCompletion) {
       }
       lastPending = trace;
     }
-    await delay2(POLL_INTERVAL_MS);
+    await delay3(POLL_INTERVAL_MS);
   }
   if (lastPending) {
     throw new Error(
@@ -11318,7 +11714,7 @@ async function waitForAccessibilityTrace(options) {
     if (fallback) {
       return fallback;
     }
-    await delay2(POLL_INTERVAL_MS);
+    await delay3(POLL_INTERVAL_MS);
   }
   throw new Error(
     `Timed out waiting for Claude Chat Desktop visible response for marker ${options.context.marker}`
@@ -11407,6 +11803,7 @@ async function parseClaudeTrace(candidate, marker16) {
     auditParsed,
     transcriptParsed,
     usageAvailable: usage !== void 0,
+    knownUsageFields: knownUsageFields(resultEvents),
     costAvailable: resultEvents.some(
       (event) => typeof event.total_cost_usd === "number"
     ),
@@ -11918,6 +12315,35 @@ function extractAggregatedUsage(events) {
     cacheCreationInputTokens: (total.cacheCreationInputTokens ?? 0) + (value.cacheCreationInputTokens ?? 0)
   }));
 }
+function knownUsageFields(events) {
+  const fields = [
+    [
+      "inputTokens",
+      (event) => event.usage?.input_tokens ?? event.usage?.inputTokens
+    ],
+    [
+      "outputTokens",
+      (event) => event.usage?.output_tokens ?? event.usage?.outputTokens
+    ],
+    [
+      "cacheReadInputTokens",
+      (event) => event.usage?.cache_read_input_tokens ?? event.usage?.cacheReadInputTokens
+    ],
+    [
+      "cacheCreationInputTokens",
+      (event) => event.usage?.cache_creation_input_tokens ?? event.usage?.cacheCreationInputTokens
+    ],
+    ["totalCostUsd", (event) => event.total_cost_usd],
+    ["durationMs", (event) => event.duration_ms],
+    ["durationApiMs", (event) => event.duration_api_ms]
+  ];
+  return fields.filter(
+    ([key, value]) => events.length > 0 && events.every((event) => {
+      const number = value(event);
+      return typeof number === "number" && Number.isFinite(number) && number >= 0 && (key === "totalCostUsd" || Number.isSafeInteger(number));
+    })
+  ).map(([key]) => key);
+}
 function extractUsage(event) {
   const usage = event.usage;
   const inputTokens = getNumber(usage, "input_tokens") ?? getNumber(usage, "inputTokens");
@@ -12014,19 +12440,28 @@ function classifyTraceFailure(message) {
 function formatError2(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/evals/coworkHost.ts
-init_anthropicComputerUse();
+init_driver();
 var OptionsSchema = z.object({
-  computerUseProvider: z.literal("anthropic-computer-use").default("anthropic-computer-use"),
+  computerUseProvider: z.enum(["anthropic-computer-use", "linux-desktop"]).default(
+    () => process.platform === "linux" ? "linux-desktop" : "anthropic-computer-use"
+  ),
   computerUseMaxActions: z.number().int().min(1).max(64).default(24),
   hitlMaxActions: z.number().int().min(1).max(24).default(12),
   computerUseModel: z.string().regex(/^[A-Za-z0-9._:-]+$/).optional(),
   dataDir: z.string().min(1).optional()
-}).strict();
+}).strict().superRefine((options, context) => {
+  if (options.computerUseProvider === "linux-desktop" && options.computerUseModel !== void 0)
+    context.addIssue({
+      code: "custom",
+      path: ["computerUseModel"],
+      message: "linux-desktop does not use a planner model."
+    });
+});
 var CoworkSchema = z.object({
   type: z.string(),
   options: OptionsSchema.default(() => OptionsSchema.parse({})),
@@ -12052,9 +12487,9 @@ async function runBatch(requests, context, selectedPlatform) {
     );
   const config = configs[0];
   const env = { ...process.env, ...context.env, ...config.env };
-  if (!env.ANTHROPIC_API_KEY)
+  if (config.options.computerUseProvider === "anthropic-computer-use" && !env.ANTHROPIC_API_KEY)
     throw new Error("ANTHROPIC_API_KEY is required for Cowork Computer Use.");
-  const platform = await getCoworkPlatform();
+  const platform = await getCoworkPlatform(config.options.computerUseProvider);
   const dataDir = platform.dataDirectory(config.options);
   const servers = requests[0].input.servers;
   const { arms: _arms, ...manifest } = context.manifest;
@@ -12085,12 +12520,20 @@ async function runBatch(requests, context, selectedPlatform) {
   active = true;
   try {
     if (env.MST_COWORK_RECOVER === "1") await platform.recover();
-    if (servers.length || config.model)
+    if (config.options.computerUseProvider === "linux-desktop" || servers.length || config.model)
       session = await platform.prepare({
         manifest: managedManifest,
         env,
         model: config.model
       });
+    if (servers.length) {
+      const readiness = await verifyCoworkMcpServers(servers, env);
+      process.stderr.write(
+        `[mst:cowork] MCP preflight ready: ${readiness.map(
+          (server) => `${server.label}(${server.toolCount ?? 0} tools, ${server.elapsedMs}ms)`
+        ).join(", ")}\\n`
+      );
+    }
     for (const [index, request] of requests.entries()) {
       const caseStartedAt = Date.now();
       const computerUse = {
@@ -12145,7 +12588,7 @@ async function runBatch(requests, context, selectedPlatform) {
         if (computerUse.submission.status !== "completed") {
           computerUse.submission = {
             status: "failed",
-            ...error instanceof ComputerUseDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
+            ...error instanceof CoworkDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
           };
         }
         results[index] = failure(safeError(error));
@@ -12184,6 +12627,18 @@ async function runBatch(requests, context, selectedPlatform) {
             maxActions: config.options.hitlMaxActions,
             model: config.options.computerUseModel,
             env,
+            approveWriteTools: context.manifest.coworkSetup?.approveWriteTools === true,
+            isComplete: async () => {
+              const current = await findMatchingClaudeSessions({
+                ...match,
+                sessionPath
+              });
+              if (current.length !== 1)
+                throw new Error(
+                  "Bound native session is missing or ambiguous."
+                );
+              return current[0].isComplete;
+            },
             task: `Handle only the currently open Cowork task just submitted with this exact query: ${request.input.scenario}. Do not switch tasks. Never create, type, or resubmit a task. If the current task cannot be identified uniquely, stop without an action.`
           });
           computerUse.hitl = {
@@ -12193,11 +12648,11 @@ async function runBatch(requests, context, selectedPlatform) {
         }
       } catch (error) {
         computerUse.hitl = {
-          status: error instanceof ComputerUseHitlBudgetError ? "budget-exhausted" : "failed",
-          ...error instanceof ComputerUseDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
+          status: error instanceof CoworkDriverError && error.kind === "hitl-budget-exhausted" ? "budget-exhausted" : "failed",
+          ...error instanceof CoworkDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
         };
         const message = safeError(error);
-        if (error instanceof ComputerUseHitlBudgetError) {
+        if (error instanceof CoworkDriverError && error.kind === "hitl-budget-exhausted") {
           hitlWarning = message;
         } else {
           hitlError = message;
@@ -12350,7 +12805,7 @@ async function runBuiltinHost(input, host, context, factory) {
     }
     controller.signal.throwIfAborted();
   }
-  async function execute() {
+  async function execute2() {
     try {
       checkDeadline();
       if (config.hostType !== "cli") {
@@ -12428,9 +12883,9 @@ async function runBuiltinHost(input, host, context, factory) {
     if (config.hostType === "cli" && config.cli?.claudeMcpServers !== void 0) {
       void expired.catch(() => {
       });
-      return await execute();
+      return await execute2();
     }
-    const result = await Promise.race([execute(), expired]);
+    const result = await Promise.race([execute2(), expired]);
     checkDeadline();
     return result;
   } catch (error) {
@@ -12580,8 +13035,8 @@ function claudeCliHost(options) {
   if (options.servers) {
     for (const key of Object.keys(mcpServers)) delete mcpServers[key];
     for (const entry of options.servers) {
-      const label = entry.label ?? "mcp-server";
-      mcpServers[label] = entry.transport === "http" ? {
+      const label2 = entry.label ?? "mcp-server";
+      mcpServers[label2] = entry.transport === "http" ? {
         type: "http",
         url: entry.serverUrl,
         headers: {
@@ -16012,9 +16467,9 @@ function buildArmDeltas(arms) {
   );
 }
 function redactServerForReport(server) {
-  const label = server.label ? { label: server.label } : {};
+  const label2 = server.label ? { label: server.label } : {};
   if (server.transport === "stdio") {
-    return { transport: "stdio", command: server.command, ...label };
+    return { transport: "stdio", command: server.command, ...label2 };
   }
   const url = new URL(server.serverUrl);
   url.username = "";
@@ -16024,7 +16479,7 @@ function redactServerForReport(server) {
   return {
     transport: "http",
     serverUrl: url.toString(),
-    ...label,
+    ...label2,
     ...server.auth?.accessTokenEnv ? { auth: { accessTokenEnv: server.auth.accessTokenEnv } } : {}
   };
 }
@@ -16325,7 +16780,7 @@ async function runEvalSuite(options) {
   for (const arm of armResults) {
     totalHostUsage = sumUsage(totalHostUsage, arm.result?.totalHostUsage);
   }
-  const telemetry = {
+  const telemetry2 = {
     cases: allResults.length,
     toolCalls: countToolCalls(allResults),
     failedCases: allResults.filter((result) => !result.pass).length,
@@ -16345,7 +16800,7 @@ async function runEvalSuite(options) {
       passRate: allResults.length > 0 ? allResults.filter((result) => result.pass).length / allResults.length : 0,
       ...computedMetrics
     },
-    telemetry,
+    telemetry: telemetry2,
     armDeltas: buildArmDeltas(armResults),
     results: allResults
   };