pi-free 2.2.3 → 2.2.5

package/providers/qoder/cosy.ts

@@ -0,0 +1,236 @@
+/**
+ * COSY cryptographic signing for Qoder API authentication.
+ *
+ * Qoder uses a proprietary signing scheme (COSY) that combines RSA-encrypted
+ * AES keys, AES-CBC-encrypted user info, and MD5 payload signing. This module
+ * reimplements the same algorithm used by the official qodercli binary.
+ *
+ * The auth flow:
+ *   1. Generate a random 16-byte AES key
+ *   2. AES-CBC-encrypt user info (uid, auth token, name, email) with it
+ *   3. RSA-encrypt the AES key with Qoder's public key
+ *   4. Build a COSY payload: { version, requestId, info, cosyVersion, ideVersion }
+ *   5. MD5-hash: payloadB64 + "\n" + cosyKey + "\n" + timestamp + "\n" + body + "\n" + sigPath
+ *   6. Send as Authorization: Bearer COSY.{payloadB64}.{sig} + 15 Cosy-* headers
+ */
+
+import crypto from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+
+const QODER_IDE_VERSION = "1.0.0";
+const QODER_CLIENT_TYPE = "5";
+const QODER_DATA_POLICY = "disagree";
+const QODER_LOGIN_VERSION = "v2";
+const QODER_MACHINE_OS = "x86_64_windows";
+const QODER_MACHINE_TYPE_MAGIC = "5";
+
+interface UserInfo {
+	uid: string;
+	security_oauth_token: string;
+	name: string;
+	aid: string;
+	email: string;
+}
+
+interface CosyPayload {
+	version: string;
+	requestId: string;
+	info: string;
+	cosyVersion: string;
+	ideVersion: string;
+}
+
+export interface CosyCredentials {
+	userID: string;
+	authToken: string;
+	name: string;
+	email: string;
+	machineID?: string;
+}
+
+type BodyInput = Buffer | string | null;
+
+function bodyToUtf8(body: BodyInput): string {
+	if (!body) return "";
+	if (Buffer.isBuffer(body)) return body.toString("utf8");
+	return body;
+}
+
+function bodyToLengthString(body: BodyInput): string {
+	if (!body) return "0";
+	if (Buffer.isBuffer(body)) return String(body.length);
+	return String(Buffer.from(body).length);
+}
+
+function rsaEncryptBase64(data: Buffer | string): string {
+	const key = {
+		key: QODER_RSA_PUBLIC_KEY,
+		padding: crypto.constants.RSA_PKCS1_PADDING,
+	};
+	const encrypted = crypto.publicEncrypt(
+		key,
+		typeof data === "string" ? Buffer.from(data) : data,
+	);
+	return encrypted.toString("base64");
+}
+
+/**
+ * Encrypt plaintext with AES-128-CBC using the same key for both key and IV.
+ *
+ * NOTE: Using key as IV is insecure in general and would be flagged by static
+ * analysis tools. However, this is a strict requirement of Qoder's COSY protocol
+ * (reverse-engineered from the official CLI). Changing the mode or IV derivation
+ * will cause authentication failures.
+ *
+ * @param plaintext - Data to encrypt
+ * @param keyStr - 16-byte hex key (also used as IV per protocol spec)
+ * @returns Base64-encoded ciphertext
+ */
+function aesEncryptCBCBase64(plaintext: string, keyStr: string): string {
+	// sonar-security: AES-CBC with key-as-IV is protocol-mandatory for Qoder COSY auth
+	const cipher = crypto.createCipheriv(
+		"aes-128-cbc",
+		Buffer.from(keyStr),
+		Buffer.from(keyStr),
+	);
+	let encrypted = cipher.update(plaintext, "utf8", "base64");
+	encrypted += cipher.final("base64");
+	return encrypted;
+}
+
+function computeSigPath(urlStr: string): string {
+	try {
+		const parsed = new URL(urlStr);
+		let sigPath = parsed.pathname;
+		if (sigPath.startsWith("/algo")) {
+			sigPath = sigPath.slice("/algo".length);
+		}
+		return sigPath;
+	} catch {
+		return "";
+	}
+}
+
+/**
+ * Get or create a persistent machine ID.
+ * Checks ~/.qoder/.auth/machine_id first, then falls back to ~/.pi/agent/qoder-machine-id.
+ */
+export function getMachineId(): string {
+	const paths = [
+		join(homedir(), ".qoder", ".auth", "machine_id"),
+		join(homedir(), ".pi", "agent", "qoder-machine-id"),
+	];
+	for (const p of paths) {
+		if (existsSync(p)) {
+			try {
+				const val = readFileSync(p, "utf8").trim();
+				if (val) return val;
+			} catch {
+				// Ignore read errors
+			}
+		}
+	}
+	const newId = crypto.randomUUID();
+	try {
+		const savePath = paths[1];
+		mkdirSync(dirname(savePath), { recursive: true });
+		writeFileSync(savePath, newId, "utf8");
+	} catch {
+		// Best-effort
+	}
+	return newId;
+}
+
+/**
+ * Build all COSY authentication headers for a Qoder API request.
+ *
+ * @param body - Request body (Buffer or string), or null for GET requests
+ * @param requestURL - Full URL being requested
+ * @param creds - COSY credentials (userID, authToken, name, email, machineID)
+ * @returns Record of headers to include in the request
+ */
+export function buildAuthHeaders(
+	body: Buffer | string | null,
+	requestURL: string,
+	creds: CosyCredentials,
+): Record<string, string> {
+	if (!creds.userID) {
+		throw new Error("cosy: user id is empty");
+	}
+	if (!creds.authToken) {
+		throw new Error("cosy: auth token is empty");
+	}
+
+	const aesKey = crypto.randomUUID().replaceAll(/-/g, "").slice(0, 16);
+	const userInfo: UserInfo = {
+		uid: creds.userID,
+		security_oauth_token: creds.authToken,
+		name: creds.name || "",
+		aid: "",
+		email: creds.email || "",
+	};
+
+	const infoB64 = aesEncryptCBCBase64(JSON.stringify(userInfo), aesKey);
+	const cosyKey = rsaEncryptBase64(aesKey);
+
+	const timestamp = Math.floor(Date.now() / 1000).toString();
+	const requestId = crypto.randomUUID();
+
+	const cosyPayload: CosyPayload = {
+		version: "v1",
+		requestId,
+		info: infoB64,
+		cosyVersion: QODER_IDE_VERSION,
+		ideVersion: "",
+	};
+
+	const payloadB64 = Buffer.from(JSON.stringify(cosyPayload)).toString(
+		"base64",
+	);
+	const sigPath = computeSigPath(requestURL);
+
+	const bodyStr = bodyToUtf8(body);
+	const sigInput = `${payloadB64}\n${cosyKey}\n${timestamp}\n${bodyStr}\n${sigPath}`;
+	// sonar-security: MD5 is protocol-mandatory for COSY signature (reverse-engineered from Qoder CLI)
+	const sig = crypto.createHash("md5").update(sigInput).digest("hex");
+
+	// sonar-security: MD5 is protocol-mandatory for COSY body hash (reverse-engineered from Qoder CLI)
+	const bodyHash = crypto
+		.createHash("md5")
+		.update(body || "")
+		.digest("hex");
+	const bodyLen = bodyToLengthString(body);
+
+	const machineID = creds.machineID || getMachineId();
+
+	return {
+		Authorization: `Bearer COSY.${payloadB64}.${sig}`,
+		"Cosy-Key": cosyKey,
+		"Cosy-User": creds.userID,
+		"Cosy-Date": timestamp,
+		"Cosy-Version": QODER_IDE_VERSION,
+		"Cosy-Machineid": machineID,
+		"Cosy-Machinetoken": machineID,
+		"Cosy-Machinetype": QODER_MACHINE_TYPE_MAGIC,
+		"Cosy-Machineos": QODER_MACHINE_OS,
+		"Cosy-Clienttype": QODER_CLIENT_TYPE,
+		"Cosy-Clientip": "127.0.0.1",
+		"Cosy-Bodyhash": bodyHash,
+		"Cosy-Bodylength": bodyLen,
+		"Cosy-Sigpath": sigPath,
+		"Cosy-Data-Policy": QODER_DATA_POLICY,
+		"Cosy-Organization-Id": "",
+		"Cosy-Organization-Tags": "",
+		"Login-Version": QODER_LOGIN_VERSION,
+		"X-Request-Id": crypto.randomUUID(),
+	};
+}

package/providers/qoder/models.ts

@@ -0,0 +1,209 @@
+/**
+ * Qoder model definitions and cache management.
+ *
+ * Qoder operates on a credits-based pricing model:
+ *   - Community Edition (free): basic models with daily message limits
+ *   - Pro / Pro+ / Ultra (paid): premium models via monthly credits
+ *
+ * The dynamic model list API is currently unavailable (legacy api3 endpoint
+ * is decommissioned). We keep a static curated list and classify models as
+ * basic (free tier) or premium (paid credits) by model ID.
+ *
+ * Dynamic model discovery is disabled until Qoder publishes a model-list
+ * endpoint on api2-v2. Stale legacy cache entries are ignored and static
+ * models in `staticModels` remain the source of truth.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { createLogger } from "../../lib/logger.ts";
+
+const _logger = createLogger("qoder");
+
+export type QoderModelConfig = ProviderModelConfig;
+
+// ─── Cache ───────────────────────────────────────────────────────────────────
+
+const CACHE_PATH = join(homedir(), ".pi", "agent", "qoder-models-cache.json");
+
+const ZERO_COST = Object.freeze({
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+});
+
+// ─── Basic (free-tier) model IDs ─────────────────────────────────────────────
+// These are the Qoder-branded router models available on Community Edition.
+// Named models (DeepSeek, Qwen, GLM, Kimi, MiniMax) are premium and cost credits.
+// This set is the single source of truth for basic-model classification.
+const BASIC_MODEL_IDS = new Set([
+	"auto",
+	"ultimate",
+	"performance",
+	"efficient",
+	"lite",
+]);
+
+// ─── Static model list ───────────────────────────────────────────────────────
+
+/**
+ * Static model definitions for Qoder.
+ * Basic models (free tier) are identified by membership in BASIC_MODEL_IDS.
+ * Premium models consume credits and require a paid plan.
+ *
+ * Model IDs are validated against the live api2-v2 endpoint; invalid IDs
+ * (dfmodel, gm51model, qmodel_latest) are excluded here.
+ */
+export const staticModels: QoderModelConfig[] = [
+	{
+		id: "auto",
+		name: "Qoder Auto",
+		reasoning: true,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 180_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "ultimate",
+		name: "Qoder Ultimate",
+		reasoning: true,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "performance",
+		name: "Qoder Performance",
+		reasoning: true,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "efficient",
+		name: "Qoder Efficient",
+		reasoning: false,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 180_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "lite",
+		name: "Qoder Lite",
+		reasoning: false,
+		input: ["text"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 180_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "qmodel",
+		name: "Qwen3.7 Plus (Qoder)",
+		reasoning: false,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "dmodel",
+		name: "DeepSeek V4 Pro (Qoder)",
+		reasoning: true,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "kmodel",
+		name: "Kimi K2.6 (Qoder)",
+		reasoning: false,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 256_000,
+		maxTokens: 32_768,
+	},
+	{
+		id: "mmodel",
+		name: "MiniMax M3 (Qoder)",
+		reasoning: false,
+		input: ["text", "image"] as ("text" | "image")[],
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 32_768,
+	},
+];
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Check if a model is a basic (free-tier) model. */
+export function isBasicModel(model: ProviderModelConfig): boolean {
+	return BASIC_MODEL_IDS.has(model.id);
+}
+
+// ─── Cache management ────────────────────────────────────────────────────────
+
+/** Get models from cache, falling back to static models. */
+export function getCachedModels(): QoderModelConfig[] {
+	if (existsSync(CACHE_PATH) && !isCacheStale()) {
+		try {
+			const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+			if (data && Array.isArray(data.models)) {
+				return data.models as QoderModelConfig[];
+			}
+		} catch (err) {
+			_logger.warn(
+				"Failed to read Qoder model cache; falling back to static models",
+				{
+					error: err instanceof Error ? err.message : String(err),
+				},
+			);
+		}
+	}
+	return staticModels;
+}
+
+/** Check if the local model cache is stale (>1 hour old). */
+export function isCacheStale(): boolean {
+	if (!existsSync(CACHE_PATH)) return true;
+	try {
+		const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+		if (!data || typeof data.updatedAt !== "number") return true;
+		return Date.now() - data.updatedAt > 3_600_000; // 1 hour
+	} catch (err) {
+		_logger.warn("Failed to check Qoder cache staleness; treating as stale", {
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return true;
+	}
+}
+
+/**
+ * Get the cached model config for a specific model key.
+ * Used to determine per-model settings (reasoning, max tokens, etc.) at stream time.
+ */
+export function getCachedModelConfig(
+	modelKey: string,
+): Record<string, unknown> | null {
+	if (existsSync(CACHE_PATH) && !isCacheStale()) {
+		try {
+			const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+			if (data?.configs?.[modelKey]) {
+				return data.configs[modelKey] as Record<string, unknown>;
+			}
+		} catch (err) {
+			_logger.warn("Failed to read Qoder model config cache", {
+				modelKey,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
+	}
+	return null;
+}

package/providers/qoder/qoder.ts

@@ -0,0 +1,119 @@
+/**
+ * Qoder Provider Extension
+ *
+ * Registers the Qoder provider with Pi, providing free access to top-tier
+ * LLM models (DeepSeek V4 Pro/Flash, Qwen3.7 Plus/Max, GLM 5.1, Kimi K2.6,
+ * MiniMax M3) through Qoder's OpenAI-compatible API.
+ *
+ * Qoder uses a custom authentication protocol (PAT exchange + COSY signing)
+ * and a credits-based pricing model:
+ *   - Community Edition (free): basic models with daily message limits
+ *   - Pro / Pro+ / Ultra (paid): premium models via monthly credits
+ *
+ * Usage:
+ *   Install pi-free, then run /login qoder to authenticate
+ *   (PAT paste or browser OAuth)
+ *   /toggle-qoder switches between basic (free-tier) and all models
+ *
+ * Environment variables:
+ *   QODER_PERSONAL_ACCESS_TOKEN — PAT for headless auth (optional)
+ *   QODER_PAT                   — Alias for above
+ */
+
+import type { Api, OAuthCredentials } from "@earendil-works/pi-ai";
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+import { BASE_URL_QODER, PROVIDER_QODER } from "../../constants.ts";
+import { getProviderShowPaid } from "../../config.ts";
+import {
+	getCachedModels,
+	isBasicModel,
+	type QoderModelConfig,
+} from "./models.ts";
+import { getCachedCredentials, loginQoder, refreshQoderToken } from "./auth.ts";
+import { streamQoder } from "./stream.ts";
+import { enhanceWithCI } from "../../provider-helper.ts";
+import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { createToggleState } from "../../lib/toggle-state.ts";
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
+export default async function qoderProvider(pi: ExtensionAPI) {
+	const logger = (await import("../../lib/logger.ts")).createLogger("qoder");
+
+	// Initial model fetch
+	const allModels: QoderModelConfig[] = getCachedModels();
+	const basicModels: QoderModelConfig[] = allModels.filter(isBasicModel);
+	const stored = { free: basicModels, all: allModels };
+
+	const toggleState = createToggleState({
+		providerId: PROVIDER_QODER,
+		initialShowPaid: getProviderShowPaid(PROVIDER_QODER),
+		initialModels: stored,
+	});
+
+	// ── OAuth config (defined before reRegister so it's always available) ──
+	const oauthConfig = {
+		name: "Qoder (Browser OAuth / PAT)",
+		login: async (callbacks: any): Promise<OAuthCredentials> => {
+			return loginQoder(callbacks);
+		},
+		refreshToken: refreshQoderToken,
+		getApiKey: (cred: OAuthCredentials) => cred.access,
+	};
+
+	// Re-register function — called by toggle, session refresh, login
+	const reRegister = (models: ProviderModelConfig[]) => {
+		const enhanced = enhanceWithCI(models, PROVIDER_QODER);
+		pi.registerProvider(PROVIDER_QODER, {
+			baseUrl: BASE_URL_QODER,
+			api: "qoder-api" as Api,
+			models: enhanced,
+			oauth: oauthConfig,
+			streamSimple: streamQoder,
+		});
+	};
+
+	// Register with global toggle system so it participates in /toggle-free
+	registerWithGlobalToggle(PROVIDER_QODER, stored, (m) => reRegister(m), false);
+
+	// Per-provider toggle: /toggle-qoder (basic free-tier ↔ all models)
+	pi.registerCommand("toggle-qoder", {
+		description: "Toggle between basic (free-tier) and all Qoder models",
+		handler: async (_args, ctx) => {
+			try {
+				const applied = toggleState.toggle(reRegister);
+				const basicCount = stored.free.length;
+				const premiumCount = stored.all.length - basicCount;
+				if (applied.mode === "all") {
+					ctx.ui.notify(
+						`qoder: showing all ${stored.all.length} models (${basicCount} basic, ${premiumCount} premium)`,
+						"info",
+					);
+				} else {
+					ctx.ui.notify(
+						`qoder: showing ${stored.free.length} basic (free-tier) models`,
+						"info",
+					);
+				}
+			} catch (err) {
+				logger.error("[qoder] toggle failed", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+				ctx.ui.notify("qoder: toggle failed", "error");
+			}
+		},
+	});
+
+	// Initial registration respects the configured show-paid mode.
+	toggleState.applyCurrent(reRegister);
+
+	logger.info(`[qoder] Provider registered with ${allModels.length} models`);
+}
+
+// Re-export key symbols for testing
+export { loginQoder, refreshQoderToken, getCachedCredentials, streamQoder };