opencommand-plugin 0.0.3 → 0.0.5

package/README.md

@@ -1,80 +1,53 @@
-# OpenCommand Plugin - OpenCode Integration
+# OpenCommand Plugin
 
-Plugin for OpenCode that manages the CommandCode proxy lifecycle.
+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.
 
 ## Features
 
-- ✅ Automatic proxy startup on editor launch
-- ✅ Dynamic port allocation (no conflicts)
-- ✅ Secure session token storage via SecretStorage
-- ✅ Health checks (proxy readiness verification)
-- ✅ Graceful shutdown on editor close
-- ✅ Configuration export to OpenCode
+- 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.
 
-## Architecture
+## Auth
 
-### ProxyManager
-Handles proxy process lifecycle:
-- Start/stop proxy on dynamic port
-- Health check polling
-- Process signal handling
+Primary token key:
 
-### SecretStorage
-Secure credential management:
-- Store CC_SESSION_COOKIE securely
-- Retrieve only when needed
-- Mock implementation (real version uses OpenCode API)
+```json
+{
+  "opencommand.command_code_token": "user_xxx..."
+}
+```
 
-### OpenCommandPlugin
-Main plugin interface:
-- activate() - Initialize on editor startup
-- deactivate() - Clean up on shutdown
-- setSessionToken() - Configure CommandCode credentials
-- getProxyConfig() - Get current config
+Do not put this token in synced `opencode.jsonc`.
 
-## Building
+## Models in v0.0.4
 
-```bash
-npm install
-npm run build
-```
+The proxy detects the active CommandCode subscription through `/alpha/billing/subscriptions` and filters models:
 
-## Testing
+- Go: open-source models only.
+- Pro: open-source + premium, excluding Opus.
+- Max / Ultra / Teams Pro: open-source + premium including Opus.
 
-```bash
-npm test
-```
+If detection fails, the plugin falls back to the local proxy model endpoint and then to the Go/open-source model list.
 
-## Usage
+## Build
 
-1. User installs plugin in OpenCode
-2. Plugin prompts for CC_SESSION_COOKIE
-3. On startup:
-   - Token retrieved from SecretStorage
-   - Proxy started on random available port
-   - Configuration saved to OpenCode
-   - Clients use http://localhost:PORT/v1 for API calls
-4. On shutdown:
-   - Proxy process terminated gracefully
-   - SIGTERM → wait 5s → SIGKILL
-
-## Configuration
+```bash
+npm ci
+npm run build
+```
 
-The plugin exports this configuration to OpenCode:
+## Test
 
-```json
-{
-  "opencommand": {
-    "proxyUrl": "http://localhost:3001",
-    "apiBaseUrl": "http://localhost:3001/v1"
-  }
-}
+```bash
+npm test -- --runInBand
 ```
 
-OpenCode and other clients use this to route requests to the proxy.
+## v0.0.5 OpenCode loading fix
 
-## Related Issues
+`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.
 
-- Fase 2 Implementation (#2)
-- Depends on: Proxy Core (Fase 1)
-- Prepares for: Cookie Scraper (Fase 3)

package/bin/opencode-plugin.js

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

package/dist/index.d.ts

@@ -11,6 +11,7 @@ interface CommandCodeModelDefinition {
     id: string;
     name: string;
     description: string;
+    category?: string;
     reasoning?: boolean;
     context: number;
     output: number;
@@ -93,8 +94,25 @@ export declare class OpenCommandPlugin {
     private restartIfPossible;
     getProxyConfig(): string;
 }
-export declare function registerOpenCommandProvider(config: OpenCodeConfig, baseURL?: string): void;
+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>;
+export declare function parseCommandCodePlanID(body: unknown): string | undefined;
+export declare function registerOpenCommandProvider(config: OpenCodeConfig, baseURL?: string, modelDefinitions?: CommandCodeModelDefinition[]): void;
 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<{
@@ -106,3 +124,4 @@ export declare const OpenCommandOpenCodePlugin: () => Promise<{
     config: (config: OpenCodeConfig) => Promise<void>;
 }>;
 export default OpenCommandOpenCodePlugin;
+export { OpenCommandOpenCodePlugin as opencommandPlugin };

package/dist/index.js

@@ -1,52 +1,16 @@
-"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.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";
-exports.COMMAND_CODE_GO_PLAN_MODELS = [
+const COMMAND_CODE_API_BASE_URL = "https://api.commandcode.ai";
+export const COMMAND_CODE_GO_PLAN_MODELS = [
     {
         id: "deepseek/deepseek-v4-pro",
         name: "DeepSeek V4 Pro",
@@ -141,7 +105,87 @@ exports.COMMAND_CODE_GO_PLAN_MODELS = [
         cost: { input: 0.1, output: 0.3, cache_read: 0.02 },
     },
 ];
-class ProxyManager {
+const COMMAND_CODE_PREMIUM_MODELS = [
+    {
+        id: "anthropic:claude-opus-4-7",
+        name: "Claude Opus 4.7",
+        description: "Premium Claude Opus coding and reasoning",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "anthropic:claude-opus-4-6",
+        name: "Claude Opus 4.6",
+        description: "Premium Claude Opus coding and reasoning",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "anthropic:claude-sonnet-4-6",
+        name: "Claude Sonnet 4.6",
+        description: "Premium Claude Sonnet coding",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "anthropic:claude-haiku-4-5-20251001",
+        name: "Claude Haiku 4.5",
+        description: "Fast premium Claude model",
+        category: "premium",
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "openai:gpt-5.5",
+        name: "GPT-5.5",
+        description: "Premium OpenAI reasoning model",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "openai:gpt-5.4",
+        name: "GPT-5.4",
+        description: "Premium OpenAI coding model",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "openai:gpt-5.4-mini",
+        name: "GPT-5.4 Mini",
+        description: "Efficient premium OpenAI coding model",
+        category: "premium",
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+    {
+        id: "openai:gpt-5.3-codex",
+        name: "GPT-5.3 Codex",
+        description: "Premium OpenAI Codex coding model",
+        category: "premium",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0, output: 0 },
+    },
+];
+export class ProxyManager {
     constructor(binaryPath = resolveProxyBinaryPath()) {
         this.proxyProcess = null;
         this.config = null;
@@ -262,8 +306,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`;
     }
@@ -301,8 +344,7 @@ class SecretStorage {
         await this.writeStore(store);
     }
 }
-exports.SecretStorage = SecretStorage;
-class BrowserCookieExtractor {
+export class BrowserCookieExtractor {
     constructor(homeDir = os.homedir()) {
         this.homeDir = homeDir;
     }
@@ -396,7 +438,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,
             });
@@ -463,7 +506,6 @@ class BrowserCookieExtractor {
         }
     }
 }
-exports.BrowserCookieExtractor = BrowserCookieExtractor;
 function decryptMacChromiumCookie(encryptedValue, safeStoragePassword) {
     try {
         const payload = encryptedValue.subarray(0, 3).toString() === "v10"
@@ -485,7 +527,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";
@@ -599,7 +641,6 @@ class OpenCommandPlugin {
         return JSON.stringify(config, null, 2);
     }
 }
-exports.OpenCommandPlugin = OpenCommandPlugin;
 function firstDefined(...values) {
     for (const value of values) {
         const trimmed = value?.trim();
@@ -622,6 +663,7 @@ function openCodeModelConfig(model) {
         id: model.id,
         name: model.name,
         description: model.description,
+        category: model.category ?? "opensource",
         reasoning: model.reasoning ?? false,
         tool_call: true,
         attachment: false,
@@ -636,9 +678,100 @@ function openCodeModelConfig(model) {
         },
     };
 }
-function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL) {
+function modelFromProxy(model) {
+    if (!model.id)
+        return undefined;
+    return {
+        id: model.id,
+        name: model.name ?? model.id,
+        description: model.description ?? "CommandCode model",
+        category: model.category,
+        reasoning: model.reasoning ?? false,
+        context: model.limit?.context ?? 200000,
+        output: model.limit?.output ?? 8192,
+        cost: model.cost ?? { input: 0, output: 0 },
+    };
+}
+export async function fetchOpenCommandModels(baseURL) {
+    try {
+        const response = await fetch(`${baseURL.replace(/\/$/, "")}/models`, {
+            headers: { Authorization: `Bearer ${PROVIDER_API_KEY_PLACEHOLDER}` },
+        });
+        if (!response.ok)
+            return undefined;
+        const body = (await response.json());
+        const models = (body.data ?? [])
+            .map(modelFromProxy)
+            .filter((model) => Boolean(model));
+        return models.length > 0 ? models : undefined;
+    }
+    catch (error) {
+        console.debug("Could not fetch OpenCommand models from local proxy:", error);
+        return undefined;
+    }
+}
+export function commandCodeModelsForPlan(planID) {
+    const models = [...COMMAND_CODE_GO_PLAN_MODELS];
+    if (!planCanUsePremium(planID))
+        return models;
+    for (const model of COMMAND_CODE_PREMIUM_MODELS) {
+        if (isOpusModel(model.id) && !planCanUseOpus(planID))
+            continue;
+        models.push(model);
+    }
+    return models;
+}
+export async function fetchCommandCodePlanModels(commandCodeToken, apiBaseURL = COMMAND_CODE_API_BASE_URL) {
+    try {
+        const response = await fetch(`${apiBaseURL.replace(/\/$/, "")}/alpha/billing/subscriptions`, {
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${commandCodeToken}`,
+            },
+        });
+        if (!response.ok)
+            return undefined;
+        const body = await response.json();
+        const planID = parseCommandCodePlanID(body);
+        return planID ? commandCodeModelsForPlan(planID) : undefined;
+    }
+    catch (error) {
+        console.debug("Could not detect CommandCode plan for model registration:", error);
+        return undefined;
+    }
+}
+export function parseCommandCodePlanID(body) {
+    const root = body;
+    if (typeof root?.planId === "string" && root.planId.trim())
+        return root.planId.trim();
+    const data = root?.data;
+    if (Array.isArray(data)) {
+        const active = data.find((item) => {
+            const entry = item;
+            return typeof entry.planId === "string" && entry.status === "active";
+        });
+        const first = active ?? data[0];
+        return typeof first?.planId === "string" && first.planId.trim()
+            ? first.planId.trim()
+            : undefined;
+    }
+    const single = data;
+    return typeof single?.planId === "string" && single.planId.trim()
+        ? single.planId.trim()
+        : undefined;
+}
+function planCanUsePremium(planID) {
+    return ["individual-pro", "individual-max", "individual-ultra", "teams-pro"].includes(planID.toLowerCase());
+}
+function planCanUseOpus(planID) {
+    return ["individual-max", "individual-ultra", "teams-pro"].includes(planID.toLowerCase());
+}
+function isOpusModel(modelID) {
+    return modelID.toLowerCase().includes("opus");
+}
+export function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL, modelDefinitions = COMMAND_CODE_GO_PLAN_MODELS) {
     const models = {};
-    for (const model of exports.COMMAND_CODE_GO_PLAN_MODELS) {
+    for (const model of modelDefinitions) {
         models[model.id] = openCodeModelConfig(model);
     }
     config.provider = {
@@ -659,7 +792,18 @@ 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 () => {
@@ -674,8 +818,17 @@ const OpenCommandOpenCodePlugin = async () => ({
         methods: [],
     },
     config: async (config) => {
-        registerOpenCommandProvider(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);
     },
 });
-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.3",
+  "version": "0.0.5",
   "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"
+    }
+  }
 }