opencommand-plugin 0.0.3 → 0.0.4

package/README.md

@@ -1,80 +1,48 @@
-# 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)
-
-### OpenCommandPlugin
-Main plugin interface:
-- activate() - Initialize on editor startup
-- deactivate() - Clean up on shutdown
-- setSessionToken() - Configure CommandCode credentials
-- getProxyConfig() - Get current config
-
-## Building
-
-```bash
-npm install
-npm run build
+```json
+{
+  "opencommand.command_code_token": "user_xxx..."
+}
 ```
 
-## Testing
+Do not put this token in synced `opencode.jsonc`.
 
-```bash
-npm test
-```
+## Models in v0.0.4
 
-## Usage
+The proxy detects the active CommandCode subscription through `/alpha/billing/subscriptions` and filters models:
 
-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
+- Go: open-source models only.
+- Pro: open-source + premium, excluding Opus.
+- Max / Ultra / Teams Pro: open-source + premium including Opus.
 
-## Configuration
+If detection fails, the plugin falls back to the local proxy model endpoint and then to the Go/open-source model list.
 
-The plugin exports this configuration to OpenCode:
+## Build
 
-```json
-{
-  "opencommand": {
-    "proxyUrl": "http://localhost:3001",
-    "apiBaseUrl": "http://localhost:3001/v1"
-  }
-}
+```bash
+npm ci
+npm run build
 ```
 
-OpenCode and other clients use this to route requests to the proxy.
-
-## Related Issues
+## Test
 
-- Fase 2 Implementation (#2)
-- Depends on: Proxy Core (Fase 1)
-- Prepares for: Cookie Scraper (Fase 3)
+```bash
+npm test -- --runInBand
+```

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,7 +94,11 @@ 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<{
     auth: {
         provider: string;

package/dist/index.js

@@ -34,6 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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"));
@@ -46,6 +50,7 @@ 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 = [
     {
         id: "deepseek/deepseek-v4-pro",
@@ -141,6 +146,86 @@ exports.COMMAND_CODE_GO_PLAN_MODELS = [
         cost: { input: 0.1, output: 0.3, cache_read: 0.02 },
     },
 ];
+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 },
+    },
+];
 class ProxyManager {
     constructor(binaryPath = resolveProxyBinaryPath()) {
         this.proxyProcess = null;
@@ -622,6 +707,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 +722,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 },
+    };
+}
+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;
+    }
+}
+function commandCodeModelsForPlan(planID) {
+    const models = [...exports.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;
+}
+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;
+    }
+}
+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");
+}
+function registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL, modelDefinitions = exports.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 = {
@@ -674,7 +851,16 @@ 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 ?? exports.COMMAND_CODE_GO_PLAN_MODELS);
     },
 });
 exports.OpenCommandOpenCodePlugin = OpenCommandOpenCodePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencommand-plugin",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "OpenCommand - CommandCode API Plugin for OpenCode",
   "main": "dist/index.js",
   "scripts": {