pi-commandcode-provider 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pat Woz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# pi-commandcode-provider
+
+A [pi](https://github.com/badlogic/pi-mono) custom provider that connects pi to the [Command Code](https://commandcode.ai) API.
+
+> **Disclaimer:** This is an unofficial, community-maintained package. I am not affiliated with, endorsed by, or connected to Command Code in any way. This provider simply forwards requests to the public Command Code API using your own API key.
+
+> **Note:** This package only provides a model _provider_. It does **not** include an API key. You must bring your own Command Code API key or subscription.
+
+> 💰 **Current offer:** Command Code offers [4× usage of DeepSeek V4](https://commandcode.ai/docs/resources/pricing-limits#deepseek-v4-pro-4x-usage) (Pro and Flash) at no extra cost.
+
+## Models
+
+18 models across premium and open-source providers:
+
+| Category        | Models                                                                                                                                         |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Anthropic**   | Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, Claude Haiku 4.5                                                                          |
+| **OpenAI**      | GPT-5.5, GPT-5.4, GPT-5.3 Codex, GPT-5.4 Mini                                                                                                  |
+| **Open-source** | DeepSeek V4, DeepSeek V4 Pro, DeepSeek V4 Flash, Kimi K2.6, Kimi K2.5, GLM-5.1, GLM-5, MiniMax M2.7, MiniMax M2.5, Qwen 3.6 Max, Qwen 3.6 Plus |
+
+## Install
+
+```sh
+pi install npm:pi-commandcode-provider
+```
+
+Or shorthand:
+
+```sh
+pi install pi-commandcode-provider
+```
+
+Then reload pi:
+
+```txt
+/reload
+```
+
+## Setup
+
+Set your Command Code API key using one of these methods:
+
+### 1. Browser login (recommended)
+
+In pi, run:
+
+```txt
+/login
+```
+
+Then select **Command Code** from the provider list.
+
+This opens Command Code in your browser and stores the returned API key in pi's auth file. If the browser shows "Copy your API key" because automatic transfer failed, copy that key and paste it into the pi terminal prompt.
+
+> Note: `/login commandcode` is not supported by pi currently; use interactive `/login` and select Command Code.
+
+### 2. Environment variable
+
+```sh
+export COMMANDCODE_API_KEY="user_..."
+```
+
+### 3. Auth file
+
+Create `~/.commandcode/auth.json`:
+
+```json
+{
+  "apiKey": "user_..."
+}
+```
+
+Or use pi's auth file at `~/.pi/agent/auth.json`:
+
+```json
+{
+  "commandcode": "user_..."
+}
+```
+
+## Usage
+
+After installing and setting your API key, select a Command Code model in pi:
+
+```txt
+/model deepseek/deepseek-v4-flash
+```
+
+Any query will then use the Command Code API. You can list available models:
+
+```sh
+pi -e index.ts --list-models
+```
+
+Or within pi:
+
+```txt
+/models
+```
+
+## Publish
+
+```sh
+npm login
+npm publish --access public
+```
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,197 @@
+/**
+ * Command Code provider for pi.
+ *
+ * Connects pi to Command Code's API (https://api.commandcode.ai/alpha/generate).
+ *
+ * Authentication (pick one):
+ *   1. Run `/login`, then select Command Code — opens browser to commandcode.ai, auto-stores API key
+ *   2. Set COMMANDCODE_API_KEY environment variable
+ *   3. Place API key in `~/.commandcode/auth.json` or `~/.pi/agent/auth.json`
+ *      as {"apiKey": "user_..."} or {"commandcode": "user_..."}
+ *
+ * Models: deepseek-v4-pro, deepseek-v4-flash, claude-sonnet-4-6, claude-opus-4-7, etc.
+ */
+
+import { calculateCost, createAssistantMessageEventStream } from "@mariozechner/pi-ai"
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+
+import { createStreamCommandCode, DEFAULT_API_BASE } from "./src/core.ts"
+import { getApiKey, login, refreshToken } from "./src/oauth.ts"
+
+const API_BASE = process.env.COMMANDCODE_API_BASE ?? DEFAULT_API_BASE
+
+// ---------------------------------------------------------------------------
+// Model definitions
+// ---------------------------------------------------------------------------
+
+const MODELS = [
+  // Premium (Anthropic)
+  {
+    id: "claude-opus-4-7",
+    name: "Claude Opus 4.7 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 32_000,
+  },
+  {
+    id: "claude-opus-4-6",
+    name: "Claude Opus 4.6 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 32_000,
+  },
+  {
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 16_384,
+  },
+  {
+    id: "claude-haiku-4-5-20251001",
+    name: "Claude Haiku 4.5 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 8_192,
+  },
+  // Premium (OpenAI)
+  {
+    id: "gpt-5.5",
+    name: "GPT-5.5 (CC)",
+    reasoning: true,
+    contextWindow: 256_000,
+    maxTokens: 128_000,
+  },
+  {
+    id: "gpt-5.4",
+    name: "GPT-5.4 (CC)",
+    reasoning: true,
+    contextWindow: 256_000,
+    maxTokens: 128_000,
+  },
+  {
+    id: "gpt-5.3-codex",
+    name: "GPT-5.3 Codex (CC)",
+    reasoning: true,
+    contextWindow: 256_000,
+    maxTokens: 128_000,
+  },
+  {
+    id: "gpt-5.4-mini",
+    name: "GPT-5.4 Mini (CC)",
+    reasoning: false,
+    contextWindow: 256_000,
+    maxTokens: 128_000,
+  },
+  // Open-source
+  {
+    id: "deepseek/deepseek-v4-pro",
+    name: "DeepSeek V4 Pro (CC)",
+    reasoning: true,
+    contextWindow: 1_000_000,
+    maxTokens: 384_000,
+  },
+  {
+    id: "deepseek/deepseek-v4-flash",
+    name: "DeepSeek V4 Flash (CC)",
+    reasoning: true,
+    contextWindow: 1_000_000,
+    maxTokens: 384_000,
+  },
+  {
+    id: "moonshotai/Kimi-K2.6",
+    name: "Kimi K2.6 (CC)",
+    reasoning: true,
+    contextWindow: 262_144,
+    maxTokens: 131_072,
+  },
+  {
+    id: "moonshotai/Kimi-K2.5",
+    name: "Kimi K2.5 (CC)",
+    reasoning: true,
+    contextWindow: 262_144,
+    maxTokens: 131_072,
+  },
+  {
+    id: "zai-org/GLM-5.1",
+    name: "GLM-5.1 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 131_072,
+  },
+  {
+    id: "zai-org/GLM-5",
+    name: "GLM-5 (CC)",
+    reasoning: true,
+    contextWindow: 200_000,
+    maxTokens: 131_072,
+  },
+  {
+    id: "MiniMaxAI/MiniMax-M2.7",
+    name: "MiniMax M2.7 (CC)",
+    reasoning: true,
+    contextWindow: 1_048_576,
+    maxTokens: 131_072,
+  },
+  {
+    id: "MiniMaxAI/MiniMax-M2.5",
+    name: "MiniMax M2.5 (CC)",
+    reasoning: true,
+    contextWindow: 1_048_576,
+    maxTokens: 131_072,
+  },
+  {
+    id: "Qwen/Qwen3.6-Max-Preview",
+    name: "Qwen 3.6 Max (CC)",
+    reasoning: true,
+    contextWindow: 1_000_000,
+    maxTokens: 131_072,
+  },
+  {
+    id: "Qwen/Qwen3.6-Plus",
+    name: "Qwen 3.6 Plus (CC)",
+    reasoning: true,
+    contextWindow: 1_000_000,
+    maxTokens: 131_072,
+  },
+]
+
+const streamCommandCode = createStreamCommandCode({
+  createStream: createAssistantMessageEventStream,
+  calculateCost,
+  apiBase: API_BASE,
+})
+
+// ---------------------------------------------------------------------------
+// Extension entry point
+// ---------------------------------------------------------------------------
+
+export default function (pi: ExtensionAPI) {
+  pi.registerProvider("commandcode", {
+    name: "Command Code",
+    baseUrl: API_BASE,
+    apiKey: "COMMANDCODE_API_KEY",
+    authHeader: true,
+    api: "commandcode-custom",
+    streamSimple: streamCommandCode,
+    headers: {
+      "x-command-code-version": "0.24.1",
+      "x-cli-environment": "production",
+    },
+    oauth: {
+      name: "Command Code",
+      login,
+      refreshToken,
+      getApiKey,
+    },
+    models: MODELS.map((model) => ({
+      id: model.id,
+      name: model.name,
+      reasoning: model.reasoning,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+    })),
+  })
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pi-commandcode-provider",
+  "version": "0.1.0",
+  "description": "pi custom provider for Command Code API (commandcode.ai)",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "commandcode",
+    "provider"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/patlux/pi-commandcode-provider.git"
+  },
+  "homepage": "https://github.com/patlux/pi-commandcode-provider#readme",
+  "bugs": {
+    "url": "https://github.com/patlux/pi-commandcode-provider/issues"
+  },
+  "files": [
+    "index.ts",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "npm run typecheck && tsx tests/test-pure-functions.ts && tsx tests/test-oauth.ts && tsx tests/test-abort.ts && tsx tests/test-stream.ts && node tests/test-pi-local.mjs",
+    "typecheck": "tsc --noEmit",
+    "format:check": "prettier --check '**/*.{ts,mjs,json,md}'",
+    "format": "prettier --write '**/*.{ts,mjs,json,md}'",
+    "test:unit": "tsx tests/test-pure-functions.ts",
+    "test:oauth": "tsx tests/test-oauth.ts",
+    "test:abort": "tsx tests/test-abort.ts",
+    "test:stream": "tsx tests/test-stream.ts",
+    "test:pi-local": "node tests/test-pi-local.mjs",
+    "test:smoke": "node tests/test-smoke.mjs"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "devDependencies": {
+    "@mariozechner/pi-coding-agent": "0.72.0",
+    "@types/node": "25.6.0",
+    "prettier": "^3.5.0",
+    "tsx": "4.21.0",
+    "typescript": "6.0.3"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "0.72.0"
+  }
+}

package/src/auth-server.ts

@@ -0,0 +1,214 @@
+/**
+ * Local HTTP callback server for the Command Code browser auth flow.
+ *
+ * Starts a one-shot server on a CLI-compatible localhost port. The Command Code
+ * Studio website POSTs the user's API key to /callback after they authenticate.
+ */
+
+import { createServer, type Server } from "node:http"
+import type { AddressInfo } from "node:net"
+
+const DEFAULT_PORT = 5959
+const DEFAULT_PORT_RANGE = 10
+
+export interface AuthCallback {
+  apiKey: string
+  state: string
+  userId: string
+  userName: string
+  keyName: string
+}
+
+export interface AuthServer {
+  server: Server
+  port: number
+  waitForCallback: Promise<AuthCallback>
+}
+
+export interface AuthServerOptions {
+  startPort?: number
+  portRange?: number
+}
+
+function listenOnAvailablePort(
+  server: Server,
+  startPort = DEFAULT_PORT,
+  range = DEFAULT_PORT_RANGE,
+): Promise<number> {
+  return new Promise((resolve, reject) => {
+    let offset = 0
+
+    const tryListen = () => {
+      const useFallbackPort = startPort === 0 || offset >= range
+      const port = useFallbackPort ? 0 : startPort + offset
+
+      const onError = (err: NodeJS.ErrnoException) => {
+        server.off("listening", onListening)
+        if (err.code === "EADDRINUSE" && !useFallbackPort) {
+          offset += 1
+          tryListen()
+          return
+        }
+        reject(err)
+      }
+
+      const onListening = () => {
+        server.off("error", onError)
+        const address = server.address() as AddressInfo
+        resolve(address.port)
+      }
+
+      server.once("error", onError)
+      server.once("listening", onListening)
+      server.listen(port, "127.0.0.1")
+    }
+
+    tryListen()
+  })
+}
+
+function closeServer(server: Server) {
+  server.close((err: NodeJS.ErrnoException | undefined) => {
+    if (err && err.code !== "ERR_SERVER_NOT_RUNNING") {
+      // There is nowhere useful to report this during auth cleanup.
+    }
+  })
+}
+
+/**
+ * Start a local HTTP server that listens for the Command Code Studio
+ * to POST the API key after the user authenticates in their browser.
+ *
+ * The server accepts exactly one valid POST to /callback and then closes.
+ */
+export async function startAuthServer(options: AuthServerOptions = {}): Promise<AuthServer> {
+  let resolveCallback!: (value: AuthCallback) => void
+  let rejectCallback!: (error: Error) => void
+
+  const waitForCallback = new Promise<AuthCallback>((resolve, reject) => {
+    resolveCallback = resolve
+    rejectCallback = reject
+  })
+
+  const server = createServer((req, res) => {
+    // CORS: allow requests from Command Code domains and localhost for dev.
+    const origin = req.headers.origin || ""
+    const allowedOrigins = [
+      "http://localhost:3000",
+      "https://staging.commandcode.ai",
+      "https://commandcode.ai",
+    ]
+    const responseOrigin = allowedOrigins.includes(origin) ? origin : allowedOrigins[0]
+    const requestedHeaders = req.headers["access-control-request-headers"]
+
+    res.setHeader("Access-Control-Allow-Origin", responseOrigin)
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS")
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      typeof requestedHeaders === "string" && requestedHeaders.length > 0
+        ? requestedHeaders
+        : "Content-Type",
+    )
+    // Chrome's Private Network Access preflight may require this for an HTTPS
+    // page posting to a localhost HTTP callback.
+    res.setHeader("Access-Control-Allow-Private-Network", "true")
+    res.setHeader("Content-Type", "application/json")
+
+    // Handle CORS preflight.
+    if (req.method === "OPTIONS") {
+      res.writeHead(204)
+      res.end()
+      return
+    }
+
+    if (req.url !== "/callback") {
+      res.writeHead(404)
+      res.end(JSON.stringify({ success: false, error: "Not found" }))
+      return
+    }
+
+    if (req.method !== "POST") {
+      res.writeHead(405)
+      res.end(
+        JSON.stringify({
+          success: false,
+          error: "Method not allowed. Use POST.",
+        }),
+      )
+      return
+    }
+
+    let body = ""
+    req.on("data", (chunk) => {
+      body += chunk.toString()
+      if (body.length > 10_000) req.destroy()
+    })
+
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body) as Record<string, unknown>
+
+        if (parsed.error) {
+          res.writeHead(200)
+          res.end(JSON.stringify({ success: true }))
+          const description =
+            typeof parsed.error_description === "string"
+              ? parsed.error_description
+              : String(parsed.error)
+          if (parsed.error === "access_denied") {
+            rejectCallback(new Error(description || "Authorization was denied by the user"))
+          } else {
+            rejectCallback(new Error(description || String(parsed.error)))
+          }
+          closeServer(server)
+          return
+        }
+
+        const apiKey = typeof parsed.apiKey === "string" ? parsed.apiKey : ""
+        const state = typeof parsed.state === "string" ? parsed.state : ""
+        const userId = typeof parsed.userId === "string" ? parsed.userId : ""
+        const userName = typeof parsed.userName === "string" ? parsed.userName : ""
+        const keyName = typeof parsed.keyName === "string" ? parsed.keyName : ""
+
+        if (!apiKey || !state || !userId || !userName || !keyName) {
+          res.writeHead(400)
+          res.end(
+            JSON.stringify({
+              success: false,
+              error: "Missing required fields",
+            }),
+          )
+          return
+        }
+
+        res.writeHead(200)
+        res.end(JSON.stringify({ success: true }))
+
+        resolveCallback({ apiKey, state, userId, userName, keyName })
+        closeServer(server)
+      } catch {
+        res.writeHead(400)
+        res.end(JSON.stringify({ success: false, error: "Invalid JSON" }))
+      }
+    })
+
+    req.on("error", () => {
+      res.writeHead(500)
+      res.end(JSON.stringify({ success: false, error: "Request error" }))
+    })
+  })
+
+  try {
+    const port = await listenOnAvailablePort(
+      server,
+      options.startPort ?? DEFAULT_PORT,
+      options.portRange ?? DEFAULT_PORT_RANGE,
+    )
+    return { server, port, waitForCallback }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    const error = new Error(`Failed to start auth server: ${message}`)
+    rejectCallback(error)
+    throw error
+  }
+}