@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/shared/qoder/cosy.js

@@ -1,175 +0,0 @@
-/**
- * Qoder COSY (hybrid RSA+AES+MD5) signing, ported from CLIProxyAPIPlus
- * qoder-provider branch (internal/auth/qoder/cosy.go).
- *
- * Every signed request carries:
- *   - an AES-128-CBC payload of the user info, the AES key wrapped in RSA
- *   - an MD5 signature over `payload || cosyKey || timestamp || body || sigPath`
- *   - the body's MD5 hash + length so the server can validate integrity
- *   - 17 Cosy-* / X-* headers fingerprinting the client (machine id, IDE
- *     version, organization id, etc.)
- *
- * The on-the-wire header keys use the same casing as qodercli:
- *   Cosy-Machineid, not Cosy-MachineID.
- */
-
-import crypto from "crypto";
-import { v4 as uuidv4 } from "uuid";
-
-import {
-  QODER_CLIENT_TYPE,
-  QODER_DATA_POLICY,
-  QODER_IDE_VERSION,
-  QODER_LOGIN_VERSION,
-  QODER_MACHINE_OS,
-  QODER_MACHINE_TYPE,
-  QODER_RSA_PUBLIC_KEY,
-} from "./constants.js";
-
-// AES-128 wants a 16-byte key. Match qodercli/Veria: take the first 16 chars
-// of a fresh UUID's canonical string (hyphens included). The key is fresh
-// per request so even though the IV reuses the key bytes, each request still
-// has a unique IV.
-function generateAesKey() {
-  return uuidv4().slice(0, 16);
-}
-
-function pkcs7Pad(data, blockSize) {
-  const padding = blockSize - (data.length % blockSize);
-  const padded = Buffer.alloc(data.length + padding, padding);
-  data.copy(padded, 0);
-  return padded;
-}
-
-function aesEncryptCbcBase64(plaintext, keyStr) {
-  const keyBytes = Buffer.from(keyStr, "utf8");
-  if (keyBytes.length !== 16) {
-    throw new Error(`aes key must be 16 bytes, got ${keyBytes.length}`);
-  }
-  const iv = keyBytes.subarray(0, 16);
-  const cipher = crypto.createCipheriv("aes-128-cbc", keyBytes, iv);
-  cipher.setAutoPadding(false);
-  const padded = pkcs7Pad(Buffer.from(plaintext, "utf8"), 16);
-  const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
-  return encrypted.toString("base64");
-}
-
-function rsaEncryptBase64(data) {
-  const encrypted = crypto.publicEncrypt(
-    { key: QODER_RSA_PUBLIC_KEY, padding: crypto.constants.RSA_PKCS1_PADDING },
-    Buffer.from(data, "utf8"),
-  );
-  return encrypted.toString("base64");
-}
-
-function encryptUserInfo(userInfo) {
-  const aesKey = generateAesKey();
-  const plaintext = JSON.stringify(userInfo);
-  const infoB64 = aesEncryptCbcBase64(plaintext, aesKey);
-  const cosyKeyB64 = rsaEncryptBase64(aesKey);
-  return { cosyKey: cosyKeyB64, info: infoB64 };
-}
-
-function md5Hex(input) {
-  return crypto.createHash("md5").update(input).digest("hex");
-}
-
-/**
- * Strip the leading "/algo" prefix from the request path. Matches qodercli
- * convention. Empty input returns "".
- */
-function computeSigPath(requestUrl) {
-  let pathname;
-  try {
-    pathname = new URL(requestUrl).pathname || "";
-  } catch {
-    return "";
-  }
-  if (pathname.startsWith("/algo")) {
-    return pathname.slice("/algo".length);
-  }
-  return pathname;
-}
-
-/**
- * Generate a fresh machine UUID. Persisted on the connection record so
- * every request from the same auth carries the same machineId.
- */
-export function generateMachineId() {
-  return uuidv4();
-}
-
-/**
- * Build the full Cosy-* header set for a single Qoder request.
- *
- * @param {Buffer|Uint8Array|string} body  The exact bytes that will be sent.
- *   For GET requests pass an empty Buffer / "".
- * @param {string} requestUrl              Full request URL (used for sigPath).
- * @param {object} creds
- * @param {string} creds.userId            Stable Qoder user id.
- * @param {string} creds.authToken         Device access token (`dt-...`).
- * @param {string} [creds.name]            Display name (optional).
- * @param {string} [creds.email]           Email (optional, can be empty).
- * @param {string} [creds.machineId]       Persisted machine UUID.
- * @returns {Record<string, string>} Header map ready to merge onto fetch().
- */
-export function buildCosyHeaders(body, requestUrl, creds) {
-  if (!creds?.userId) throw new Error("cosy: user id is empty");
-  if (!creds?.authToken) throw new Error("cosy: auth token is empty");
-
-  const bodyBuf = Buffer.isBuffer(body)
-    ? body
-    : typeof body === "string"
-      ? Buffer.from(body, "latin1")
-      : Buffer.from(body || []);
-
-  const { cosyKey, info } = encryptUserInfo({
-    uid: creds.userId,
-    security_oauth_token: creds.authToken,
-    name: creds.name || "",
-    aid: "",
-    email: creds.email || "",
-  });
-
-  const timestamp = String(Math.floor(Date.now() / 1000));
-  const requestId = uuidv4();
-
-  const payloadJson = JSON.stringify({
-    version: "v1",
-    requestId,
-    info,
-    cosyVersion: QODER_IDE_VERSION,
-    ideVersion: "",
-  });
-  const payloadB64 = Buffer.from(payloadJson, "utf8").toString("base64");
-
-  const sigPath = computeSigPath(requestUrl);
-  const sigInput = `${payloadB64}\n${cosyKey}\n${timestamp}\n${bodyBuf.toString("latin1")}\n${sigPath}`;
-  const sig = md5Hex(Buffer.from(sigInput, "latin1"));
-
-  const machineId = creds.machineId || generateMachineId();
-  const bodyHash = md5Hex(bodyBuf);
-  const bodyLength = String(bodyBuf.length);
-
-  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,
-    "Cosy-Machineos": QODER_MACHINE_OS,
-    "Cosy-Clienttype": QODER_CLIENT_TYPE,
-    "Cosy-Clientip": "127.0.0.1",
-    "Cosy-Bodyhash": bodyHash,
-    "Cosy-Bodylength": bodyLength,
-    "Cosy-Sigpath": sigPath,
-    "Cosy-Data-Policy": QODER_DATA_POLICY,
-    "Cosy-Organization-Id": "",
-    "Cosy-Organization-Tags": "",
-    "Login-Version": QODER_LOGIN_VERSION,
-    "X-Request-Id": uuidv4(),
-  };
-}

package/open-sse/shared/qoder/encoding.js

@@ -1,55 +0,0 @@
-/**
- * Qoder body encoding ported from qoder2api's QoderEncoding.java (via the
- * CLIProxyAPIPlus qoder-provider branch).
- *
- * Algorithm:
- *   1. base64-encode the plaintext bytes (standard alphabet).
- *   2. Rearrange: split into thirds, reorder as [tail][mid][head].
- *   3. Substitute each character via a custom alphabet mapping.
- *
- * The encoded body must be sent with `&Encode=1` appended to the URL so the
- * server decodes in reverse. The obfuscation prevents Alibaba Cloud WAF from
- * pattern-matching the plaintext request body.
- */
-
-const QODER_STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const QODER_CUSTOM_ALPHABET = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
-
-const QODER_S2C = (() => {
-  const table = new Int16Array(128).fill(-1);
-  for (let i = 0; i < 64; i++) {
-    table[QODER_STD_ALPHABET.charCodeAt(i)] = QODER_CUSTOM_ALPHABET.charCodeAt(i);
-  }
-  table["=".charCodeAt(0)] = "$".charCodeAt(0);
-  return table;
-})();
-
-/**
- * Encode plaintext bytes/string using Qoder's WAF-bypass scheme.
- * @param {Buffer|Uint8Array|string} plaintext
- * @returns {string} encoded string
- */
-export function qoderEncodeBody(plaintext) {
-  const buf = Buffer.isBuffer(plaintext)
-    ? plaintext
-    : typeof plaintext === "string"
-      ? Buffer.from(plaintext, "utf8")
-      : Buffer.from(plaintext);
-
-  const std = buf.toString("base64");
-  const n = std.length;
-  const a = Math.floor(n / 3);
-  // [tail][mid][head]
-  const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
-
-  const out = Buffer.alloc(n);
-  for (let i = 0; i < n; i++) {
-    const c = rearranged.charCodeAt(i);
-    if (c < 128 && QODER_S2C[c] >= 0) {
-      out[i] = QODER_S2C[c];
-    } else {
-      out[i] = c;
-    }
-  }
-  return out.toString("latin1");
-}

package/open-sse/transformer/responsesTransformer.js

@@ -1,439 +0,0 @@
-/**
- * Responses API Transformer
- * Converts OpenAI Chat Completions SSE to Codex Responses API SSE format
- * Can be used in both Next.js and Cloudflare Workers
- */
-
-import fs from "fs";
-import path from "path";
-
-// Create log directory for responses (Node.js only)
-export function createResponsesLogger(model, logsDir = null) {
-  // Skip logging in worker environment (no fs)
-  if (typeof fs.mkdirSync !== "function") {
-    return null;
-  }
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "").slice(0, 15);
-  const uniqueId = Math.random().toString(36).slice(2, 8);
-  const baseDir = logsDir || (typeof process !== "undefined" ? process.cwd() : ".");
-  const logDir = path.join(baseDir, "logs", `responses_${model}_${timestamp}_${uniqueId}`);
-  
-  try {
-    fs.mkdirSync(logDir, { recursive: true });
-  } catch {
-    return null;
-  }
-
-  let inputEvents = [];
-  let outputEvents = [];
-
-  return {
-    logInput: (event) => {
-      inputEvents.push(event);
-    },
-    logOutput: (event) => {
-      outputEvents.push(event);
-    },
-    flush: () => {
-      try {
-        fs.writeFileSync(path.join(logDir, "1_input_stream.txt"), inputEvents.join("\n"));
-        fs.writeFileSync(path.join(logDir, "2_output_stream.txt"), outputEvents.join("\n"));
-      } catch (e) {
-        console.log("[RESPONSES] Failed to write logs:", e.message);
-      }
-    }
-  };
-}
-
-/**
- * Create TransformStream that converts Chat Completions SSE to Responses API SSE
- * @param {Object} logger - Optional logger instance
- * @returns {TransformStream}
- */
-export function createResponsesApiTransformStream(logger = null) {
-  const state = {
-    seq: 0,
-    responseId: `resp_${Date.now()}`,
-    created: Math.floor(Date.now() / 1000),
-    started: false,
-    msgTextBuf: {},
-    msgItemAdded: {},
-    msgContentAdded: {},
-    msgItemDone: {},
-    reasoningId: "",
-    reasoningIndex: -1,
-    reasoningBuf: "",
-    reasoningPartAdded: false,
-    reasoningDone: false,
-    inThinking: false,
-    funcArgsBuf: {},
-    funcNames: {},
-    funcCallIds: {},
-    funcArgsDone: {},
-    funcItemDone: {},
-    buffer: "",
-    completedSent: false
-  };
-
-  const encoder = new TextEncoder();
-  const nextSeq = () => ++state.seq;
-  
-  const emit = (controller, eventType, data) => {
-    data.sequence_number = nextSeq();
-    const output = `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
-    logger?.logOutput(output.trim());
-    controller.enqueue(encoder.encode(output));
-  };
-
-  // Helper to start reasoning
-  const startReasoning = (controller, idx) => {
-    if (!state.reasoningId) {
-      state.reasoningId = `rs_${state.responseId}_${idx}`;
-      state.reasoningIndex = idx;
-      
-      emit(controller, "response.output_item.added", {
-        type: "response.output_item.added",
-        output_index: idx,
-        item: {
-          id: state.reasoningId,
-          type: "reasoning",
-          summary: []
-        }
-      });
-
-      emit(controller, "response.reasoning_summary_part.added", {
-        type: "response.reasoning_summary_part.added",
-        item_id: state.reasoningId,
-        output_index: idx,
-        summary_index: 0,
-        part: { type: "summary_text", text: "" }
-      });
-      state.reasoningPartAdded = true;
-    }
-  };
-
-  const emitReasoningDelta = (controller, text) => {
-    if (!text) return;
-    state.reasoningBuf += text;
-    emit(controller, "response.reasoning_summary_text.delta", {
-      type: "response.reasoning_summary_text.delta",
-      item_id: state.reasoningId,
-      output_index: state.reasoningIndex,
-      summary_index: 0,
-      delta: text
-    });
-  };
-
-  const closeReasoning = (controller) => {
-    if (state.reasoningId && !state.reasoningDone) {
-      state.reasoningDone = true;
-      
-      emit(controller, "response.reasoning_summary_text.done", {
-        type: "response.reasoning_summary_text.done",
-        item_id: state.reasoningId,
-        output_index: state.reasoningIndex,
-        summary_index: 0,
-        text: state.reasoningBuf
-      });
-
-      emit(controller, "response.reasoning_summary_part.done", {
-        type: "response.reasoning_summary_part.done",
-        item_id: state.reasoningId,
-        output_index: state.reasoningIndex,
-        summary_index: 0,
-        part: { type: "summary_text", text: state.reasoningBuf }
-      });
-
-      emit(controller, "response.output_item.done", {
-        type: "response.output_item.done",
-        output_index: state.reasoningIndex,
-        item: {
-          id: state.reasoningId,
-          type: "reasoning",
-          summary: [{ type: "summary_text", text: state.reasoningBuf }]
-        }
-      });
-    }
-  };
-
-  const closeMessage = (controller, idx) => {
-    if (state.msgItemAdded[idx] && !state.msgItemDone[idx]) {
-      state.msgItemDone[idx] = true;
-      const fullText = state.msgTextBuf[idx] || "";
-      const msgId = `msg_${state.responseId}_${idx}`;
-
-      emit(controller, "response.output_text.done", {
-        type: "response.output_text.done",
-        item_id: msgId,
-        output_index: parseInt(idx),
-        content_index: 0,
-        text: fullText,
-        logprobs: []
-      });
-
-      emit(controller, "response.content_part.done", {
-        type: "response.content_part.done",
-        item_id: msgId,
-        output_index: parseInt(idx),
-        content_index: 0,
-        part: { type: "output_text", annotations: [], logprobs: [], text: fullText }
-      });
-
-      emit(controller, "response.output_item.done", {
-        type: "response.output_item.done",
-        output_index: parseInt(idx),
-        item: {
-          id: msgId,
-          type: "message",
-          content: [{ type: "output_text", annotations: [], logprobs: [], text: fullText }],
-          role: "assistant"
-        }
-      });
-    }
-  };
-
-  const closeToolCall = (controller, idx) => {
-    const callId = state.funcCallIds[idx];
-    if (callId && !state.funcItemDone[idx]) {
-      const args = state.funcArgsBuf[idx] || "{}";
-      
-      emit(controller, "response.function_call_arguments.done", {
-        type: "response.function_call_arguments.done",
-        item_id: `fc_${callId}`,
-        output_index: parseInt(idx),
-        arguments: args
-      });
-
-      emit(controller, "response.output_item.done", {
-        type: "response.output_item.done",
-        output_index: parseInt(idx),
-        item: {
-          id: `fc_${callId}`,
-          type: "function_call",
-          arguments: args,
-          call_id: callId,
-          name: state.funcNames[idx] || ""
-        }
-      });
-
-      state.funcItemDone[idx] = true;
-      state.funcArgsDone[idx] = true;
-    }
-  };
-
-  const sendCompleted = (controller) => {
-    if (!state.completedSent) {
-      state.completedSent = true;
-      emit(controller, "response.completed", {
-        type: "response.completed",
-        response: {
-          id: state.responseId,
-          object: "response",
-          created_at: state.created,
-          status: "completed",
-          background: false,
-          error: null
-        }
-      });
-    }
-  };
-
-  return new TransformStream({
-    transform(chunk, controller) {
-      const text = new TextDecoder().decode(chunk);
-      logger?.logInput(text.trim());
-      state.buffer += text;
-
-      const messages = state.buffer.split("\n\n");
-      state.buffer = messages.pop() || "";
-
-      for (const msg of messages) {
-        if (!msg.trim()) continue;
-
-        const dataMatch = msg.match(/^data:\s*(.+)$/m);
-        if (!dataMatch) continue;
-
-        const dataStr = dataMatch[1].trim();
-        if (dataStr === "[DONE]") continue;
-
-        let parsed;
-        try {
-          parsed = JSON.parse(dataStr);
-        } catch {
-          continue;
-        }
-
-        if (!parsed.choices?.length) continue;
-        
-        const choice = parsed.choices[0];
-        const idx = choice.index || 0;
-        const delta = choice.delta || {};
-
-        // Emit initial events
-        if (!state.started) {
-          state.started = true;
-          state.responseId = parsed.id ? `resp_${parsed.id}` : state.responseId;
-          
-          emit(controller, "response.created", {
-            type: "response.created",
-            response: {
-              id: state.responseId,
-              object: "response",
-              created_at: state.created,
-              status: "in_progress",
-              background: false,
-              error: null,
-              output: []
-            }
-          });
-
-          emit(controller, "response.in_progress", {
-            type: "response.in_progress",
-            response: {
-              id: state.responseId,
-              object: "response",
-              created_at: state.created,
-              status: "in_progress"
-            }
-          });
-        }
-
-        // Handle reasoning_content (OpenAI native format)
-        if (delta.reasoning_content) {
-          startReasoning(controller, idx);
-          emitReasoningDelta(controller, delta.reasoning_content);
-        }
-
-        // Handle text content (may contain <think> tags)
-        if (delta.content) {
-          let content = delta.content;
-
-          if (content.includes("<think>")) {
-            state.inThinking = true;
-            content = content.replace("<think>", "");
-            startReasoning(controller, idx);
-          }
-
-          if (content.includes("</think>")) {
-            const parts = content.split("</think>");
-            const thinkPart = parts[0];
-            const textPart = parts.slice(1).join("</think>");
-            
-            if (thinkPart) emitReasoningDelta(controller, thinkPart);
-            closeReasoning(controller);
-            state.inThinking = false;
-            content = textPart;
-          }
-
-          if (state.inThinking && content) {
-            emitReasoningDelta(controller, content);
-            continue;
-          }
-
-          // Regular text content
-          if (content) {
-            if (!state.msgItemAdded[idx]) {
-              state.msgItemAdded[idx] = true;
-              const msgId = `msg_${state.responseId}_${idx}`;
-              
-              emit(controller, "response.output_item.added", {
-                type: "response.output_item.added",
-                output_index: idx,
-                item: { id: msgId, type: "message", content: [], role: "assistant" }
-              });
-            }
-
-            if (!state.msgContentAdded[idx]) {
-              state.msgContentAdded[idx] = true;
-              
-              emit(controller, "response.content_part.added", {
-                type: "response.content_part.added",
-                item_id: `msg_${state.responseId}_${idx}`,
-                output_index: idx,
-                content_index: 0,
-                part: { type: "output_text", annotations: [], logprobs: [], text: "" }
-              });
-            }
-
-            emit(controller, "response.output_text.delta", {
-              type: "response.output_text.delta",
-              item_id: `msg_${state.responseId}_${idx}`,
-              output_index: idx,
-              content_index: 0,
-              delta: content,
-              logprobs: []
-            });
-
-            if (!state.msgTextBuf[idx]) state.msgTextBuf[idx] = "";
-            state.msgTextBuf[idx] += content;
-          }
-        }
-
-        // Handle tool_calls
-        if (delta.tool_calls) {
-          closeMessage(controller, idx);
-
-          for (const tc of delta.tool_calls) {
-            const tcIdx = tc.index ?? 0;
-            const newCallId = tc.id;
-            const funcName = tc.function?.name;
-
-            if (funcName) state.funcNames[tcIdx] = funcName;
-
-            if (!state.funcCallIds[tcIdx] && newCallId) {
-              state.funcCallIds[tcIdx] = newCallId;
-              
-              emit(controller, "response.output_item.added", {
-                type: "response.output_item.added",
-                output_index: tcIdx,
-                item: {
-                  id: `fc_${newCallId}`,
-                  type: "function_call",
-                  arguments: "",
-                  call_id: newCallId,
-                  name: state.funcNames[tcIdx] || ""
-                }
-              });
-            }
-
-            if (!state.funcArgsBuf[tcIdx]) state.funcArgsBuf[tcIdx] = "";
-
-            if (tc.function?.arguments) {
-              const refCallId = state.funcCallIds[tcIdx] || newCallId;
-              if (refCallId) {
-                emit(controller, "response.function_call_arguments.delta", {
-                  type: "response.function_call_arguments.delta",
-                  item_id: `fc_${refCallId}`,
-                  output_index: tcIdx,
-                  delta: tc.function.arguments
-                });
-              }
-              state.funcArgsBuf[tcIdx] += tc.function.arguments;
-            }
-          }
-        }
-
-        // Handle finish_reason
-        if (choice.finish_reason) {
-          for (const i in state.msgItemAdded) closeMessage(controller, i);
-          closeReasoning(controller);
-          for (const i in state.funcCallIds) closeToolCall(controller, i);
-          sendCompleted(controller);
-        }
-      }
-    },
-
-    flush(controller) {
-      for (const i in state.msgItemAdded) closeMessage(controller, i);
-      closeReasoning(controller);
-      for (const i in state.funcCallIds) closeToolCall(controller, i);
-      sendCompleted(controller);
-
-      logger?.logOutput("data: [DONE]");
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-      logger?.flush();
-    }
-  });
-}
-