dsh-mcp 1.7.0 → 1.9.0

package/lib/index.js

@@ -266,7 +266,13 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 const SECRET_REF_PREFIX = "DSH_MCP_";
 /** Credential reference namespace prefix for process-level secret env values. */
 const GLOBAL_ENV_REF_PREFIX = "DSH_MCP_ENV_";
-const Config = z.object({ probeTimeoutMs: z.number().min(1).default(15e3) });
+/** Credential reference namespace prefix for per-server OAuth tokens/clients (see lib/oauth.js). */
+const OAUTH_REF_PREFIX = "DSH_MCP_OAUTH_";
+const Config = z.object({
+	probeTimeoutMs: z.number().min(1).default(15e3),
+	/** When true, mounts open the browser for OAuth authorization on their own (legacy behavior); default false keeps mounts browser-free. */
+	allowBrowserOnMount: z.boolean().default(false)
+});
 /** The mcp-client plugin as a Cordis object plugin, mounted per server. */
 const MCP_CLIENT_PLUGIN = {
 	name: mcpClient.name,
@@ -468,6 +474,8 @@ let McpManagerService = (() => {
 		/** Server ids whose secret writes are this manager's own; skip restart echoes. */
 		suppressRestart = /* @__PURE__ */ new Set();
 		probeTimeoutMs;
+		/** Whether mounts may open the browser for OAuth authorization (see {@link Config.allowBrowserOnMount}). */
+		allowBrowserOnMount;
 		/** Per-tool enable switches: a stored `false` disables that tool; absent means enabled. */
 		toolSwitches = /* @__PURE__ */ new Map();
 		/** Injection mode: `search` (default) injects only resident + hot tools; `full` injects every enabled tool. */
@@ -483,6 +491,7 @@ let McpManagerService = (() => {
 		constructor(ctx, config) {
 			super(ctx, "mcpManager");
 			this.probeTimeoutMs = config.probeTimeoutMs;
+			this.allowBrowserOnMount = config.allowBrowserOnMount;
 		}
 		/** Open the storage domain, mount stored servers, and subscribe to secret changes. */
 		async [Service.init]() {
@@ -495,7 +504,28 @@ let McpManagerService = (() => {
 			this.envTable = domain.table("global_env");
 			for (const [id, row] of this.table.entries()) if (row.enabled) this.mount(id, row);
 			this.installToolControl();
-			this.ctx.on("credentials/updated", (ref) => {
+			this.ctx.on("credentials/reference-updated", (ref) => {
+				// OAuth token/client refs (`DSH_MCP_OAUTH_<serverName>_<hash>` /
+				// `DSH_MCP_OAUTH_CLIENT_...`) do not carry the managed server id,
+				// so managedServerId() cannot resolve them. Resolve by the
+				// sanitized serverName instead: after an authorization flow
+				// stores tokens, remount every enabled server of that name so
+				// its tools register without a manual refresh.
+				if (ref.startsWith(OAUTH_REF_PREFIX)) {
+					const rest = ref.slice(OAUTH_REF_PREFIX.length);
+					const separator = rest.lastIndexOf("_");
+					if (separator > 0) {
+						const safeName = rest.slice(0, separator);
+						for (const [id, row] of this.requireTable().entries()) {
+							if (row.enabled && row.serverName.replace(/[^A-Za-z0-9_]/g, "_") === safeName && !this.suppressRestart.has(id)) {
+								this.serialize(id, async () => {
+									if (this.requireTable().get(id) !== void 0) await this.reconcileMount(id);
+								});
+							}
+						}
+					}
+					return;
+				}
 				const id = managedServerId(ref);
 				if (id === void 0 || this.suppressRestart.has(id)) return;
 				this.serialize(id, async () => {
@@ -595,10 +625,11 @@ let McpManagerService = (() => {
 					const globalEnv = await this.resolveGlobalEnv();
 					// Every server gets an OAuth provider: servers that require
 					// OAuth (authorization-code flow) trigger browser auth on
-					// connect; servers that do not are unaffected. Tokens are
-					// keyed by serverName so a test-connection authorization is
-					// reused by the mount.
-					const authProvider = createOAuthProvider(row.serverName, this.ctx);
+					// connect (unless allowBrowserOnMount is off, the default);
+					// servers that do not are unaffected. Tokens are keyed by
+					// serverName so a test-connection authorization is reused
+					// by the mount.
+					const authProvider = createOAuthProvider(row.serverName, this.ctx, { allowBrowser: this.allowBrowserOnMount, serverUrl: row.url });
 					handle = this.ctx.plugin(MCP_CLIENT_PLUGIN, { ...this.toClientConfig(row, env, globalEnv), authProvider });
 				} catch (error) {
 					entry.phase = "failed";
@@ -1018,7 +1049,7 @@ let McpManagerService = (() => {
 			const globalEnv = await this.resolveGlobalEnv();
 			const probe = await probeConnection(this.toClientConfig(request.server, env, globalEnv), {
 				timeoutMs: this.probeTimeoutMs,
-				authProvider: createOAuthProvider(request.server.serverName, this.ctx)
+				authProvider: createOAuthProvider(request.server.serverName, this.ctx, { serverUrl: request.server.url })
 			});
 			const elapsedMs = Date.now() - startedAt;
 			return {
@@ -1151,6 +1182,16 @@ let McpManagerService = (() => {
 					});
 				}
 				assembly.tools = kept;
+				// Canonical tool order: render MCP tools sorted by name so the
+				// system prompt stays byte-stable for the same tool set no
+				// matter the registration or hot-set order (hot tools move on
+				// every call, and servers may reorder tools/list) — stable
+				// output is what preserves prompt-cache hits.
+				const mcpKept = [];
+				const otherKept = [];
+				for (const tool of assembly.tools) (tool.name.startsWith("mcp__") ? mcpKept : otherKept).push(tool);
+				mcpKept.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+				assembly.tools = [...otherKept, ...mcpKept];
 				return next();
 			});
 			this.ctx.on("tools/result", (exec) => {

package/lib/mcp-client.js

@@ -10,6 +10,7 @@ import { isDeepStrictEqual } from "node:util";
 import { z as z$1 } from "zod";
 import { isImageAdmissionError } from "@deepseek-ai/dsh-attachment";
 import { assertSupportedJsonSchema } from "@deepseek-ai/dsh-tools";
+import { createToolAuthorizationUrl } from "./oauth.js";
 //#region lib/types/transport.js
 /**
 * Transport factory: creates the appropriate MCP transport based on the
@@ -204,9 +205,22 @@ function toolPublicEqual(a, b) {
 	if (!jsonEqual(a.parameters, b.parameters)) return false;
 	return jsonEqual(a.output && a.output.schema, b.output && b.output.schema);
 }
-/** Deep equality of JSON-serializable values (schema objects). */
+/**
+* Recursively sort object keys so semantically identical JSON compares equal
+* regardless of key order (servers often reorder schema keys between lists).
+*/
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const key of Object.keys(value).sort()) out[key] = canonicalize(value[key]);
+		return out;
+	}
+	return value;
+}
+/** Deep equality of JSON-serializable values, ignoring object key order. */
 function jsonEqual(a, b) {
-	return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+	return JSON.stringify(canonicalize(a ?? null)) === JSON.stringify(canonicalize(b ?? null));
 }
 /** Keep a supported advertised schema; unsupported MCP vocabulary falls back to JsonValue. */
 function supportedOutputSchema(candidate) {
@@ -224,7 +238,11 @@ function createDefinition(client, ctx, publicName, rawName, description, paramet
 	return {
 		name: publicName,
 		description,
-		parameters,
+		// Canonicalize before registration: servers often return JSON Schema
+		// with unstable key ordering; sorting keys keeps the model-visible tool
+		// list byte-stable across re-syncs and reconnects, which is what
+		// preserves prompt-cache hits.
+		parameters: canonicalize(parameters),
 		output: createOutput(rawName, structuredSchema),
 		execute: createExecutor(client, ctx, rawName, taskRequired, opts, projections),
 		finalizeContent(exec, result) {
@@ -248,7 +266,7 @@ function createOutput(rawName, structuredSchema) {
 					type: "array",
 					items: {}
 				},
-				structuredContent: structuredSchema ?? {}
+				structuredContent: canonicalize(structuredSchema ?? {})
 			},
 			required: structuredSchema === void 0 ? ["content"] : ["content", "structuredContent"],
 			additionalProperties: false
@@ -274,6 +292,30 @@ function createOutput(rawName, structuredSchema) {
 function createExecutor(client, ctx, rawName, taskRequired, opts, projections) {
 	return async (args, exec) => {
 		if (taskRequired) throw new Error(`Tool "${rawName}" requires task-based execution, which this bridge does not support`);
+		// OAuth servers: if the stored token is missing or expired, do NOT let
+		// the SDK open a browser from inside a tool call (a session could open
+		// several tabs at once). Instead, build an authorization URL and return
+		// it for the user to click; a background listener completes the flow.
+		if (opts.authProvider !== void 0 && opts.authProvider.tokens !== void 0) {
+			const tokens = await opts.authProvider.tokens();
+			const expired = tokens === void 0 || tokens.access_token === void 0 || (() => {
+				try {
+					const payload = JSON.parse(Buffer.from(String(tokens.access_token).split(".")[1] ?? "", "base64url").toString("utf8"));
+					return typeof payload.exp === "number" && Date.now() / 1000 >= payload.exp;
+				} catch {
+					return false;
+				}
+			})();
+			if (expired) {
+				try {
+					const authUrl = await createToolAuthorizationUrl(opts.serverName, ctx, opts.url);
+					throw new Error(`服务器 "${opts.serverName}" 需要 OAuth 授权，请在浏览器打开以下链接完成授权后重试：\n${authUrl}`);
+				} catch (error) {
+					if (error instanceof Error && error.message.includes("授权")) throw error;
+					throw new Error(`服务器 "${opts.serverName}" 需要 OAuth 授权：请在 Settings → MCP 编辑该服务器并点击「测试连接」完成授权后重试`);
+				}
+			}
+		}
 		const result = await callToolUncached(client, rawName, typeof args === "object" && args !== null ? args : {}, exec, opts);
 		if (!Array.isArray(result.content)) {
 			const rendered = "toolResult" in result ? JSON.stringify(result.toolResult) : "(no output)";
@@ -862,7 +904,13 @@ async function apply(ctx, config) {
 		return () => connection.dispose();
 	}, "mcp-client.connection");
 	const outcome = await connection.ready;
-	if (outcome.error !== void 0 && config.failOnStartupError) throw new Error(`mcp-client(${config.serverName}): initial connection or tool synchronization failed`, { cause: outcome.error });
+	// Keep the cause readable: the mount failure view only surfaces the
+	// message, so fold the underlying detail (e.g. an OAuth authorization
+	// link) into it instead of burying it in `cause`.
+	if (outcome.error !== void 0 && config.failOnStartupError) {
+		const detail = outcome.error instanceof Error && outcome.error.message ? outcome.error.message : String(outcome.error);
+		throw new Error(`mcp-client(${config.serverName}): initial connection or tool synchronization failed: ${detail}`, { cause: outcome.error });
+	}
 }
 //#endregion
 export { Config, apply, inject, name, probeConnection };

package/lib/oauth.js

@@ -15,7 +15,10 @@ import { createServer } from "node:http";
 import { spawn } from "node:child_process";
 import {
   discoverAuthorizationServerMetadata,
+  discoverOAuthServerInfo,
   exchangeAuthorization,
+  registerClient,
+  startAuthorization,
 } from "@modelcontextprotocol/sdk/client/auth.js";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 
@@ -100,17 +103,18 @@ function stablePort(serverId) {
 }
 
 /**
- * Serialize authorization flows per server: the loopback port is stable per
- * server, so two concurrent flows (e.g. mount and a test connection) would
- * both try to listen on the same port and one fails with EADDRINUSE. Queue
- * them so only one browser authorization runs at a time per server.
+ * Serialize ALL authorization flows globally: each server's loopback port is
+ * stable, so concurrent flows (multiple mounts, mount + test, several OAuth
+ * servers at startup) would otherwise each open a browser tab at once. A
+ * single global queue means at most one browser authorization is running at
+ * any time; a flow that gets the lock after another one stored fresh tokens
+ * skips the browser entirely (see redirectToAuthorization).
  */
-const authLocks = /* @__PURE__ */ new Map();
+let authQueue = Promise.resolve();
 
-function withAuthLock(serverId, fn) {
-  const previous = authLocks.get(serverId) ?? Promise.resolve();
-  const run = previous.then(fn, fn);
-  authLocks.set(serverId, run.then(() => {}, () => {}));
+function withAuthLock(fn) {
+  const run = authQueue.then(fn, fn);
+  authQueue = run.then(() => {}, () => {});
   return run;
 }
 
@@ -120,9 +124,11 @@ function withAuthLock(serverId, fn) {
  * @param ctx - Host context carrying the credentials service.
  * @returns an MCP SDK `OAuthClientProvider` implementation.
  */
-export function createOAuthProvider(serverId, ctx) {
+export function createOAuthProvider(serverId, ctx, options = {}) {
   let codeVerifierValue = null;
   let savedClientInfo = null;
+  const allowBrowser = options.allowBrowser !== false;
+  const serverUrl = options.serverUrl;
   const port = stablePort(serverId);
   const redirectUrl = `http://127.0.0.1:${port}/callback`;
   const log = ctx?.logger ?? console;
@@ -215,9 +221,48 @@ export function createOAuthProvider(serverId, ctx) {
       return codeVerifierValue;
     },
     async redirectToAuthorization(authorizationUrl) {
-      // Serialize per server: the loopback port is stable, so concurrent
-      // flows (mount + test) would collide on the same port. Queue them.
-      return withAuthLock(serverId, async () => {
+      // Global serialization: at most one browser authorization runs at a
+      // time (stable per-server ports would otherwise collide, and several
+      // OAuth servers at startup would open many tabs at once).
+      return withAuthLock(async () => {
+        // Another queued flow may have just completed authorization and
+        // stored fresh tokens while we waited. If so, skip the browser — the
+        // SDK will throw on this attempt and the next connect uses the token.
+        const existing = await ctx.credentials.resolve(oauthTokenRef(serverId));
+        if (existing !== void 0) {
+          try {
+            const stored = JSON.parse(existing.value);
+            const exp = jwtExp(stored.access_token);
+            if (exp === void 0 || Date.now() / 1000 < exp) {
+              log.info(`${tag}: tokens already refreshed by another flow, skipping browser`);
+              return;
+            }
+          } catch {
+            // malformed stored token — fall through and authorize
+          }
+        }
+        if (serverUrl !== void 0) {
+          // One shared pending-callback listener per server:
+          // createToolAuthorizationUrl deduplicates by serverId, so a mount
+          // failure and a test connection reuse the same loopback listener
+          // instead of both binding the stable port (an unhandled EADDRINUSE
+          // on listen would crash the Host).
+          const url = await createToolAuthorizationUrl(serverId, ctx, serverUrl);
+          if (!allowBrowser) {
+            // Mount-time connections must not pop the browser on their own;
+            // fail with the clickable authorization link. The shared
+            // listener keeps running so opening the URL completes the flow.
+            log.info(`${tag}: mount requires authorization, not opening browser`);
+            throw new Error(`服务器 "${serverId}" 需要 OAuth 授权，请在浏览器打开以下链接完成授权后重试（也可在 Settings → MCP 点击「测试连接」）：\n${url}`);
+          }
+          log.info(`${tag}: opening browser for authorization: ${url}`);
+          openBrowser(url);
+          const pending = pendingCallbacks.get(serverId);
+          if (pending !== void 0) await pending.done;
+          return;
+        }
+        // Fallback (no server URL known): legacy loopback listener with an
+        // error handler so a bind failure can never crash the Host.
         let resolveResult;
         const resultPromise = new Promise((resolve) => {
           resolveResult = resolve;
@@ -237,6 +282,10 @@ export function createOAuthProvider(serverId, ctx) {
           log.info(`${tag}: authorization callback received (code)`);
           resolveResult({ code });
         });
+        server.on("error", (error) => {
+          log.error(`${tag}: callback server error: ${error instanceof Error ? error.message : String(error)}`);
+          resolveResult({ error: error instanceof Error ? error.message : String(error) });
+        });
         await new Promise((resolve) => server.listen(port, "127.0.0.1", resolve));
         log.info(`${tag}: opening browser for authorization: ${authorizationUrl}`);
         openBrowser(authorizationUrl.toString());
@@ -273,3 +322,123 @@ export function createOAuthProvider(serverId, ctx) {
     },
   };
 }
+
+/** Pending background authorization callbacks per server (one at a time). */
+const pendingCallbacks = /* @__PURE__ */ new Map();
+
+/**
+ * Build an authorization URL for a tool call that needs authorization and
+ * start a background loopback listener that completes the flow when the user
+ * opens the URL. The browser is NOT opened automatically — the caller returns
+ * the URL to the model/user to click. Concurrent requests for the same server
+ * reuse the pending flow.
+ * @param serverId - Managed server id (stable loopback port + token key).
+ * @param ctx - Host context carrying credentials.
+ * @param serverUrl - The MCP server URL (used for OAuth discovery).
+ * @returns the authorization URL to present to the user.
+ */
+export async function createToolAuthorizationUrl(serverId, ctx, serverUrl) {
+  const port = stablePort(serverId);
+  const redirectUrl = `http://127.0.0.1:${port}/callback`;
+  const log = ctx?.logger ?? console;
+  const tag = `mcp-oauth(${serverId})`;
+  const existing = pendingCallbacks.get(serverId);
+  if (existing !== void 0) return existing.url;
+
+  const info = await discoverOAuthServerInfo(serverUrl, { fetchFn: fetch });
+  let clientInfo = await ctx.credentials.resolve(oauthClientRef(serverId));
+  if (clientInfo !== void 0) {
+    try {
+      clientInfo = JSON.parse(clientInfo.value);
+    } catch {
+      clientInfo = void 0;
+    }
+    if (clientInfo !== void 0 && (!Array.isArray(clientInfo.redirect_uris) || !clientInfo.redirect_uris.includes(redirectUrl))) {
+      clientInfo = void 0; // stale redirect_uris → re-register
+    }
+  }
+  if (clientInfo === void 0) {
+    clientInfo = await registerClient(info.authorizationServerUrl, {
+      metadata: info.authorizationServerMetadata,
+      clientMetadata: {
+        client_name: "dsh-mcp",
+        redirect_uris: [redirectUrl],
+      },
+      fetchFn: fetch,
+    });
+    await ctx.credentials.set(oauthClientRef(serverId), JSON.stringify(clientInfo));
+  }
+  // The SDK expects a URL object (it reads `resource.href`); passing a bare
+  // string would serialize the resource parameter as "undefined". Prefer the
+  // protected-resource metadata's resource when available.
+  const resourceUrl = info.resourceMetadata?.resource !== void 0
+    ? new URL(info.resourceMetadata.resource)
+    : new URL(serverUrl);
+  const { authorizationUrl, codeVerifier } = await startAuthorization(info.authorizationServerUrl, {
+    metadata: info.authorizationServerMetadata,
+    clientInformation: clientInfo,
+    redirectUrl,
+    resource: resourceUrl,
+  });
+  const url = String(authorizationUrl);
+
+  // Background listener: wait for the user to open the URL and authorize.
+  const pending = {
+    url,
+    done: new Promise((resolve) => {
+      const server = createServer(async (req, res) => {
+        const callbackUrl = new URL(req.url, redirectUrl);
+        const code = callbackUrl.searchParams.get("code");
+        const error = callbackUrl.searchParams.get("error");
+        res.setHeader("content-type", "text/html; charset=utf-8");
+        if (error) {
+          res.end(`授权失败：${error}，可关闭此页面并返回 DSH。`);
+          log.error(`${tag}: callback rejected: ${error}`);
+          resolve();
+          server.close();
+          return;
+        }
+        res.end("授权成功，可关闭此页面并返回 DSH。");
+        log.info(`${tag}: tool-auth callback received (code)`);
+        try {
+          const authServerUrl = new URL(authorizationUrl.origin);
+          const metadata = await discoverAuthorizationServerMetadata(authServerUrl);
+          const tokens = await exchangeAuthorization(authServerUrl, {
+            metadata,
+            clientInformation: clientInfo,
+            authorizationCode: code,
+            codeVerifier,
+            redirectUri: redirectUrl,
+          });
+          await ctx.credentials.set(oauthTokenRef(serverId), JSON.stringify(tokens));
+          log.info(`${tag}: tool-auth tokens saved`);
+        } catch (exchangeError) {
+          log.error(`${tag}: tool-auth exchange failed: ${exchangeError instanceof Error ? exchangeError.message : String(exchangeError)}`);
+        }
+        resolve();
+        server.close();
+      });
+      // Never let a bind failure crash the Host: resolve the pending flow so
+      // callers surface a readable error instead of an unhandled event.
+      server.on("error", (listenError) => {
+        log.error(`${tag}: tool-auth listener error: ${listenError instanceof Error ? listenError.message : String(listenError)}`);
+        resolve();
+      });
+      server.listen(port, "127.0.0.1", () => {
+        log.info(`${tag}: tool-auth listener ready on :${port}`);
+      });
+      // Give up after 5 minutes so the listener never leaks.
+      const timer = setTimeout(() => {
+        log.info(`${tag}: tool-auth listener expired`);
+        server.close();
+        resolve();
+      }, 5 * 60e3);
+      timer.unref?.();
+    }),
+  };
+  pendingCallbacks.set(serverId, pending);
+  void pending.done.finally(() => {
+    if (pendingCallbacks.get(serverId) === pending) pendingCallbacks.delete(serverId);
+  });
+  return url;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "MCP 管理界面 + tool search：可视化配置/启停/刷新 MCP 服务器与工具勾选，按需检索（tool search）热注入；工具列表稳定命中缓存、不撑爆上下文。DeepSeek Harness plugin: MCP management UI + tool search — stable tool list, cache-friendly, no context bloat.",
   "type": "module",
   "main": "lib/index.js",

package/src/client/ServerForm.tsx

@@ -3,6 +3,7 @@ import type { McpManagerFailure, McpServerId, McpServerView } from './types.ts'
 import type {
   McpDraft, McpTestOutcome,
 } from './mcp-store.ts'
+import { parseArgs } from './mcp-store.ts'
 import type { McpSettingsLocaleKey } from './locales.ts'
 import css from './ServerForm.module.css'
 
@@ -168,11 +169,17 @@ export function McpServerForm(props: McpServerFormProps): ReactNode {
           <label className={css.field}>
             <span>{t('args')}</span>
             <textarea
-              rows={2}
+              rows={3}
               value={draft.argsText}
               placeholder={t('argsPlaceholder')}
               onChange={(event) => update({ argsText: event.currentTarget.value })}
             />
+            {(() => {
+              const parsed = parseArgs(draft.argsText)
+              if (parsed.length === 0) return <span className={css.muted}>{t('argsPreviewEmpty')}</span>
+              const shown = parsed.map(arg => arg.length > 48 ? `${arg.slice(0, 45)}…` : arg).join(' | ')
+              return <span className={css.muted}>{t('argsPreview')}: {parsed.length} · {shown}</span>
+            })()}
           </label>
           <label className={css.field}>
             <span>{t('cwd')}</span>
@@ -182,6 +189,7 @@ export function McpServerForm(props: McpServerFormProps): ReactNode {
               placeholder={t('cwdPlaceholder')}
               onChange={(event) => update({ cwd: event.currentTarget.value })}
             />
+            <span className={css.muted}>{t('cwdHint')}</span>
           </label>
         </>
       ) : (

package/src/client/locales.ts

@@ -18,9 +18,12 @@ export const zh = {
   command: '命令',
   commandPlaceholder: '例如 npx',
   args: '参数',
-  argsPlaceholder: '每行一个参数',
+  argsPlaceholder: '空格/换行分隔，支持引号，如：-y @modelcontextprotocol/server-filesystem /path/to/dir',
+  argsPreview: '参数预览',
+  argsPreviewEmpty: '（无参数）',
   cwd: '工作目录',
   cwdPlaceholder: '留空继承 Host 工作目录',
+  cwdHint: '留空会继承 DSH 的工作目录。若该目录是 pnpm workspace，npx 等命令可能解析到错误的本地包；建议填一个普通目录的绝对路径。',
   url: '服务器 URL',
   urlPlaceholder: '例如 http://localhost:3000/mcp',
   headers: '请求头',
@@ -121,9 +124,12 @@ export const en = {
   command: 'Command',
   commandPlaceholder: 'e.g. npx',
   args: 'Arguments',
-  argsPlaceholder: 'One argument per line',
+  argsPlaceholder: 'Space/newline separated, quotes supported, e.g. -y @modelcontextprotocol/server-filesystem /path/to/dir',
+  argsPreview: 'Argument preview',
+  argsPreviewEmpty: '(no arguments)',
   cwd: 'Working directory',
   cwdPlaceholder: 'Leave empty to inherit the Host working directory',
+  cwdHint: 'An empty value inherits the DSH working directory. If that directory is a pnpm workspace, npx and similar commands may resolve to a wrong local package; prefer an absolute path to a plain directory.',
   url: 'Server URL',
   urlPlaceholder: 'e.g. http://localhost:3000/mcp',
   headers: 'Headers',

package/src/client/mcp-store.ts

@@ -103,6 +103,67 @@ function parseLines(text: string): string[] {
   return text.split('\n').map(line => line.trim()).filter(line => line.length > 0)
 }
 
+/**
+ * Shell-style argument parsing: split on whitespace (spaces, tabs, newlines)
+ * while honoring single quotes, double quotes (with `\"` and `\\` escapes),
+ * and backslash escapes outside quotes. Unclosed quotes are tolerated: the
+ * remaining input becomes one argument. An explicitly empty quoted argument
+ * (`""` or `''`) is preserved.
+ */
+export function parseArgs(text: string): string[] {
+  const args: string[] = []
+  let current = ''
+  let quote: '"' | "'" | null = null
+  let hasToken = false
+  let i = 0
+  while (i < text.length) {
+    const ch = text[i]
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null
+        i += 1
+        continue
+      }
+      if (ch === '\\' && quote === '"' && i + 1 < text.length && (text[i + 1] === '"' || text[i + 1] === '\\')) {
+        current += text[i + 1]
+        i += 2
+        continue
+      }
+      current += ch
+      i += 1
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      hasToken = true
+      i += 1
+      continue
+    }
+    if (ch === '\\' && i + 1 < text.length) {
+      current += text[i + 1]
+      hasToken = true
+      i += 2
+      continue
+    }
+    if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+      if (hasToken || current.length > 0) {
+        args.push(current)
+        current = ''
+        hasToken = false
+      }
+      i += 1
+      continue
+    }
+    current += ch
+    hasToken = true
+    i += 1
+  }
+  if (quote !== null || hasToken || current.length > 0) {
+    args.push(current)
+  }
+  return args
+}
+
 /** Parse "Name: value" header lines; malformed lines are dropped. */
 function parseHeaders(text: string): Array<{ name: string; value: string }> {
   const headers: Array<{ name: string; value: string }> = []
@@ -139,7 +200,7 @@ export function draftToSubmission(draft: McpDraft): McpSubmission {
       transport: draft.transport,
       enabled: draft.enabled,
       command: draft.command.trim(),
-      args: parseLines(draft.argsText),
+      args: parseArgs(draft.argsText),
       cwd: draft.cwd.trim(),
       url: draft.url.trim(),
       headers: parseHeaders(draft.headersText),