opencommand-plugin 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,45 +1,56 @@
 export interface ProxyConfig {
     port: number;
-    sessionToken: string;
+    commandCodeToken: string;
+    sessionCookie?: string;
 }
+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);
-    /**
-     * Find an available port (dynamic allocation)
-     */
+    constructor(binaryPath?: string);
     findAvailablePort(): Promise<number>;
-    /**
-     * Start the proxy server
-     */
-    start(sessionToken: string): Promise<ProxyConfig>;
-    /**
-     * Stop the proxy server
-     */
+    start(startConfig: ProxyStartConfig): Promise<ProxyConfig>;
     stop(): Promise<void>;
-    /**
-     * Wait for proxy to be healthy
-     */
     private waitForHealthz;
-    /**
-     * Get current proxy configuration
-     */
     getConfig(): ProxyConfig | null;
-    /**
-     * Get proxy base URL
-     */
     getBaseUrl(): string | null;
-    /**
-     * Check if proxy is running
-     */
     isRunning(): boolean;
 }
-/**
- * File-based persistent secret storage.
- * Fix: Persists session token across plugin restarts (not instance-local Map).
- */
 export declare class SecretStorage {
     private filePath;
     constructor(storageDir?: string);
@@ -49,38 +60,49 @@ export declare class SecretStorage {
     get(key: string): Promise<string | undefined>;
     delete(key: string): Promise<void>;
 }
-/**
- * OpenCommand Plugin Main Class
- */
+export declare class BrowserCookieExtractor {
+    private readonly homeDir;
+    constructor(homeDir?: string);
+    extractCommandCodeCookie(): Promise<string | undefined>;
+    static buildCookieHeader(pairs: CookiePair[]): string | undefined;
+    private findBrowserProfiles;
+    private profileDirectories;
+    private readCommandCodeCookies;
+    private cookiePairFromRow;
+    private decryptChromiumCookie;
+    private safeStoragePassword;
+}
 export declare class OpenCommandPlugin {
     private proxyManager;
     private secretStorage;
-    private SESSION_TOKEN_KEY;
-    constructor(proxyBinaryPath: string, storageDir?: string);
-    /**
-     * Initialize plugin on editor startup
-     */
+    private cookieExtractor;
+    private readonly commandCodeTokenKey;
+    private readonly legacyTokenKey;
+    private readonly sessionCookieKey;
+    constructor(proxyBinaryPath?: string, storageDir?: string);
     activate(): Promise<void>;
-    /**
-     * Clean up on editor shutdown
-     */
+    ensureStarted(): Promise<ProxyConfig | undefined>;
     deactivate(): Promise<void>;
-    /**
-     * Save proxy config to OpenCode configuration.
-     * Fix: Persist to file so OpenCodeBar can discover the dynamic port.
-     */
+    private loadCommandCodeToken;
+    private loadSessionCookie;
     private saveOpenCodeConfig;
-    /**
-     * Persist proxy URL and port to a config file (Issue #5).
-     * OpenCodeBar reads this to discover the dynamically allocated port.
-     */
     private persistProxyConfig;
-    /**
-     * Set session token via command
-     */
+    setCommandCodeToken(token: string): Promise<void>;
     setSessionToken(token: string): Promise<void>;
-    /**
-     * Get proxy configuration
-     */
+    setSessionCookie(cookie: string): Promise<void>;
+    private restartIfPossible;
     getProxyConfig(): string;
 }
+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,18 +33,120 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenCommandPlugin = 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"));
+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;
     }
-    /**
-     * Find an available port (dynamic allocation)
-     */
     async findAvailablePort() {
         return new Promise((resolve, reject) => {
             const server = net.createServer();
@@ -52,53 +154,48 @@ class ProxyManager {
                 const address = server.address();
                 if (address && typeof address === "object" && address.port) {
                     server.close(() => resolve(address.port));
+                    return;
                 }
-                else {
-                    reject(new Error("Failed to find available port"));
-                }
+                reject(new Error("Failed to find available port"));
             });
             server.on("error", reject);
         });
     }
-    /**
-     * Start the proxy server
-     */
-    async start(sessionToken) {
-        // Find available port
+    async start(startConfig) {
         const port = await this.findAvailablePort();
-        this.config = { port, sessionToken };
-        // Prepare environment
+        this.config = {
+            port,
+            commandCodeToken: startConfig.commandCodeToken,
+            sessionCookie: startConfig.sessionCookie,
+        };
         const env = {
             ...process.env,
             PORT: String(port),
-            CC_SESSION_COOKIE: sessionToken,
+            COMMAND_CODE_TOKEN: startConfig.commandCodeToken,
+            COMMANDCODE_API_KEY: startConfig.commandCodeToken,
             PRODUCTION: "true",
         };
-        // Start proxy process
+        if (startConfig.sessionCookie) {
+            env.CC_SESSION_COOKIE = startConfig.sessionCookie;
+        }
         this.proxyProcess = cp.spawn(this.proxyBinaryPath, [], {
             env,
             stdio: ["ignore", "pipe", "pipe"],
         });
-        // Log output
         this.proxyProcess.stdout?.on("data", (data) => {
             console.log(`[Proxy stdout] ${data}`);
         });
         this.proxyProcess.stderr?.on("data", (data) => {
             console.error(`[Proxy stderr] ${data}`);
         });
-        // Wait for proxy to be ready
         await this.waitForHealthz(port, 30000);
         console.log(`✓ Proxy started on port ${port}`);
         return this.config;
     }
-    /**
-     * Stop the proxy server
-     */
     async stop() {
         const proc = this.proxyProcess;
-        if (!proc) {
+        if (!proc)
             return;
-        }
         return new Promise((resolve) => {
             let resolved = false;
             const finish = () => {
@@ -114,9 +211,8 @@ class ProxyManager {
                 finish();
             });
             try {
-                if (!proc.killed) {
+                if (!proc.killed)
                     proc.kill("SIGTERM");
-                }
             }
             catch (error) {
                 console.error("Failed to send SIGTERM to proxy process:", error);
@@ -136,9 +232,6 @@ class ProxyManager {
             }, 5000);
         });
     }
-    /**
-     * Wait for proxy to be healthy
-     */
     async waitForHealthz(port, timeoutMs) {
         const startTime = Date.now();
         while (Date.now() - startTime < timeoutMs) {
@@ -149,9 +242,8 @@ class ProxyManager {
                     signal: controller.signal,
                 });
                 clearTimeout(timeoutId);
-                if (response.ok) {
+                if (response.ok)
                     return;
-                }
             }
             catch (err) {
                 console.debug(`Health check attempt failed for port ${port}:`, err);
@@ -160,38 +252,24 @@ class ProxyManager {
         }
         throw new Error(`Proxy failed to become healthy after ${timeoutMs}ms on port ${port}`);
     }
-    /**
-     * Get current proxy configuration
-     */
     getConfig() {
         return this.config;
     }
-    /**
-     * Get proxy base URL
-     */
     getBaseUrl() {
         return this.config ? `http://localhost:${this.config.port}` : null;
     }
-    /**
-     * Check if proxy is running
-     */
     isRunning() {
         return this.proxyProcess !== null && !this.proxyProcess.killed;
     }
 }
 exports.ProxyManager = ProxyManager;
-/**
- * File-based persistent secret storage.
- * Fix: Persists session token across plugin restarts (not instance-local Map).
- */
 class SecretStorage {
     constructor(storageDir = `${process.env.HOME || "/tmp"}/.opencommand`) {
         this.filePath = `${storageDir}/opencommand-secrets.json`;
     }
     async readStore() {
-        const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
         try {
-            const data = await fs.readFile(this.filePath, "utf-8");
+            const data = await fsp.readFile(this.filePath, "utf-8");
             return JSON.parse(data);
         }
         catch (error) {
@@ -202,11 +280,9 @@ class SecretStorage {
         }
     }
     async writeStore(store) {
-        const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
-        const path = await Promise.resolve().then(() => __importStar(require("path")));
         const dir = path.dirname(this.filePath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(this.filePath, JSON.stringify(store, null, 2), {
+        await fsp.mkdir(dir, { recursive: true });
+        await fsp.writeFile(this.filePath, JSON.stringify(store, null, 2), {
             mode: 0o600,
         });
     }
@@ -226,70 +302,261 @@ class SecretStorage {
     }
 }
 exports.SecretStorage = SecretStorage;
-/**
- * OpenCommand Plugin Main Class
- */
+class BrowserCookieExtractor {
+    constructor(homeDir = os.homedir()) {
+        this.homeDir = homeDir;
+    }
+    async extractCommandCodeCookie() {
+        const rows = this.findBrowserProfiles().flatMap((profile) => this.readCommandCodeCookies(profile));
+        const pairs = rows
+            .map((row) => this.cookiePairFromRow(row))
+            .filter((pair) => pair !== undefined);
+        return BrowserCookieExtractor.buildCookieHeader(pairs);
+    }
+    static buildCookieHeader(pairs) {
+        const unique = new Map();
+        for (const pair of pairs) {
+            if (pair.name && pair.value)
+                unique.set(pair.name, pair.value);
+        }
+        if (unique.size === 0)
+            return undefined;
+        return [...unique.entries()]
+            .map(([name, value]) => `${name}=${value}`)
+            .join("; ");
+    }
+    findBrowserProfiles() {
+        const candidates = [
+            {
+                browser: "Chrome",
+                base: "Library/Application Support/Google/Chrome",
+                services: ["Chrome Safe Storage", "Google Chrome Safe Storage"],
+            },
+            {
+                browser: "Comet",
+                base: "Library/Application Support/Comet",
+                services: ["Comet Safe Storage", "Chrome Safe Storage"],
+            },
+            {
+                browser: "Brave",
+                base: "Library/Application Support/BraveSoftware/Brave-Browser",
+                services: ["Brave Safe Storage", "Chrome Safe Storage"],
+            },
+            {
+                browser: "Edge",
+                base: "Library/Application Support/Microsoft Edge",
+                services: ["Microsoft Edge Safe Storage", "Chrome Safe Storage"],
+            },
+        ];
+        const profiles = [];
+        for (const candidate of candidates) {
+            const basePath = path.join(this.homeDir, candidate.base);
+            for (const profileDir of this.profileDirectories(basePath)) {
+                for (const cookieDatabase of [
+                    path.join(profileDir, "Network", "Cookies"),
+                    path.join(profileDir, "Cookies"),
+                ]) {
+                    if (fs.existsSync(cookieDatabase)) {
+                        profiles.push({
+                            browser: candidate.browser,
+                            safeStorageServices: candidate.services,
+                            cookieDatabase,
+                        });
+                    }
+                }
+            }
+        }
+        const firefoxBase = path.join(this.homeDir, "Library/Application Support/Firefox/Profiles");
+        for (const profileDir of this.profileDirectories(firefoxBase)) {
+            const cookieDatabase = path.join(profileDir, "cookies.sqlite");
+            if (fs.existsSync(cookieDatabase)) {
+                profiles.push({
+                    browser: "Firefox",
+                    safeStorageServices: [],
+                    cookieDatabase,
+                });
+            }
+        }
+        return profiles;
+    }
+    profileDirectories(basePath) {
+        if (!fs.existsSync(basePath))
+            return [];
+        const directCookie = path.join(basePath, "cookies.sqlite");
+        if (fs.existsSync(directCookie))
+            return [basePath];
+        return fs
+            .readdirSync(basePath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(basePath, entry.name));
+    }
+    readCommandCodeCookies(profile) {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "opencommand-cookies-"));
+        const tmpDb = path.join(tmpDir, "cookies.sqlite");
+        try {
+            fs.copyFileSync(profile.cookieDatabase, tmpDb);
+            const query = profile.browser === "Firefox" ? firefoxCookieQuery : chromiumCookieQuery;
+            const output = cp.execFileSync("/usr/bin/sqlite3", [tmpDb, query], {
+                encoding: "utf8",
+                timeout: 5000,
+            });
+            return output
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                const [host = "", name = "", value = "", encryptedHex = ""] = line.split("\t");
+                return {
+                    host,
+                    name,
+                    value,
+                    encryptedHex,
+                    browser: profile.browser,
+                    safeStorageServices: profile.safeStorageServices,
+                };
+            });
+        }
+        catch (error) {
+            console.debug(`Could not read ${profile.browser} cookies:`, error);
+            return [];
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    }
+    cookiePairFromRow(row) {
+        if (!row.host.includes("commandcode.ai") || !row.name)
+            return undefined;
+        const value = row.value || this.decryptChromiumCookie(row);
+        if (!value)
+            return undefined;
+        return { name: row.name, value };
+    }
+    decryptChromiumCookie(row) {
+        if (!row.encryptedHex || row.browser === "Firefox")
+            return undefined;
+        const encrypted = Buffer.from(row.encryptedHex, "hex");
+        if (encrypted.length <= 3)
+            return undefined;
+        for (const service of row.safeStorageServices) {
+            const password = this.safeStoragePassword(service);
+            if (!password)
+                continue;
+            const decrypted = decryptMacChromiumCookie(encrypted, password);
+            if (decrypted)
+                return decrypted;
+        }
+        return undefined;
+    }
+    safeStoragePassword(service) {
+        try {
+            return cp
+                .execFileSync("/usr/bin/security", [
+                "find-generic-password",
+                "-w",
+                "-s",
+                service,
+            ], { encoding: "utf8", timeout: 5000 })
+                .trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.BrowserCookieExtractor = BrowserCookieExtractor;
+function decryptMacChromiumCookie(encryptedValue, safeStoragePassword) {
+    try {
+        const payload = encryptedValue.subarray(0, 3).toString() === "v10"
+            ? encryptedValue.subarray(3)
+            : encryptedValue;
+        const key = crypto.pbkdf2Sync(safeStoragePassword, "saltysalt", 1003, 16, "sha1");
+        const decipher = crypto.createDecipheriv("aes-128-cbc", key, Buffer.alloc(16, " "));
+        return Buffer.concat([decipher.update(payload), decipher.final()]).toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+const chromiumCookieQuery = [
+    ".mode tabs",
+    "SELECT host_key, name, value, hex(encrypted_value) FROM cookies WHERE host_key LIKE '%commandcode.ai%';",
+].join("\n");
+const firefoxCookieQuery = [
+    ".mode tabs",
+    "SELECT host, name, value, '' FROM moz_cookies WHERE host LIKE '%commandcode.ai%';",
+].join("\n");
 class OpenCommandPlugin {
-    constructor(proxyBinaryPath, storageDir) {
-        this.SESSION_TOKEN_KEY = "opencommand.cc_session_token";
+    constructor(proxyBinaryPath = resolveProxyBinaryPath(), storageDir) {
+        this.commandCodeTokenKey = "opencommand.command_code_token";
+        this.legacyTokenKey = "opencommand.cc_session_token";
+        this.sessionCookieKey = "opencommand.cc_session_cookie";
         this.proxyManager = new ProxyManager(proxyBinaryPath);
         const dir = storageDir || `${process.env.HOME || "/tmp"}/.opencommand`;
         this.secretStorage = new SecretStorage(dir);
+        this.cookieExtractor = new BrowserCookieExtractor();
     }
-    /**
-     * Initialize plugin on editor startup
-     */
     async activate() {
         console.log("OpenCommand Plugin activating...");
-        // Try to retrieve stored session token
-        const storedToken = await this.secretStorage.get(this.SESSION_TOKEN_KEY);
-        if (!storedToken) {
-            console.warn("No CC_SESSION_COOKIE found. Please configure token.");
-            return;
-        }
-        // Start proxy
         try {
-            const config = await this.proxyManager.start(storedToken);
-            console.log(`✓ OpenCommand proxy ready at ${config.port}`);
-            // Store config for use by OpenCode
-            this.saveOpenCodeConfig(config);
+            const config = await this.ensureStarted();
+            if (config)
+                console.log(`✓ OpenCommand proxy ready at ${config.port}`);
         }
         catch (error) {
             console.error("Failed to start proxy:", error);
         }
     }
-    /**
-     * Clean up on editor shutdown
-     */
+    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 undefined;
+        }
+        const sessionCookie = await this.loadSessionCookie();
+        if (!sessionCookie) {
+            console.warn("No CommandCode Studio cookie found. Inference works, but usage scraping may be unavailable.");
+        }
+        const config = await this.proxyManager.start({
+            commandCodeToken,
+            sessionCookie,
+        });
+        this.saveOpenCodeConfig(config);
+        return config;
+    }
     async deactivate() {
         console.log("OpenCommand Plugin deactivating...");
         await this.proxyManager.stop();
         console.log("✓ Proxy stopped");
     }
-    /**
-     * Save proxy config to OpenCode configuration.
-     * Fix: Persist to file so OpenCodeBar can discover the dynamic port.
-     */
+    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));
+        if (token && token === (await this.secretStorage.get(this.legacyTokenKey))) {
+            await this.secretStorage.set(this.commandCodeTokenKey, token);
+        }
+        return token;
+    }
+    async loadSessionCookie() {
+        const configured = firstDefined(process.env.CC_SESSION_COOKIE, await this.secretStorage.get(this.sessionCookieKey));
+        if (configured)
+            return configured;
+        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");
+        }
+        return extracted;
+    }
     saveOpenCodeConfig(config) {
         const proxyUrl = `http://localhost:${config.port}`;
-        const openCodeConfig = {
-            opencommand: {
-                proxyUrl,
-                apiBaseUrl: `${proxyUrl}/v1`,
-            },
-        };
-        // Log for debugging
-        console.log("Proxy configuration saved:", openCodeConfig);
-        // Persist to config file (readable by OpenCodeBar)
+        console.log("Proxy configuration saved:", {
+            opencommand: { proxyUrl, apiBaseUrl: `${proxyUrl}/v1` },
+        });
         this.persistProxyConfig(proxyUrl, config.port);
     }
-    /**
-     * Persist proxy URL and port to a config file (Issue #5).
-     * OpenCodeBar reads this to discover the dynamically allocated port.
-     */
     persistProxyConfig(url, port) {
-        const fs = require("fs");
-        const path = require("path");
         const configDir = `${process.env.HOME || "/tmp"}/.opencommand`;
         const configPath = path.join(configDir, "proxy-config.json");
         try {
@@ -301,26 +568,114 @@ class OpenCommandPlugin {
             console.error("Failed to persist proxy config:", err);
         }
     }
-    /**
-     * Set session token via command
-     */
+    async setCommandCodeToken(token) {
+        await this.secretStorage.set(this.commandCodeTokenKey, token);
+        console.log("✓ CommandCode API key saved securely");
+        await this.restartIfPossible();
+    }
     async setSessionToken(token) {
-        await this.secretStorage.set(this.SESSION_TOKEN_KEY, token);
-        console.log("✓ Session token saved securely");
-        // Restart proxy with new token
+        await this.setCommandCodeToken(token);
+    }
+    async setSessionCookie(cookie) {
+        await this.secretStorage.set(this.sessionCookieKey, cookie);
+        console.log("✓ CommandCode Studio cookie saved securely");
+        await this.restartIfPossible();
+    }
+    async restartIfPossible() {
+        const commandCodeToken = await this.loadCommandCodeToken();
+        if (!commandCodeToken)
+            return;
         await this.proxyManager.stop();
-        const config = await this.proxyManager.start(token);
+        const config = await this.proxyManager.start({
+            commandCodeToken,
+            sessionCookie: await this.loadSessionCookie(),
+        });
         this.saveOpenCodeConfig(config);
     }
-    /**
-     * Get proxy configuration
-     */
     getProxyConfig() {
         const config = this.proxyManager.getConfig();
-        if (!config) {
+        if (!config)
             return "Proxy not running";
-        }
         return JSON.stringify(config, null, 2);
     }
 }
 exports.OpenCommandPlugin = OpenCommandPlugin;
+function firstDefined(...values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    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.1",
+  "version": "0.0.3",
   "description": "OpenCommand - CommandCode API Plugin for OpenCode",
   "main": "dist/index.js",
   "scripts": {