opencommand-plugin 0.0.10 → 0.0.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenCommand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,20 +1,58 @@
-# OpenCommand Plugin
+# OpenCommand
 
-OpenCode plugin for CommandCode. It starts the local OpenCommand proxy, stores CommandCode auth locally, registers the `opencommand` provider, and loads the right model list for the active CommandCode plan.
+OpenCommand is één OpenCode/NPM-plugin voor CommandCode. De plugin registreert de provider `opencommand`, start lokaal een OpenAI-compatible proxy en bundelt die proxy-binaries zelf in het NPM-package.
 
-## Features
+Er is dus geen losse proxy-installatie of lokale repo-checkout meer nodig in OpenCode. De Go-code staat nog wel in `proxy/`, maar alleen als broncode: bij `npm run build:proxy` worden de binaries naar `dist/proxy/` gebouwd en met `opencommand-plugin` gepubliceerd.
 
-- Starts/stops the Go proxy automatically.
-- Uses a dynamic local port and exposes `http://localhost:<port>/v1` to OpenCode.
-- Stores the CommandCode API token locally in `~/.opencommand/opencommand-secrets.json`.
-- Supports `COMMAND_CODE_TOKEN` and `COMMANDCODE_API_KEY` environment overrides.
-- Attempts local browser cookie discovery for CommandCode Studio usage scraping.
-- Registers OpenCode provider `opencommand` using `@ai-sdk/openai-compatible`.
-- Detects the active CommandCode plan and registers the matching OpenCode model list.
+## Huidige structuur
 
-## Auth
+```text
+.
+├── bin/opencode-plugin.js        # OpenCode plugin entrypoint
+├── src/index.ts                  # plugin runtime/provider/proxy manager
+├── proxy/                        # Go source voor de lokale proxy
+├── scripts/build-proxy-binaries.mjs
+├── tests/                        # Jest tests voor plugin/runtime
+├── package.json                  # NPM package: opencommand-plugin
+└── dist/                         # build output, niet getrackt
+```
+
+## Gebruik met OpenCode
+
+Gebruik na publicatie:
+
+```jsonc
+{
+  "plugin": ["opencommand-plugin@latest"],
+  "model": "opencommand/deepseek/deepseek-v4-flash",
+  "small_model": "opencommand/deepseek/deepseek-v4-flash"
+}
+```
+
+Voor een vaste versie kun je `opencommand-plugin@0.0.12` pinnen.
+
+Bij OpenCode-start doet de plugin dit automatisch:
+
+1. kiest de juiste gebundelde proxybinary voor macOS/Linux/Windows;
+2. start de proxy op een lokale poort;
+3. schrijft `~/.opencommand/proxy-config.json` met de actieve URL;
+4. registreert provider `opencommand` met `http://localhost:<port>/v1`;
+5. detecteert het actieve CommandCode-plan en registreert de bijpassende modellen.
+
+OpenCode moet opnieuw worden gestart nadat `opencode.jsonc` of de pluginversie is gewijzigd, want plugin-config wordt bij startup geladen.
+
+## Auth-model
+
+Gebruik primair een CommandCode token (`user_...`). Zet secrets niet in gesyncte `opencode.jsonc`.
 
-Primary token key:
+Prioriteit:
+
+1. inkomende `Authorization: Bearer user_...` requests;
+2. `COMMAND_CODE_TOKEN`;
+3. alias `COMMANDCODE_API_KEY`;
+4. lokale secret `~/.opencommand/opencommand-secrets.json` met sleutel `opencommand.command_code_token`.
+
+Voorbeeld:
 
 ```json
 {
@@ -22,39 +60,125 @@ Primary token key:
 }
 ```
 
-Do not put this token in synced `opencode.jsonc`.
+De plugin maakt `~/.opencommand` met `0700` permissies en schrijft secrets met `0600`. `CC_SESSION_COOKIE` is alleen bedoeld voor CommandCode Studio usage scraping, niet als primaire model-auth.
+
+## Lokale bestanden
+
+OpenCommand gebruikt alleen lokale bestanden buiten de repo:
+
+- `~/.opencommand/opencommand-secrets.json` — CommandCode token en optionele Studio-cookie.
+- `~/.opencommand/proxy-config.json` — actieve proxy URL/poort.
+- `~/.opencommand/model-cache.json` — laatst bekende plan/model-lijst.
+
+Voorbeeld `proxy-config.json`:
+
+```json
+{
+  "url": "http://localhost:3000",
+  "port": 3000,
+  "updatedAt": "2026-05-19T20:00:00.000Z"
+}
+```
+
+## Browser-cookie extractie
 
-## Models in v0.0.4
+Voor usage scraping kan de plugin op macOS proberen een CommandCode Studio-cookie te vinden in Chrome, Comet, Brave, Edge of Firefox. Gevonden cookies worden lokaal opgeslagen als:
 
-The proxy detects the active CommandCode subscription through `/alpha/billing/subscriptions` and filters models:
+```json
+{
+  "opencommand.cc_session_cookie": "..."
+}
+```
+
+Cookie-waarden worden niet gelogd en niet in `opencode.jsonc` opgeslagen.
+
+## Model-detectie per plan
+
+De proxy/plugin vraagt `/alpha/billing/subscriptions` op en filtert modellen per plan:
 
-- Go: open-source models only.
-- Pro: open-source + premium, excluding Opus.
-- Max / Ultra / Teams Pro: open-source + premium including Opus.
+- `individual-go`: open-source modellen.
+- `individual-pro`: open-source + premium, zonder Opus.
+- `individual-max`, `individual-ultra`, `teams-pro`: open-source + premium inclusief Opus.
 
-If detection fails, the plugin falls back to the local proxy model endpoint and then to the Go/open-source model list.
+Als plan-detectie faalt, valt OpenCommand terug op de lokale cached/static Go/open-source lijst zodat OpenCode alsnog kan starten.
 
-## Build
+## Lokale API
+
+De proxy biedt OpenAI-compatible endpoints:
+
+- `POST /v1/chat/completions` — streaming en non-streaming chat completions.
+- `GET /v1/models` — plan-gefilterde OpenAI model-lijst.
+- `GET /v1/models/allowed` — CommandCode Studio allowed-models/usage info.
+- `GET /v1/account/usage` — usage summary.
+- `GET /healthz` — health check.
+
+De proxy vertaalt OpenAI `messages`, `tools`, `tool_choice` en streaming responses naar/van het huidige CommandCode CLI-protocol.
+
+## Development
+
+Root package:
 
 ```bash
 npm ci
+npm test -- --runInBand
 npm run build
+npm run build:proxy
+npm pack --dry-run
 ```
 
-## Test
+Go proxy tests:
 
 ```bash
-npm test -- --runInBand
+cd proxy
+go vet ./...
+go test -race ./...
+go build -o proxy main.go
 ```
 
-## v0.0.8 non-blocking OpenCode startup
+`npm pack` bevat alleen de runtimebestanden:
+
+- `README.md`
+- `package.json`
+- `bin/opencode-plugin.js`
+- `dist/index.js`
+- `dist/index.d.ts`
+- `dist/proxy/opencommand-proxy-*`
+
+De bronmappen `src/`, `tests/` en `proxy/` worden niet gepubliceerd in het NPM-package.
+
+## Publicatie
+
+Package: `opencommand-plugin`.
+
+De publish workflow staat in `.github/workflows/npm-publish.yml`. Deze workflow bouwt/test de root package, bouwt de proxybinaries en controleert dat alle vereiste bestanden in het NPM-package zitten.
+
+## Release notes
+
+### v0.0.12
+
+- OpenAI-compatible chat schema voor OpenCode requests.
+- Deterministische samenvoeging van system/developer messages naar `params.system`.
+- Conversie van OpenAI tool calls/results naar CommandCode `tool-call`/`tool-result` parts.
+- Conversie van OpenAI `tools` en `tool_choice` naar CommandCode tool schema.
+- Fixes voor CommandCode 400-errors rond `params.messages[0].role`, string content en `params.tools[0].name`.
+- Repo-layout opgeschoond: root is nu het NPM/OpenCode package; `proxy/` is alleen Go-source voor bundled binaries.
+
+### v0.0.11
+
+- NPM-package bundelt proxybinaries voor macOS, Linux en Windows.
+- OpenCode heeft alleen `opencommand-plugin` nodig; geen losse proxy-installatie.
+- Proxy vertaalt CommandCode streaming events naar OpenAI-compatible chat-completion chunks/responses.
+
+### v0.0.10
 
-`opencommand-plugin@0.0.8` keeps OpenCode startup non-blocking: provider registration uses cached/static models immediately, while proxy startup and CommandCode plan/model refresh run in the background. Pin `opencode.jsonc` to `opencommand-plugin@0.0.10` (or newer) instead of `@latest` to avoid stale plugin cache entries.
+- Plugin start de lokale proxy vanuit de OpenCode config hook.
+- Gesyncte `opencode.jsonc` heeft geen absolute lokale `file://` plugin path meer nodig.
 
-## v0.0.9 CommandCode protocol update
+### v0.0.9
 
-`opencommand-plugin@0.0.9` updates the bundled proxy to the current CommandCode CLI protocol headers (`x-command-code-version: 0.26.3`, production CLI environment, and OpenCommand project slug). Older `OPENCOMMAND_COMMAND_CODE_CLIENT_VERSION` overrides can no longer downgrade the bundled protocol version.
-## v0.0.10 OpenCode autostart preload
+- CommandCode protocol headers bijgewerkt naar CLI-versie `0.26.3`.
+- Productie CLI-environment en OpenCommand project slug toegevoegd.
 
-`opencommand-plugin@0.0.10` starts the local proxy from the OpenCode config hook so synced `opencode.jsonc` installs do not depend on an absolute local `file://` plugin path. Use `opencommand-plugin@0.0.10` in iCloud/Open sync configs.
+### v0.0.8
 
+- Non-blocking OpenCode startup: cached/static models direct, proxy/plan refresh op de achtergrond.

package/dist/index.d.ts

@@ -38,6 +38,9 @@ interface CookiePair {
     name: string;
     value: string;
 }
+interface CommandCodeCookieExtractor {
+    extractCommandCodeCookie(): Promise<string | undefined>;
+}
 export declare const COMMAND_CODE_GO_PLAN_MODELS: CommandCodeModelDefinition[];
 export declare class ProxyManager {
     private proxyProcess;
@@ -77,12 +80,13 @@ export declare class BrowserCookieExtractor {
 export declare class OpenCommandPlugin {
     private proxyManager;
     private secretStorage;
+    private browserCookieExtractor;
     private startPromise;
     private preloadPromise;
     private readonly commandCodeTokenKey;
     private readonly legacyTokenKey;
     private readonly sessionCookieKey;
-    constructor(proxyBinaryPath?: string, storageDir?: string);
+    constructor(proxyBinaryPath?: string, storageDir?: string, browserCookieExtractor?: CommandCodeCookieExtractor);
     activate(): Promise<void>;
     ensureStarted(): Promise<ProxyConfig | undefined>;
     preloadForOpenCode(): void;
@@ -100,6 +104,7 @@ export declare class OpenCommandPlugin {
     private restartIfPossible;
     getProxyConfig(): string;
 }
+export declare function resolveProxyBinaryPath(): string;
 export declare function fetchOpenCommandModels(baseURL: string): Promise<CommandCodeModelDefinition[] | undefined>;
 export declare function commandCodeModelsForPlan(planID: string): CommandCodeModelDefinition[];
 export declare function fetchCommandCodePlanModels(commandCodeToken: string, apiBaseURL?: string): Promise<CommandCodeModelDefinition[] | undefined>;

package/dist/index.js

@@ -5,11 +5,14 @@ import * as fsp from "fs/promises";
 import * as net from "net";
 import * as os from "os";
 import * as path from "path";
+import { fileURLToPath } from "url";
 const PROVIDER_ID = "opencommand";
 const PROVIDER_NAME = "CommandCode";
 const PROVIDER_API_KEY_PLACEHOLDER = "opencommand";
 const DEFAULT_PROXY_BASE_URL = "http://localhost:3000/v1";
 const COMMAND_CODE_API_BASE_URL = "https://api.commandcode.ai";
+const COMMAND_CODE_CLIENT_VERSION = "0.26.3";
+const COMMAND_CODE_PROJECT_SLUG = "opencommand";
 const MODEL_CACHE_MAX_AGE_MS = 10 * 60 * 1000;
 function isDebugEnabled() {
     return ["1", "true", "yes", "on"].includes((process.env.OPENCOMMAND_DEBUG ?? "").trim().toLowerCase());
@@ -123,7 +126,7 @@ export const COMMAND_CODE_GO_PLAN_MODELS = [
 ];
 const COMMAND_CODE_PREMIUM_MODELS = [
     {
-        id: "anthropic:claude-opus-4-7",
+        id: "claude-opus-4-7",
         name: "Claude Opus 4.7",
         description: "Premium Claude Opus coding and reasoning",
         category: "premium",
@@ -133,7 +136,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "anthropic:claude-opus-4-6",
+        id: "claude-opus-4-6",
         name: "Claude Opus 4.6",
         description: "Premium Claude Opus coding and reasoning",
         category: "premium",
@@ -143,7 +146,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "anthropic:claude-sonnet-4-6",
+        id: "claude-sonnet-4-6",
         name: "Claude Sonnet 4.6",
         description: "Premium Claude Sonnet coding",
         category: "premium",
@@ -153,7 +156,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "anthropic:claude-haiku-4-5-20251001",
+        id: "claude-haiku-4-5-20251001",
         name: "Claude Haiku 4.5",
         description: "Fast premium Claude model",
         category: "premium",
@@ -162,7 +165,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "openai:gpt-5.5",
+        id: "gpt-5.5",
         name: "GPT-5.5",
         description: "Premium OpenAI reasoning model",
         category: "premium",
@@ -172,7 +175,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "openai:gpt-5.4",
+        id: "gpt-5.4",
         name: "GPT-5.4",
         description: "Premium OpenAI coding model",
         category: "premium",
@@ -182,7 +185,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "openai:gpt-5.4-mini",
+        id: "gpt-5.4-mini",
         name: "GPT-5.4 Mini",
         description: "Efficient premium OpenAI coding model",
         category: "premium",
@@ -191,7 +194,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
     {
-        id: "openai:gpt-5.3-codex",
+        id: "gpt-5.3-codex",
         name: "GPT-5.3 Codex",
         description: "Premium OpenAI Codex coding model",
         category: "premium",
@@ -355,10 +358,12 @@ export class SecretStorage {
     }
     async writeStore(store) {
         const dir = path.dirname(this.filePath);
-        await fsp.mkdir(dir, { recursive: true });
+        await fsp.mkdir(dir, { recursive: true, mode: 0o700 });
+        await fsp.chmod(dir, 0o700).catch(() => undefined);
         await fsp.writeFile(this.filePath, JSON.stringify(store, null, 2), {
             mode: 0o600,
         });
+        await fsp.chmod(this.filePath, 0o600).catch(() => undefined);
     }
     async set(key, value) {
         const store = await this.readStore();
@@ -559,11 +564,12 @@ const firefoxCookieQuery = [
     "SELECT host, name, value, '' FROM moz_cookies WHERE host LIKE '%commandcode.ai%';",
 ].join("\n");
 export class OpenCommandPlugin {
-    constructor(proxyBinaryPath = resolveProxyBinaryPath(), storageDir) {
+    constructor(proxyBinaryPath = resolveProxyBinaryPath(), storageDir, browserCookieExtractor = new BrowserCookieExtractor()) {
         this.commandCodeTokenKey = "opencommand.command_code_token";
         this.legacyTokenKey = "opencommand.cc_session_token";
         this.sessionCookieKey = "opencommand.cc_session_cookie";
         this.proxyManager = new ProxyManager(proxyBinaryPath);
+        this.browserCookieExtractor = browserCookieExtractor;
         const dir = storageDir || `${process.env.HOME || "/tmp"}/.opencommand`;
         this.secretStorage = new SecretStorage(dir);
     }
@@ -644,7 +650,21 @@ export class OpenCommandPlugin {
         return token;
     }
     async loadConfiguredSessionCookie() {
-        return firstDefined(process.env.CC_SESSION_COOKIE, await this.secretStorage.get(this.sessionCookieKey));
+        const configuredCookie = firstDefined(process.env.CC_SESSION_COOKIE, await this.secretStorage.get(this.sessionCookieKey));
+        if (configuredCookie)
+            return configuredCookie;
+        try {
+            const browserCookie = await this.browserCookieExtractor.extractCommandCodeCookie();
+            if (!browserCookie)
+                return undefined;
+            await this.secretStorage.set(this.sessionCookieKey, browserCookie);
+            debugLog("✓ CommandCode Studio cookie discovered from local browser storage");
+            return browserCookie;
+        }
+        catch (error) {
+            debugLog("Could not discover CommandCode Studio cookie from browser storage:", error);
+            return undefined;
+        }
     }
     saveOpenCodeConfig(config) {
         const proxyUrl = `http://localhost:${config.port}`;
@@ -704,15 +724,49 @@ function firstDefined(...values) {
     }
     return undefined;
 }
-function resolveProxyBinaryPath() {
+export function resolveProxyBinaryPath() {
+    if (process.env.OPENCOMMAND_PROXY_PATH?.trim()) {
+        return process.env.OPENCOMMAND_PROXY_PATH.trim();
+    }
     const candidates = [
-        process.env.OPENCOMMAND_PROXY_PATH,
+        bundledProxyBinaryPath(),
         path.join(os.homedir(), ".opencommand", "proxy"),
-        path.join(process.cwd(), "packages", "proxy", "proxy"),
+        path.join(process.cwd(), "proxy", "proxy"),
         path.join(process.cwd(), "proxy"),
     ].filter((candidate) => Boolean(candidate));
     return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[candidates.length - 1];
 }
+function bundledProxyBinaryPath() {
+    const goos = process.platform === "win32" ? "windows" : process.platform;
+    const goarch = process.arch === "x64" ? "amd64" : process.arch;
+    if (!isSupportedBundledProxyTarget(goos, goarch))
+        return undefined;
+    const ext = goos === "windows" ? ".exe" : "";
+    const binaryName = `opencommand-proxy-${goos}-${goarch}${ext}`;
+    return path.join(currentModuleDirectory(), "proxy", binaryName);
+}
+function currentModuleDirectory() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+        Error.prepareStackTrace = (_, stack) => stack;
+        const stack = new Error().stack;
+        const fileName = stack.find((frame) => frame.getFileName()?.endsWith(path.join("src", "index.ts")))?.getFileName()
+            ?? stack.find((frame) => frame.getFileName()?.endsWith(path.join("dist", "index.js")))?.getFileName()
+            ?? stack[0]?.getFileName();
+        return fileName ? path.dirname(normalizeStackFileName(fileName)) : process.cwd();
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+}
+function normalizeStackFileName(fileName) {
+    return fileName.startsWith("file:") ? fileURLToPath(fileName) : fileName;
+}
+function isSupportedBundledProxyTarget(goos, goarch) {
+    return ((goos === "darwin" && (goarch === "arm64" || goarch === "amd64")) ||
+        (goos === "linux" && (goarch === "arm64" || goarch === "amd64")) ||
+        (goos === "windows" && goarch === "amd64"));
+}
 function openCodeModelConfig(model) {
     return {
         id: model.id,
@@ -780,6 +834,7 @@ export async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL =
     try {
         const response = await fetch(`${apiBaseURL.replace(/\/$/, "")}/alpha/billing/subscriptions`, {
             headers: {
+                ...commandCodeClientHeaders(),
                 Accept: "application/json",
                 Authorization: `Bearer ${commandCodeToken}`,
             },
@@ -795,6 +850,19 @@ export async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL =
         return undefined;
     }
 }
+function commandCodeClientHeaders() {
+    return {
+        "User-Agent": `CommandCodeCLI/${COMMAND_CODE_CLIENT_VERSION} OpenCommandPlugin`,
+        "X-Command-Code-Version": COMMAND_CODE_CLIENT_VERSION,
+        "X-CLI-Environment": "production",
+        "X-Project-Slug": COMMAND_CODE_PROJECT_SLUG,
+        "X-CommandCode-Client": "cli",
+        "X-CommandCode-Client-Version": COMMAND_CODE_CLIENT_VERSION,
+        "X-CommandCode-CLI-Version": COMMAND_CODE_CLIENT_VERSION,
+        "X-Command-Code-Client-Version": COMMAND_CODE_CLIENT_VERSION,
+        "X-Command-Code-CLI-Version": COMMAND_CODE_CLIENT_VERSION,
+    };
+}
 export function parseCommandCodePlanID(body) {
     const root = body;
     if (typeof root?.planId === "string" && root.planId.trim())
@@ -871,6 +939,29 @@ function writeCachedOpenCommandModels(models) {
 function openCommandModelCachePath() {
     return path.join(process.env.HOME || "/tmp", ".opencommand", "model-cache.json");
 }
+function proxyBaseURLForRegistration() {
+    const runtimeConfig = runtimePlugin?.getCurrentProxyConfig();
+    if (runtimeConfig)
+        return `http://localhost:${runtimeConfig.port}/v1`;
+    const persistedBaseURL = readPersistedProxyBaseURL();
+    return persistedBaseURL ?? DEFAULT_PROXY_BASE_URL;
+}
+function readPersistedProxyBaseURL() {
+    try {
+        const configPath = path.join(process.env.HOME || "/tmp", ".opencommand", "proxy-config.json");
+        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (typeof config.port === "number" && Number.isInteger(config.port) && config.port > 0 && config.port < 65536) {
+            return `http://localhost:${config.port}/v1`;
+        }
+        if (typeof config.url === "string" && config.url.trim()) {
+            return `${config.url.replace(/\/$/, "")}/v1`;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
 function parseProxyPort(value) {
     const port = Number(value);
     return Number.isInteger(port) && port > 0 && port < 65536 ? port : undefined;
@@ -880,35 +971,43 @@ function getRuntimePlugin() {
     runtimePlugin ?? (runtimePlugin = new OpenCommandPlugin());
     return runtimePlugin;
 }
-export const OpenCommandOpenCodePlugin = async () => ({
-    provider: {
-        [PROVIDER_ID]: {
-            npm: "@ai-sdk/openai-compatible",
-            name: PROVIDER_NAME,
-            options: {
-                apiKey: PROVIDER_API_KEY_PLACEHOLDER,
-                baseURL: DEFAULT_PROXY_BASE_URL,
+export const OpenCommandOpenCodePlugin = async () => {
+    const baseURL = proxyBaseURLForRegistration();
+    return {
+        provider: {
+            [PROVIDER_ID]: {
+                npm: "@ai-sdk/openai-compatible",
+                name: PROVIDER_NAME,
+                options: {
+                    apiKey: PROVIDER_API_KEY_PLACEHOLDER,
+                    baseURL,
+                },
+                models: Object.fromEntries(COMMAND_CODE_GO_PLAN_MODELS.map((model) => [model.id, openCodeModelConfig(model)])),
             },
-            models: Object.fromEntries(COMMAND_CODE_GO_PLAN_MODELS.map((model) => [model.id, openCodeModelConfig(model)])),
         },
-    },
-    auth: {
-        provider: PROVIDER_ID,
-        loader: async () => {
-            const proxyConfig = await getRuntimePlugin().ensureStarted();
-            if (!proxyConfig)
-                return null;
-            return {
-                apiKey: PROVIDER_API_KEY_PLACEHOLDER,
-                baseURL: `http://localhost:${proxyConfig.port}/v1`,
-            };
+        auth: {
+            provider: PROVIDER_ID,
+            loader: async () => {
+                const proxyConfig = await getRuntimePlugin().ensureStarted();
+                if (!proxyConfig)
+                    return null;
+                return {
+                    apiKey: PROVIDER_API_KEY_PLACEHOLDER,
+                    baseURL: `http://localhost:${proxyConfig.port}/v1`,
+                };
+            },
+            methods: [],
         },
-        methods: [],
-    },
-    config: async (config) => {
-        getRuntimePlugin().preloadForOpenCode();
-        registerOpenCommandProvider(config, DEFAULT_PROXY_BASE_URL, readCachedOpenCommandModels() ?? COMMAND_CODE_GO_PLAN_MODELS);
-    },
-});
+        config: async (config) => {
+            const plugin = getRuntimePlugin();
+            plugin.preloadForOpenCode();
+            const currentConfig = plugin.getCurrentProxyConfig();
+            const registrationBaseURL = currentConfig
+                ? `http://localhost:${currentConfig.port}/v1`
+                : proxyBaseURLForRegistration();
+            registerOpenCommandProvider(config, registrationBaseURL, readCachedOpenCommandModels() ?? COMMAND_CODE_GO_PLAN_MODELS);
+        },
+    };
+};
 export default OpenCommandOpenCodePlugin;
 export { OpenCommandOpenCodePlugin as opencommandPlugin };

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "opencommand-plugin",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "OpenCommand - CommandCode API Plugin for OpenCode",
   "main": "./bin/opencode-plugin.js",
   "module": "./bin/opencode-plugin.js",
   "scripts": {
     "build": "tsc",
+    "build:proxy": "node scripts/build-proxy-binaries.mjs",
     "test": "jest --config jest.config.cjs",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
-    "prepack": "npm run build"
+    "prepack": "npm run build && npm run build:proxy"
   },
   "keywords": [
     "opencode",
@@ -26,9 +27,7 @@
     "ts-jest": "^29.0.0",
     "typescript": "^5.0.0"
   },
-  "dependencies": {
-    "node-fetch": "^3.0.0"
-  },
+  "dependencies": {},
   "files": [
     "dist/**",
     "bin/**",