open-in-editor-bridge 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 894d087228ad0690acd8e32f1f2284240055e9b934965fd181556adc7aba116b
-  data.tar.gz: f5fd6f10dc3110132077b781224d9c1e67eb46d9c6c83d85f0f083cca89b1391
+  metadata.gz: 7d25bb9c59762f68ee9b164865d324147c717b4b1d5c13bb3163dc57b2c65763
+  data.tar.gz: 85c973a0426c36ece6f5daec5b767380bc4621d0c39e28ccb01e572279c58db0
 SHA512:
-  metadata.gz: 00a3e25e014adfdff6d33fa389e4eb11d75ba364fb89536d83b83128154854322dc367938544d34ccad2ffab7a5487ad3f7a3d4f135c35ec5694ebb15f2c315b
-  data.tar.gz: 1b6a96b2710f51240f152028b49d0b9ac573dc844d7bb6c8177586faaf3c4a59cd18cf6c09aba920fafd688e22350be1403d6ddf102a606a6cb81af2bdb47260
+  metadata.gz: d35441d1493bfda18b675cacf05e94baa1c2872543d4464492bc8271b4032213b8aa8826e9b567334aa19cc6cdf7f7c1fbfed1bccda78e60a3bcfb66b09d9d1c
+  data.tar.gz: 7d8a2e2aaf8641d415ea9f8cd6a4d78f67735506bcb38a3095d9dca4b1123635661995e2358767d496be9ef13c3d2d81412ca777cb1d815f393c1854c633cd83

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.3.0 — 2026-10-09
+
+### Added
+
+- `OpenInEditorBridge.compose` for library-owned Docker/Vite integration: generated service overrides mount a bundled Vite plugin and checkout identity, without session environment/query plumbing in applications.
+- Development-only Vite plugin that routes editor requests to the mounted checkout, replacing duplicate caller selectors while preserving encoded file paths and line/column.
+- Minimal adoption instructions and an ELCC migration path for removing its bespoke session transport.
+
+### Security and Lifecycle
+
+- Docker startup still requires explicit network-exposure opt-in. Only non-secret identity/target data and plugin code are mounted read-only; lifecycle credentials stay on the host.
+- Missing/malformed Vite identity fails startup safely; only the editor endpoint is proxied.
+- Foreground cleanup and idempotent detached registration reuse the existing lease protocol. Failed startup releases only a new registration, and failed shutdown retains the active registration.
+- Unrelated Compose commands and production Vite builds do not require editor setup.
+
 ## 0.2.0 — 2026-10-09
 
 ### Added

data/README.md

@@ -5,95 +5,104 @@ A Ruby gem that runs a shared local HTTP bridge for opening container files in t
 ## Install
 
 ```ruby
-gem "open-in-editor-bridge", "~> 0.2"
+gem "open-in-editor-bridge", "~> 0.3"
 ```
 
 ```sh
 gem install open-in-editor-bridge
 ```
 
-## Foreground Ruby API
+## Docker and Vite Integration
 
-Wrap commands whose lifetime matches the application, such as foreground Compose:
+Use the host-side Compose adapter and the gem's mounted Vite plugin. The library owns checkout identity transport, the host-gateway entry, and the editor proxy; **do not export a session variable or write a request rewrite**.
+
+Replace the development Compose startup/shutdown call:
 
 ```ruby
 require "open_in_editor_bridge"
 
-OpenInEditorBridge.with_running do |session_id|
-  ENV["OPEN_IN_EDITOR_SESSION_ID"] = session_id
-  system("docker", "compose", "up", exception: true)
-end
+# Explicit network-exposure opt-in; use only on a trusted development network.
+ENV["OPEN_IN_EDITOR_BRIDGE_BIND_ADDRESS"] = "0.0.0.0"
+ENV["OPEN_IN_EDITOR_COMMAND"] = "code"
+
+OpenInEditorBridge.compose("up", service: "web")
+# Detached startup: OpenInEditorBridge.compose("up", "-d", service: "web")
+# Shutdown: OpenInEditorBridge.compose("down", service: "web")
 ```
 
-The block returns its normal result. Its checkout lease is released in `ensure`, including when the block raises; cleanup does not replace the original exception. Overlapping wrappers have independent leases, even in the same checkout. Finishing one wrapper never releases another wrapper or an existing detached registration.
+Add the plugin to your existing Vite configuration for Docker development:
 
-`OpenInEditorBridge.session_id` returns the stable ID for the configured checkout without starting the bridge. `OpenInEditorBridge.new(env: ..., project_root: ...)` supports explicit configuration for library consumers.
+```js
+import { defineConfig } from "vite";
 
-## Detached Compose
+export default defineConfig(async ({ command, mode }) => {
+  const plugins = [];
+  if (command === "serve" && mode === "development") {
+    const integrationPath = "/open-in-editor-bridge/vite.mjs";
+    const { default: openInEditorBridge } = await import(integrationPath);
+    plugins.push(openInEditorBridge());
+  }
 
-`up -d` returns before the application stops. Use persistent registration, **not** `with_running` around detached startup:
+  return { plugins, server: { host: "0.0.0.0" } };
+});
+```
 
-```ruby
-require "open_in_editor_bridge"
+Keep your application's existing plugins and other Vite settings. The variable-based dynamic import is intentional: production builds and test-mode configuration can load without Docker's development mounts. This path supports Docker-hosted Vite development; native-host Vite and custom development modes need their own explicit opt-in condition. The plugin requires a valid mounted manifest when enabled and fails startup if it is missing or malformed. Vite 6 is exercised by release QA.
 
-OpenInEditorBridge.call("--ensure-running")
-ENV["OPEN_IN_EDITOR_SESSION_ID"] = OpenInEditorBridge.session_id
-system("docker", "compose", "up", "-d", exception: true)
-```
+### Application Configuration That Remains
 
-Release that checkout's persistent registration when taking it down:
+- Select the Vite service (`service: "web"` by default); retain its image, command, source mounts, ports, and normal environment.
+- Select Compose files/project options when necessary, for example `compose_options: ["-f", "docker-compose.development.yaml", "-p", "my-checkout"]`. Pass subcommand options after `"up"` / `"down"`, not in `compose_options`.
+- Select checkout/container/host roots and the editor through the existing bridge configuration below. `project_root:` defaults to the current checkout; `env:` supplies bridge configuration and child-process environment overrides.
+- Explicitly select a Docker-reachable bind address. The adapter rejects loopback startup and never changes the default binding itself.
 
-```ruby
-OpenInEditorBridge.with_running(ensure_running: false) do
-  system("docker", "compose", "down", exception: true)
-end
-```
+When no explicit `-f` is supplied, the adapter respects `COMPOSE_FILE` / `COMPOSE_PATH_SEPARATOR`, or discovers a standard Compose file and its default override from the project directory upward. `--project-directory` is supported. Compose runs in `project_root:` and inherits normal process input/output. Failures raise; successful commands return `true`.
 
-`ensure_running: false` does not register a new lease and releases only the detached registration after the block. You can alternatively call `OpenInEditorBridge.call("--shutdown")` directly. Repeated `--ensure-running` calls are idempotent for a checkout; one `--shutdown` releases its detached registration. Foreground leases and registrations for other checkouts remain active. The listener exits when the last lease is released.
+Only `up` adds editor setup. Foreground `up` owns an independent lease and releases it even on failure. `up -d` / `up --detach` use the existing idempotent detached registration. Failed detached startup releases a newly acquired registration but preserves one that was already active. Successful `down` releases that checkout's detached registration; failed `down` keeps it. Other commands (`config`, `build`, `exec`, `run`, `logs`, and so on) execute ordinary Compose without editor setup or requiring an editor. `stop` does not release detached registration; use `down` or `--shutdown` when done. If a new container needs the editor mounts, create it through `up`.
 
-## CLI
+The generated override mounts just two read-only files at `/open-in-editor-bridge`: the packaged `vite.mjs` and a checkout-specific `session.json` containing identity and target URL. It never mounts broker state, the whole private runtime directory, or lifecycle control credentials. Temporary Compose overrides are removed after each invocation; non-secret manifests remain in the private host runtime directory for existing detached containers.
 
-Run lifecycle commands from the host checkout (or set `OPEN_IN_EDITOR_PROJECT_ROOT` explicitly):
+All checkouts share the standard host port `3333`, bind address, and private runtime directory. Each may use the same container directory `/usr/src/web`: the plugin selects its own host checkout from its mounted identity. It replaces all caller-supplied `session` selectors, including duplicates and encoded selector names, without rewriting other query bytes. Only `/__open-in-editor` is proxied; health and lifecycle endpoints are not. Existing exact editor proxy entries are replaced, and editor routing takes precedence over broader application proxy entries.
 
-```sh
-export OPEN_IN_EDITOR_COMMAND='code'
-# Explicit opt-in for Docker bridge-network access; read the security section.
-export OPEN_IN_EDITOR_BRIDGE_BIND_ADDRESS=0.0.0.0
-export OPEN_IN_EDITOR_SESSION_ID="$(open-in-editor-bridge --session-id)"
-open-in-editor-bridge --ensure-running
-docker compose up -d
+### Adopting in ELCC
 
-# Later, with the same port, bind address, runtime directory, and project root:
-docker compose down
-open-in-editor-bridge --shutdown
-```
+After installing 0.3.0, ELCC can replace the editor lifecycle/Compose `up` and `down` path in `bin/dev` with `OpenInEditorBridge.compose`, passing its existing development/gateway `-f` options, project name, host user/group variables, and gateway hostname. Keep gateway lifecycle ownership and pipe-input handling for unrelated commands unchanged.
 
-`--serve` runs the broker in the foreground and registers the current checkout. It requires a free port. Prefer the managed lifecycle above for sharing: manually interrupting a foreground broker stops all its sessions.
+Remove the `OPEN_IN_EDITOR_SESSION_ID` export from `dynamic_environment_variables`, its web-service pass-through in `docker-compose.development.yaml`, and the handwritten `/__open-in-editor` target/rewrite in `web/vite.config.js`. Add the mounted plugin to the existing Vue/Vuetify/gateway plugin list under the development-only condition above. The adapter supplies the host-gateway entry, so an editor-only `extra_hosts` entry is no longer necessary. Keep the explicit trusted-network bind opt-in and existing root/editor settings. No consumer files are changed automatically.
 
-## Docker and Checkout Routing
+## Low-Level Ruby API
 
-All worktrees using one listener must agree on port, bind address, and runtime directory. Each checkout registers its own host-root mapping and editor command. Simultaneous startup is serialized by a shared per-port lock, not by checkout-local pidfiles.
+For non-Compose applications or custom integrations:
 
-On Linux, make the host accessible from Compose and pass the checkout ID into the web service:
+```ruby
+require "open_in_editor_bridge"
 
-```yaml
-services:
-  web:
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-    environment:
-      OPEN_IN_EDITOR_SESSION_ID: "${OPEN_IN_EDITOR_SESSION_ID:?Set the host checkout session ID}"
+OpenInEditorBridge.with_running do |session_id|
+  # A custom integration may use session_id to select this checkout.
+  system("./bin/app", exception: true)
+end
 ```
 
-The container's dev-server proxy must forward editor requests to `http://host.docker.internal:3333` and add its `OPEN_IN_EDITOR_SESSION_ID` as the `session` query parameter. For example:
+The block returns its normal result. Its checkout lease is released in `ensure`, including when the block raises; cleanup does not replace the original exception. Overlapping wrappers have independent leases, even in the same checkout. Finishing one wrapper never releases another wrapper or an existing detached registration.
+
+`OpenInEditorBridge.session_id` returns the stable ID without starting the bridge. `OpenInEditorBridge.new(env: ..., project_root: ...)` supports explicit configuration. `call("--ensure-running")` registers a detached checkout; `call("--shutdown")` releases it. Repeated registration is idempotent. `with_running(ensure_running: false)` runs its block without acquiring a lease and releases detached registration afterward. Do not wrap detached startup in a foreground lease.
+
+## CLI and Session Protocol
+
+Run lifecycle commands from the host checkout (or set `OPEN_IN_EDITOR_PROJECT_ROOT`):
 
-```text
-GET /__open-in-editor?session=<checkout-id>&file=%2Fusr%2Fsrc%2Fweb%2Fapp.rb%3A12%3A4
+```sh
+open-in-editor-bridge --session-id
+open-in-editor-bridge --ensure-running
+# Later, with the same configuration:
+open-in-editor-bridge --shutdown
 ```
 
-`GET /health` reports the broker PID, protocol, bind address, and active checkout IDs. `GET /__open-in-editor` spawns the registered editor with `--goto <translated-target>`, preserving optional `:line:column`. Container paths equal to or below `/usr/src/web` map to that checkout's host `web` directory. Other paths pass through unchanged. Query encoding is decoded exactly once, preserving literal percent sequences in filenames.
+The CLI is the low-level lifecycle interface, not a substitute for the Docker/Vite adapter. `--serve` runs a foreground broker and registers the current checkout; it requires a free port. Manually interrupting it stops all sessions. Prefer the managed API for sharing.
+
+`GET /health` reports PID, protocol, bind address, and active checkout IDs. `GET /__open-in-editor?file=<encoded-target>&session=<checkout-id>` spawns that checkout's editor with `--goto <translated-target>`, preserving optional `:line:column`. Paths equal to or below `/usr/src/web` map to the host `web` directory; other paths pass through unchanged. Query encoding is decoded exactly once, preserving literal percent sequences in filenames.
 
-With exactly one checkout, existing links without `session` still work. With multiple checkouts, missing `session` returns HTTP 400 rather than guessing a checkout; unknown IDs return HTTP 404. Registering the same checkout with different roots or editor configuration while it is active is rejected; stop its existing leases before changing configuration.
+Custom integrations may use the same session protocol. With exactly one checkout, links without `session` work. With multiple checkouts, missing identity returns HTTP 400 rather than guessing; unknown IDs return HTTP 404. Conflicting roots/editor settings for an active checkout are rejected. Foreground and detached leases are independent; the last released lease shuts down the listener.
 
 ## Configuration
 
@@ -122,6 +131,12 @@ Version 0.2 replaces checkout-local PID/log files with shared runtime state. Sto
 
 ## Development and Release
 
+Commit the root `Gemfile.lock` to keep development and release-test dependencies reproducible. Regenerate it with Bundler after changing `Gemfile`, and commit both files together when both change. This development lockfile is not included in the gem package and does not constrain applications installing this gem; those applications resolve the gemspec's dependencies using their own lockfiles.
+
+Keep generated `*.gem` packages, `.ruby-lsp/` editor state, and local `pkg/` / `tmp/` artifacts out of version control.
+
+Development checks require Node.js 18+ for the bundled Vite plugin's dependency-free tests; the Ruby library itself remains dependency-free. `rake test` runs both Ruby and Node checks.
+
 ```sh
 bundle install
 bundle exec rake test

data/lib/open_in_editor_bridge/docker.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+class OpenInEditorBridge
+  class Docker
+    CONTAINER_DIRECTORY = "/open-in-editor-bridge"
+    COMPOSE_FILES = %w[compose.yaml compose.yml docker-compose.yaml docker-compose.yml].freeze
+    OVERRIDE_FILES = %w[compose.override.yaml compose.override.yml docker-compose.override.yaml docker-compose.override.yml].freeze
+
+    def initialize(env:, project_root:, service:, compose_options:)
+      @env = env.to_h
+      @project_root = File.expand_path(project_root || @env.fetch("OPEN_IN_EDITOR_PROJECT_ROOT", Dir.pwd))
+      @service = service
+      @compose_options = compose_options
+    end
+
+    def call(*args)
+      return up(args) if args.first == "up"
+
+      result = run(args)
+      bridge.call("--shutdown") if args.first == "down"
+      result
+    end
+
+    private
+
+    def configuration
+      @configuration ||= Configuration.new(env: @env, project_root: @project_root)
+    end
+
+    def bridge
+      @bridge ||= OpenInEditorBridge.new(env: @env, project_root: @project_root)
+    end
+
+    def up(args)
+      if %w[127.0.0.1 ::1 localhost].include?(configuration.bind_address)
+        raise ArgumentError, "Docker editor access requires explicit OPEN_IN_EDITOR_BRIDGE_BIND_ADDRESS (for example 0.0.0.0 on a trusted network)."
+      end
+      raise ArgumentError, "Select a Compose service for the Vite integration" if @service.to_s.empty?
+
+      # Resolve Compose inputs before acquiring a lease; invalid setup must not leave a broker behind.
+      files = compose_file_options
+      with_override do |override|
+        options = [*files, "-f", override]
+        detached?(args) ? detached_up(args, options) : foreground_up(args, options)
+      end
+    end
+
+    def foreground_up(args, options)
+      lease = SecureRandom.hex(16)
+      bridge.start_session(lease)
+      begin
+        run(args, options)
+      ensure
+        release_preserving_error(lease)
+      end
+    end
+
+    def detached_up(args, options)
+      registration = bridge.start_session("detached")
+      run(args, options)
+    rescue StandardError
+      release_preserving_error("detached") if registration == :started
+      raise
+    end
+
+    def release_preserving_error(lease)
+      original_error = $!
+      bridge.stop_session(lease)
+    rescue StandardError
+      raise unless original_error
+    end
+
+    def detached?(args)
+      flags = args.select { |arg| %w[-d --detach --detach=true --detach=false -d=true -d=false].include?(arg) }
+      !flags.empty? && !%w[--detach=false -d=false].include?(flags.last)
+    end
+
+    def run(args, extra_options = [])
+      system(@env, "docker", "compose", *@compose_options, *extra_options, *args,
+        chdir: @project_root, exception: true)
+    end
+
+    def with_override
+      configuration.ensure_runtime_directory
+      manifest = write_manifest
+      mounts = [
+        file_mount(File.join(__dir__, "vite.mjs"), "vite.mjs"),
+        file_mount(manifest, "session.json"),
+      ]
+      override = { "services" => { @service => {
+        "extra_hosts" => { "host.docker.internal" => "host-gateway" },
+        "volumes" => mounts,
+      } } }
+      Tempfile.create(["compose-", ".json"], configuration.runtime_directory) do |file|
+        file.write(JSON.generate(override))
+        file.flush
+        yield file.path
+      end
+    end
+
+    def file_mount(source, name)
+      { "type" => "bind", "source" => File.expand_path(source),
+        "target" => "#{CONTAINER_DIRECTORY}/#{name}", "read_only" => true,
+        "bind" => { "create_host_path" => false } }
+    end
+
+    def write_manifest
+      path = File.join(configuration.runtime_directory, "docker-#{configuration.port}-#{configuration.session_id}.json")
+      payload = { "session" => configuration.session_id, "target" => "http://host.docker.internal:#{configuration.port}" }
+      # Atomic replacement keeps simultaneous starts from exposing a partial identity file.
+      Tempfile.create(["session-", ".json"], configuration.runtime_directory) do |file|
+        file.write(JSON.generate(payload))
+        file.flush
+        file.chmod(0o644)
+        File.rename(file.path, path)
+      end
+      path
+    end
+
+    def compose_file_options
+      return [] if @compose_options.any? { |arg| arg == "-f" || arg == "--file" || arg.start_with?("--file=") || arg.match?(/\A-f.+/) }
+
+      if @env["COMPOSE_FILE"] && !@env["COMPOSE_FILE"].empty?
+        separator = @env.fetch("COMPOSE_PATH_SEPARATOR", File::PATH_SEPARATOR)
+        return @env.fetch("COMPOSE_FILE").split(separator).flat_map { |path| ["-f", File.expand_path(path, @project_root)] }
+      end
+
+      directory = discovery_directory
+      loop do
+        base = COMPOSE_FILES.find { |name| File.file?(File.join(directory, name)) }
+        if base
+          override = OVERRIDE_FILES.find { |name| File.file?(File.join(directory, name)) }
+          return [base, override].compact.flat_map { |name| ["-f", File.join(directory, name)] }
+        end
+        parent = File.dirname(directory)
+        raise ArgumentError, "No Compose file found; select it with compose_options: [\"-f\", path]" if parent == directory
+        directory = parent
+      end
+    end
+
+    def discovery_directory
+      @compose_options.each_with_index do |option, index|
+        return File.expand_path(@compose_options.fetch(index + 1), @project_root) if option == "--project-directory"
+        return File.expand_path(option.delete_prefix("--project-directory="), @project_root) if option.start_with?("--project-directory=")
+      end
+      @project_root
+    end
+  end
+end

data/lib/open_in_editor_bridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class OpenInEditorBridge
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/open_in_editor_bridge/vite.mjs

@@ -0,0 +1,79 @@
+import { readFileSync } from "node:fs";
+
+const sessionManifestPath = new URL("./session.json", import.meta.url);
+const editorRouteKey = "^/__open-in-editor(?:\\?|$)";
+
+function readSession() {
+  try {
+    const manifest = JSON.parse(readFileSync(sessionManifestPath, "utf8"));
+    if (
+      !manifest ||
+      typeof manifest.session !== "string" ||
+      !/^[a-f0-9]{64}$/.test(manifest.session) ||
+      typeof manifest.target !== "string"
+    ) {
+      throw new Error("Invalid checkout identity");
+    }
+
+    const target = new URL(manifest.target);
+    if (
+      target.protocol !== "http:" ||
+      !target.hostname ||
+      target.username ||
+      target.password ||
+      target.pathname !== "/" ||
+      target.search ||
+      target.hash
+    ) {
+      throw new Error("Invalid bridge target");
+    }
+
+    return { session: manifest.session, target: target.origin };
+  } catch (cause) {
+    throw new Error("OpenInEditorBridge requires a valid Docker session manifest; start Vite through OpenInEditorBridge.compose.", { cause });
+  }
+}
+
+function withSession(requestUrl, session) {
+  const queryStart = requestUrl.indexOf("?");
+  if (queryStart === -1) return `${requestUrl}?session=${encodeURIComponent(session)}`;
+
+  const path = requestUrl.slice(0, queryStart);
+  const query = requestUrl.slice(queryStart + 1);
+  const retained = query.split("&").filter((part) => {
+    const separator = part.indexOf("=");
+    const rawName = separator === -1 ? part : part.slice(0, separator);
+    try {
+      return decodeURIComponent(rawName.replace(/\+/g, " ")) !== "session";
+    } catch {
+      return true;
+    }
+  });
+  retained.push(`session=${encodeURIComponent(session)}`);
+  return `${path}?${retained.join("&")}`;
+}
+
+export default function openInEditorBridge() {
+  const identity = readSession();
+
+  return {
+    name: "open-in-editor-bridge",
+    enforce: "post",
+    config(config) {
+      const existing = { ...config.server?.proxy };
+      delete existing["/__open-in-editor"];
+      delete existing["^/__open-in-editor$"];
+      delete existing[editorRouteKey];
+
+      config.server ??= {};
+      config.server.proxy = {
+        [editorRouteKey]: {
+          target: identity.target,
+          changeOrigin: true,
+          rewrite: (requestUrl) => withSession(requestUrl, identity.session),
+        },
+        ...existing,
+      };
+    },
+  };
+}

data/lib/open_in_editor_bridge.rb

@@ -14,6 +14,10 @@ class OpenInEditorBridge
     new.session_id
   end
 
+  def self.compose(*args, service: "web", compose_options: [], env: ENV, project_root: nil)
+    Docker.new(env: env, project_root: project_root, service: service, compose_options: compose_options).call(*args)
+  end
+
   def self.with_running(ensure_running: true)
     bridge = new
     lease = SecureRandom.hex(16) if ensure_running
@@ -69,5 +73,6 @@ require_relative "open_in_editor_bridge/configuration"
 require_relative "open_in_editor_bridge/authentication"
 require_relative "open_in_editor_bridge/server"
 require_relative "open_in_editor_bridge/client"
+require_relative "open_in_editor_bridge/docker"
 
 OpenInEditorBridge.call(*ARGV) if $PROGRAM_NAME == __FILE__

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open-in-editor-bridge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Marlen Brunner
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-09 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies: []
 description: Ruby API and CLI for serving local open-in-editor requests during development.
 email:
@@ -26,8 +26,10 @@ files:
 - lib/open_in_editor_bridge/authentication.rb
 - lib/open_in_editor_bridge/client.rb
 - lib/open_in_editor_bridge/configuration.rb
+- lib/open_in_editor_bridge/docker.rb
 - lib/open_in_editor_bridge/server.rb
 - lib/open_in_editor_bridge/version.rb
+- lib/open_in_editor_bridge/vite.mjs
 homepage: https://github.com/klondikemarlen/open-in-editor-bridge
 licenses:
 - MIT