@neuralnomads/codenomad-dev 0.15.0-dev-20260512-91652990 → 0.15.0-dev-20260512-cf88dc06

package/dist/opencode-plugin.js

@@ -0,0 +1,146 @@
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { createLogger } from "./logger";
+const log = createLogger({ component: "opencode-plugin" });
+const pluginPackageName = "@codenomad/codenomad-opencode-plugin";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const resourcesPath = process.resourcesPath;
+const devPluginEntry = path.resolve(__dirname, "../../opencode-plugin/plugin/codenomad.ts");
+const prodPluginDirs = [
+    resourcesPath ? path.resolve(resourcesPath, "opencode-plugin") : undefined,
+    resourcesPath ? path.resolve(resourcesPath, "server/dist/opencode-plugin") : undefined,
+    path.resolve(__dirname, "opencode-plugin"),
+].filter((dir) => Boolean(dir));
+const isDevBuild = Boolean(process.env.CODENOMAD_DEV ??
+    process.env.CLI_UI_DEV_SERVER ??
+    process.env.VITE_DEV_SERVER_URL ??
+    process.env.ELECTRON_RENDERER_URL);
+const isSourceRun = path.basename(__dirname) === "src" && existsSync(devPluginEntry);
+export function getCodeNomadPluginUrl() {
+    if (isDevBuild || isSourceRun) {
+        if (!existsSync(devPluginEntry)) {
+            throw new Error(`CodeNomad OpenCode plugin entry missing at ${devPluginEntry}`);
+        }
+        log.debug({ pluginEntry: devPluginEntry }, "Using OpenCode plugin source directly (dev mode)");
+        return pathToFileURL(devPluginEntry).href;
+    }
+    for (const dir of prodPluginDirs) {
+        const tarball = findPluginTarball(dir);
+        if (tarball) {
+            return toNpmFileSpecifier(tarball);
+        }
+    }
+    throw new Error(`CodeNomad OpenCode plugin package missing in ${prodPluginDirs.join(", ")}`);
+}
+export function buildOpencodeConfigContent(existingContent, pluginUrl) {
+    const config = existingContent?.trim() ? parseJsoncObject(existingContent) : {};
+    const existingPlugins = normalizePluginEntries(config.plugin);
+    if (!existingPlugins.includes(pluginUrl)) {
+        existingPlugins.push(pluginUrl);
+    }
+    return JSON.stringify({
+        "$schema": typeof config["$schema"] === "string" ? config["$schema"] : "https://opencode.ai/config.json",
+        ...config,
+        plugin: existingPlugins,
+    }, null, 2);
+}
+export function resolveExistingOpencodeConfigContent(userEnvironment) {
+    const userValue = normalizeConfigContentValue(userEnvironment.OPENCODE_CONFIG_CONTENT);
+    if (userValue) {
+        return userValue;
+    }
+    return normalizeConfigContentValue(process.env.OPENCODE_CONFIG_CONTENT);
+}
+function toNpmFileSpecifier(filePath) {
+    return `${pluginPackageName}@file:${filePath.replace(/\\/g, "/")}`;
+}
+function findPluginTarball(dir) {
+    if (!existsSync(dir)) {
+        return null;
+    }
+    const tarballs = readdirSync(dir)
+        .filter((name) => name.endsWith(".tgz"))
+        .sort();
+    return tarballs.length > 0 ? path.resolve(dir, tarballs[tarballs.length - 1]) : null;
+}
+function normalizeConfigContentValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function parseJsoncObject(content) {
+    try {
+        const parsed = JSON.parse(stripJsonc(content));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("OPENCODE_CONFIG_CONTENT must be a JSON object");
+        }
+        return parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse OPENCODE_CONFIG_CONTENT: ${reason}`);
+    }
+}
+function normalizePluginEntries(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+        return [...value];
+    }
+    throw new Error("OPENCODE_CONFIG_CONTENT plugin field must be a string or string array");
+}
+function stripJsonc(input) {
+    let output = "";
+    let inString = false;
+    let escape = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const next = input[index + 1];
+        if (escape) {
+            output += char;
+            escape = false;
+            continue;
+        }
+        if (char === "\\" && inString) {
+            output += char;
+            escape = true;
+            continue;
+        }
+        if (char === '"') {
+            output += char;
+            inString = !inString;
+            continue;
+        }
+        if (!inString && char === "/" && next === "/") {
+            while (index < input.length && input[index] !== "\n") {
+                index += 1;
+            }
+            output += "\n";
+            continue;
+        }
+        if (!inString && char === "/" && next === "*") {
+            index += 2;
+            while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) {
+                output += input[index] === "\n" ? "\n" : "";
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        if (!inString && char === ",") {
+            let lookahead = index + 1;
+            while (lookahead < input.length && /\s/.test(input[lookahead])) {
+                lookahead += 1;
+            }
+            if (input[lookahead] === "}" || input[lookahead] === "]") {
+                continue;
+            }
+        }
+        output += char;
+    }
+    return output;
+}

package/dist/opencode-plugin.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildOpencodeConfigContent } from "./opencode-plugin";
+describe("buildOpencodeConfigContent", () => {
+    it("creates config content with the CodeNomad plugin", () => {
+        const content = buildOpencodeConfigContent(undefined, "file:///plugin.tgz");
+        assert.deepEqual(JSON.parse(content), {
+            "$schema": "https://opencode.ai/config.json",
+            plugin: ["file:///plugin.tgz"],
+        });
+    });
+    it("merges with existing JSONC content", () => {
+        const content = buildOpencodeConfigContent(`{
+        // user plugin
+        "plugin": ["npm:user-plugin",],
+        "model": "test-model",
+      }`, "file:///plugin.tgz");
+        assert.deepEqual(JSON.parse(content), {
+            "$schema": "https://opencode.ai/config.json",
+            plugin: ["npm:user-plugin", "file:///plugin.tgz"],
+            model: "test-model",
+        });
+    });
+    it("does not duplicate the CodeNomad plugin", () => {
+        const content = buildOpencodeConfigContent('{"plugin":["file:///plugin.tgz"]}', "file:///plugin.tgz");
+        assert.deepEqual(JSON.parse(content).plugin, ["file:///plugin.tgz"]);
+    });
+});

package/dist/workspaces/__tests__/spawn.test.js

@@ -34,12 +34,12 @@ describe("buildWindowsSpawnSpec", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
             cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
             env: {
-                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\CodeNomad\opencode-config`,
+                OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: ["file:///C:/Users/dev/AppData/Roaming/CodeNomad/plugin.tgz"] }),
                 CODENOMAD_INSTANCE_ID: "workspace-123",
                 OPENCODE_SERVER_BASE_URL: "https://127.0.0.1:4321/workspaces/workspace-123/worktrees/root/instance",
                 OPENCODE_SERVER_PASSWORD: "secret",
             },
-            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "CODENOMAD_INSTANCE_ID", "OPENCODE_SERVER_BASE_URL", "OPENCODE_SERVER_PASSWORD"],
+            propagateEnvKeys: ["OPENCODE_CONFIG_CONTENT", "CODENOMAD_INSTANCE_ID", "OPENCODE_SERVER_BASE_URL", "OPENCODE_SERVER_PASSWORD"],
         });
         assert.equal(spec.command, "wsl.exe");
         assert.deepEqual(spec.args, [
@@ -54,17 +54,35 @@ describe("buildWindowsSpawnSpec", () => {
             "0",
         ]);
         assert.equal(spec.cwd, undefined);
-        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:CODENOMAD_INSTANCE_ID:OPENCODE_SERVER_BASE_URL:OPENCODE_SERVER_PASSWORD");
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_CONTENT:CODENOMAD_INSTANCE_ID:OPENCODE_SERVER_BASE_URL:OPENCODE_SERVER_PASSWORD");
     });
-    it("upgrades existing WSLENV path entries to include /p", () => {
+    it("preserves non-path OPENCODE_CONFIG_CONTENT WSLENV entries", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
             env: {
-                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\CodeNomad\opencode-config`,
-                WSLENV: "OPENCODE_CONFIG_DIR:CODENOMAD_INSTANCE_ID/u",
+                OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: ["file:///C:/Users/dev/AppData/Roaming/CodeNomad/plugin.tgz"] }),
+                WSLENV: "OPENCODE_CONFIG_CONTENT:CODENOMAD_INSTANCE_ID/u",
             },
-            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "CODENOMAD_INSTANCE_ID"],
+            propagateEnvKeys: ["OPENCODE_CONFIG_CONTENT", "CODENOMAD_INSTANCE_ID"],
         });
-        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:CODENOMAD_INSTANCE_ID/u");
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_CONTENT:CODENOMAD_INSTANCE_ID/u");
+    });
+    it("rewrites packaged plugin paths for WSL before launching", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            env: {
+                OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                    plugin: [
+                        "@codenomad/codenomad-opencode-plugin@file:C:/Users/dev/AppData/Roaming/CodeNomad/codenomad-opencode-plugin.tgz",
+                    ],
+                }),
+            },
+            propagateEnvKeys: ["OPENCODE_CONFIG_CONTENT"],
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.equal(spec.env?.CODENOMAD_OPENCODE_PLUGIN_WSL_PATH, String.raw `C:\Users\dev\AppData\Roaming\CodeNomad\codenomad-opencode-plugin.tgz`);
+        assert.match(spec.env?.OPENCODE_CONFIG_CONTENT ?? "", /__CODENOMAD_OPENCODE_PLUGIN_WSL_PATH__/);
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_CONTENT:CODENOMAD_OPENCODE_PLUGIN_WSL_PATH/p");
+        assert.deepEqual(spec.args.slice(0, 4), ["--distribution", "Ubuntu", "--exec", "sh"]);
+        assert.match(spec.args[5] ?? "", /CODENOMAD_OPENCODE_PLUGIN_WSL_PATH/);
     });
     it("propagates inherited known path variables even when they are not explicitly requested", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {

package/dist/workspaces/manager.js

@@ -5,7 +5,7 @@ import { FileSystemBrowser } from "../filesystem/browser";
 import { searchWorkspaceFiles } from "../filesystem/search";
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
 import { WorkspaceRuntime } from "./runtime";
-import { getOpencodeConfigDir } from "../opencode-config.js";
+import { buildOpencodeConfigContent, getCodeNomadPluginUrl, resolveExistingOpencodeConfigContent, } from "../opencode-plugin.js";
 import { OPENCODE_SERVER_BASE_URL_ENV, buildOpencodeBasicAuthHeader, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, resolveOpencodeServerAuth, } from "./opencode-auth";
 const STARTUP_STABILITY_DELAY_MS = 1500;
 export class WorkspaceManager {
@@ -14,7 +14,7 @@ export class WorkspaceManager {
         this.workspaces = new Map();
         this.opencodeAuth = new Map();
         this.runtime = new WorkspaceRuntime(this.options.eventBus, this.options.logger);
-        this.opencodeConfigDir = getOpencodeConfigDir();
+        this.codeNomadPluginUrl = getCodeNomadPluginUrl();
     }
     list() {
         return Array.from(this.workspaces.values());
@@ -79,6 +79,7 @@ export class WorkspaceManager {
         const serverConfig = this.options.settings.getOwner("config", "server");
         const envVars = serverConfig?.environmentVariables;
         const userEnvironment = envVars && typeof envVars === "object" && !Array.isArray(envVars) ? envVars : {};
+        const opencodeConfigContent = buildOpencodeConfigContent(resolveExistingOpencodeConfigContent(userEnvironment), this.codeNomadPluginUrl);
         const serverBaseUrl = this.options.getServerBaseUrl();
         const normalizedServerBaseUrl = serverBaseUrl.replace(/\/+$/, "");
         const { username: opencodeUsername, password: opencodePassword } = resolveOpencodeServerAuth({
@@ -92,7 +93,7 @@ export class WorkspaceManager {
         this.opencodeAuth.set(id, { username: opencodeUsername, password: opencodePassword, authorization });
         const environment = {
             ...userEnvironment,
-            OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
+            OPENCODE_CONFIG_CONTENT: opencodeConfigContent,
             CODENOMAD_INSTANCE_ID: id,
             CODENOMAD_BASE_URL: serverBaseUrl,
             ...(this.options.nodeExtraCaCertsPath ? { NODE_EXTRA_CA_CERTS: this.options.nodeExtraCaCertsPath } : {}),

package/dist/workspaces/spawn.js

@@ -4,7 +4,11 @@ export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"]);
 export const WINDOWS_POWERSHELL_EXTENSIONS = new Set([".ps1"]);
 const VERSION_REGEX = /([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/;
 const WSL_UNC_PATH_REGEX = /^\\\\wsl(?:\.localhost|\$)\\([^\\/]+)(?:[\\/](.*))?$/i;
-const WSL_PATH_ENV_KEYS = new Set(["OPENCODE_CONFIG_DIR", "NODE_EXTRA_CA_CERTS"]);
+const CODENOMAD_PLUGIN_PACKAGE_NAME = "@codenomad/codenomad-opencode-plugin";
+const WSL_PLUGIN_PATH_ENV = "CODENOMAD_OPENCODE_PLUGIN_WSL_PATH";
+const WSL_PLUGIN_PATH_PLACEHOLDER = "__CODENOMAD_OPENCODE_PLUGIN_WSL_PATH__";
+const CODENOMAD_PLUGIN_FILE_SPEC_REGEX = new RegExp(`(${escapeRegex(CODENOMAD_PLUGIN_PACKAGE_NAME)}@file:)([A-Za-z]:[^"\\r\\n]+?\\.tgz)`);
+const WSL_PATH_ENV_KEYS = new Set(["NODE_EXTRA_CA_CERTS", WSL_PLUGIN_PATH_ENV]);
 export function parseWslUncPath(input) {
     const normalized = input.trim().replace(/\//g, "\\");
     const match = normalized.match(WSL_UNC_PATH_REGEX);
@@ -129,16 +133,18 @@ export function probeBinaryVersion(binaryPath) {
 }
 function buildWslSpawnSpec(wslPath, args, options) {
     const workingDirectory = options.cwd ? resolveWslWorkingDirectory(options.cwd, wslPath.distro) : undefined;
+    const env = buildWslEnvironment(options.env, options.propagateEnvKeys);
+    const shouldTranslatePluginPath = Boolean(env?.[WSL_PLUGIN_PATH_ENV]);
     if (options.cwd && !workingDirectory) {
         throw new Error(`Unable to translate workspace folder for WSL binary in distro "${wslPath.distro}": ${options.cwd}`);
     }
     const wslArgs = ["--distribution", wslPath.distro];
-    const shouldWrapWithShell = Boolean(options.wslPidMarker) || workingDirectory?.kind === "windows";
+    const shouldWrapWithShell = Boolean(options.wslPidMarker) || workingDirectory?.kind === "windows" || shouldTranslatePluginPath;
     if (!shouldWrapWithShell && workingDirectory?.kind === "linux") {
         wslArgs.push("--cd", workingDirectory.path);
     }
     if (shouldWrapWithShell) {
-        const launchScript = buildWslLaunchScript(workingDirectory ?? undefined, options.wslPidMarker);
+        const launchScript = buildWslLaunchScript(workingDirectory ?? undefined, options.wslPidMarker, shouldTranslatePluginPath);
         wslArgs.push("--exec", "sh", "-lc", launchScript, "codenomad-wsl-launch");
         if (workingDirectory) {
             wslArgs.push(workingDirectory.path);
@@ -152,11 +158,11 @@ function buildWslSpawnSpec(wslPath, args, options) {
         command: "wsl.exe",
         args: wslArgs,
         options: {},
-        env: buildWslEnvironment(options.env, options.propagateEnvKeys),
+        env,
         wsl: { distro: wslPath.distro, pidMarker: options.wslPidMarker },
     };
 }
-function buildWslLaunchScript(workingDirectory, pidMarker) {
+function buildWslLaunchScript(workingDirectory, pidMarker, translatePluginPath) {
     const steps = [];
     if (pidMarker) {
         steps.push(`printf '%s%s\\n' '${pidMarker}' "$$"`);
@@ -169,6 +175,9 @@ function buildWslLaunchScript(workingDirectory, pidMarker) {
         steps.push('cd "$(wslpath -au "$1")"');
         steps.push("shift");
     }
+    if (translatePluginPath) {
+        steps.push(`if [ -n "$${WSL_PLUGIN_PATH_ENV}" ] && [ -n "$OPENCODE_CONFIG_CONTENT" ]; then escaped_plugin_path=$(printf '%s' "$${WSL_PLUGIN_PATH_ENV}" | sed 's/[\\&|]/\\\\&/g'); OPENCODE_CONFIG_CONTENT=$(printf '%s' "$OPENCODE_CONFIG_CONTENT" | sed "s|${WSL_PLUGIN_PATH_PLACEHOLDER}|$escaped_plugin_path|g"); export OPENCODE_CONFIG_CONTENT; unset ${WSL_PLUGIN_PATH_ENV}; fi`);
+    }
     steps.push('exec "$@"');
     return steps.join(" && ");
 }
@@ -186,14 +195,15 @@ function buildWslEnvironment(env, propagateEnvKeys) {
     if (!env) {
         return env;
     }
+    const next = { ...env };
+    rewriteOpencodePluginPathForWsl(next);
     const keysToPropagate = Array.from(new Set([
-        ...(propagateEnvKeys ?? []).filter((key) => env[key] !== undefined),
-        ...Array.from(WSL_PATH_ENV_KEYS).filter((key) => env[key] !== undefined),
+        ...(propagateEnvKeys ?? []).filter((key) => next[key] !== undefined),
+        ...Array.from(WSL_PATH_ENV_KEYS).filter((key) => next[key] !== undefined),
     ]));
     if (keysToPropagate.length === 0) {
-        return env;
+        return next;
     }
-    const next = { ...env };
     const entries = (next.WSLENV ?? "").split(":").filter((entry) => entry.length > 0);
     const byName = new Map(entries.map((entry) => [entry.split("/")[0] ?? entry, entry]));
     for (const key of keysToPropagate) {
@@ -207,6 +217,19 @@ function buildWslEnvironment(env, propagateEnvKeys) {
     next.WSLENV = Array.from(byName.values()).join(":");
     return next;
 }
+function rewriteOpencodePluginPathForWsl(env) {
+    const content = env.OPENCODE_CONFIG_CONTENT;
+    if (!content) {
+        return;
+    }
+    const match = content.match(CODENOMAD_PLUGIN_FILE_SPEC_REGEX);
+    const hostPath = match?.[2];
+    if (!hostPath) {
+        return;
+    }
+    env.OPENCODE_CONFIG_CONTENT = content.replace(hostPath, WSL_PLUGIN_PATH_PLACEHOLDER);
+    env[WSL_PLUGIN_PATH_ENV] = path.win32.normalize(hostPath);
+}
 function ensureWslenvEntry(entry, requiresPathTranslation) {
     if (!requiresPathTranslation) {
         return entry;
@@ -217,3 +240,6 @@ function ensureWslenvEntry(entry, requiresPathTranslation) {
     }
     return rawFlags.length > 0 ? `${name}/${rawFlags}p` : `${name}/p`;
 }
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-dev",
-  "version": "0.15.0-dev-20260512-91652990",
+  "version": "0.15.0-dev-20260512-cf88dc06",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {
@@ -17,10 +17,10 @@
     "codenomad": "dist/bin.js"
   },
   "scripts": {
-    "build": "npm run build:ui && npm run prepare-ui && tsc -p tsconfig.json && node ./scripts/copy-auth-pages.mjs && npm run prepare-config",
+    "build": "npm run build:ui && npm run prepare-ui && tsc -p tsconfig.json && node ./scripts/copy-auth-pages.mjs && npm run prepare-plugin",
     "build:ui": "npm run build --prefix ../ui",
     "prepare-ui": "node ./scripts/copy-ui-dist.mjs",
-    "prepare-config": "node ./scripts/copy-opencode-config.mjs",
+    "prepare-plugin": "node ./scripts/package-opencode-plugin.mjs",
     "dev": "cross-env CODENOMAD_DEV=1 CODENOMAD_SERVER_PASSWORD=codenomad-dev CLI_UI_DEV_SERVER=http://localhost:3000 CLI_HTTPS=false CLI_HTTP=true tsx src/index.ts",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },

package/public/index.html

@@ -30,8 +30,8 @@
     <link rel="modulepreload" crossorigin href="/assets/git-diff-vendor-CSgooKT_.js">
     <link rel="modulepreload" crossorigin href="/assets/monaco-viewer-B3iAKbO0.js">
     <link rel="modulepreload" crossorigin href="/assets/index-Bo2Zanex.js">
-    <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
     <link rel="stylesheet" crossorigin href="/assets/index-C2gIF7lT.css">
+    <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
   <link rel="manifest" href="/manifest.webmanifest"><script id="vite-plugin-pwa:register-sw" src="/registerSW.js"></script>
 <meta name="theme-color" content="#1a1a1a">
 <link rel="icon" href="/favicon.ico" sizes="48x48">

package/public/loading.html

@@ -20,8 +20,8 @@
     <link rel="modulepreload" crossorigin href="/assets/git-diff-vendor-CSgooKT_.js">
     <link rel="modulepreload" crossorigin href="/assets/monaco-viewer-B3iAKbO0.js">
     <link rel="modulepreload" crossorigin href="/assets/index-Bo2Zanex.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-C2gIF7lT.css">
     <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-C2gIF7lT.css">
     <link rel="stylesheet" crossorigin href="/assets/loading-CmEVQgyj.css">
   <link rel="manifest" href="/manifest.webmanifest"><script id="vite-plugin-pwa:register-sw" src="/registerSW.js"></script>
 <meta name="theme-color" content="#1a1a1a">

package/dist/opencode-config/README.md

@@ -1,32 +0,0 @@
-# opencode-config
-
-## TLDR
-Template config + plugins injected into every OpenCode instance that CodeNomad launches. It provides a CodeNomad bridge plugin for local event exchange between the CLI server and opencode.
-
-## What it is
-A packaged config directory that CodeNomad copies into `~/.config/codenomad/opencode-config` for production builds or uses directly in dev. OpenCode autoloads any `plugin/*.ts` or `plugin/*.js` from this directory.
-
-## How it works
-- CodeNomad sets `OPENCODE_CONFIG_DIR` when spawning each opencode instance (`packages/server/src/workspaces/manager.ts`).
-- This template is synced from `packages/opencode-config` (`packages/server/src/opencode-config.ts`, `packages/server/scripts/copy-opencode-config.mjs`).
-- OpenCode autoloads plugins from `plugin/` (`packages/opencode-config/plugin/codenomad.ts`).
-- The `CodeNomadPlugin` reads `CODENOMAD_INSTANCE_ID` + `CODENOMAD_BASE_URL`, connects to `GET /workspaces/:id/plugin/events`, and posts to `POST /workspaces/:id/plugin/event` (`packages/opencode-config/plugin/lib/client.ts`).
-- The server exposes the plugin routes and maps events into the UI SSE pipeline (`packages/server/src/server/routes/plugin.ts`, `packages/server/src/plugins/handlers.ts`).
-
-## Expectations
-- Local-only bridge (no auth/token yet).
-- Plugin must fail startup if it cannot connect after 3 retries.
-- Keep plugin entrypoints thin; put shared logic under `plugin/lib/` to avoid autoloaded helpers.
-- Keep event shapes small and explicit; use `type` + `properties` only.
-
-## Ideas
-- Add feature modules under `plugin/lib/features/` (tool lifecycle, permission prompts, custom commands).
-- Expand `/workspaces/:id/plugin/*` with dedicated endpoints as needed.
-- Promote stable event shapes and version tags once the protocol settles.
-
-## Pointers
-- Plugin entry: `packages/opencode-config/plugin/codenomad.ts`
-- Plugin client: `packages/opencode-config/plugin/lib/client.ts`
-- Plugin server routes: `packages/server/src/server/routes/plugin.ts`
-- Plugin event handling: `packages/server/src/plugins/handlers.ts`
-- Workspace env injection: `packages/server/src/workspaces/manager.ts`

package/dist/opencode-config/opencode.jsonc

@@ -1,3 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json"
-}