opencommand-plugin 0.0.4 → 0.0.6

package/README.md

@@ -46,3 +46,8 @@ npm run build
 ```bash
 npm test -- --runInBand
 ```
+
+## v0.0.6 non-blocking OpenCode startup
+
+`opencommand-plugin@0.0.6` 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.6` (or newer) instead of `@latest` to avoid stale plugin cache entries.
+

package/bin/opencode-plugin.js

@@ -0,0 +1,3 @@
+import plugin from '../dist/index.js';
+
+export default plugin;

package/dist/index.d.ts

@@ -46,6 +46,7 @@ export declare class ProxyManager {
     constructor(binaryPath?: string);
     findAvailablePort(): Promise<number>;
     start(startConfig: ProxyStartConfig): Promise<ProxyConfig>;
+    private isPortAvailable;
     stop(): Promise<void>;
     private waitForHealthz;
     getConfig(): ProxyConfig | null;
@@ -77,13 +78,19 @@ export declare class OpenCommandPlugin {
     private proxyManager;
     private secretStorage;
     private cookieExtractor;
+    private startPromise;
+    private preloadPromise;
     private readonly commandCodeTokenKey;
     private readonly legacyTokenKey;
     private readonly sessionCookieKey;
     constructor(proxyBinaryPath?: string, storageDir?: string);
     activate(): Promise<void>;
     ensureStarted(): Promise<ProxyConfig | undefined>;
+    preloadForOpenCode(): void;
+    private preload;
+    private startProxy;
     deactivate(): Promise<void>;
+    getCurrentProxyConfig(): ProxyConfig | undefined;
     private loadCommandCodeToken;
     private loadSessionCookie;
     private saveOpenCodeConfig;
@@ -99,15 +106,30 @@ export declare function commandCodeModelsForPlan(planID: string): CommandCodeMod
 export declare function fetchCommandCodePlanModels(commandCodeToken: string, apiBaseURL?: string): Promise<CommandCodeModelDefinition[] | undefined>;
 export declare function parseCommandCodePlanID(body: unknown): string | undefined;
 export declare function registerOpenCommandProvider(config: OpenCodeConfig, baseURL?: string, modelDefinitions?: CommandCodeModelDefinition[]): void;
+export declare function readCachedOpenCommandModels(maxAgeMs?: number): CommandCodeModelDefinition[] | undefined;
 export declare const OpenCommandOpenCodePlugin: () => Promise<{
+    provider: {
+        opencommand: {
+            npm: string;
+            name: string;
+            options: {
+                apiKey: string;
+                baseURL: string;
+            };
+            models: {
+                [k: string]: Record<string, unknown>;
+            };
+        };
+    };
     auth: {
         provider: string;
         loader: () => Promise<{
             apiKey: string;
             baseURL: string;
-        } | null>;
+        }>;
         methods: never[];
     };
     config: (config: OpenCodeConfig) => Promise<void>;
 }>;
 export default OpenCommandOpenCodePlugin;
+export { OpenCommandOpenCodePlugin as opencommandPlugin };

package/dist/index.js

@@ -1,57 +1,32 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenCommandOpenCodePlugin = exports.OpenCommandPlugin = exports.BrowserCookieExtractor = exports.SecretStorage = exports.ProxyManager = exports.COMMAND_CODE_GO_PLAN_MODELS = void 0;
-exports.fetchOpenCommandModels = fetchOpenCommandModels;
-exports.commandCodeModelsForPlan = commandCodeModelsForPlan;
-exports.fetchCommandCodePlanModels = fetchCommandCodePlanModels;
-exports.parseCommandCodePlanID = parseCommandCodePlanID;
-exports.registerOpenCommandProvider = registerOpenCommandProvider;
-const cp = __importStar(require("child_process"));
-const crypto = __importStar(require("crypto"));
-const fs = __importStar(require("fs"));
-const fsp = __importStar(require("fs/promises"));
-const net = __importStar(require("net"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
+import * as cp from "child_process";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as fsp from "fs/promises";
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
 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";
-exports.COMMAND_CODE_GO_PLAN_MODELS = [
+const MODEL_CACHE_MAX_AGE_MS = 10 * 60 * 1000;
+function isDebugEnabled() {
+    return ["1", "true", "yes", "on"].includes((process.env.OPENCOMMAND_DEBUG ?? "").trim().toLowerCase());
+}
+function debugLog(...args) {
+    if (isDebugEnabled())
+        console.log(...args);
+}
+function debugWarn(...args) {
+    if (isDebugEnabled())
+        console.warn(...args);
+}
+function debugError(...args) {
+    if (isDebugEnabled())
+        console.error(...args);
+}
+export const COMMAND_CODE_GO_PLAN_MODELS = [
     {
         id: "deepseek/deepseek-v4-pro",
         name: "DeepSeek V4 Pro",
@@ -226,7 +201,7 @@ const COMMAND_CODE_PREMIUM_MODELS = [
         cost: { input: 0, output: 0 },
     },
 ];
-class ProxyManager {
+export class ProxyManager {
     constructor(binaryPath = resolveProxyBinaryPath()) {
         this.proxyProcess = null;
         this.config = null;
@@ -247,7 +222,10 @@ class ProxyManager {
         });
     }
     async start(startConfig) {
-        const port = await this.findAvailablePort();
+        const preferredPort = parseProxyPort(process.env.OPENCOMMAND_PROXY_PORT) ?? 3000;
+        const port = (await this.isPortAvailable(preferredPort))
+            ? preferredPort
+            : await this.findAvailablePort();
         this.config = {
             port,
             commandCodeToken: startConfig.commandCodeToken,
@@ -263,20 +241,32 @@ class ProxyManager {
         if (startConfig.sessionCookie) {
             env.CC_SESSION_COOKIE = startConfig.sessionCookie;
         }
+        const debug = isDebugEnabled();
         this.proxyProcess = cp.spawn(this.proxyBinaryPath, [], {
             env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        this.proxyProcess.stdout?.on("data", (data) => {
-            console.log(`[Proxy stdout] ${data}`);
-        });
-        this.proxyProcess.stderr?.on("data", (data) => {
-            console.error(`[Proxy stderr] ${data}`);
+            stdio: ["ignore", debug ? "pipe" : "ignore", debug ? "pipe" : "ignore"],
         });
+        if (debug) {
+            this.proxyProcess.stdout?.on("data", (data) => {
+                debugLog(`[Proxy stdout] ${data}`);
+            });
+            this.proxyProcess.stderr?.on("data", (data) => {
+                debugError(`[Proxy stderr] ${data}`);
+            });
+        }
         await this.waitForHealthz(port, 30000);
-        console.log(`✓ Proxy started on port ${port}`);
+        debugLog(`✓ Proxy started on port ${port}`);
         return this.config;
     }
+    async isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.once("error", () => resolve(false));
+            server.listen(port, () => {
+                server.close(() => resolve(true));
+            });
+        });
+    }
     async stop() {
         const proc = this.proxyProcess;
         if (!proc)
@@ -292,7 +282,7 @@ class ProxyManager {
             };
             proc.once("exit", finish);
             proc.once("error", (error) => {
-                console.error("Proxy process error while stopping:", error);
+                debugError("Proxy process error while stopping:", error);
                 finish();
             });
             try {
@@ -300,7 +290,7 @@ class ProxyManager {
                     proc.kill("SIGTERM");
             }
             catch (error) {
-                console.error("Failed to send SIGTERM to proxy process:", error);
+                debugError("Failed to send SIGTERM to proxy process:", error);
                 finish();
                 return;
             }
@@ -310,7 +300,7 @@ class ProxyManager {
                         proc.kill("SIGKILL");
                     }
                     catch (error) {
-                        console.error("Failed to send SIGKILL to proxy process:", error);
+                        debugError("Failed to send SIGKILL to proxy process:", error);
                     }
                 }
                 finish();
@@ -331,7 +321,7 @@ class ProxyManager {
                     return;
             }
             catch (err) {
-                console.debug(`Health check attempt failed for port ${port}:`, err);
+                debugLog(`Health check attempt failed for port ${port}:`, err);
             }
             await new Promise((r) => setTimeout(r, 500));
         }
@@ -347,8 +337,7 @@ class ProxyManager {
         return this.proxyProcess !== null && !this.proxyProcess.killed;
     }
 }
-exports.ProxyManager = ProxyManager;
-class SecretStorage {
+export class SecretStorage {
     constructor(storageDir = `${process.env.HOME || "/tmp"}/.opencommand`) {
         this.filePath = `${storageDir}/opencommand-secrets.json`;
     }
@@ -359,7 +348,7 @@ class SecretStorage {
         }
         catch (error) {
             if (error.code !== "ENOENT") {
-                console.debug("Could not read OpenCommand secret store:", error);
+                debugLog("Could not read OpenCommand secret store:", error);
             }
             return {};
         }
@@ -386,8 +375,7 @@ class SecretStorage {
         await this.writeStore(store);
     }
 }
-exports.SecretStorage = SecretStorage;
-class BrowserCookieExtractor {
+export class BrowserCookieExtractor {
     constructor(homeDir = os.homedir()) {
         this.homeDir = homeDir;
     }
@@ -481,7 +469,8 @@ class BrowserCookieExtractor {
         try {
             fs.copyFileSync(profile.cookieDatabase, tmpDb);
             const query = profile.browser === "Firefox" ? firefoxCookieQuery : chromiumCookieQuery;
-            const output = cp.execFileSync("/usr/bin/sqlite3", [tmpDb, query], {
+            const output = cp.execFileSync("/usr/bin/sqlite3", [tmpDb], {
+                input: query,
                 encoding: "utf8",
                 timeout: 5000,
             });
@@ -501,7 +490,7 @@ class BrowserCookieExtractor {
             });
         }
         catch (error) {
-            console.debug(`Could not read ${profile.browser} cookies:`, error);
+            debugLog(`Could not read ${profile.browser} cookies:`, error);
             return [];
         }
         finally {
@@ -548,7 +537,6 @@ class BrowserCookieExtractor {
         }
     }
 }
-exports.BrowserCookieExtractor = BrowserCookieExtractor;
 function decryptMacChromiumCookie(encryptedValue, safeStoragePassword) {
     try {
         const payload = encryptedValue.subarray(0, 3).toString() === "v10"
@@ -570,7 +558,7 @@ const firefoxCookieQuery = [
     ".mode tabs",
     "SELECT host, name, value, '' FROM moz_cookies WHERE host LIKE '%commandcode.ai%';",
 ].join("\n");
-class OpenCommandPlugin {
+export class OpenCommandPlugin {
     constructor(proxyBinaryPath = resolveProxyBinaryPath(), storageDir) {
         this.commandCodeTokenKey = "opencommand.command_code_token";
         this.legacyTokenKey = "opencommand.cc_session_token";
@@ -581,28 +569,61 @@ class OpenCommandPlugin {
         this.cookieExtractor = new BrowserCookieExtractor();
     }
     async activate() {
-        console.log("OpenCommand Plugin activating...");
+        debugLog("OpenCommand Plugin activating...");
         try {
             const config = await this.ensureStarted();
             if (config)
-                console.log(`✓ OpenCommand proxy ready at ${config.port}`);
+                debugLog(`✓ OpenCommand proxy ready at ${config.port}`);
         }
         catch (error) {
-            console.error("Failed to start proxy:", error);
+            debugError("Failed to start proxy:", error);
         }
     }
     async ensureStarted() {
+        const existingConfig = this.proxyManager.getConfig();
+        if (existingConfig && this.proxyManager.isRunning())
+            return existingConfig;
+        this.startPromise ?? (this.startPromise = this.startProxy());
+        try {
+            return await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
+    }
+    preloadForOpenCode() {
+        if (this.preloadPromise)
+            return;
+        this.preloadPromise = this.preload()
+            .catch((error) => {
+            debugLog("OpenCommand background preload failed:", error);
+        })
+            .finally(() => {
+            this.preloadPromise = undefined;
+        });
+    }
+    async preload() {
+        const proxyConfig = await this.ensureStarted();
+        if (!proxyConfig)
+            return;
+        const baseURL = `http://localhost:${proxyConfig.port}/v1`;
+        const models = (await fetchCommandCodePlanModels(proxyConfig.commandCodeToken)) ??
+            (await fetchOpenCommandModels(baseURL));
+        if (models)
+            writeCachedOpenCommandModels(models);
+    }
+    async startProxy() {
         const existingConfig = this.proxyManager.getConfig();
         if (existingConfig && this.proxyManager.isRunning())
             return existingConfig;
         const commandCodeToken = await this.loadCommandCodeToken();
         if (!commandCodeToken) {
-            console.warn("No COMMAND_CODE_TOKEN found. Please configure your CommandCode API key.");
+            debugWarn("No COMMAND_CODE_TOKEN found. Please configure your CommandCode API key.");
             return undefined;
         }
         const sessionCookie = await this.loadSessionCookie();
         if (!sessionCookie) {
-            console.warn("No CommandCode Studio cookie found. Inference works, but usage scraping may be unavailable.");
+            debugWarn("No CommandCode Studio cookie found. Inference works, but usage scraping may be unavailable.");
         }
         const config = await this.proxyManager.start({
             commandCodeToken,
@@ -612,9 +633,12 @@ class OpenCommandPlugin {
         return config;
     }
     async deactivate() {
-        console.log("OpenCommand Plugin deactivating...");
+        debugLog("OpenCommand Plugin deactivating...");
         await this.proxyManager.stop();
-        console.log("✓ Proxy stopped");
+        debugLog("✓ Proxy stopped");
+    }
+    getCurrentProxyConfig() {
+        return this.proxyManager.getConfig() ?? undefined;
     }
     async loadCommandCodeToken() {
         const token = firstDefined(process.env.COMMAND_CODE_TOKEN, process.env.COMMANDCODE_API_KEY, await this.secretStorage.get(this.commandCodeTokenKey), await this.secretStorage.get(this.legacyTokenKey));
@@ -630,13 +654,13 @@ class OpenCommandPlugin {
         const extracted = await this.cookieExtractor.extractCommandCodeCookie();
         if (extracted) {
             await this.secretStorage.set(this.sessionCookieKey, extracted);
-            console.log("✓ CommandCode Studio cookie discovered from local browser profile");
+            debugLog("✓ CommandCode Studio cookie discovered from local browser profile");
         }
         return extracted;
     }
     saveOpenCodeConfig(config) {
         const proxyUrl = `http://localhost:${config.port}`;
-        console.log("Proxy configuration saved:", {
+        debugLog("Proxy configuration saved:", {
             opencommand: { proxyUrl, apiBaseUrl: `${proxyUrl}/v1` },
         });
         this.persistProxyConfig(proxyUrl, config.port);
@@ -647,15 +671,15 @@ class OpenCommandPlugin {
         try {
             fs.mkdirSync(configDir, { recursive: true });
             fs.writeFileSync(configPath, JSON.stringify({ url, port, updatedAt: new Date().toISOString() }, null, 2), { mode: 0o644 });
-            console.log(`✓ Proxy config persisted to ${configPath}`);
+            debugLog(`✓ Proxy config persisted to ${configPath}`);
         }
         catch (err) {
-            console.error("Failed to persist proxy config:", err);
+            debugError("Failed to persist proxy config:", err);
         }
     }
     async setCommandCodeToken(token) {
         await this.secretStorage.set(this.commandCodeTokenKey, token);
-        console.log("✓ CommandCode API key saved securely");
+        debugLog("✓ CommandCode API key saved securely");
         await this.restartIfPossible();
     }
     async setSessionToken(token) {
@@ -663,7 +687,7 @@ class OpenCommandPlugin {
     }
     async setSessionCookie(cookie) {
         await this.secretStorage.set(this.sessionCookieKey, cookie);
-        console.log("✓ CommandCode Studio cookie saved securely");
+        debugLog("✓ CommandCode Studio cookie saved securely");
         await this.restartIfPossible();
     }
     async restartIfPossible() {
@@ -684,7 +708,6 @@ class OpenCommandPlugin {
         return JSON.stringify(config, null, 2);
     }
 }
-exports.OpenCommandPlugin = OpenCommandPlugin;
 function firstDefined(...values) {
     for (const value of values) {
         const trimmed = value?.trim();
@@ -698,7 +721,7 @@ function resolveProxyBinaryPath() {
         process.env.OPENCOMMAND_PROXY_PATH,
         path.join(os.homedir(), ".opencommand", "proxy"),
         path.join(process.cwd(), "packages", "proxy", "proxy"),
-        path.join(__dirname, "proxy"),
+        path.join(process.cwd(), "proxy"),
     ].filter((candidate) => Boolean(candidate));
     return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[candidates.length - 1];
 }
@@ -736,7 +759,7 @@ function modelFromProxy(model) {
         cost: model.cost ?? { input: 0, output: 0 },
     };
 }
-async function fetchOpenCommandModels(baseURL) {
+export async function fetchOpenCommandModels(baseURL) {
     try {
         const response = await fetch(`${baseURL.replace(/\/$/, "")}/models`, {
             headers: { Authorization: `Bearer ${PROVIDER_API_KEY_PLACEHOLDER}` },
@@ -750,12 +773,12 @@ async function fetchOpenCommandModels(baseURL) {
         return models.length > 0 ? models : undefined;
     }
     catch (error) {
-        console.debug("Could not fetch OpenCommand models from local proxy:", error);
+        debugLog("Could not fetch OpenCommand models from local proxy:", error);
         return undefined;
     }
 }
-function commandCodeModelsForPlan(planID) {
-    const models = [...exports.COMMAND_CODE_GO_PLAN_MODELS];
+export function commandCodeModelsForPlan(planID) {
+    const models = [...COMMAND_CODE_GO_PLAN_MODELS];
     if (!planCanUsePremium(planID))
         return models;
     for (const model of COMMAND_CODE_PREMIUM_MODELS) {
@@ -765,7 +788,7 @@ function commandCodeModelsForPlan(planID) {
     }
     return models;
 }
-async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL = COMMAND_CODE_API_BASE_URL) {
+export async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL = COMMAND_CODE_API_BASE_URL) {
     try {
         const response = await fetch(`${apiBaseURL.replace(/\/$/, "")}/alpha/billing/subscriptions`, {
             headers: {
@@ -780,11 +803,11 @@ async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL = COMMAND
         return planID ? commandCodeModelsForPlan(planID) : undefined;
     }
     catch (error) {
-        console.debug("Could not detect CommandCode plan for model registration:", error);
+        debugLog("Could not detect CommandCode plan for model registration:", error);
         return undefined;
     }
 }
-function parseCommandCodePlanID(body) {
+export function parseCommandCodePlanID(body) {
     const root = body;
     if (typeof root?.planId === "string" && root.planId.trim())
         return root.planId.trim();
@@ -813,7 +836,7 @@ function planCanUseOpus(planID) {
 function isOpusModel(modelID) {
     return modelID.toLowerCase().includes("opus");
 }
-function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL, modelDefinitions = exports.COMMAND_CODE_GO_PLAN_MODELS) {
+export function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL, modelDefinitions = COMMAND_CODE_GO_PLAN_MODELS) {
     const models = {};
     for (const model of modelDefinitions) {
         models[model.id] = openCodeModelConfig(model);
@@ -831,37 +854,75 @@ function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL, m
         },
     };
 }
+export function readCachedOpenCommandModels(maxAgeMs = MODEL_CACHE_MAX_AGE_MS) {
+    try {
+        const raw = fs.readFileSync(openCommandModelCachePath(), "utf8");
+        const cache = JSON.parse(raw);
+        if (!cache.updatedAt || !Array.isArray(cache.models))
+            return undefined;
+        const updatedAt = Date.parse(cache.updatedAt);
+        if (!Number.isFinite(updatedAt) || Date.now() - updatedAt > maxAgeMs) {
+            return undefined;
+        }
+        return cache.models.length > 0 ? cache.models : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCachedOpenCommandModels(models) {
+    try {
+        const cachePath = openCommandModelCachePath();
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, JSON.stringify({ updatedAt: new Date().toISOString(), models }, null, 2), { mode: 0o644 });
+    }
+    catch (error) {
+        debugLog("Could not write OpenCommand model cache:", error);
+    }
+}
+function openCommandModelCachePath() {
+    return path.join(process.env.HOME || "/tmp", ".opencommand", "model-cache.json");
+}
+function parseProxyPort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : undefined;
+}
 let runtimePlugin;
 function getRuntimePlugin() {
     runtimePlugin ?? (runtimePlugin = new OpenCommandPlugin());
     return runtimePlugin;
 }
-const OpenCommandOpenCodePlugin = async () => ({
+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,
+            },
+            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;
+            const runtime = getRuntimePlugin();
+            const proxyConfig = runtime.getCurrentProxyConfig();
+            runtime.preloadForOpenCode();
             return {
                 apiKey: PROVIDER_API_KEY_PLACEHOLDER,
-                baseURL: `http://localhost:${proxyConfig.port}/v1`,
+                baseURL: proxyConfig
+                    ? `http://localhost:${proxyConfig.port}/v1`
+                    : DEFAULT_PROXY_BASE_URL,
             };
         },
         methods: [],
     },
     config: async (config) => {
-        let baseURL = DEFAULT_PROXY_BASE_URL;
-        let models;
-        const proxyConfig = await getRuntimePlugin().ensureStarted();
-        if (proxyConfig) {
-            baseURL = `http://localhost:${proxyConfig.port}/v1`;
-            models =
-                (await fetchCommandCodePlanModels(proxyConfig.commandCodeToken)) ??
-                    (await fetchOpenCommandModels(baseURL));
-        }
-        registerOpenCommandProvider(config, baseURL, models ?? exports.COMMAND_CODE_GO_PLAN_MODELS);
+        registerOpenCommandProvider(config, DEFAULT_PROXY_BASE_URL, readCachedOpenCommandModels() ?? COMMAND_CODE_GO_PLAN_MODELS);
+        getRuntimePlugin().preloadForOpenCode();
     },
 });
-exports.OpenCommandOpenCodePlugin = OpenCommandOpenCodePlugin;
-exports.default = exports.OpenCommandOpenCodePlugin;
+export default OpenCommandOpenCodePlugin;
+export { OpenCommandOpenCodePlugin as opencommandPlugin };

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "opencommand-plugin",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "OpenCommand - CommandCode API Plugin for OpenCode",
-  "main": "dist/index.js",
+  "main": "./bin/opencode-plugin.js",
+  "module": "./bin/opencode-plugin.js",
   "scripts": {
     "build": "tsc",
     "test": "jest",
@@ -30,7 +31,20 @@
   },
   "files": [
     "dist/**",
+    "bin/**",
     "README.md",
     "package.json"
-  ]
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./bin/opencode-plugin.js"
+    },
+    "./dist/index.js": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  }
 }