memshell-party-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,983 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command3 } from "commander";
+
+// src/api/client.ts
+var ApiError = class extends Error {
+  constructor(message, status, url) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.name = "ApiError";
+  }
+  status;
+  url;
+};
+var MemPartyClient = class {
+  baseUrl;
+  fetchImpl;
+  timeoutMs;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    if (typeof this.fetchImpl !== "function") {
+      throw new Error(
+        "No fetch implementation available. Use Node.js >= 18 or pass a custom fetch."
+      );
+    }
+  }
+  // ---------- config ----------
+  getServers() {
+    return this.request("GET", "/api/config/servers");
+  }
+  getConfig() {
+    return this.request("GET", "/api/config");
+  }
+  getPackerTree() {
+    return this.request("GET", "/api/config/packers/tree");
+  }
+  getPackers() {
+    return this.request("GET", "/api/config/packers");
+  }
+  getCommandConfigs() {
+    return this.request("GET", "/api/config/command/configs");
+  }
+  getVersion() {
+    return this.request("GET", "/api/version");
+  }
+  // ---------- generation ----------
+  generateMemShell(req) {
+    return this.request("POST", "/api/memshell/generate", {
+      json: req
+    });
+  }
+  generateProbe(req) {
+    return this.request("POST", "/api/probe/generate", {
+      json: req
+    });
+  }
+  /** Parse a fully-qualified class name from a base64-encoded .class file. */
+  parseClassName(classBase64) {
+    return this.request("POST", "/api/className", {
+      text: classBase64,
+      raw: true
+    });
+  }
+  // ---------- transport ----------
+  async request(method, path, opts = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {};
+    let body;
+    if (opts.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(opts.json);
+    } else if (opts.text !== void 0) {
+      headers["Content-Type"] = "text/plain";
+      body = opts.text;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body,
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new ApiError(`Request timed out after ${this.timeoutMs}ms`, 0, url);
+      }
+      throw new ApiError(
+        `Failed to reach ${url}: ${err.message}`,
+        0,
+        url
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+    const rawText = await response.text();
+    if (!response.ok) {
+      let message = rawText || response.statusText;
+      try {
+        const parsed = JSON.parse(rawText);
+        if (parsed?.error) message = parsed.error;
+      } catch {
+      }
+      throw new ApiError(message, response.status, url);
+    }
+    if (opts.raw) {
+      return rawText;
+    }
+    if (rawText === "") {
+      return void 0;
+    }
+    return JSON.parse(rawText);
+  }
+};
+
+// src/core/config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_API_URL = "https://party.mem.mk";
+var ENV_VAR = "MEMPARTY_API_URL";
+function readRcFile(home) {
+  const path = join(home, ".mempartyrc");
+  try {
+    const raw = readFileSync(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function resolveApiUrl(input3 = {}) {
+  const env = input3.env ?? process.env;
+  const home = input3.home ?? homedir();
+  const fromFlag = input3.flag?.trim();
+  if (fromFlag) return fromFlag;
+  const fromEnv = env[ENV_VAR]?.trim();
+  if (fromEnv) return fromEnv;
+  const fromFile = readRcFile(home)?.apiUrl?.trim();
+  if (fromFile) return fromFile;
+  return DEFAULT_API_URL;
+}
+
+// src/cli-context.ts
+function createClient(opts) {
+  const baseUrl = resolveApiUrl({ flag: opts.api });
+  const timeoutMs = opts.timeout ? Number(opts.timeout) : void 0;
+  return new MemPartyClient({ baseUrl, timeoutMs });
+}
+function logInfo(msg) {
+  process.stderr.write(`${msg}
+`);
+}
+
+// src/commands/config.ts
+function printJsonOrLines(data, json, renderLines) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderLines().join("\n")}
+`);
+  }
+}
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Query supported servers, shell tools, shell types, and packers");
+  config.command("servers").description("List supported servers and their shell types").option("--json", "output raw JSON").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const servers = await client.getServers();
+    printJsonOrLines(
+      servers,
+      opts.json,
+      () => Object.entries(servers).map(([name, types]) => `${name}
+  ${types.join(", ")}`)
+    );
+  });
+  config.command("tools").description("List shell tools (and their shell types) per server").argument("[server]", "filter by a single server name").option("--json", "output raw JSON").action(async (server, opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const config2 = await client.getConfig();
+    const filtered = server ? { [server]: config2[server] ?? {} } : config2;
+    printJsonOrLines(
+      filtered,
+      opts.json,
+      () => Object.entries(filtered).flatMap(([name, tools]) => [
+        name,
+        ...Object.entries(tools).map(([tool, types]) => `  ${tool}: ${types.join(", ")}`)
+      ])
+    );
+  });
+  config.command("packers").description("List packers (parent / child tree)").option("--json", "output raw JSON").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const tree = await client.getPackerTree();
+    printJsonOrLines(
+      tree,
+      opts.json,
+      () => tree.map((p) => p.children.length ? `${p.name}
+  ${p.children.join(", ")}` : p.name)
+    );
+  });
+  config.command("command").description("List Command-tool encryptors and implementation classes").option("--json", "output raw JSON").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const cc = await client.getCommandConfigs();
+    printJsonOrLines(cc, opts.json, () => [
+      `encryptors: ${cc.encryptors.join(", ")}`,
+      `implementationClasses: ${cc.implementationClasses.join(", ")}`
+    ]);
+  });
+}
+
+// src/commands/gen.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { Option } from "commander";
+
+// src/core/output.ts
+import { writeFileSync } from "fs";
+var BINARY_EXTENSIONS = [".class", ".jar", ".zip", ".ser", ".bin"];
+function hasBinaryExtension(path) {
+  const lower = path.toLowerCase();
+  return BINARY_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function shouldDecode(opts) {
+  if (opts.decode !== void 0) return opts.decode;
+  if (opts.outFile) return hasBinaryExtension(opts.outFile);
+  return false;
+}
+function emitPayload(payload, opts, sinks = {}) {
+  const writeFile = sinks.writeFile ?? ((p, d) => writeFileSync(p, d));
+  const writeStdout = sinks.writeStdout ?? ((d) => process.stdout.write(d));
+  const decoded = shouldDecode(opts);
+  if (opts.outFile) {
+    if (decoded) {
+      const buf = Buffer.from(payload, "base64");
+      writeFile(opts.outFile, buf);
+      return { destination: opts.outFile, size: buf.length, decoded: true };
+    }
+    writeFile(opts.outFile, payload);
+    return { destination: opts.outFile, size: Buffer.byteLength(payload), decoded: false };
+  }
+  if (decoded) {
+    const buf = Buffer.from(payload, "base64");
+    writeStdout(buf.toString("binary"));
+    return { destination: "stdout", size: buf.length, decoded: true };
+  }
+  writeStdout(payload.endsWith("\n") ? payload : `${payload}
+`);
+  return { destination: "stdout", size: payload.length, decoded: false };
+}
+
+// src/core/request-builder.ts
+import { randomInt } from "crypto";
+
+// src/core/jdk.ts
+var JDK_VERSIONS = {
+  java6: 50,
+  java8: 52,
+  java9: 53,
+  java11: 55,
+  java17: 61,
+  java21: 65
+};
+function resolveJreVersion(input3) {
+  if (input3 === void 0 || input3 === "") return void 0;
+  if (typeof input3 === "number") return input3;
+  const normalized = input3.trim().toLowerCase();
+  if (normalized in JDK_VERSIONS) return JDK_VERSIONS[normalized];
+  const withPrefix = `java${normalized}`;
+  if (withPrefix in JDK_VERSIONS) return JDK_VERSIONS[withPrefix];
+  const num = Number(normalized);
+  if (Number.isInteger(num) && num > 0) return num;
+  throw new Error(
+    `Invalid JDK version "${input3}". Use one of: ${Object.keys(JDK_VERSIONS).join(", ")}, or a class-file major version like 52.`
+  );
+}
+
+// src/core/request-builder.ts
+var SPRING_GZIP_JDK17_RELATED_PACKERS = /* @__PURE__ */ new Set([
+  "SpEL",
+  "SpELSpringGzipJDK17",
+  "OGNL",
+  "OGNLSpringGzipJDK17",
+  "JXPath",
+  "JXPathSpringGzipJDK17"
+]);
+var UPPERCASE_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var CLASS_NAME_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function randomChar(chars) {
+  return chars[randomInt(chars.length)];
+}
+function generateSpringExpressionInjectorClassName() {
+  const randomName = Array.from({ length: 5 }, () => randomChar(CLASS_NAME_LETTERS)).join("");
+  return `org.springframework.expression.${randomChar(UPPERCASE_LETTERS)}${randomName}Util`;
+}
+function buildMemShellRequest(opts) {
+  const injectorClassName = SPRING_GZIP_JDK17_RELATED_PACKERS.has(opts.packer) ? generateSpringExpressionInjectorClassName() : opts.injectorClassName;
+  return {
+    shellConfig: {
+      server: opts.server,
+      serverVersion: opts.serverVersion,
+      shellTool: opts.shellTool,
+      shellType: opts.shellType,
+      targetJreVersion: resolveJreVersion(opts.jdk),
+      debug: opts.debug,
+      byPassJavaModule: opts.byPassJavaModule,
+      shrink: opts.shrink,
+      lambdaSuffix: opts.lambdaSuffix,
+      probe: opts.probe
+    },
+    shellToolConfig: {
+      shellClassName: opts.shellClassName,
+      godzillaPass: opts.godzillaPass,
+      godzillaKey: opts.godzillaKey,
+      commandParamName: opts.commandParamName,
+      commandTemplate: opts.commandTemplate,
+      behinderPass: opts.behinderPass,
+      antSwordPass: opts.antSwordPass,
+      headerName: opts.headerName,
+      headerValue: opts.headerValue,
+      shellClassBase64: opts.shellClassBase64,
+      encryptor: opts.encryptor,
+      implementationClass: opts.implementationClass
+    },
+    injectorConfig: {
+      injectorClassName,
+      urlPattern: opts.urlPattern,
+      staticInitialize: opts.staticInitialize
+    },
+    packer: opts.packer
+  };
+}
+function buildProbeRequest(opts) {
+  return {
+    probeConfig: {
+      probeMethod: opts.probeMethod,
+      probeContent: opts.probeContent,
+      shellClassName: opts.shellClassName,
+      targetJreVersion: resolveJreVersion(opts.jdk),
+      debug: opts.debug,
+      byPassJavaModule: opts.byPassJavaModule,
+      shrink: opts.shrink,
+      staticInitialize: opts.staticInitialize,
+      lambdaSuffix: opts.lambdaSuffix
+    },
+    probeContentConfig: {
+      host: opts.host,
+      seconds: opts.seconds,
+      sleepServer: opts.sleepServer,
+      server: opts.server,
+      reqParamName: opts.reqParamName,
+      commandTemplate: opts.commandTemplate
+    },
+    packer: opts.packer
+  };
+}
+
+// src/wizard/memshell-wizard.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { checkbox, confirm, input, select, Separator } from "@inquirer/prompts";
+var JDK_CHOICES = [
+  { name: "server default", value: "" },
+  ...Object.entries(JDK_VERSIONS).map(([name, major]) => ({
+    name: `${name} (${major})`,
+    value: name
+  }))
+];
+function packerChoices(tree) {
+  const choices = [];
+  for (const parent of tree) {
+    choices.push(new Separator(`\u2500\u2500 ${parent.name} \u2500\u2500`));
+    choices.push({ name: parent.name, value: parent.name });
+    for (const child of parent.children) {
+      choices.push({ name: `  ${child}`, value: child });
+    }
+  }
+  return choices;
+}
+async function runMemShellWizard(client) {
+  const [config, packerTree] = await Promise.all([client.getConfig(), client.getPackerTree()]);
+  const server = await select({
+    message: "Target server",
+    choices: Object.keys(config).map((s) => ({ name: s, value: s }))
+  });
+  const tools = Object.keys(config[server]);
+  const shellTool = await select({
+    message: "Shell tool",
+    choices: tools.map((t) => ({ name: t, value: t }))
+  });
+  const shellType = await select({
+    message: "Shell type",
+    choices: config[server][shellTool].map((t) => ({ name: t, value: t }))
+  });
+  const packer = await select({
+    message: "Packer",
+    choices: packerChoices(packerTree)
+  });
+  const opts = { server, shellTool, shellType, packer };
+  switch (shellTool) {
+    case "Godzilla":
+      opts.godzillaPass = await input({ message: "Godzilla pass", default: "pass" });
+      opts.godzillaKey = await input({ message: "Godzilla key", default: "key" });
+      break;
+    case "Behinder":
+      opts.behinderPass = await input({ message: "Behinder pass", default: "rebeyond" });
+      break;
+    case "AntSword":
+      opts.antSwordPass = await input({ message: "AntSword pass", default: "ant" });
+      break;
+    case "Command": {
+      opts.commandParamName = await input({ message: "Command param name", default: "cmd" });
+      const cc = await client.getCommandConfigs();
+      opts.encryptor = await select({
+        message: "Encryptor",
+        choices: cc.encryptors.map((e) => ({ name: e, value: e }))
+      });
+      opts.implementationClass = await select({
+        message: "Implementation class",
+        choices: cc.implementationClasses.map((e) => ({ name: e, value: e }))
+      });
+      const template = await input({ message: "Command template (optional, {command} placeholder)", default: "" });
+      if (template) opts.commandTemplate = template;
+      break;
+    }
+    case "Custom": {
+      const file = await input({ message: "Path to custom .class file" });
+      opts.shellClassBase64 = readFileSync2(file).toString("base64");
+      break;
+    }
+    default:
+      break;
+  }
+  opts.headerName = await input({ message: "Header name", default: "User-Agent" });
+  const headerValue = await input({ message: "Header value (optional)", default: "" });
+  if (headerValue) opts.headerValue = headerValue;
+  const shellClassName = await input({ message: "Shell class name (optional, random if empty)", default: "" });
+  if (shellClassName) opts.shellClassName = shellClassName;
+  opts.urlPattern = await input({ message: "URL pattern", default: "/*" });
+  const jdk = await select({ message: "Target JDK", choices: JDK_CHOICES });
+  if (jdk) opts.jdk = jdk;
+  const toggles = await checkbox({
+    message: "Options",
+    choices: [
+      { name: "shrink bytecode", value: "shrink", checked: true },
+      { name: "static initialize", value: "staticInitialize", checked: true },
+      { name: "bypass Java module", value: "byPassJavaModule" },
+      { name: "lambda suffix", value: "lambdaSuffix" },
+      { name: "debug", value: "debug" }
+    ]
+  });
+  opts.shrink = toggles.includes("shrink");
+  opts.staticInitialize = toggles.includes("staticInitialize");
+  opts.byPassJavaModule = toggles.includes("byPassJavaModule");
+  opts.lambdaSuffix = toggles.includes("lambdaSuffix");
+  opts.debug = toggles.includes("debug");
+  const confirmed = await confirm({ message: `Generate ${shellTool} ${shellType} for ${server} (${packer})?` });
+  if (!confirmed) {
+    throw new Error("Cancelled by user.");
+  }
+  return opts;
+}
+
+// src/commands/gen.ts
+var REQUIRED = ["server", "tool", "type", "packer"];
+function toOptions(o) {
+  let shellClassBase64 = o.shellClassBase64;
+  if (o.shellClassFile) {
+    shellClassBase64 = readFileSync3(o.shellClassFile).toString("base64");
+  }
+  return {
+    server: o.server,
+    serverVersion: o.serverVersion,
+    shellTool: o.tool,
+    shellType: o.type,
+    packer: o.packer,
+    jdk: o.jdk,
+    debug: o.debug,
+    byPassJavaModule: o.bypassModule,
+    shrink: o.shrink,
+    lambdaSuffix: o.lambdaSuffix,
+    probe: o.probe,
+    shellClassName: o.shellClassName,
+    godzillaPass: o.godzillaPass,
+    godzillaKey: o.godzillaKey,
+    behinderPass: o.behinderPass,
+    antSwordPass: o.antswordPass,
+    commandParamName: o.commandParamName,
+    commandTemplate: o.commandTemplate,
+    encryptor: o.encryptor,
+    implementationClass: o.implementationClass,
+    headerName: o.headerName,
+    headerValue: o.headerValue,
+    shellClassBase64,
+    urlPattern: o.urlPattern,
+    injectorClassName: o.injectorClassName,
+    staticInitialize: o.staticInitialize
+  };
+}
+function registerGenCommand(program) {
+  program.command("gen").alias("generate").description("Generate a memory shell. Runs an interactive wizard when required flags are missing.").option("-s, --server <server>", "target server, e.g. Tomcat").option("--server-version <v>", "target server version").option("-t, --tool <tool>", "shell tool, e.g. Godzilla, Behinder, Command").option("-y, --type <type>", "shell type, e.g. Listener, Filter, Servlet").option("-p, --packer <packer>", "packer, e.g. Base64, Jar, JSP").option("--jdk <version>", "target JDK: java6/8/9/11/17/21, or a class-file major version").option("--debug", "enable debug output in the payload").option("--bypass-module", "bypass Java module restrictions").option("--no-shrink", "disable bytecode shrinking (enabled by default)").option("--lambda-suffix", "append a lambda class-name suffix").option("--probe", "use echo/probe mode").option("--shell-class-name <name>", "explicit shell class name (random if omitted)").option("--godzilla-pass <pass>", "Godzilla password").option("--godzilla-key <key>", "Godzilla key").option("--behinder-pass <pass>", "Behinder password").option("--antsword-pass <pass>", "AntSword password").option("--command-param-name <name>", "Command tool parameter name").option("--command-template <tpl>", "Command template ({command} placeholder)").option("--encryptor <name>", "Command encryptor").option("--implementation-class <name>", "Command implementation class").option("--header-name <name>", "auth header name").option("--header-value <value>", "auth header value").option("--shell-class-base64 <b64>", "custom shell class (base64) for the Custom tool").option("--shell-class-file <path>", "custom shell .class file for the Custom tool").option("--url-pattern <pattern>", "injector URL pattern").option("--injector-class-name <name>", "explicit injector class name").option("--no-static-initialize", "disable injector static initialization (enabled by default)").option("-o, --output <file>", "write payload to a file instead of stdout").addOption(new Option("--decode", "base64-decode the payload before writing")).addOption(new Option("--no-decode", "do not base64-decode the payload")).option("--json", "print the full JSON response instead of just the payload").option("-i, --interactive", "force the interactive wizard").option("--no-interactive", "never launch the wizard; error on missing flags").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const missing = REQUIRED.filter((k) => !opts[k]);
+    const stdinIsTty = Boolean(process.stdin.isTTY);
+    const wantWizard = opts.interactive === true || opts.interactive !== false && missing.length > 0 && stdinIsTty;
+    let memOpts;
+    if (wantWizard) {
+      memOpts = await runMemShellWizard(client);
+    } else {
+      if (missing.length > 0) {
+        throw new Error(
+          `Missing required option(s): ${missing.map((m) => `--${m}`).join(", ")}. Run in a terminal for the wizard, or pass -i.`
+        );
+      }
+      memOpts = toOptions(opts);
+    }
+    const request = buildMemShellRequest(memOpts);
+    const response = await client.generateMemShell(request);
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(response, null, 2)}
+`);
+      return;
+    }
+    const r = response.memShellResult;
+    logInfo(`shell class:    ${r.shellClassName} (${r.shellSize} bytes)`);
+    logInfo(`injector class: ${r.injectorClassName} (${r.injectorSize} bytes)`);
+    if (response.allPackResults && Object.keys(response.allPackResults).length > 0) {
+      for (const [name, value] of Object.entries(response.allPackResults)) {
+        logInfo(`
+=== ${name} ===`);
+        process.stdout.write(`${value}
+`);
+      }
+      return;
+    }
+    if (response.packResult === void 0) {
+      throw new Error("Server returned no packResult.");
+    }
+    const result = emitPayload(response.packResult, {
+      outFile: opts.output,
+      decode: opts.decode
+    });
+    if (result.destination !== "stdout") {
+      logInfo(`wrote ${result.size} bytes to ${result.destination}${result.decoded ? " (base64-decoded)" : ""}`);
+    }
+  });
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var version = "0.0.0";
+try {
+  version = require2("../package.json").version;
+} catch {
+  try {
+    version = require2("./package.json").version;
+  } catch {
+  }
+}
+var CLI_VERSION = version;
+
+// src/mcp/server.ts
+function jsonContent(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorContent(err) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: `Error: ${err.message}` }]
+  };
+}
+var memShellInput = {
+  server: z.string().describe("Target server, e.g. Tomcat"),
+  serverVersion: z.string().optional(),
+  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"),
+  debug: z.boolean().optional(),
+  byPassJavaModule: z.boolean().optional(),
+  shrink: z.boolean().optional(),
+  lambdaSuffix: z.boolean().optional(),
+  probe: z.boolean().optional(),
+  shellClassName: z.string().optional(),
+  godzillaPass: z.string().optional(),
+  godzillaKey: z.string().optional(),
+  behinderPass: z.string().optional(),
+  antSwordPass: z.string().optional(),
+  commandParamName: z.string().optional(),
+  commandTemplate: z.string().optional(),
+  encryptor: z.string().optional(),
+  implementationClass: z.string().optional(),
+  headerName: z.string().optional(),
+  headerValue: z.string().optional(),
+  shellClassBase64: z.string().optional(),
+  urlPattern: z.string().optional(),
+  injectorClassName: z.string().optional(),
+  staticInitialize: z.boolean().optional()
+};
+var probeInput = {
+  probeMethod: z.enum(["ResponseBody", "DNSLog", "Sleep"]),
+  probeContent: z.string().describe("BasicInfo, Server, OS, JDK, Bytecode, Command"),
+  packer: z.string(),
+  jdk: z.string().optional(),
+  debug: z.boolean().optional(),
+  byPassJavaModule: z.boolean().optional(),
+  shrink: z.boolean().optional(),
+  lambdaSuffix: z.boolean().optional(),
+  staticInitialize: z.boolean().optional(),
+  shellClassName: z.string().optional(),
+  host: z.string().optional(),
+  seconds: z.number().optional(),
+  sleepServer: z.string().optional(),
+  server: z.string().optional(),
+  reqParamName: z.string().optional(),
+  commandTemplate: z.string().optional()
+};
+function createMcpServer(client) {
+  const server = new McpServer({ name: "memshell-party", version: CLI_VERSION });
+  server.registerTool(
+    "list_servers",
+    { title: "List servers", description: "List supported servers and their shell types" },
+    async () => {
+      try {
+        return jsonContent(await client.getServers());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_config",
+    {
+      title: "List full config",
+      description: "List every server's shell tools and their supported shell types"
+    },
+    async () => {
+      try {
+        return jsonContent(await client.getConfig());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_packers",
+    { title: "List packers", description: "List packers as a parent/child tree" },
+    async () => {
+      try {
+        return jsonContent(await client.getPackerTree());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_command_configs",
+    {
+      title: "List command configs",
+      description: "List Command-tool encryptors and implementation classes"
+    },
+    async () => {
+      try {
+        return jsonContent(await client.getCommandConfigs());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "generate_memshell",
+    { title: "Generate memory shell", description: "Generate a Java memory shell payload", inputSchema: memShellInput },
+    async (args) => {
+      try {
+        const response = await client.generateMemShell(buildMemShellRequest(args));
+        return jsonContent(response);
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "generate_probe",
+    { title: "Generate probe shell", description: "Generate a probe/detection shell payload", inputSchema: probeInput },
+    async (args) => {
+      try {
+        const response = await client.generateProbe(buildProbeRequest(args));
+        return jsonContent(response);
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "parse_classname",
+    {
+      title: "Parse class name",
+      description: "Parse the fully-qualified class name from base64-encoded .class bytes",
+      inputSchema: { classBase64: z.string().describe("base64-encoded .class file bytes") }
+    },
+    async ({ classBase64 }) => {
+      try {
+        return jsonContent({ className: await client.parseClassName(classBase64) });
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "server_version",
+    { title: "Server version", description: "Get the backend server version info" },
+    async () => {
+      try {
+        return jsonContent(await client.getVersion());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  return server;
+}
+async function startMcpStdio(client) {
+  const server = createMcpServer(client);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/mcp.ts
+function registerMcpCommand(program) {
+  program.command("mcp").description("Run as an MCP server over stdio (exposes generation + config tools)").action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const client = createClient(globals);
+    logInfo(`memshell-party MCP server starting (api: ${resolveApiUrl({ flag: globals.api })})`);
+    await startMcpStdio(client);
+  });
+}
+
+// src/commands/parse-classname.ts
+import { readFileSync as readFileSync4 } from "fs";
+function registerParseClassNameCommand(program) {
+  program.command("parse-classname").description("Parse the fully-qualified class name from a .class file").argument("[base64]", "base64-encoded .class bytes (omit when using --file)").option("-f, --file <path>", "read a .class file from disk instead of passing base64").action(async (base64, opts, cmd) => {
+    let classBase64;
+    if (opts.file) {
+      classBase64 = readFileSync4(opts.file).toString("base64");
+    } else if (base64) {
+      classBase64 = base64.trim();
+    } else {
+      throw new Error("Provide base64 bytes as an argument or use --file <path>.");
+    }
+    const client = createClient(cmd.optsWithGlobals());
+    const name = await client.parseClassName(classBase64);
+    process.stdout.write(`${name}
+`);
+  });
+}
+
+// src/commands/probe.ts
+import { Option as Option2 } from "commander";
+
+// src/wizard/probe-wizard.ts
+import { checkbox as checkbox2, confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
+var JDK_CHOICES2 = [
+  { name: "server default", value: "" },
+  ...Object.entries(JDK_VERSIONS).map(([name, major]) => ({ name: `${name} (${major})`, value: name }))
+];
+var PROBE_METHODS = ["ResponseBody", "DNSLog", "Sleep"];
+var PROBE_CONTENTS = ["BasicInfo", "Server", "OS", "JDK", "Bytecode", "Command"];
+async function runProbeWizard(client) {
+  const [config, packerTree] = await Promise.all([client.getConfig(), client.getPackerTree()]);
+  const servers = Object.keys(config);
+  const probeMethod = await select2({
+    message: "Probe method",
+    choices: PROBE_METHODS.map((m) => ({ name: m, value: m }))
+  });
+  const probeContent = await select2({
+    message: "Probe content",
+    choices: PROBE_CONTENTS.map((c) => ({ name: c, value: c }))
+  });
+  const packer = await select2({
+    message: "Packer",
+    choices: packerTree.flatMap((p) => [
+      { name: p.name, value: p.name },
+      ...p.children.map((c) => ({ name: `  ${c}`, value: c }))
+    ])
+  });
+  const opts = { probeMethod, probeContent, packer };
+  switch (probeMethod) {
+    case "DNSLog":
+      opts.host = await input2({ message: "DNSLog host" });
+      break;
+    case "Sleep":
+      opts.sleepServer = await select2({
+        message: "Sleep server",
+        choices: servers.map((s) => ({ name: s, value: s }))
+      });
+      opts.seconds = Number(await input2({ message: "Seconds", default: "5" }));
+      break;
+    case "ResponseBody":
+      opts.server = await select2({
+        message: "Server",
+        choices: servers.map((s) => ({ name: s, value: s }))
+      });
+      opts.reqParamName = await input2({ message: "Request param name", default: "cmd" });
+      opts.commandTemplate = await input2({
+        message: "Command template (optional, {command} placeholder)",
+        default: ""
+      });
+      break;
+    default:
+      break;
+  }
+  const shellClassName = await input2({ message: "Shell class name (optional)", default: "" });
+  if (shellClassName) opts.shellClassName = shellClassName;
+  const jdk = await select2({ message: "Target JDK", choices: JDK_CHOICES2 });
+  if (jdk) opts.jdk = jdk;
+  const toggles = await checkbox2({
+    message: "Options",
+    choices: [
+      { name: "shrink bytecode", value: "shrink", checked: true },
+      { name: "static initialize", value: "staticInitialize", checked: true },
+      { name: "bypass Java module", value: "byPassJavaModule" },
+      { name: "lambda suffix", value: "lambdaSuffix" },
+      { name: "debug", value: "debug" }
+    ]
+  });
+  opts.shrink = toggles.includes("shrink");
+  opts.staticInitialize = toggles.includes("staticInitialize");
+  opts.byPassJavaModule = toggles.includes("byPassJavaModule");
+  opts.lambdaSuffix = toggles.includes("lambdaSuffix");
+  opts.debug = toggles.includes("debug");
+  const confirmed = await confirm2({ message: `Generate ${probeMethod} probe (${packer})?` });
+  if (!confirmed) throw new Error("Cancelled by user.");
+  return opts;
+}
+
+// src/commands/probe.ts
+var REQUIRED2 = ["method", "content", "packer"];
+function toOptions2(o) {
+  return {
+    probeMethod: o.method,
+    probeContent: o.content,
+    packer: o.packer,
+    jdk: o.jdk,
+    debug: o.debug,
+    byPassJavaModule: o.bypassModule,
+    shrink: o.shrink,
+    lambdaSuffix: o.lambdaSuffix,
+    staticInitialize: o.staticInitialize,
+    shellClassName: o.shellClassName,
+    host: o.host,
+    seconds: o.seconds !== void 0 ? Number(o.seconds) : void 0,
+    sleepServer: o.sleepServer,
+    server: o.server,
+    reqParamName: o.reqParamName,
+    commandTemplate: o.commandTemplate
+  };
+}
+function registerProbeCommand(program) {
+  program.command("probe").description("Generate a probe/detection shell. Runs an interactive wizard when required flags are missing.").option("-m, --method <method>", "probe method: ResponseBody, DNSLog, Sleep").option("-c, --content <content>", "probe content: BasicInfo, Server, OS, JDK, Bytecode, Command").option("-p, --packer <packer>", "packer, e.g. Base64, JSP").option("--jdk <version>", "target JDK: java6/8/9/11/17/21, or a class-file major version").option("--debug", "enable debug output").option("--bypass-module", "bypass Java module restrictions").option("--no-shrink", "disable bytecode shrinking (enabled by default)").option("--lambda-suffix", "append a lambda class-name suffix").option("--no-static-initialize", "disable static initialization (enabled by default)").option("--shell-class-name <name>", "explicit shell class name").option("--host <host>", "DNSLog host (DNSLog method)").option("--seconds <n>", "sleep seconds (Sleep method)").option("--sleep-server <server>", "server to fingerprint (Sleep method)").option("--server <server>", "server (ResponseBody method)").option("--req-param-name <name>", "request param name (ResponseBody method)").option("--command-template <tpl>", "command template ({command} placeholder)").option("-o, --output <file>", "write payload to a file instead of stdout").addOption(new Option2("--decode", "base64-decode the payload before writing")).addOption(new Option2("--no-decode", "do not base64-decode the payload")).option("--json", "print the full JSON response instead of just the payload").option("-i, --interactive", "force the interactive wizard").option("--no-interactive", "never launch the wizard; error on missing flags").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    const missing = REQUIRED2.filter((k) => !opts[k]);
+    const stdinIsTty = Boolean(process.stdin.isTTY);
+    const wantWizard = opts.interactive === true || opts.interactive !== false && missing.length > 0 && stdinIsTty;
+    let probeOpts;
+    if (wantWizard) {
+      probeOpts = await runProbeWizard(client);
+    } else {
+      if (missing.length > 0) {
+        throw new Error(
+          `Missing required option(s): ${missing.map((m) => `--${m}`).join(", ")}. Run in a terminal for the wizard, or pass -i.`
+        );
+      }
+      probeOpts = toOptions2(opts);
+    }
+    const request = buildProbeRequest(probeOpts);
+    const response = await client.generateProbe(request);
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(response, null, 2)}
+`);
+      return;
+    }
+    const r = response.probeShellResult;
+    logInfo(`shell class: ${r.shellClassName} (${r.shellSize} bytes)`);
+    if (response.allPackResults && Object.keys(response.allPackResults).length > 0) {
+      for (const [name, value] of Object.entries(response.allPackResults)) {
+        logInfo(`
+=== ${name} ===`);
+        process.stdout.write(`${value}
+`);
+      }
+      return;
+    }
+    if (response.packResult === void 0) {
+      throw new Error("Server returned no packResult.");
+    }
+    const result = emitPayload(response.packResult, {
+      outFile: opts.output,
+      decode: opts.decode
+    });
+    if (result.destination !== "stdout") {
+      logInfo(`wrote ${result.size} bytes to ${result.destination}${result.decoded ? " (base64-decoded)" : ""}`);
+    }
+  });
+}
+
+// src/commands/version.ts
+function registerVersionCommand(program) {
+  program.command("version").description("Show CLI version and the backend server version").option("--json", "output raw JSON").action(async (opts, cmd) => {
+    const client = createClient(cmd.optsWithGlobals());
+    let server;
+    try {
+      server = await client.getVersion();
+    } catch (err) {
+      server = { error: err.message };
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify({ cli: CLI_VERSION, server }, null, 2)}
+`);
+      return;
+    }
+    const lines = [`CLI:    ${CLI_VERSION}`];
+    if ("error" in server) {
+      lines.push(`Server: (unavailable) ${server.error}`);
+    } else {
+      lines.push(`Server: ${server.currentVersion}`);
+      if (server.hasUpdate) {
+        lines.push(`Update: ${server.latestVersion} available`);
+      }
+    }
+    process.stdout.write(`${lines.join("\n")}
+`);
+  });
+}
+
+// src/cli.ts
+function buildProgram() {
+  const program = new Command3();
+  program.name("memparty").description("CLI + MCP client for MemShellParty (party.mem.mk)").version(CLI_VERSION, "-v, --version", "output the CLI version").option(
+    "--api <url>",
+    `MemShellParty backend URL (env ${ENV_VAR}, default ${DEFAULT_API_URL})`
+  ).option("--timeout <ms>", "request timeout in milliseconds", "30000");
+  registerGenCommand(program);
+  registerProbeCommand(program);
+  registerConfigCommand(program);
+  registerParseClassNameCommand(program);
+  registerVersionCommand(program);
+  registerMcpCommand(program);
+  return program;
+}
+async function main() {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof ApiError) {
+      process.stderr.write(`API error (${err.status || "network"}): ${err.message}
+`);
+      process.exitCode = 1;
+    } else if (err instanceof Error) {
+      if (err.name === "ExitPromptError") {
+        process.stderr.write("\nAborted.\n");
+        process.exitCode = 130;
+      } else {
+        process.stderr.write(`Error: ${err.message}
+`);
+        process.exitCode = 1;
+      }
+    } else {
+      process.stderr.write(`Error: ${String(err)}
+`);
+      process.exitCode = 1;
+    }
+  }
+}
+void main();
+//# sourceMappingURL=cli.js.map