opencommand-plugin 0.0.5 → 0.0.6

package/README.md

@@ -47,7 +47,7 @@ npm run build
 npm test -- --runInBand
 ```
 
-## v0.0.5 OpenCode loading fix
+## v0.0.6 non-blocking OpenCode startup
 
-`opencommand-plugin@0.0.5` publishes an explicit ESM wrapper at `bin/opencode-plugin.js` and should be pinned in `opencode.jsonc` as `opencommand-plugin@0.0.5` (or newer). This avoids stale `@latest` cache entries and ensures OpenCode sees the plugin default export as a function.
+`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/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,6 +106,7 @@ 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: {
@@ -118,7 +126,7 @@ export declare const OpenCommandOpenCodePlugin: () => Promise<{
         loader: () => Promise<{
             apiKey: string;
             baseURL: string;
-        } | null>;
+        }>;
         methods: never[];
     };
     config: (config: OpenCodeConfig) => Promise<void>;

package/dist/index.js

@@ -10,6 +10,22 @@ 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 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",
@@ -206,7 +222,10 @@ export 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,
@@ -222,20 +241,32 @@ export 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)
@@ -251,7 +282,7 @@ export 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 {
@@ -259,7 +290,7 @@ export 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;
             }
@@ -269,7 +300,7 @@ export 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();
@@ -290,7 +321,7 @@ export 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));
         }
@@ -317,7 +348,7 @@ export 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 {};
         }
@@ -459,7 +490,7 @@ export class BrowserCookieExtractor {
             });
         }
         catch (error) {
-            console.debug(`Could not read ${profile.browser} cookies:`, error);
+            debugLog(`Could not read ${profile.browser} cookies:`, error);
             return [];
         }
         finally {
@@ -538,28 +569,61 @@ export 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,
@@ -569,9 +633,12 @@ export 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));
@@ -587,13 +654,13 @@ export 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);
@@ -604,15 +671,15 @@ export 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) {
@@ -620,7 +687,7 @@ export 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() {
@@ -654,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];
 }
@@ -706,7 +773,7 @@ export 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;
     }
 }
@@ -736,7 +803,7 @@ export async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL =
         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;
     }
 }
@@ -787,6 +854,39 @@ export function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE
         },
     };
 }
+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());
@@ -807,27 +907,21 @@ export const OpenCommandOpenCodePlugin = async () => ({
     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 ?? COMMAND_CODE_GO_PLAN_MODELS);
+        registerOpenCommandProvider(config, DEFAULT_PROXY_BASE_URL, readCachedOpenCommandModels() ?? COMMAND_CODE_GO_PLAN_MODELS);
+        getRuntimePlugin().preloadForOpenCode();
     },
 });
 export default OpenCommandOpenCodePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencommand-plugin",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "OpenCommand - CommandCode API Plugin for OpenCode",
   "main": "./bin/opencode-plugin.js",
   "module": "./bin/opencode-plugin.js",