memshell-party-cli 0.8.0 → 0.8.1

package/dist/index.d.ts

@@ -20,7 +20,10 @@ interface ShellConfig {
     obfuscation?: ObfuscationConfig;
     obfuscationScope?: "ALL" | "MEMSHELL_INJECTOR" | "INJECTOR" | "MEMSHELL";
 }
+type ShellToolConfigObject = Record<string, unknown>;
+type ShellToolConfigValue = string | ShellToolConfigObject;
 interface ShellToolConfig {
+    [key: string]: ShellToolConfigValue | undefined;
     shellClassName?: string;
     pass?: string;
     key?: string;
@@ -156,17 +159,39 @@ interface CommandConfigVO {
 }
 interface ToolConfigParam {
     name: string;
-    type: "string" | "enum";
+    type: "string" | "enum" | "object";
     options: string[];
     group?: string;
     label?: string;
     placeholder?: string;
+    ui?: RemoteSelectUiHint;
 }
 interface ToolConfigDescriptor {
     tool: string;
     params: ToolConfigParam[];
 }
 type ObfuscationOption = Record<string, unknown>;
+interface RemoteSelectUiHint {
+    kind: "remote-select";
+    urlQueryParam: string;
+    itemsPath: string;
+    labelPath: string;
+    valuePath?: string;
+    required: boolean;
+}
+interface PluginDescriptor {
+    jarFileName: string;
+    name: string;
+    version?: string | null;
+    author?: string | null;
+    description?: string | null;
+    homepage?: string | null;
+    license?: string | null;
+    source?: string | null;
+    spiServices: string[];
+    loaded: boolean;
+    loadError?: string | null;
+}
 interface VersionInfo {
     currentVersion: string;
     latestVersion: string;
@@ -211,6 +236,7 @@ declare class MemPartyClient {
     getObfuscationOptions(): Promise<ObfuscationOption[]>;
     getProbeResponseServers(): Promise<string[]>;
     getVersion(): Promise<VersionInfo>;
+    getPlugins(): Promise<PluginDescriptor[]>;
     generateMemShell(req: MemShellGenerateRequest): Promise<MemShellGenerateResponse>;
     private getGenerationApiVersion;
     generateProbe(req: ProbeShellGenerateRequest): Promise<ProbeShellGenerateResponse>;
@@ -238,6 +264,8 @@ interface MemShellOptions {
     obfuscationOptions?: Record<string, unknown>;
     obfuscationScope?: "ALL" | "MEMSHELL_INJECTOR" | "INJECTOR" | "MEMSHELL";
     shellClassName?: string;
+    shellToolConfig?: Record<string, ShellToolConfigValue>;
+    shellToolParams?: ToolConfigParam[];
     godzillaPass?: string;
     godzillaKey?: string;
     commandParamName?: string;
@@ -333,6 +361,19 @@ declare const JDK_VERSIONS: Record<string, number>;
  */
 declare function resolveJreVersion(input: string | number | undefined): number | undefined;
 
+declare function toolConfigForTool(configs: ToolConfigDescriptor[], tool: string): ToolConfigDescriptor | undefined;
+declare function parseShellToolConfig(assignments: string[] | undefined, params: ToolConfigParam[] | undefined): Record<string, ShellToolConfigValue>;
+declare function parseToolConfigFile(source: string, params: ToolConfigParam[] | undefined): Record<string, ShellToolConfigValue>;
+declare function validateRequiredRemoteOptions(config: Record<string, ShellToolConfigValue>, params: ToolConfigParam[] | undefined): void;
+interface RemoteOption {
+    label: string;
+    value: ShellToolConfigValue;
+}
+declare function readRemotePath(value: unknown, path: string): unknown;
+declare function normalizeRemoteOptions(payload: unknown, hint: RemoteSelectUiHint, objectMode: boolean): RemoteOption[];
+declare function validateRemoteOptionsUrl(value: string): string;
+declare function fetchRemoteOptions(sourceUrl: string, hint: RemoteSelectUiHint, objectMode: boolean, fetchImpl?: typeof fetch, signal?: AbortSignal): Promise<RemoteOption[]>;
+
 type OpCategory = "gen" | "probe" | "connect" | "exec" | "download" | "upload" | "save" | "note" | "remove";
 interface OpLogEntry {
     /** ISO timestamp. */
@@ -828,4 +869,4 @@ declare function testSuo5(url: string, options?: Suo5ConnectOptions): Promise<Co
 
 declare const CLI_VERSION: string;
 
-export { ApiError, type ApiErrorResponse, type BehinderConnectOptions, type BuildDeps, type BytecodeResult, type BytecodeTransformRequest, type BytecodeTransformResponse, CLI_VERSION, type CommandConfigVO, type CommonConnectOptions, type ConnectTestResult, type ConnectTool, type ConnectionFlags, type CustomBuildInput, type CustomBuildResult, DEFAULT_API_URL, ENV_VAR, type ExecResult, type FetchLike, type FilterTemplateOptions, type GenerateClient, type GodzillaExecOptions, type InjectorConfig, type InstallSkillOptions, JDK_VERSIONS, LEGACY_CIPHER, type MainConfig, MemPartyClient, type MemPartyClientOptions, type MemShellGenerateRequest, type MemShellGenerateResponse, type MemShellOptions, type MemShellResult, type MimicCipher, OUTPUT_LIMIT, type ObfuscationConfig, type ObfuscationOption, type OpCategory, type OpFilter, type OpLogEntry, type OutputOptions, type OutputResult, type PackerOption, type PackerTree, type ProbeConfig, type ProbeContent, type ProbeContentConfig, type ProbeMethod, type ProbeOptions, type ProbeShellGenerateRequest, type ProbeShellGenerateResponse, type ProbeShellResult, type ResolvedConnection, SKILL_NAME, type ServerConfig, type ShellConfig, type ShellInput, type ShellToolConfig, type SkillInstallResult, type SkillScope, type StoredProject, type StoredShell, type Suo5ConnectOptions, type Suo5Mode, type ToolConfigDescriptor, type ToolConfigParam, type VersionInfo, autoSaveShell, buildCustomMemshell, buildMemShellRequest, buildProbeRequest, createMcpServer, defaultClassName, deriveMarkers, emitPayload, execBehinder, execGodzilla, formatOp, getProject, hasJavac, installSkill, listProjects, logOp, marshalFrameBase64, marshalSuo5Map, opLogPath, profileSecretFields, readOps, removeProject, removeShell, renderCryptoProbe, renderFilterJava, resolveApiUrl, resolveCipher, resolveConnection, resolveJreVersion, saveProjectMeta, saveShell, saveShellMeta, shouldDecode, skillSourceDir, skillTargetDir, startMcpStdio, targetStorePath, testBehinder, testGodzilla, testSuo5, truncateOutput, unmarshalFrameBase64, unmarshalSuo5Map };
+export { ApiError, type ApiErrorResponse, type BehinderConnectOptions, type BuildDeps, type BytecodeResult, type BytecodeTransformRequest, type BytecodeTransformResponse, CLI_VERSION, type CommandConfigVO, type CommonConnectOptions, type ConnectTestResult, type ConnectTool, type ConnectionFlags, type CustomBuildInput, type CustomBuildResult, DEFAULT_API_URL, ENV_VAR, type ExecResult, type FetchLike, type FilterTemplateOptions, type GenerateClient, type GodzillaExecOptions, type InjectorConfig, type InstallSkillOptions, JDK_VERSIONS, LEGACY_CIPHER, type MainConfig, MemPartyClient, type MemPartyClientOptions, type MemShellGenerateRequest, type MemShellGenerateResponse, type MemShellOptions, type MemShellResult, type MimicCipher, OUTPUT_LIMIT, type ObfuscationConfig, type ObfuscationOption, type OpCategory, type OpFilter, type OpLogEntry, type OutputOptions, type OutputResult, type PackerOption, type PackerTree, type PluginDescriptor, type ProbeConfig, type ProbeContent, type ProbeContentConfig, type ProbeMethod, type ProbeOptions, type ProbeShellGenerateRequest, type ProbeShellGenerateResponse, type ProbeShellResult, type RemoteOption, type RemoteSelectUiHint, type ResolvedConnection, SKILL_NAME, type ServerConfig, type ShellConfig, type ShellInput, type ShellToolConfig, type ShellToolConfigObject, type ShellToolConfigValue, type SkillInstallResult, type SkillScope, type StoredProject, type StoredShell, type Suo5ConnectOptions, type Suo5Mode, type ToolConfigDescriptor, type ToolConfigParam, type VersionInfo, autoSaveShell, buildCustomMemshell, buildMemShellRequest, buildProbeRequest, createMcpServer, defaultClassName, deriveMarkers, emitPayload, execBehinder, execGodzilla, fetchRemoteOptions, formatOp, getProject, hasJavac, installSkill, listProjects, logOp, marshalFrameBase64, marshalSuo5Map, normalizeRemoteOptions, opLogPath, parseShellToolConfig, parseToolConfigFile, profileSecretFields, readOps, readRemotePath, removeProject, removeShell, renderCryptoProbe, renderFilterJava, resolveApiUrl, resolveCipher, resolveConnection, resolveJreVersion, saveProjectMeta, saveShell, saveShellMeta, shouldDecode, skillSourceDir, skillTargetDir, startMcpStdio, targetStorePath, testBehinder, testGodzilla, testSuo5, toolConfigForTool, truncateOutput, unmarshalFrameBase64, unmarshalSuo5Map, validateRemoteOptionsUrl, validateRequiredRemoteOptions };

package/dist/index.js

@@ -83,6 +83,14 @@ var MemPartyClient = class {
   getVersion() {
     return this.request("GET", "/api/version");
   }
+  async getPlugins() {
+    try {
+      return await this.request("GET", "/api/plugins");
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) return [];
+      throw err;
+    }
+  }
   // ---------- generation ----------
   async generateMemShell(req) {
     const apiVersion = await this.getGenerationApiVersion();
@@ -204,6 +212,127 @@ function toLegacyMemShellRequest(req) {
 // src/core/request-builder.ts
 import { randomInt } from "crypto";
 
+// src/core/shell-tool-config.ts
+function toolConfigForTool(configs, tool) {
+  return configs.find((config) => config.tool === tool);
+}
+function parseShellToolConfig(assignments, params) {
+  const result = {};
+  for (const assignment of assignments ?? []) {
+    const separator = assignment.indexOf("=");
+    if (separator <= 0) {
+      throw new Error(`Invalid --tool-option "${assignment}". Expected name=value.`);
+    }
+    const name = assignment.slice(0, separator).trim();
+    const rawValue = assignment.slice(separator + 1);
+    if (!name) throw new Error(`Invalid --tool-option "${assignment}". Expected name=value.`);
+    const param = params?.find((candidate) => candidate.name === name);
+    if (params !== void 0 && param === void 0) {
+      throw new Error(
+        `Unknown shell tool option "${name}". Available options: ${params.map((item) => item.name).join(", ") || "(none)"}.`
+      );
+    }
+    if (param?.type === "object") {
+      result[name] = parseJsonObject(rawValue, `--tool-option ${name}`);
+    } else if (rawValue.startsWith("{")) {
+      result[name] = parseJsonObject(rawValue, `--tool-option ${name}`);
+    } else {
+      result[name] = rawValue;
+    }
+  }
+  return result;
+}
+function parseToolConfigFile(source, params) {
+  const parsed = parseJsonObject(source, "--tool-config");
+  const assignments = Object.entries(parsed).map(([name, value]) => {
+    if (typeof value === "string") return `${name}=${value}`;
+    return `${name}=${JSON.stringify(value)}`;
+  });
+  return parseShellToolConfig(assignments, params);
+}
+function validateRequiredRemoteOptions(config, params) {
+  const missing = (params ?? []).filter((param) => param.ui?.kind === "remote-select" && param.ui.required).filter((param) => {
+    const value = config[param.name];
+    return value === void 0 || typeof value === "string" && value.trim() === "";
+  }).map((param) => param.name);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required remote shell tool option(s): ${missing.join(", ")}. Provide them with --tool-option or --tool-config.`
+    );
+  }
+}
+function parseJsonObject(source, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    throw new Error(`${label} must be valid JSON: ${err.message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readRemotePath(value, path) {
+  if (!path) return value;
+  let current = value;
+  for (const segment of path.split(".")) {
+    if (!segment || typeof current !== "object" || current === null || Array.isArray(current) || !(segment in current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeRemoteOptions(payload, hint, objectMode) {
+  const items = readRemotePath(payload, hint.itemsPath);
+  if (!Array.isArray(items)) {
+    throw new Error("Remote options response does not contain an array at itemsPath.");
+  }
+  return items.map((item) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      throw new Error("Remote option items must be objects.");
+    }
+    const rawLabel = readRemotePath(item, hint.labelPath);
+    if (typeof rawLabel !== "string" && typeof rawLabel !== "number") {
+      throw new Error("Remote option labels must be strings or numbers.");
+    }
+    if (objectMode) return { label: String(rawLabel), value: item };
+    if (!hint.valuePath) throw new Error("String remote options require valuePath.");
+    const rawValue = readRemotePath(item, hint.valuePath);
+    if (typeof rawValue !== "string" && typeof rawValue !== "number") {
+      throw new Error("Remote option values must be strings or numbers.");
+    }
+    return { label: String(rawLabel), value: String(rawValue) };
+  });
+}
+function validateRemoteOptionsUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Remote options URL must use HTTP or HTTPS.");
+  }
+  return url.toString();
+}
+async function fetchRemoteOptions(sourceUrl, hint, objectMode, fetchImpl = globalThis.fetch, signal) {
+  const url = validateRemoteOptionsUrl(sourceUrl);
+  const response = await fetchImpl(url, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    redirect: "follow",
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`Remote options request failed (${response.status} ${response.statusText}).`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("Remote options response must be valid JSON.");
+  }
+  return normalizeRemoteOptions(payload, hint, objectMode);
+}
+
 // src/core/jdk.ts
 var JDK_VERSIONS = {
   java6: 50,
@@ -247,6 +376,7 @@ function generateSpringExpressionInjectorClassName() {
   return `org.springframework.expression.${randomChar(UPPERCASE_LETTERS)}${randomName}Util`;
 }
 function buildMemShellRequest(opts) {
+  validateRequiredRemoteOptions(opts.shellToolConfig ?? {}, opts.shellToolParams);
   const injectorClassName = SPRING_GZIP_JDK17_RELATED_PACKERS.has(opts.packer) ? generateSpringExpressionInjectorClassName() : opts.injectorClassName;
   return {
     shellConfig: {
@@ -273,7 +403,8 @@ function buildMemShellRequest(opts) {
       headerValue: opts.headerValue,
       shellClassBase64: opts.shellClassBase64,
       encryptor: opts.encryptor,
-      implementationClass: opts.implementationClass
+      implementationClass: opts.implementationClass,
+      ...opts.shellToolConfig
     },
     injectorConfig: {
       injectorClassName,
@@ -2692,6 +2823,10 @@ var memShellInput = {
   obfuscationOptions: z.string().optional().describe("obfuscation overrides: key=value, comma-separated"),
   obfuscationScope: z.enum(["ALL", "MEMSHELL_INJECTOR", "INJECTOR", "MEMSHELL"]).optional(),
   shellClassName: z.string().optional(),
+  toolOptions: z.record(z.union([z.string(), z.record(z.unknown())])).optional().describe(
+    "Additional shell-tool fields from list_shell_tool_configs, including plugin fields. String/enum fields use strings; v3.1+ object fields use JSON objects. These override matching built-in convenience arguments."
+  ),
+  toolOptionJson: z.record(z.string()).optional().describe("String-encoded shell-tool fields (name -> value); object fields contain JSON text."),
   godzillaPass: z.string().optional(),
   godzillaKey: z.string().optional(),
   behinderPass: z.string().optional(),
@@ -2966,6 +3101,50 @@ function createMcpServer(client) {
       }
     }
   );
+  server.registerTool(
+    "list_plugins",
+    {
+      title: "List external plugins",
+      description: "List v3.1+ external plugin metadata, SPI services, load status and load errors. An empty list means no plugins or a backend older than v3.1."
+    },
+    async () => {
+      try {
+        return jsonContent(await client.getPlugins());
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_remote_options",
+    {
+      title: "Resolve remote shell tool options",
+      description: "Fetch and normalize a v3.1 remote-select field. Returns labels and string IDs or complete objects ready to pass to generate_memshell toolOptions.",
+      inputSchema: {
+        tool: z.string(),
+        param: z.string(),
+        url: z.string().optional().describe("Remote HTTP(S) endpoint; falls back to the urlQueryParam environment variable."),
+        object: z.boolean().optional().describe("Override object mode; normally inferred from the field type.")
+      }
+    },
+    async (args) => {
+      try {
+        const descriptor = (await client.getShellToolConfigs()).find((config) => config.tool === args.tool);
+        const param = descriptor?.params.find((candidate) => candidate.name === args.param);
+        if (!param?.ui || param.ui.kind !== "remote-select") {
+          throw new Error(`${args.tool}.${args.param} is not a remote-select shell tool option.`);
+        }
+        const sourceUrl = args.url ?? process.env[param.ui.urlQueryParam];
+        if (!sourceUrl) {
+          throw new Error(`Provide url or set the ${param.ui.urlQueryParam} environment variable.`);
+        }
+        const options = await fetchRemoteOptions(sourceUrl, param.ui, args.object ?? param.type === "object");
+        return jsonContent({ tool: args.tool, param: args.param, sourceUrl, options });
+      } catch (err) {
+        return errorContent(err);
+      }
+    }
+  );
   server.registerTool(
     "list_obfuscation_options",
     {
@@ -3003,9 +3182,21 @@ function createMcpServer(client) {
             "agentArgs requires an Agent* shell type and an AgentJar, AgentJarWithJDKAttacher, or AgentJarWithJREAttacher packer."
           );
         }
+        const hasPluginOptions = args.toolOptions !== void 0 || args.toolOptionJson !== void 0;
+        const toolConfigs = hasPluginOptions ? await client.getShellToolConfigs() : [];
+        const shellToolParams = hasPluginOptions ? toolConfigs.find((config) => config.tool === args.shellTool)?.params : void 0;
+        const shellToolConfig = {
+          ...args.toolOptions,
+          ...parseShellToolConfig(
+            Object.entries(args.toolOptionJson ?? {}).map(([name, value]) => `${name}=${value}`),
+            shellToolParams
+          )
+        };
         const response = await client.generateMemShell(
           buildMemShellRequest({
             ...args,
+            shellToolConfig: hasPluginOptions ? shellToolConfig : void 0,
+            shellToolParams,
             obfuscationOptions: parseObfuscationOptions(args.obfuscationOptions)
           })
         );
@@ -4229,6 +4420,7 @@ export {
   emitPayload,
   execBehinder,
   execGodzilla,
+  fetchRemoteOptions,
   formatOp,
   getProject,
   hasJavac,
@@ -4237,9 +4429,13 @@ export {
   logOp,
   marshalFrameBase64,
   marshalSuo5Map,
+  normalizeRemoteOptions,
   opLogPath,
+  parseShellToolConfig,
+  parseToolConfigFile,
   profileSecretFields,
   readOps,
+  readRemotePath,
   removeProject,
   removeShell,
   renderCryptoProbe,
@@ -4259,8 +4455,11 @@ export {
   testBehinder,
   testGodzilla,
   testSuo5,
+  toolConfigForTool,
   truncateOutput,
   unmarshalFrameBase64,
-  unmarshalSuo5Map
+  unmarshalSuo5Map,
+  validateRemoteOptionsUrl,
+  validateRequiredRemoteOptions
 };
 //# sourceMappingURL=index.js.map