pi-windsurf-beta 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 khanhdeptraivaicachuong
+
+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,2 @@
+# pi-windsurf-beta
+

package/auth.ts

@@ -0,0 +1,139 @@
+/**
+ * Mint short-lived user_jwt for chat RPCs.
+ *
+ * POST https://server.codeium.com/exa.auth_pb.AuthService/GetUserJwt
+ */
+import * as crypto from "crypto";
+import { encodeMessage, iterFields } from "./wire";
+import { buildMetadata } from "./metadata";
+
+const DEFAULT_HOST = "https://server.codeium.com";
+
+function anySignal(signals: AbortSignal[]): AbortSignal {
+  const builtin = (AbortSignal as unknown as { any?: (s: AbortSignal[]) => AbortSignal }).any;
+  if (typeof builtin === "function") return builtin(signals);
+  const controller = new AbortController();
+  const onAbort = (reason: unknown): void => {
+    if (!controller.signal.aborted) controller.abort(reason);
+  };
+  for (const s of signals) {
+    if (s.aborted) { onAbort(s.reason); break; }
+    s.addEventListener("abort", () => onAbort(s.reason), { once: true });
+  }
+  return controller.signal;
+}
+
+export interface MintedUserJwt {
+  jwt: string;
+  expiresAt: number;
+}
+
+export class CloudAuthError extends Error {
+  constructor(message: string, public readonly status?: number) {
+    super(message);
+    this.name = "CloudAuthError";
+  }
+}
+
+export async function mintUserJwt(
+  apiKey: string,
+  host: string = DEFAULT_HOST,
+  signal?: AbortSignal,
+): Promise<MintedUserJwt> {
+  const metadata = buildMetadata({
+    apiKey,
+    sessionId: crypto.randomUUID(),
+    requestId: BigInt(Date.now()),
+    triggerId: crypto.randomUUID(),
+  });
+  const req = encodeMessage(1, metadata);
+
+  const timeoutSignal = AbortSignal.timeout(30_000);
+  const combinedSignal: AbortSignal = signal ? anySignal([signal, timeoutSignal]) : timeoutSignal;
+
+  const resp = await fetch(`${host.replace(/\/$/, "")}/exa.auth_pb.AuthService/GetUserJwt`, {
+    method: "POST",
+    headers: { "Content-Type": "application/proto", "Connect-Protocol-Version": "1" },
+    body: req,
+    signal: combinedSignal,
+  });
+  const buf = Buffer.from(await resp.arrayBuffer());
+
+  if (!resp.ok) {
+    const text = buf.toString("utf8");
+    throw new CloudAuthError(`GetUserJwt HTTP ${resp.status}: ${text.slice(0, 400)}`, resp.status);
+  }
+
+  let jwt: string | null = null;
+  for (const f of iterFields(buf)) {
+    if (f.num === 1 && f.wire === 2 && Buffer.isBuffer(f.value)) {
+      const s = (f.value as Buffer).toString("utf8");
+      if (/^eyJ[A-Za-z0-9_-]{10,}={0,2}\.[A-Za-z0-9_-]+={0,2}\.[A-Za-z0-9_-]+={0,2}$/.test(s)) {
+        jwt = s;
+        break;
+      }
+    }
+  }
+  if (!jwt) {
+    throw new CloudAuthError(`GetUserJwt 200 but no field-1 JWT found (${buf.length} bytes)`);
+  }
+
+  let expiresAt = Math.floor(Date.now() / 1000) + 600;
+  try {
+    const parts = jwt.split(".");
+    const pad = (s: string) => s + "=".repeat((4 - (s.length % 4)) % 4);
+    const payload = JSON.parse(
+      Buffer.from(pad(parts[1]).replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8"),
+    );
+    if (typeof payload.exp === "number") expiresAt = payload.exp;
+  } catch { /* fall back to default */ }
+
+  return { jwt, expiresAt };
+}
+
+// ----------------------------------------------------------------------------
+// In-memory cache
+// ----------------------------------------------------------------------------
+
+interface CacheEntry {
+  jwt: string;
+  expiresAt: number;
+  apiKey: string;
+  host: string;
+}
+
+let cache: CacheEntry | null = null;
+const inFlight = new Map<string, Promise<MintedUserJwt>>();
+let cacheEpoch = 0;
+
+function flightKey(apiKey: string, host: string): string {
+  return `${host}\x1f${apiKey}`;
+}
+
+export async function getCachedUserJwt(apiKey: string, host: string = DEFAULT_HOST, signal?: AbortSignal): Promise<string> {
+  const now = Math.floor(Date.now() / 1000);
+  if (cache && cache.apiKey === apiKey && cache.host === host && cache.expiresAt > now + 60) {
+    return cache.jwt;
+  }
+  const key = flightKey(apiKey, host);
+  const existing = inFlight.get(key);
+  if (existing) return (await existing).jwt;
+  const promise = mintUserJwt(apiKey, host, signal);
+  inFlight.set(key, promise);
+  const epochAtStart = cacheEpoch;
+  try {
+    const minted = await promise;
+    if (cacheEpoch === epochAtStart) {
+      cache = { jwt: minted.jwt, expiresAt: minted.expiresAt, apiKey, host };
+    }
+    return minted.jwt;
+  } finally {
+    inFlight.delete(key);
+  }
+}
+
+export function clearCachedUserJwt(): void {
+  cache = null;
+  inFlight.clear();
+  cacheEpoch++;
+}

package/catalog.ts

@@ -0,0 +1,139 @@
+/**
+ * Per-account model catalog from Cognition's GetCascadeModelConfigs.
+ *
+ * Fetches live model list at startup and after login. Used for:
+ *   1. Dynamic model registration (new models appear automatically)
+ *   2. Pre-flight availability check (reject disabled models before wasting a roundtrip)
+ */
+import * as crypto from "crypto";
+import { buildMetadata } from "./metadata";
+import { getCachedUserJwt, clearCachedUserJwt } from "./auth";
+import { encodeMessage, iterFields } from "./wire";
+import { clearSessionIds } from "./chat";
+
+const CATALOG_TTL_MS = 10 * 60 * 1000;
+const CATALOG_FETCH_TIMEOUT_MS = 10_000;
+
+export interface ModelCatalogEntry {
+  modelUid: string;
+  label: string;
+  disabled: boolean;
+}
+
+interface CacheEntry {
+  byUid: Map<string, ModelCatalogEntry>;
+  fetchedAt: number;
+  apiKey: string;
+  host: string;
+}
+
+let cached: CacheEntry | null = null;
+let inFlight: Promise<CacheEntry> | null = null;
+let inFlightKey: string | null = null;
+
+function flightKey(apiKey: string, host: string): string {
+  return `${host}\x1f${apiKey}`;
+}
+
+async function fetchCatalog(apiKey: string, host: string, signal?: AbortSignal): Promise<CacheEntry> {
+  const userJwt = await getCachedUserJwt(apiKey, host, signal);
+
+  const metadata = buildMetadata({
+    apiKey, userJwt,
+    sessionId: crypto.randomUUID(),
+    requestId: BigInt(Date.now()),
+    triggerId: crypto.randomUUID(),
+  });
+  const reqBody = encodeMessage(1, metadata);
+
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(new Error(`catalog fetch timeout (${CATALOG_FETCH_TIMEOUT_MS}ms)`)), CATALOG_FETCH_TIMEOUT_MS);
+  let resp: Response;
+  try {
+    resp = await fetch(`${host}/exa.api_server_pb.ApiServerService/GetCascadeModelConfigs`, {
+      method: "POST",
+      headers: { "Content-Type": "application/proto", "Connect-Protocol-Version": "1" },
+      body: reqBody,
+      signal: ac.signal,
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`GetCascadeModelConfigs HTTP ${resp.status}: ${text.slice(0, 200)}`);
+  }
+  const buf = Buffer.from(await resp.arrayBuffer());
+
+  const byUid = new Map<string, ModelCatalogEntry>();
+  for (const f of iterFields(buf)) {
+    if (f.num !== 1 || f.wire !== 2 || !Buffer.isBuffer(f.value)) continue;
+    let label = "";
+    let modelUid = "";
+    let disabled = false;
+    for (const sf of iterFields(f.value as Buffer)) {
+      if (sf.num === 1 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
+        label = (sf.value as Buffer).toString("utf8");
+      } else if (sf.num === 4 && sf.wire === 0) {
+        disabled = sf.value === 1n;
+      } else if (sf.num === 22 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
+        modelUid = (sf.value as Buffer).toString("utf8");
+      }
+    }
+    if (modelUid.length > 0) {
+      byUid.set(modelUid, { modelUid, label: label || modelUid, disabled });
+    }
+  }
+
+  return { byUid, fetchedAt: Date.now(), apiKey, host };
+}
+
+export async function getCachedCatalog(
+  apiKey: string,
+  host: string,
+  signal?: AbortSignal,
+): Promise<CacheEntry | null> {
+  if (cached && cached.apiKey === apiKey && cached.host === host) {
+    if (Date.now() - cached.fetchedAt < CATALOG_TTL_MS) return cached;
+  }
+
+  const key = flightKey(apiKey, host);
+  if (inFlight && inFlightKey === key) {
+    try { return await inFlight; } catch { return null; }
+  }
+
+  const promise = fetchCatalog(apiKey, host, signal);
+  inFlight = promise;
+  inFlightKey = key;
+  try {
+    const result = await promise;
+    cached = result;
+    return result;
+  } catch {
+    return null;
+  } finally {
+    if (inFlight === promise) { inFlight = null; inFlightKey = null; }
+  }
+}
+
+export function clearCachedCatalog(): void {
+  cached = null;
+  inFlight = null;
+  inFlightKey = null;
+}
+
+export class ModelNotAvailableError extends Error {
+  constructor(
+    public readonly modelUid: string,
+    public readonly label: string,
+    public readonly reason: "disabled" | "not_listed",
+  ) {
+    super(
+      reason === "disabled"
+        ? `Model "${label}" (uid=${modelUid}) is not enabled for your Cognition account. Check https://codeium.com/account.`
+        : `Model uid "${modelUid}" is not listed in the Cognition catalog for your account.`,
+    );
+    this.name = "ModelNotAvailableError";
+  }
+}