opencommand-plugin 0.0.1

package/README.md

@@ -0,0 +1,80 @@
+# OpenCommand Plugin - OpenCode Integration
+
+Plugin for OpenCode that manages the CommandCode proxy lifecycle.
+
+## 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
+
+## Architecture
+
+### ProxyManager
+Handles proxy process lifecycle:
+- Start/stop proxy on dynamic port
+- Health check polling
+- Process signal handling
+
+### 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
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Usage
+
+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
+
+The plugin exports this configuration to OpenCode:
+
+```json
+{
+  "opencommand": {
+    "proxyUrl": "http://localhost:3001",
+    "apiBaseUrl": "http://localhost:3001/v1"
+  }
+}
+```
+
+OpenCode and other clients use this to route requests to the proxy.
+
+## Related Issues
+
+- Fase 2 Implementation (#2)
+- Depends on: Proxy Core (Fase 1)
+- Prepares for: Cookie Scraper (Fase 3)

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+export interface ProxyConfig {
+    port: number;
+    sessionToken: string;
+}
+export declare class ProxyManager {
+    private proxyProcess;
+    private config;
+    private proxyBinaryPath;
+    constructor(binaryPath: string);
+    /**
+     * Find an available port (dynamic allocation)
+     */
+    findAvailablePort(): Promise<number>;
+    /**
+     * Start the proxy server
+     */
+    start(sessionToken: string): Promise<ProxyConfig>;
+    /**
+     * Stop the proxy server
+     */
+    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);
+    private readStore;
+    private writeStore;
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | undefined>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * OpenCommand Plugin Main Class
+ */
+export declare class OpenCommandPlugin {
+    private proxyManager;
+    private secretStorage;
+    private SESSION_TOKEN_KEY;
+    constructor(proxyBinaryPath: string, storageDir?: string);
+    /**
+     * Initialize plugin on editor startup
+     */
+    activate(): Promise<void>;
+    /**
+     * Clean up on editor shutdown
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Save proxy config to OpenCode configuration.
+     * Fix: Persist to file so OpenCodeBar can discover the dynamic port.
+     */
+    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
+     */
+    setSessionToken(token: string): Promise<void>;
+    /**
+     * Get proxy configuration
+     */
+    getProxyConfig(): string;
+}

package/dist/index.js

@@ -0,0 +1,326 @@
+"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.OpenCommandPlugin = exports.SecretStorage = exports.ProxyManager = void 0;
+const cp = __importStar(require("child_process"));
+const net = __importStar(require("net"));
+class ProxyManager {
+    constructor(binaryPath) {
+        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();
+            server.listen(0, () => {
+                const address = server.address();
+                if (address && typeof address === "object" && address.port) {
+                    server.close(() => resolve(address.port));
+                }
+                else {
+                    reject(new Error("Failed to find available port"));
+                }
+            });
+            server.on("error", reject);
+        });
+    }
+    /**
+     * Start the proxy server
+     */
+    async start(sessionToken) {
+        // Find available port
+        const port = await this.findAvailablePort();
+        this.config = { port, sessionToken };
+        // Prepare environment
+        const env = {
+            ...process.env,
+            PORT: String(port),
+            CC_SESSION_COOKIE: sessionToken,
+            PRODUCTION: "true",
+        };
+        // Start proxy process
+        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) {
+            return;
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            const finish = () => {
+                if (!resolved) {
+                    resolved = true;
+                    this.proxyProcess = null;
+                    resolve();
+                }
+            };
+            proc.once("exit", finish);
+            proc.once("error", (error) => {
+                console.error("Proxy process error while stopping:", error);
+                finish();
+            });
+            try {
+                if (!proc.killed) {
+                    proc.kill("SIGTERM");
+                }
+            }
+            catch (error) {
+                console.error("Failed to send SIGTERM to proxy process:", error);
+                finish();
+                return;
+            }
+            setTimeout(() => {
+                if (!resolved && !proc.killed) {
+                    try {
+                        proc.kill("SIGKILL");
+                    }
+                    catch (error) {
+                        console.error("Failed to send SIGKILL to proxy process:", error);
+                    }
+                }
+                finish();
+            }, 5000);
+        });
+    }
+    /**
+     * Wait for proxy to be healthy
+     */
+    async waitForHealthz(port, timeoutMs) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 2000);
+                const response = await fetch(`http://localhost:${port}/healthz`, {
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    return;
+                }
+            }
+            catch (err) {
+                console.debug(`Health check attempt failed for port ${port}:`, err);
+            }
+            await new Promise((r) => setTimeout(r, 500));
+        }
+        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");
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.debug("Could not read OpenCommand secret store:", error);
+            }
+            return {};
+        }
+    }
+    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), {
+            mode: 0o600,
+        });
+    }
+    async set(key, value) {
+        const store = await this.readStore();
+        store[key] = value;
+        await this.writeStore(store);
+    }
+    async get(key) {
+        const store = await this.readStore();
+        return store[key];
+    }
+    async delete(key) {
+        const store = await this.readStore();
+        delete store[key];
+        await this.writeStore(store);
+    }
+}
+exports.SecretStorage = SecretStorage;
+/**
+ * OpenCommand Plugin Main Class
+ */
+class OpenCommandPlugin {
+    constructor(proxyBinaryPath, storageDir) {
+        this.SESSION_TOKEN_KEY = "opencommand.cc_session_token";
+        this.proxyManager = new ProxyManager(proxyBinaryPath);
+        const dir = storageDir || `${process.env.HOME || "/tmp"}/.opencommand`;
+        this.secretStorage = new SecretStorage(dir);
+    }
+    /**
+     * 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);
+        }
+        catch (error) {
+            console.error("Failed to start proxy:", error);
+        }
+    }
+    /**
+     * Clean up on editor shutdown
+     */
+    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.
+     */
+    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)
+        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 {
+            fs.mkdirSync(configDir, { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify({ url, port, updatedAt: new Date().toISOString() }, null, 2), { mode: 0o644 });
+            console.log(`✓ Proxy config persisted to ${configPath}`);
+        }
+        catch (err) {
+            console.error("Failed to persist proxy config:", err);
+        }
+    }
+    /**
+     * Set session token via command
+     */
+    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.proxyManager.stop();
+        const config = await this.proxyManager.start(token);
+        this.saveOpenCodeConfig(config);
+    }
+    /**
+     * Get proxy configuration
+     */
+    getProxyConfig() {
+        const config = this.proxyManager.getConfig();
+        if (!config) {
+            return "Proxy not running";
+        }
+        return JSON.stringify(config, null, 2);
+    }
+}
+exports.OpenCommandPlugin = OpenCommandPlugin;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "opencommand-plugin",
+  "version": "0.0.1",
+  "description": "OpenCommand - CommandCode API Plugin for OpenCode",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "commandcode",
+    "api",
+    "proxy"
+  ],
+  "author": "OpenCommand",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/jest": "^29.0.0",
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "dependencies": {
+    "node-fetch": "^3.0.0"
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "package.json"
+  ]
+}