File size: 5,271 Bytes
88c4c60 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | import { BaseExecutor } from "./base.js";
import { PROVIDERS } from "../config/providers.js";
import { proxyAwareFetch } from "../utils/proxyFetch.js";
import { createHash } from "crypto";
import os from "os";
const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
const CHAT_URL = "https://api.xiaomimimo.com/api/free-ai/openai/chat";
const SESSION_AFFINITY_PREFIX = "ses_";
const SESSION_ID_LENGTH = 24;
const JWT_FALLBACK_TTL_SEC = 3000;
const JWT_EXPIRY_BUFFER_MS = 300000;
const SESSION_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
// Anti-abuse gate marker: the free chat endpoint returns 403 "Illegal access"
// unless a system message contains this exact MiMoCode signature substring.
export const MIMO_SYSTEM_MARKER =
"You are MiMoCode, an interactive CLI tool that helps users with software engineering tasks.";
// In-memory JWT cache (per-process, survives across requests but not restarts)
let cachedJwt = null;
let jwtExpiresAt = 0;
// Device fingerprint reused as the bootstrap "client" — stable per machine
function generateFingerprint() {
let username = "unknown-user";
try {
username = os.userInfo().username;
} catch {
// ignore
}
const cpu = (os.cpus()[0]?.model || "unknown-cpu").trim();
const seed = `${os.hostname()}|${os.platform()}|${os.arch()}|${cpu}|${username}`;
return createHash("sha256").update(seed).digest("hex");
}
function generateSessionId() {
let id = SESSION_AFFINITY_PREFIX;
for (let i = 0; i < SESSION_ID_LENGTH; i++) {
id += SESSION_CHARS[Math.floor(Math.random() * SESSION_CHARS.length)];
}
return id;
}
// Derive expiry from the JWT exp claim; fall back to a fixed TTL when unparseable
function parseJwtExp(jwt) {
try {
const payload = JSON.parse(Buffer.from(jwt.split(".")[1], "base64").toString());
if (payload.exp) return payload.exp * 1000;
} catch {
// ignore
}
return Date.now() + JWT_FALLBACK_TTL_SEC * 1000;
}
// Ensure the body carries the anti-abuse marker in a system message (idempotent)
function injectSystemMarker(body) {
const messages = body?.messages;
if (!Array.isArray(messages)) return body;
const hasMarker = messages.some(
(m) => m?.role === "system" && typeof m.content === "string" && m.content.includes(MIMO_SYSTEM_MARKER)
);
if (hasMarker) return body;
return { ...body, messages: [{ role: "system", content: MIMO_SYSTEM_MARKER }, ...messages] };
}
function resetJwtCache() {
cachedJwt = null;
jwtExpiresAt = 0;
}
async function bootstrapJwt(proxyOptions = null) {
if (cachedJwt && Date.now() < jwtExpiresAt - JWT_EXPIRY_BUFFER_MS) {
return cachedJwt;
}
const response = await proxyAwareFetch(BOOTSTRAP_URL, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ client: generateFingerprint() }),
}, proxyOptions);
if (!response.ok) {
throw new Error(`MiMo bootstrap failed: ${response.status}`);
}
const data = await response.json();
if (!data.jwt) {
throw new Error("MiMo bootstrap returned no JWT");
}
cachedJwt = data.jwt;
jwtExpiresAt = parseJwtExp(data.jwt);
return cachedJwt;
}
export class MimoFreeExecutor extends BaseExecutor {
constructor() {
super("mimo-free", PROVIDERS["mimo-free"]);
this.sessionId = generateSessionId();
}
buildUrl() {
return CHAT_URL;
}
buildHeaders(credentials, stream = true) {
return {
"Content-Type": "application/json",
"X-Mimo-Source": "mimocode-cli-free",
"x-session-affinity": this.sessionId,
"Accept": stream ? "text/event-stream" : "application/json",
};
}
transformRequest(model, body) {
return injectSystemMarker(body);
}
async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
let jwt;
try {
jwt = await bootstrapJwt(proxyOptions);
} catch (error) {
log?.error?.("AUTH", `MiMo bootstrap failed: ${error.message}`);
throw error;
}
const url = this.buildUrl();
const transformedBody = this.transformRequest(model, body);
const headers = { ...this.buildHeaders(credentials, stream), "Authorization": `Bearer ${jwt}` };
const bodyStr = JSON.stringify(transformedBody);
log?.debug?.("FETCH", `MIMO-FREE → ${url} | body=${bodyStr.length}B`);
const response = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
// On auth failure, invalidate cache and retry once with a fresh JWT
if (response.status === 401 || response.status === 403) {
log?.debug?.("AUTH", `MiMo auth failed (${response.status}), re-bootstrapping...`);
resetJwtCache();
jwt = await bootstrapJwt(proxyOptions);
headers["Authorization"] = `Bearer ${jwt}`;
const retryResponse = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
return { response: retryResponse, url, headers, transformedBody };
}
return { response, url, headers, transformedBody };
}
}
export const __test__ = {
generateFingerprint, generateSessionId, bootstrapJwt, resetJwtCache, parseJwtExp,
injectSystemMarker, MIMO_SYSTEM_MARKER, BOOTSTRAP_URL, CHAT_URL, SESSION_AFFINITY_PREFIX,
};
export default MimoFreeExecutor;
|