opencommand-plugin 0.0.2 → 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

@@ -7,15 +7,43 @@ export interface ProxyStartConfig {
     commandCodeToken: string;
     sessionCookie?: string;
 }
+interface CommandCodeModelDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category?: string;
+    reasoning?: boolean;
+    context: number;
+    output: number;
+    cost: {
+        input: number;
+        output: number;
+        cache_read?: number;
+        cache_write?: number;
+    };
+}
+interface OpenCodeProviderConfig {
+    npm: string;
+    name: string;
+    options: {
+        apiKey: string;
+        baseURL: string;
+    };
+    models: Record<string, unknown>;
+}
+interface OpenCodeConfig {
+    provider?: Record<string, OpenCodeProviderConfig>;
+}
 interface CookiePair {
     name: string;
     value: string;
 }
+export declare const COMMAND_CODE_GO_PLAN_MODELS: CommandCodeModelDefinition[];
 export declare class ProxyManager {
     private proxyProcess;
     private config;
     private proxyBinaryPath;
-    constructor(binaryPath: string);
+    constructor(binaryPath?: string);
     findAvailablePort(): Promise<number>;
     start(startConfig: ProxyStartConfig): Promise<ProxyConfig>;
     stop(): Promise<void>;
@@ -52,8 +80,9 @@ export declare class OpenCommandPlugin {
     private readonly commandCodeTokenKey;
     private readonly legacyTokenKey;
     private readonly sessionCookieKey;
-    constructor(proxyBinaryPath: string, storageDir?: string);
+    constructor(proxyBinaryPath?: string, storageDir?: string);
     activate(): Promise<void>;
+    ensureStarted(): Promise<ProxyConfig | undefined>;
     deactivate(): Promise<void>;
     private loadCommandCodeToken;
     private loadSessionCookie;
@@ -65,4 +94,20 @@ export declare class OpenCommandPlugin {
     private restartIfPossible;
     getProxyConfig(): string;
 }
-export {};
+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;
+        loader: () => Promise<{
+            apiKey: string;
+            baseURL: string;
+        } | null>;
+        methods: never[];
+    };
+    config: (config: OpenCodeConfig) => Promise<void>;
+}>;
+export default OpenCommandOpenCodePlugin;

package/dist/index.js

@@ -33,7 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenCommandPlugin = exports.BrowserCookieExtractor = exports.SecretStorage = exports.ProxyManager = void 0;
+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"));
@@ -41,8 +46,188 @@ const fsp = __importStar(require("fs/promises"));
 const net = __importStar(require("net"));
 const os = __importStar(require("os"));
 const path = __importStar(require("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 = [
+    {
+        id: "deepseek/deepseek-v4-pro",
+        name: "DeepSeek V4 Pro",
+        description: "Hybrid-attention long-context reasoning",
+        reasoning: true,
+        context: 1000000,
+        output: 8192,
+        cost: { input: 1.74, output: 3.48, cache_read: 0.0145 },
+    },
+    {
+        id: "deepseek/deepseek-v4-flash",
+        name: "DeepSeek V4 Flash",
+        description: "Fast hybrid-attention reasoning",
+        reasoning: true,
+        context: 1000000,
+        output: 8192,
+        cost: { input: 0.14, output: 0.28, cache_read: 0.01 },
+    },
+    {
+        id: "moonshotai/Kimi-K2.6",
+        name: "Kimi K2.6",
+        description: "Long-horizon coding with vision",
+        context: 256000,
+        output: 8192,
+        cost: { input: 0.95, output: 4.0, cache_read: 0.16 },
+    },
+    {
+        id: "moonshotai/Kimi-K2.5",
+        name: "Kimi K2.5",
+        description: "Multimodal frontend coding",
+        context: 256000,
+        output: 8192,
+        cost: { input: 0.6, output: 3.0, cache_read: 0.1 },
+    },
+    {
+        id: "zai-org/GLM-5.1",
+        name: "GLM-5.1",
+        description: "Long-horizon autonomous coding agent",
+        context: 200000,
+        output: 8192,
+        cost: { input: 1.4, output: 4.4, cache_read: 0.26 },
+    },
+    {
+        id: "zai-org/GLM-5",
+        name: "GLM-5",
+        description: "Multi-mode thinking and long-range planning",
+        context: 200000,
+        output: 8192,
+        cost: { input: 1.0, output: 3.2, cache_read: 0.2 },
+    },
+    {
+        id: "MiniMaxAI/MiniMax-M2.7",
+        name: "MiniMax M2.7",
+        description: "End-to-end software engineering agent",
+        context: 200000,
+        output: 8192,
+        cost: { input: 0.3, output: 1.2, cache_read: 0.06 },
+    },
+    {
+        id: "MiniMaxAI/MiniMax-M2.5",
+        name: "MiniMax M2.5",
+        description: "Cross-platform full-stack agentic development",
+        context: 200000,
+        output: 8192,
+        cost: { input: 0.27, output: 0.95, cache_read: 0.03 },
+    },
+    {
+        id: "Qwen/Qwen3.6-Max-Preview",
+        name: "Qwen 3.6 Max Preview",
+        description: "Vibe coding and efficient agent execution",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 1.3, output: 7.8, cache_read: 0.26, cache_write: 1.63 },
+    },
+    {
+        id: "Qwen/Qwen3.6-Plus",
+        name: "Qwen 3.6 Plus",
+        description: "Agentic coding and reasoning",
+        reasoning: true,
+        context: 200000,
+        output: 8192,
+        cost: { input: 0.5, output: 3.0, cache_read: 0.1 },
+    },
+    {
+        id: "stepfun/Step-3.5-Flash",
+        name: "Step 3.5 Flash",
+        description: "Fast sparse-MoE agentic reasoning",
+        reasoning: true,
+        context: 1000000,
+        output: 8192,
+        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) {
+    constructor(binaryPath = resolveProxyBinaryPath()) {
         this.proxyProcess = null;
         this.config = null;
         this.proxyBinaryPath = binaryPath;
@@ -386,7 +571,7 @@ const firefoxCookieQuery = [
     "SELECT host, name, value, '' FROM moz_cookies WHERE host LIKE '%commandcode.ai%';",
 ].join("\n");
 class OpenCommandPlugin {
-    constructor(proxyBinaryPath, storageDir) {
+    constructor(proxyBinaryPath = resolveProxyBinaryPath(), storageDir) {
         this.commandCodeTokenKey = "opencommand.command_code_token";
         this.legacyTokenKey = "opencommand.cc_session_token";
         this.sessionCookieKey = "opencommand.cc_session_cookie";
@@ -397,26 +582,34 @@ class OpenCommandPlugin {
     }
     async activate() {
         console.log("OpenCommand Plugin activating...");
+        try {
+            const config = await this.ensureStarted();
+            if (config)
+                console.log(`✓ OpenCommand proxy ready at ${config.port}`);
+        }
+        catch (error) {
+            console.error("Failed to start proxy:", error);
+        }
+    }
+    async ensureStarted() {
+        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.");
-            return;
+            return undefined;
         }
         const sessionCookie = await this.loadSessionCookie();
         if (!sessionCookie) {
             console.warn("No CommandCode Studio cookie found. Inference works, but usage scraping may be unavailable.");
         }
-        try {
-            const config = await this.proxyManager.start({
-                commandCodeToken,
-                sessionCookie,
-            });
-            console.log(`✓ OpenCommand proxy ready at ${config.port}`);
-            this.saveOpenCodeConfig(config);
-        }
-        catch (error) {
-            console.error("Failed to start proxy:", error);
-        }
+        const config = await this.proxyManager.start({
+            commandCodeToken,
+            sessionCookie,
+        });
+        this.saveOpenCodeConfig(config);
+        return config;
     }
     async deactivate() {
         console.log("OpenCommand Plugin deactivating...");
@@ -500,3 +693,175 @@ function firstDefined(...values) {
     }
     return undefined;
 }
+function resolveProxyBinaryPath() {
+    const candidates = [
+        process.env.OPENCOMMAND_PROXY_PATH,
+        path.join(os.homedir(), ".opencommand", "proxy"),
+        path.join(process.cwd(), "packages", "proxy", "proxy"),
+        path.join(__dirname, "proxy"),
+    ].filter((candidate) => Boolean(candidate));
+    return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[candidates.length - 1];
+}
+function openCodeModelConfig(model) {
+    return {
+        id: model.id,
+        name: model.name,
+        description: model.description,
+        category: model.category ?? "opensource",
+        reasoning: model.reasoning ?? false,
+        tool_call: true,
+        attachment: false,
+        cost: model.cost,
+        limit: {
+            context: model.context,
+            output: model.output,
+        },
+        modalities: {
+            input: ["text"],
+            output: ["text"],
+        },
+    };
+}
+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 modelDefinitions) {
+        models[model.id] = openCodeModelConfig(model);
+    }
+    config.provider = {
+        ...(config.provider ?? {}),
+        [PROVIDER_ID]: {
+            npm: "@ai-sdk/openai-compatible",
+            name: PROVIDER_NAME,
+            options: {
+                apiKey: PROVIDER_API_KEY_PLACEHOLDER,
+                baseURL,
+            },
+            models,
+        },
+    };
+}
+let runtimePlugin;
+function getRuntimePlugin() {
+    runtimePlugin ?? (runtimePlugin = new OpenCommandPlugin());
+    return runtimePlugin;
+}
+const OpenCommandOpenCodePlugin = async () => ({
+    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: [],
+    },
+    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);
+    },
+});
+exports.OpenCommandOpenCodePlugin = OpenCommandOpenCodePlugin;
+exports.default = exports.OpenCommandOpenCodePlugin;

package/package.json

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