opencommand-plugin 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -7,15 +7,42 @@ export interface ProxyStartConfig {
     commandCodeToken: string;
     sessionCookie?: string;
 }
+interface CommandCodeModelDefinition {
+    id: string;
+    name: string;
+    description: 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 +79,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 +93,16 @@ export declare class OpenCommandPlugin {
     private restartIfPossible;
     getProxyConfig(): string;
 }
-export {};
+export declare function registerOpenCommandProvider(config: OpenCodeConfig, baseURL?: string): 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,8 @@ 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.registerOpenCommandProvider = registerOpenCommandProvider;
 const cp = __importStar(require("child_process"));
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
@@ -41,8 +42,107 @@ 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";
+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 },
+    },
+];
 class ProxyManager {
-    constructor(binaryPath) {
+    constructor(binaryPath = resolveProxyBinaryPath()) {
         this.proxyProcess = null;
         this.config = null;
         this.proxyBinaryPath = binaryPath;
@@ -386,7 +486,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 +497,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 +608,74 @@ 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,
+        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 registerOpenCommandProvider(config, baseURL = DEFAULT_PROXY_BASE_URL) {
+    const models = {};
+    for (const model of exports.COMMAND_CODE_GO_PLAN_MODELS) {
+        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) => {
+        registerOpenCommandProvider(config);
+    },
+});
+exports.OpenCommandOpenCodePlugin = OpenCommandOpenCodePlugin;
+exports.default = exports.OpenCommandOpenCodePlugin;

package/package.json

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