Add custom ruff/ty binary path support

Closes #408

Users in offline environments cannot use the extension's managed ruff/ty
language servers because `uv pip install` tries to download packages
from the internet. This adds a 3-tier binary resolution strategy so
these users can point to locally-installed binaries instead.

Binary resolution now follows this priority for both ruff and ty:

1. User-configured path via `marimo.ruff.path` / `marimo.ty.path`
2. Companion extension discovery — checks the `charliermarsh.ruff` or
   `astral-sh.ty` extension's configured path setting, then its bundled
   binary at `<extensionPath>/bundled/libs/bin/<binary>`
3. Existing `uv pip install` fallback (unchanged behavior)

Each candidate binary is validated by running `<binary> --version` and
checking the result meets the minimum version requirement (ruff >=
0.15.0, ty >= 0.0.15). If validation fails at any tier, resolution falls
through to the next.

Author: manzt

extension/README.md

@@ -64,6 +64,8 @@ icon in the editor title bar to open it as a notebook (see image above).
 | --------------------------------------- | --------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `marimo.lsp.path`                       | `array`   | `[]`    | Path to a custom `marimo-lsp` executable, e.g., `["/path/to/marimo-lsp"]`. Leave empty to use the bundled version via `uvx`.                                                                        |
 | `marimo.uv.path`                        | `string`  |         | Path to the `uv` binary, e.g., `/Users/me/.local/bin/uv`. Leave empty to use `uv` from the system PATH.                                                                                             |
+| `marimo.ruff.path`                      | `string`  |         | Path to a custom `ruff` binary, e.g., `/usr/local/bin/ruff`. Useful for offline environments. Leave empty to auto-discover or install via uv.                                                       |
+| `marimo.ty.path`                        | `string`  |         | Path to a custom `ty` binary, e.g., `/usr/local/bin/ty`. Useful for offline environments. Leave empty to auto-discover or install via uv.                                                           |
 | `marimo.disableUvIntegration`           | `boolean` | `false` | Disable uv integration features such as automatic package installation prompts.                                                                                                                     |
 | `marimo.disableManagedLanguageFeatures` | `boolean` | `false` | Disable marimo's managed Python language features (completions, diagnostics, formatting). When enabled, notebook cells use the standard `python` language ID and rely on external language servers. |
 | `marimo.telemetry`                      | `boolean` | `true`  | Anonymous usage data. This helps us prioritize features for the marimo VSCode extension.                                                                                                            |

extension/package.json

@@ -94,6 +94,18 @@
           "default": true,
           "description": "Anonymous usage data. This helps us prioritize features for the marimo VSCode extension."
         },
+        "marimo.ruff.path": {
+          "type": "string",
+          "default": "",
+          "markdownDescription": "Path to a custom `ruff` binary, e.g., `/usr/local/bin/ruff`. Useful for offline environments. Leave empty to auto-discover or install via uv.",
+          "scope": "resource"
+        },
+        "marimo.ty.path": {
+          "type": "string",
+          "default": "",
+          "markdownDescription": "Path to a custom `ty` binary, e.g., `/usr/local/bin/ty`. Useful for offline environments. Leave empty to auto-discover or install via uv.",
+          "scope": "resource"
+        },
         "marimo.disableManagedLanguageFeatures": {
           "type": "boolean",
           "default": false,

extension/src/services/Config.ts

@@ -18,6 +18,12 @@ export class Config extends Effect.Service<Config>()("Config", {
           path: Effect.succeed(Option.none<string>()),
           enabled: Effect.succeed(false),
         },
+        ruff: {
+          path: Effect.succeed(Option.none<string>()),
+        },
+        ty: {
+          path: Effect.succeed(Option.none<string>()),
+        },
         lsp: {
           executable: Effect.succeed(Option.none()),
         },
@@ -45,6 +51,28 @@ export class Config extends Effect.Service<Config>()("Config", {
           );
         },
       },
+      ruff: {
+        get path() {
+          return Effect.map(
+            code.value.workspace.getConfiguration("marimo.ruff"),
+            (config) =>
+              Option.fromNullable(config.get<string>("path")).pipe(
+                Option.filter((p) => p.length > 0),
+              ),
+          );
+        },
+      },
+      ty: {
+        get path() {
+          return Effect.map(
+            code.value.workspace.getConfiguration("marimo.ty"),
+            (config) =>
+              Option.fromNullable(config.get<string>("path")).pipe(
+                Option.filter((p) => p.length > 0),
+              ),
+          );
+        },
+      },
       lsp: {
         get executable() {
           return Effect.gen(function* () {

extension/src/services/Uv.ts

@@ -687,6 +687,6 @@ const handleUvNotInstalled = Effect.fn("handleUvNotInstalled")(function* (
   return yield* Effect.die(error);
 });
 
-function resolvePlatformBinaryName(name: "uv" | "ruff" | "ty") {
+export function resolvePlatformBinaryName(name: "uv" | "ruff" | "ty") {
   return NodeProcess.platform === "win32" ? `${name}.exe` : name;
 }

extension/src/services/completions/RuffLanguageServer.ts

@@ -1,3 +1,5 @@
+import * as NodePath from "node:path";
+
 import {
   type Cause,
   Data,
@@ -11,6 +13,7 @@ import {
 import type * as vscode from "vscode";
 import * as lsp from "vscode-languageclient/node";
 
+import { validateBinary } from "../../utils/binaryResolution.ts";
 import {
   createManagedLanguageClient,
   type ManagedLanguageClient,
@@ -19,7 +22,8 @@ import { showErrorAndPromptLogs } from "../../utils/showErrorAndPromptLogs.ts";
 import { Config } from "../Config.ts";
 import { OutputChannel } from "../OutputChannel.ts";
 import { Sentry } from "../Sentry.ts";
-import { Uv } from "../Uv.ts";
+import { ExtensionContext } from "../Storage.ts";
+import { resolvePlatformBinaryName, Uv } from "../Uv.ts";
 import { VariablesService } from "../variables/VariablesService.ts";
 import { VsCode } from "../VsCode.ts";
 import {
@@ -91,14 +95,16 @@ export class RuffLanguageServer extends Effect.Service<RuffLanguageServer>()(
             return;
           }
 
-          // Phase 1: Install the language server
+          // Phase 1: Resolve the ruff binary using 3-tier strategy
           yield* Effect.logInfo("Starting language server").pipe(
             Effect.annotateLogs({
               server: RUFF_SERVER.name,
               version: RUFF_SERVER.version,
             }),
           );
 
+          const binaryPath = yield* resolveRuffBinary();
+
           // Create isolated sync instance with its own cell count tracking.
           const notebookSync = yield* sync.forClient();
 
@@ -116,7 +122,7 @@ export class RuffLanguageServer extends Effect.Service<RuffLanguageServer>()(
           });
 
           const installExit = yield* Effect.exit(
-            createManagedLanguageClient(RUFF_SERVER, {
+            createManagedLanguageClient(RUFF_SERVER, binaryPath, {
               notebookSync,
               clientOptions: {
                 outputChannelName: "marimo (ruff)",
@@ -224,6 +230,85 @@ export class RuffLanguageServer extends Effect.Service<RuffLanguageServer>()(
   },
 ) {}
 
+/**
+ * Resolves the ruff binary path using a 3-tier strategy:
+ * 1. User-configured path (marimo.ruff.path)
+ * 2. Companion extension discovery (charliermarsh.ruff bundled binary or ruff.path setting)
+ * 3. Fallback to uv installation
+ */
+const resolveRuffBinary = Effect.fn(function* () {
+  const code = yield* VsCode;
+  const config = yield* Config;
+  const uv = yield* Uv;
+  const context = yield* ExtensionContext;
+
+  // Tier 1: User-configured path
+  const userPath = yield* config.ruff.path;
+  if (Option.isSome(userPath)) {
+    const validated = yield* validateBinary(
+      userPath.value,
+      RUFF_SERVER.version,
+    );
+    if (Option.isSome(validated)) {
+      yield* Effect.logInfo(
+        `Using user-configured ruff binary: ${validated.value}`,
+      );
+      return validated.value;
+    }
+    yield* Effect.logWarning(
+      `User-configured ruff path "${userPath.value}" is invalid, falling back to discovery`,
+    );
+  }
+
+  // Tier 2: Companion extension discovery
+  const ruffExtension = code.extensions.getExtension(RUFF_EXTENSION_ID);
+  if (Option.isSome(ruffExtension)) {
+    // First check the companion extension's ruff.path setting
+    const ruffExtConfig = yield* code.workspace.getConfiguration("ruff");
+    const extConfiguredPath = Option.fromNullable(
+      ruffExtConfig.get<string>("path"),
+    ).pipe(Option.filter((p) => p.length > 0));
+
+    if (Option.isSome(extConfiguredPath)) {
+      const validated = yield* validateBinary(
+        extConfiguredPath.value,
+        RUFF_SERVER.version,
+      );
+      if (Option.isSome(validated)) {
+        yield* Effect.logInfo(
+          `Using ruff binary from ruff.path setting: ${validated.value}`,
+        );
+        return validated.value;
+      }
+    }
+
+    // Then check bundled binary in the extension's install directory
+    const bundledPath = NodePath.join(
+      ruffExtension.value.extensionPath,
+      "bundled",
+      "libs",
+      "bin",
+      resolvePlatformBinaryName("ruff"),
+    );
+    const validated = yield* validateBinary(bundledPath, RUFF_SERVER.version);
+    if (Option.isSome(validated)) {
+      yield* Effect.logInfo(
+        `Using bundled ruff binary from ${RUFF_EXTENSION_ID}: ${validated.value}`,
+      );
+      return validated.value;
+    }
+  }
+
+  // Tier 3: Fallback to uv installation
+  yield* Effect.logInfo(
+    "No custom or companion ruff binary found, falling back to uv installation",
+  );
+  const targetPath = NodePath.resolve(context.globalStorageUri.fsPath, "libs");
+  return yield* uv.ensureLanguageServerBinaryInstalled(RUFF_SERVER, {
+    targetPath,
+  });
+});
+
 /**
  * Read ruff.* settings from a WorkspaceConfiguration and return them in the format
  * expected by the Ruff language server's initializationOptions.