cartethyia 2.7.6 → 2.7.8

package/src/providers/integrations/qoder/qoder-realm.ts

@@ -13,6 +13,9 @@
 // Sourced from the donor hub `Public/qoder2api-hub` (`REALM_CONFIGS` in
 // `qoder_accounts.py`), which builds every upstream URL from this table.
 
+/** The bundled provider id for the intl deployment. */
+export const QODER_PROVIDER_ID = "qoder" as const;
+
 /** One Qoder deployment. */
 export type QoderRealm = "intl" | "cn";
 
@@ -30,10 +33,30 @@ export interface QoderRealmConfig {
   readonly clientId: string;
   /** Native redirect the desktop client registers. */
   readonly redirectUri: string;
-  /** Upstream-facing User-Agent. */
+  /**
+   * Upstream-facing User-Agent for the openapi/business surface. Verified
+   * live: the /sash campaign surface accepts plain `Qoder` / `QoderWork`
+   * (no version token).
+   */
   readonly userAgent: string;
+  /**
+   * Job-token exchange endpoint for PAT → jt (v1, plain JSON body).
+   * Verified live: `POST center.qoder.sh/api/v1/jobToken/exchange` with
+   * `{personal_token, machine_id}` returns `{token: jt-…, …}`.
+   */
+  readonly jobTokenUrl: string;
 }
 
+/**
+ * User agents observed in actual live captures of the real client
+ * (2026-11-05, mitmproxy):
+ * - CLI / legacy COSY chat + device flow: `Bun/1.4.2` (flow 218/030, v1.1.83)
+ * - IDE surface `/model/v1`: `Bun/1.4.4` (flow 219)
+ * - job-token exchange: `qoder/<version>` (capture, e.g. `qoder/1.1.83`)
+ */
+export const QODER_UA_CLI = "Bun/1.4.2";
+export const QODER_UA_IDE = "Bun/1.4.4";
+
 /** Chat + model-list paths, identical across realms. */
 export const QODER_CHAT_PATH =
   "/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
@@ -58,6 +81,17 @@ export function qoderIdeChatUrl(realm: QoderRealm): string {
     : `https://api2-v2.qoder.sh${QODER_IDE_CHAT_PATH}`;
 }
 
+/**
+ * The gRPC model-server host for one realm.
+ *
+ * Matches the desktop client's prod host (`wYA` in `qoder-worker-runtime.mjs`:
+ * intl `api2-v2.qoder.sh`, CN `gateway.qoder.com.cn`). The gRPC service path
+ * is `/model.chat.ChatService/ChatCompletionStream` on port 443.
+ */
+export function qoderGrpcHost(realm: QoderRealm): string {
+  return realm === "cn" ? "gateway.qoder.com.cn" : "api2-v2.qoder.sh";
+}
+
 /**
  * Realm → deployment.
  *
@@ -73,7 +107,8 @@ export const QODER_REALMS: Readonly<Record<QoderRealm, QoderRealmConfig>> = {
     website: "https://qoder.com",
     clientId: "e883ade2-e6e3-4d6d-adf7-f92ceff5fdcb",
     redirectUri: "qoder://aicoding.aicoding-agent/login-success",
-    userAgent: "Qoder/1.1.64",
+    userAgent: "Qoder",
+    jobTokenUrl: "https://center.qoder.sh/api/v1/jobToken/exchange",
   },
   cn: {
     gateway: "https://gateway.qoder.com.cn",
@@ -84,7 +119,8 @@ export const QODER_REALMS: Readonly<Record<QoderRealm, QoderRealmConfig>> = {
     // the client id the IDE registers for the CN deployment.
     clientId: "e93fe488-5778-4c35-a6fc-0f54ed7b3139",
     redirectUri: "qoder-work-cn://",
-    userAgent: "QoderWork/1.1.64",
+    userAgent: "QoderWork",
+    jobTokenUrl: "https://openapi.qoder.com.cn/api/v1/jobToken/exchange",
   },
 };
 
@@ -101,7 +137,7 @@ export function qoderGatewayCandidates(realm: QoderRealm): readonly string[] {
 
 /**
  * Inference hosts for one realm, ordered by token kind — mirrors the donor's
- * `qoderInferenceBase` (9router): job tokens (`jt-...`) are served by `api2`
+ * `qoderInferenceBase` (donor hub): job tokens (`jt-...`) are served by `api2`
  * and get rejected by `api3` with "Login expired" (403), while device tokens
  * (`dt-...`) and everything else use the ordinary gateway set. CN has a
  * single gateway and serves every token kind.

package/src/providers/integrations/qoder/qoder-types.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared Qoder types.
+ *
+ * Kept as a separate module so the transports (gRPC, IDE/HTTP, legacy COSY)
+ * and the auth layer share one shape without importing each other.
+ */
+import type { QoderRealm } from "./qoder-realm";
+
+export type { QoderRealm };
+
+export interface QoderAuth {
+  userId: string;
+  userName: string;
+  userType: string;
+  securityOauthToken: string;
+  refreshToken: string;
+  /** One UUID-like machine id used in COSY signing and session identity. */
+  machineId: string;
+  /**
+   * Native UMID machine token (`P1gA…`), when a native identity is bound.
+   * Absent for OAuth device tokens; the COSY header set then falls back to
+   * `machineId` for the token/type/code fields.
+   */
+  machineToken?: string;
+  /** Native UMID machine type (18-hex), when known. */
+  machineType?: string;
+  /** Native UMID machine code (18-hex), when known. */
+  machineCode?: string;
+}
+
+export interface QoderModelConfig {
+  id: string;
+  display_name: string;
+  max_input_tokens: number;
+  max_output_tokens?: number;
+  is_vl: boolean;
+  is_reasoning: boolean;
+  /**
+   * Whether upstream publishes this row as free. Only an explicit `true`
+   * marks the model as free-tier; absent or `false` means billed/unknown, so
+   * a 402/116 there is genuine quota exhaustion, not a free-tier entitlement
+   * refusal, and must not trigger a legacy-surface fallback.
+   */
+  is_free?: boolean;
+  source?: string;
+  /**
+   * Reasoning effort to send when the caller did not ask for one. Some models
+   * on the IDE surface stream no reasoning unless an effort is present.
+   */
+  default_reasoning_effort?: string;
+}

package/src/providers/integrations/qoder/qoder-umid.ts

@@ -34,8 +34,10 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { log } from "../../../observability/logger";
+import { qoderMachineHostname, qoderMachineOs } from "../../operations/cli-platform";
 
 /** Environment code: an upstream "region/flavor", not a device identity. */
 const ENV_CODE = "3";
@@ -60,12 +62,66 @@ export function umidpackDir(): string {
   return join(process.cwd(), "vendor", "qoder-umid", "umidpack");
 }
 
+/** The vendored mini-ELF tarball (static glibc bundle for containers). */
+export function umidMiniTarball(): string {
+  return join(process.cwd(), "vendor", "qoder-umid", "qoder-umid-mini.tar.gz");
+}
+
+/**
+ * Staging directory for the extracted mini-ELF bundle. Uses a per-user cache
+ * dir (respecting `XDG_CACHE_HOME` on Linux) so a container does not need to
+ * carry the extracted tree, and the repo stays clean.
+ */
+export function umidMiniDir(): string {
+  const base = process.env.XDG_CACHE_HOME?.trim() || join(process.env.HOME ?? tmpdir(), ".cache");
+  return join(base, "cartethyia", "umid-mini");
+}
+
+let miniExtracted = false;
+
+/** Extracts `qoder-umid-mini.tar.gz` once into {@link umidMiniDir}. */
+export function ensureUmidMiniExtracted(): boolean {
+  const tar = umidMiniTarball();
+  const out = umidMiniDir();
+  if (!existsSync(tar)) return false;
+  if (existsSync(join(out, "opt", "umid", "runtime-info")) && miniExtracted) return true;
+  try {
+    mkdirSync(out, { recursive: true });
+    // Re-extract on empty/missing target only; leave existing tree in place.
+    if (!existsSync(join(out, "opt", "umid", "runtime-info"))) {
+      const r = spawnSync("tar", ["-xzf", tar, "-C", out], { encoding: "utf8", timeout: 30_000 });
+      if (r.status !== 0) {
+        log.warn(`[qoder] umid mini extract failed: ${String(r.stderr ?? "").slice(0, 300)}`);
+        return false;
+      }
+    }
+    const bin = join(out, "opt", "umid", "runtime-info");
+    if (existsSync(bin)) chmodSync(bin, 0o755);
+    miniExtracted = true;
+    return true;
+  } catch (error) {
+    log.warn("[qoder] umid mini extract error", error as Error);
+    return false;
+  }
+}
+
 /** WSL-side staging/seed paths for the Linux bridge on a Windows host. */
 const WSL_BIN = "/tmp/umidpack/runtime-info";
 const WSL_SEED = "/home/risun/.config/.locale_cfg";
 const WSL_LOCK = "/tmp/umidpack/bridge.lock";
 
-type Bridge = { kind: "elf" | "macho" | "pe" | "wsl-elf" };
+type Bridge = { kind: "elf" | "macho" | "pe" | "wsl-elf" | "mini-elf" };
+
+/** True when this process runs inside a container (Docker/Podman). */
+function isContainerized(): boolean {
+  if (existsSync(join("/", ".dockerenv")) || existsSync(join("/", ".containerenv"))) return true;
+  try {
+    const cgroup = readFileSync("/proc/1/cgroup", "utf8");
+    return /(?:docker|containerd|podman|kubepods)/i.test(cgroup);
+  } catch {
+    return false;
+  }
+}
 
 /** Picks the bridge for this host; `null` when nothing genuine can run. */
 function pickBridge(): Bridge | null {
@@ -77,15 +133,34 @@ function pickBridge(): Bridge | null {
     const exe = join(umidpackDir(), "runtime-info.exe");
     const dll = join(umidpackDir(), "sgsdk.dll");
     if (existsSync(exe) && existsSync(dll)) return { kind: "pe" };
-    return null;
+    // Windows has no native mini-ELF runner; WSL may still be present.
+    return ensureUmidMiniExtracted() ? { kind: "wsl-elf" } : null;
   }
   if (process.platform === "darwin") {
     const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
+    // Prefer the re-signed adhoc `.clean` binary (DYLD-spoofable); the stock
+    // vendored binary is Hardened Runtime and ignores DYLD_INSERT_LIBRARIES.
+    const clean = join(umidpackDir(), arch, "runtime-info.clean");
+    if (existsSync(clean)) return { kind: "macho" };
     return existsSync(join(umidpackDir(), arch, "runtime-info")) ? { kind: "macho" } : null;
   }
+  // Linux. Containers (Docker/K8s/Podman) prefer the mini-ELF bundle: it ships
+  // a static glibc tree and mints tokens with `isVm:false`, so a containerized
+  // deployment is not flagged as a VM. Set CARTETHYIA_QODER_UMID_MINI=1 to
+  // force it on any Linux host, or =0 to disable container detection.
+  const miniForced = process.env.CARTETHYIA_QODER_UMID_MINI;
+  const wantMini =
+    miniForced === "1" || (miniForced !== "0" && isContainerized());
+  if (wantMini && process.arch === "x64" && ensureUmidMiniExtracted()) {
+    return { kind: "mini-elf" };
+  }
   const arch = process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64";
   if (existsSync(join(umidpackDir(), arch, "runtime-info"))) return { kind: "elf" };
-  return existsSync(join(umidpackDir(), "elf-x86_64", "runtime-info")) ? { kind: "elf" } : null;
+  if (existsSync(join(umidpackDir(), "elf-x86_64", "runtime-info"))) return { kind: "elf" };
+  // Linux without a native vendored ELF (e.g. a slim container with no mini):
+  // fall back to the mini-ELF bundle when it extracts.
+  if (ensureUmidMiniExtracted() && process.arch === "x64") return { kind: "mini-elf" };
+  return null;
 }
 
 /** Generated (software) identity — deterministic per account id, NOT SG-signed. */
@@ -216,6 +291,23 @@ export function mintQoderNativeIdentity(accountId: string): { identity: QoderNat
     return { identity, seed: existsSync(seed) ? readFileSync(seed, "utf8") : "" };
   }
 
+  if (bridge.kind === "mini-elf") {
+    const exe = join(umidMiniDir(), "opt", "umid", "runtime-info");
+    ensurePosixExecutable(exe);
+    const seed = seedPath();
+    const dir = seed.slice(0, seed.lastIndexOf("/"));
+    mkdirSync(dir, { recursive: true });
+    try { spawnSync("rm", ["-f", seed]); } catch { /* ignore */ }
+    const r = spawnSync(exe, [ENV_CODE], {
+      encoding: "utf8",
+      timeout: 25_000,
+      env: { ...process.env, LD_LIBRARY_PATH: join(umidMiniDir(), "lib", "x86_64-linux-gnu") },
+    });
+    const identity = parseBridgeLine(String(r.stdout ?? ""));
+    if (!identity) { log.warn("[qoder] mini-elf mint failed"); return null; }
+    return { identity, seed: existsSync(seed) ? readFileSync(seed, "utf8") : "" };
+  }
+
   // pe — hardware-bound; no seed concept on Windows.
   const exe = join(umidpackDir(), "runtime-info.exe");
   const r = spawnSync(exe, [ENV_CODE], { encoding: "utf8", timeout: 30_000, windowsHide: true, cwd: umidpackDir() });
@@ -267,17 +359,40 @@ export function replayQoderNativeIdentity(seed: string, accountId: string): Qode
     return parseBridgeLine(String(r.stdout ?? ""));
   }
 
+  if (bridge.kind === "mini-elf") {
+    const exe = join(umidMiniDir(), "opt", "umid", "runtime-info");
+    ensurePosixExecutable(exe);
+    const seedPathStr = seedPath();
+    writeFileSync(seedPathStr, seed, "utf8");
+    const r = spawnSync(exe, [ENV_CODE], {
+      encoding: "utf8",
+      timeout: 25_000,
+      env: { ...process.env, LD_LIBRARY_PATH: join(umidMiniDir(), "lib", "x86_64-linux-gnu") },
+    });
+    return parseBridgeLine(String(r.stdout ?? ""));
+  }
+
   return null; // pe: cannot replay a seed on a hardware-bound identity
 }
 
-/** The six native machine headers for one identity. */
-export function qoderMachineHeaders(identity: QoderNativeIdentity): Record<string, string> {
+/**
+ * The six native machine headers for one identity.
+ *
+ * The upstream treats `cosy-machineid` as a stable UUID-shaped machine id
+ * (the desktop client caches it; the donor hub derives a UUIDv4 from the
+ * account uid). The native machineToken/Type/Code come from the UMID bridge.
+ * The OS and hostname are derived from the real runtime (`qoderMachineOs` /
+ * `qoderMachineHostname`), not hardcoded — the campaign surface fingerprint
+ * must match the actual client (verified live 2026-11-04).
+ */
+export function qoderMachineHeaders(identity: QoderNativeIdentity, machineId?: string): Record<string, string> {
+  const mid = machineId && machineId.length > 0 ? machineId : identity.machineToken;
   return {
-    "cosy-machineid": identity.machineToken,
+    "cosy-machineid": mid,
     "cosy-machinetoken": identity.machineToken,
     "cosy-machinetype": identity.machineType,
     "cosy-machinecode": identity.machineCode,
-    "cosy-machineos": "x86_64_linux",
-    "cosy-machinehostname": "DESKTOP-QODER",
+    "cosy-machineos": qoderMachineOs(),
+    "cosy-machinehostname": qoderMachineHostname(),
   };
 }