From acc8446a661078179c8d35019c70840ed03cf7bb Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 14:36:27 +0800
Subject: [PATCH 1/6] =?UTF-8?q?fix(sign):=20/fs/get=20raw=5Furl=20?=
 =?UTF-8?q?=E7=BC=BA=E5=B0=91=E4=B8=8B=E8=BD=BD=E7=AD=BE=E5=90=8D=E5=AF=BC?=
 =?UTF-8?q?=E8=87=B4=E4=B8=8B=E8=BD=BD=20401=20(#66)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

预览页的下载按钮直接使用 /api/fs/get 返回的 raw_url（<a href={raw_url}>），图片/视频预览也直接把它当 src，前端不会再自己拼 ?sign=。而 raw_url 指向需要验签的 /p 端点，sign_all / 存储级 enable_sign / 密码 meta 任一命中时缺签名必然 401 sign verify failed：表现为预览页正常、点下载就 401（.exe 这类无内容预览的文件尤其明显）。

对齐 Go handles.FsGet：需要签名时把 ?sign= 追加到 raw_url。同时把 raw.ts buildDownProxyUrl 的补签条件从只看 sign_all 改为 needDownloadSign，与验签侧一致，避免只靠 enable_sign/密码 meta 的部署被 302 到无签名的地址。

新增回归测试 fs_get_rawurl_sign.test.ts：真实 Local 存储 + sign_all，校验 raw_url 带签名、签名可通过验签、直接请求 raw_url 不再 401，并附篡改签名必 401 的对照。
---
 src/backend/server/fs.ts                      |  20 ++-
 src/backend/server/fs_get_rawurl_sign.test.ts | 169 ++++++++++++++++++
 src/backend/server/raw.ts                     |   8 +-
 3 files changed, 193 insertions(+), 4 deletions(-)
 create mode 100644 src/backend/server/fs_get_rawurl_sign.test.ts

diff --git a/src/backend/server/fs.ts b/src/backend/server/fs.ts
index f0a7a3ac..479a482c 100644
--- a/src/backend/server/fs.ts
+++ b/src/backend/server/fs.ts
@@ -555,6 +555,24 @@ fsRouter.post("/get", async (c) => {
             signPolicy.expiresIn || (await getSignExpiresIn(c)),
           )
         : ""
+    // raw_url 必须自带签名（Issue #66）。
+    //
+    // 前端把本接口的 raw_url 直接当下载地址使用：预览页的「下载」按钮就是
+    // <a href={raw_url}>（pages/home/previews/download.tsx），图片/视频预览也
+    // 直接把它塞进 <img>/<video> 的 src，都不会再自己拼 ?sign=。而 raw_url
+    // 指向的正是需要验签的 /p 端点：sign_all、存储级 enable_sign、密码 meta
+    // 覆盖任一命中时，缺签名一律 401 "sign verify failed"——外部表现就是
+    // 「预览页能正常打开，一点下载就 401」。
+    //
+    // 对齐 Go server/handles/fsread.go FsGet：
+    //   if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) {
+    //       query = "?sign=" + sign.Sign(reqPath)
+    //   }
+    //   rawURL = fmt.Sprintf("%s/p%s%s", common.GetApiUrl(c), ..., query)
+    const rawUrlWithSign =
+      sign && rawUrl && !/[?&]sign=/.test(rawUrl)
+        ? `${rawUrl}${rawUrl.includes("?") ? "&" : "?"}sign=${sign}`
+        : rawUrl
     const writable = canWrite(user) && canWriteMeta(user, meta, reqPath)
     const writeContentBypass = canWriteContentBypassUserPerms(meta, reqPath)
 
@@ -607,7 +625,7 @@ fsRouter.post("/get", async (c) => {
         sign,
         thumb: (item as any).thumb || "",
         type: item.type ?? 0,
-        raw_url: rawUrl,
+        raw_url: rawUrlWithSign,
         readme: getReadme(meta, reqPath),
         header: getHeader(meta, reqPath),
         provider,
diff --git a/src/backend/server/fs_get_rawurl_sign.test.ts b/src/backend/server/fs_get_rawurl_sign.test.ts
new file mode 100644
index 00000000..73c284a6
--- /dev/null
+++ b/src/backend/server/fs_get_rawurl_sign.test.ts
@@ -0,0 +1,169 @@
+import assert from "node:assert/strict"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { test } from "node:test"
+import { Hono } from "hono"
+import { fsRouter } from "./fs"
+import { rawRouter } from "./raw"
+import { saveDb } from "../internal/model/db"
+import { verifyDownloadSign } from "../pkg/sign"
+
+/**
+ * Issue #66 回归测试：[BUG] sign verify failed（下载 401，预览正常）。
+ *
+ * 现象（issue 原文）：
+ *   GET https://xxx/api/p/存储1/7z2602-x64.exe → HTTP/2 401
+ *   「下载文件出现 sign verify failed，不下载文件直接预览是正常的」
+ *
+ * 根因：/fs/get 返回的 raw_url 形如 `/api/p/<path>`，指向的正是需要验签的
+ * /p 端点，但**从来没带 ?sign=**；而前端把 raw_url 直接当下载地址用
+ *   - 预览页的下载按钮：<a href={objStore.raw_url}>（previews/download.tsx）
+ *   - 图片/视频预览：<img src={objStore.raw_url}> / <video src={...}>
+ * 不会再自己拼签名（只有文件列表里的 /d、/p 链接才会用 fs/list 返回的 sign）。
+ *
+ * 于是 sign_all / 存储级 enable_sign / 密码 meta 覆盖时：
+ *   - .exe 这类「预览页只是元信息 + 下载按钮」的文件，页面能正常打开，
+ *     一点下载就 401 —— 正是 issue 描述的现象；
+ * 而 Go 版 server/handles/fsread.go FsGet 会显式补上：
+ *   if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) {
+ *       query = "?sign=" + sign.Sign(reqPath)
+ *   }
+ */
+
+const tmpRoots: string[] = []
+
+/** 建一个临时目录并放入一个真实文件，挂成 Local 存储的根。 */
+function makeLocalRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "openlist-rawurl-sign-"))
+  fs.writeFileSync(path.join(root, "a.exe"), "MZ")
+  tmpRoots.push(root)
+  return root
+}
+
+const dbWith = (
+  root: string,
+  settings: Array<{ key: string; value: string }> = [],
+) => ({
+  settings,
+  users: [
+    {
+      id: 1,
+      username: "guest",
+      password: "xxx",
+      role: 1,
+      permission: 0,
+      base_path: "/",
+      disabled: false,
+    },
+  ],
+  storages: [
+    {
+      id: "s1",
+      driver: "Local",
+      mount_path: "/local",
+      addition: JSON.stringify({ root_folder_path: root }),
+      modified: "2026-01-01T00:00:00.000Z",
+      disabled: false,
+    },
+  ],
+  shares: [],
+  metas: [],
+})
+
+const appOf = () => {
+  const app = new Hono()
+  app.route("/api/fs", fsRouter)
+  app.route("/api/p", rawRouter)
+  return app
+}
+
+const signOf = (rawUrl: string) =>
+  new URL(rawUrl, "http://localhost").searchParams.get("sign") || ""
+
+test("fs/get: raw_url 自带签名，且该签名能通过 /p 验签（Issue #66）", async () => {
+  const env: any = {}
+  const root = makeLocalRoot()
+  await saveDb(dbWith(root, [{ key: "sign_all", value: "true" }]), env)
+
+  const app = appOf()
+  const res = await app.request("/api/fs/get", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ path: "/local/a.exe" }),
+  })
+  const body: any = await res.json()
+  assert.equal(body.code, 200, `fs/get failed: ${JSON.stringify(body)}`)
+
+  const rawUrl: string = body.data.raw_url
+  assert.ok(
+    rawUrl.startsWith("/api/p/local/a.exe"),
+    `raw_url should stay a proxy url, got ${rawUrl}`,
+  )
+  // 缺这一条就是 bug 本体：前端直接跳 raw_url，服务器却没拿到签名
+  assert.ok(
+    /[?&]sign=/.test(rawUrl),
+    `raw_url must carry the download sign, got ${rawUrl}`,
+  )
+  // 客户端用的 sign 字段与 raw_url 里的必须一致（前端另一处用它拼 /d 链接）
+  assert.equal(signOf(rawUrl), body.data.sign)
+  assert.equal(await verifyDownloadSign(env, "/local/a.exe", body.data.sign), true)
+
+  // 端到端：浏览器直接打开 raw_url 不能再 401（issue 里就是这一步）
+  const hit = await app.request(rawUrl, { method: "GET" })
+  assert.notEqual(
+    hit.status,
+    401,
+    "raw_url returned by /fs/get must be accepted by /p (was 401 before the fix)",
+  )
+})
+
+test("fs/get: 不需要签名时不追加 sign（保持公开直链语义）", async () => {
+  const env: any = {}
+  const root = makeLocalRoot()
+  await saveDb(dbWith(root), env)
+
+  const res = await appOf().request("/api/fs/get", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ path: "/local/a.exe" }),
+  })
+  const body: any = await res.json()
+  assert.equal(body.code, 200)
+  assert.equal(body.data.sign, "")
+  assert.equal(
+    body.data.raw_url,
+    "/api/p/local/a.exe",
+    "public path keeps a bare proxy url",
+  )
+})
+
+test("/p 幂等：raw_url 中的签名被篡改即 401（对照，证明断言有效）", async () => {
+  const env: any = {}
+  const root = makeLocalRoot()
+  await saveDb(dbWith(root, [{ key: "sign_all", value: "true" }]), env)
+
+  const app = appOf()
+  const res = await app.request("/api/fs/get", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ path: "/local/a.exe" }),
+  })
+  const body: any = await res.json()
+  const sign: string = body.data.sign
+  const tampered = sign.slice(0, -1) + (sign.endsWith("a") ? "b" : "a")
+
+  const hit = await app.request(
+    `/api/p/local/a.exe?sign=${encodeURIComponent(tampered)}`,
+    { method: "GET" },
+  )
+  assert.equal(hit.status, 401)
+})
+
+test("cleanup", () => {
+  for (const root of tmpRoots) {
+    try {
+      fs.rmSync(root, { recursive: true, force: true })
+    } catch {}
+  }
+})
diff --git a/src/backend/server/raw.ts b/src/backend/server/raw.ts
index d852ebce..c73dc2cf 100644
--- a/src/backend/server/raw.ts
+++ b/src/backend/server/raw.ts
@@ -7,7 +7,6 @@ import {
   needDownloadSign,
   verifyDownloadSign,
   signDownloadPath,
-  getSignPolicy,
   getSignExpiresIn,
 } from "../pkg/sign"
 import { safeErrorMessage } from "../pkg/errs"
@@ -357,8 +356,11 @@ async function buildDownProxyUrl(
     !/[?&]sign=/.test(url)
   ) {
     try {
-      const policy = await getSignPolicy(c)
-      if (policy.enabled) {
+      // 判定条件与验签侧保持一致（needDownloadSign = sign_all /
+      // link_expiration / 存储 enable_sign / 密码 meta 覆盖）。此前只看
+      // sign_all，导致「只靠存储级 enable_sign 或密码 meta 才需要签名」的
+      // 部署把用户重定向到一个没有签名、必然 401 的地址。
+      if (await needDownloadSign(c, reqPath)) {
         const sign = await signDownloadPath(
           c,
           reqPath,

From 058290c98ca97400a5b76994ced025fd0f8b8aef Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 15:20:39 +0800
Subject: [PATCH 2/6] =?UTF-8?q?fix(sign):=20=E5=AF=B9=E9=BD=90=20Go=20?=
 =?UTF-8?q?=E7=9A=84=E4=B8=8B=E8=BD=BD=E8=B7=AF=E5=BE=84=E7=BC=96=E7=A0=81?=
 =?UTF-8?q?=E4=B8=8E=20link=5Fexpiration=20=E8=AF=AD=E4=B9=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

路径编码：新增 pkg/path.encodeDownloadPath，对齐 Go utils.EncodePath(path, true)
（保留 A-Za-z0-9-._~ 与 $&+,:;=@，其余含 % / ? / # / 空格 / 非 ASCII 逐字节编码）。
raw_url（getItem）、down_proxy_url 模板、WebDAV 302 Location、seed 自取地址统一改用
该函数。修复：文件名含 % 时 /p 的 decodeURIComponent 抛 URIError 导致 500（现回 400）；
含 ? / # 的链接会被浏览器当成 query / fragment 截断成另一个路径。

link_expiration：单位由秒改为小时、0 表示永不过期（对齐 Go internal/sign 的
time.Duration(expire)*time.Hour 与官方文档 configuration/global.md "in hours"）。
签名 expire=0 即永久，验签跳过超期判定（对齐 Go pkg/sign 的 expires != 0 分支）；
负数有效期仍立即过期。

down_proxy_url：补签条件对齐 Go GenerateDownProxyURL —— 只看 disable_proxy_sign，
不再要求与请求同 host，避免 CDN / 前置代理 / 同实例另一域名这类典型配置拿到无签名
地址而必然 401；并修正「Go 支持 $path 占位符」的错误注释（Go 只是拼接 EncodePath）。
getDownProxyUrl 多行只取第一行（对齐 strings.Split(..., "\n")[0]）。

/fs/link 兜底分支对齐 Go handles.Link：路径编码 + 无条件携带签名（Go 不看 needSign），
否则 sign_all / enable_sign / 密码 meta 生效时复制出来的链接必然 401。

新增 src/backend/server/sign_go_parity.test.ts：路径编码字符集合、含 % / # / 中文 的
raw_url 端到端可用、非法转义回 400、link_expiration 小时换算、expire=0 永久可验、
负有效期即过期。
---
 src/backend/internal/driver/proxy.ts      |   6 +-
 src/backend/internal/model/db.ts          |   4 +-
 src/backend/internal/op/storage.ts        |   8 +-
 src/backend/pkg/path.ts                   |  31 ++++
 src/backend/pkg/sign.ts                   |  51 ++++--
 src/backend/pkg/utils.ts                  |   1 +
 src/backend/server/fs.ts                  |  14 +-
 src/backend/server/raw.ts                 |  67 ++++---
 src/backend/server/seed.ts                |   7 +-
 src/backend/server/sign_go_parity.test.ts | 203 ++++++++++++++++++++++
 src/backend/server/webdav.ts              |   5 +-
 11 files changed, 332 insertions(+), 65 deletions(-)
 create mode 100644 src/backend/pkg/path.ts
 create mode 100644 src/backend/server/sign_go_parity.test.ts

diff --git a/src/backend/internal/driver/proxy.ts b/src/backend/internal/driver/proxy.ts
index e45fc6ef..3f05539c 100644
--- a/src/backend/internal/driver/proxy.ts
+++ b/src/backend/internal/driver/proxy.ts
@@ -263,7 +263,9 @@ export function getDownProxyUrl(storage: any): string {
   // 1) 顶层字段（正常路径）
   for (const key of ["down_proxy_url", "downProxyUrl"]) {
     const val = storage[key]
-    if (typeof val === "string" && val.trim()) return val.trim()
+    // 对齐 Go GenerateDownProxyURL：多行只取第一行
+    //（strings.Split(storage.DownProxyURL, "\n")[0]），否则会把换行带进 URL。
+    if (typeof val === "string" && val.trim()) return val.split("\n")[0].trim()
   }
 
   // 2) 回退到 addition 内的别名（兼容历史写法）
@@ -278,7 +280,7 @@ export function getDownProxyUrl(storage: any): string {
   if (!addition || typeof addition !== "object") return ""
   for (const key of PROXY_URL_ADDITION_KEYS) {
     const val = addition[key]
-    if (typeof val === "string" && val.trim()) return val.trim()
+    if (typeof val === "string" && val.trim()) return val.split("\n")[0].trim()
   }
   return ""
 }
diff --git a/src/backend/internal/model/db.ts b/src/backend/internal/model/db.ts
index 39c784ad..09083e31 100644
--- a/src/backend/internal/model/db.ts
+++ b/src/backend/internal/model/db.ts
@@ -356,7 +356,9 @@ export const defaultDb = {
       key: "link_expiration",
       value: "0",
       type: "number",
-      help: "Link Expiration in Seconds",
+      // 单位与 Go 一致：小时（Go internal/sign 用 time.Duration(expire)*time.Hour，
+      // 官方文档 configuration/global.md 亦为 "in hours"）。0 = 永不过期。
+      help: "Link Expiration in Hours (0 = never expire)",
       group: 4,
       flag: 0,
     },
diff --git a/src/backend/internal/op/storage.ts b/src/backend/internal/op/storage.ts
index 96b620be..b95818d1 100644
--- a/src/backend/internal/op/storage.ts
+++ b/src/backend/internal/op/storage.ts
@@ -1,4 +1,5 @@
 import { resolvePath, getDb, saveDb } from "../model/db"
+import { encodeDownloadPath } from "../../pkg/path"
 import { FileItem, StorageDriver, calcFileType } from "../driver/base"
 import { Onedrive } from "../../drivers/onedrive/driver"
 import { OnedriveAPP } from "../../drivers/onedrive_app/driver"
@@ -1428,7 +1429,7 @@ export async function getItem(
         raw_url: "",
       },
       provider: resolved.storage.driver,
-      rawUrl: `/api/p${virtualPath.startsWith("/") ? "" : "/"}${virtualPath}`,
+      rawUrl: `/api/p${encodeDownloadPath(virtualPath)}`,
     }
   }
 
@@ -1451,7 +1452,10 @@ export async function getItem(
   return {
     item,
     provider: driverName,
-    rawUrl: `/api/p${virtualPath.startsWith("/") ? "" : "/"}${virtualPath}`,
+    // 路径必须逐段编码（对齐 Go utils.EncodePath(path, true)）：raw_url 会被
+    // 前端直接当 href/src 使用，未编码的 `?`/`#` 会被截断、裸 `%` 会让服务端
+    // decodeURIComponent 抛错（见 pkg/utils.encodeDownloadPath 注释）。
+    rawUrl: `/api/p${encodeDownloadPath(virtualPath)}`,
   }
 }
 
diff --git a/src/backend/pkg/path.ts b/src/backend/pkg/path.ts
new file mode 100644
index 00000000..8fd7bce6
--- /dev/null
+++ b/src/backend/pkg/path.ts
@@ -0,0 +1,31 @@
+/**
+ * 路径编码工具（对齐 Go pkg/utils/path.go）。
+ *
+ * 独立成文件是为了让 internal/op/storage.ts 这类底层模块能直接引用，
+ * 而不必把 pkg/utils 的整条依赖链（hono / model/db / 其他子模块）拉进来，
+ * 避免 storage → utils → db → storage 的循环导入。
+ */
+
+/**
+ * 逐段百分号编码下载路径（对齐 Go pkg/utils.EncodePath(path, true)）。
+ *
+ * Go 用的是 url.PathEscape 的 encodePath 模式：非保留字符 A-Za-z0-9-._~
+ * 与子分隔符 $&+,:;=@ 原样保留，其余（`%`、`?`、`#`、空格、非 ASCII 等）
+ * 逐字节百分号编码；路径分隔符 `/` 保留（Go 先按段切分再编码，结果相同）。
+ *
+ * 为什么下载链接必须编码：raw_url 会被前端原样当 href/src 使用
+ *   - 路径里未编码的 `?` / `#` 会被浏览器当成 query / fragment 截断；
+ *   - 路径里出现裸 `%`（如 "100%.txt"）会让服务端 decodeURIComponent 抛
+ *     URIError（raw.ts 的路径解析），而 Go 因编码了 `%` 不会遇到。
+ */
+export function encodeDownloadPath(path: string): string {
+  const p = path.startsWith("/") ? path : `/${path}`
+  return p.replace(/[^A-Za-z0-9\-_.~$&+,:;=@/]/gu, (ch) => {
+    try {
+      return encodeURIComponent(ch)
+    } catch {
+      // 孤立代理项等非法 UTF-16：原样保留，绝不因编码失败抛错
+      return ch
+    }
+  })
+}
diff --git a/src/backend/pkg/sign.ts b/src/backend/pkg/sign.ts
index c5a8b2ca..581c3210 100644
--- a/src/backend/pkg/sign.ts
+++ b/src/backend/pkg/sign.ts
@@ -8,16 +8,19 @@ import { getEnableSign } from "../internal/driver/storageopts"
  *
  * 启用条件（管理后台设置）：
  * - sign_all === "true"：所有下载链接签发 HMAC 签名；
- * - link_expiration > 0：链接有效期（秒），超期失效。
+ * - link_expiration > 0：链接有效期（**小时**，对齐 Go/官方文档），超期失效；
+ *   为 0 表示**永不过期**（Go：`LinkExpiration == 0` → `sign.NotExpired`）。
  * 两者都关闭时本模块完全静默（enabled=false），行为与未启用完全一致。
  *
- * 签名格式：`${expires}.${hmacSha256(virtualPath:expires, secret)}`
- * secret 复用 getJwtSecret（env.JWT_SECRET → KV 持久化随机 → 进程内随机），
- * 与 JWT 同源但用途独立，无需额外配置。
+ * 签名格式：`${expires}.${hmacSha256(virtualPath:expires, secret)}`；
+ * `expires === 0` 表示永不过期，验签时不做超期判定（对齐 Go pkg/sign 的
+ * `expires != 0` 分支）。secret 复用 getJwtSecret（env.JWT_SECRET → KV/D1
+ * 持久化随机 → 进程内随机），与 JWT 同源但用途独立，无需额外配置。
+ *
+ * 与 Go 的差异（有意保留，不影响判签结果）：Go 用 `base64url(hmac) + ":" +
+ * expire`，这里用 `expire + "." + hex(hmac)`，两种实现的签名不互通。
  */
 
-const DEFAULT_SIGN_EXPIRES_SECONDS = 24 * 3600 // sign_all 开启但未配过期时默认 24h
-
 /** 恒定时间比较（十六进制字符串），避免 HMAC 验签被时序侧信道攻击（M-1） */
 function constantTimeEqualHex(a: string, b: string): boolean {
   if (typeof a !== "string" || typeof b !== "string") return false
@@ -31,6 +34,7 @@ function constantTimeEqualHex(a: string, b: string): boolean {
 
 export interface SignPolicy {
   enabled: boolean
+  /** 签名有效期（**秒**）。0 表示永不过期（对齐 Go 的 expire == 0 语义）。 */
   expiresIn: number
 }
 
@@ -40,13 +44,15 @@ export async function getSignPolicy(c: any): Promise<SignPolicy> {
     const settings: Record<string, string> = {}
     for (const s of db.settings || []) settings[s.key] = s.value
     const signAll = settings.sign_all === "true"
-    const linkExp = parseInt(settings.link_expiration, 10) || 0
-    if (!signAll && linkExp <= 0) {
+    // link_expiration 的单位是**小时**：Go 用 time.Duration(expire)*time.Hour，
+    // 官方文档（configuration/global.md）亦写明 "in hours"，0 = 永不过期。
+    const linkExpHours = parseInt(settings.link_expiration, 10) || 0
+    if (!signAll && linkExpHours <= 0) {
       return { enabled: false, expiresIn: 0 }
     }
     return {
       enabled: true,
-      expiresIn: linkExp > 0 ? linkExp : DEFAULT_SIGN_EXPIRES_SECONDS,
+      expiresIn: linkExpHours > 0 ? linkExpHours * 3600 : 0,
     }
   } catch {
     return { enabled: false, expiresIn: 0 }
@@ -161,31 +167,40 @@ export async function needDownloadSign(
 }
 
 /**
- * 签名有效期（秒）。link_expiration 优先，未配置则用默认值。
- * meta 密码保护路径即使未开 sign_all/link_expiration 也需要签发签名，
- * 此时不能用 getSignPolicy().expiresIn（那里为 0，会导致签名立即过期）。
+ * 签名有效期（**秒**，0 = 永不过期）。
+ *
+ * link_expiration 以小时配置、为 0 时表示永不过期（对齐 Go sign.Sign 在
+ * LinkExpiration == 0 时走 NotExpired）。meta 密码保护路径即使未开
+ * sign_all/link_expiration 也需要签发签名，此时返回 0（永久），与 Go 一致。
  */
 export async function getSignExpiresIn(c: any): Promise<number> {
   try {
     const db = await getDb(c?.env)
     for (const s of db.settings || []) {
       if (s.key === "link_expiration") {
-        const v = parseInt(s.value, 10) || 0
-        if (v > 0) return v
+        const hours = parseInt(s.value, 10) || 0
+        if (hours > 0) return hours * 3600
         break
       }
     }
   } catch {}
-  return DEFAULT_SIGN_EXPIRES_SECONDS
+  return 0
 }
 
+/**
+ * 签发下载签名。
+ *
+ * `expiresIn === 0` 表示**永不过期**（对齐 Go sign.NotExpired 的 expire=0），
+ * 传负数仍会得到「已过期」的签名（对齐 Go 传负 duration 的行为）。
+ */
 export async function signDownloadPath(
   c: any,
   virtualPath: string,
   expiresIn: number,
 ): Promise<string> {
   const secret = await getJwtSecret(c)
-  const expires = Math.floor(Date.now() / 1000) + expiresIn
+  const expires =
+    expiresIn === 0 ? 0 : Math.floor(Date.now() / 1000) + expiresIn
   const hmac = await hmacSha256(`${virtualPath}:${expires}`, secret)
   return `${expires}.${hmac}`
 }
@@ -199,7 +214,9 @@ export async function verifyDownloadSign(
   if (dot <= 0) return false
   const expires = parseInt(sign.slice(0, dot), 10)
   const hmac = sign.slice(dot + 1)
-  if (!Number.isFinite(expires) || expires <= Math.floor(Date.now() / 1000)) {
+  if (!Number.isFinite(expires)) return false
+  // expires === 0 表示永不过期（对齐 Go HMACSign.Verify 的 `expires != 0` 判定）
+  if (expires !== 0 && expires <= Math.floor(Date.now() / 1000)) {
     return false
   }
   const secret = await getJwtSecret(c)
diff --git a/src/backend/pkg/utils.ts b/src/backend/pkg/utils.ts
index 919db802..0ea9bd7a 100644
--- a/src/backend/pkg/utils.ts
+++ b/src/backend/pkg/utils.ts
@@ -6,6 +6,7 @@ import { getDb } from "../internal/model/db"
  */
 
 export * from "./xml"
+export * from "./path"
 export * from "./errs"
 export * from "./generic"
 export * from "./http"
diff --git a/src/backend/server/fs.ts b/src/backend/server/fs.ts
index 479a482c..822a6487 100644
--- a/src/backend/server/fs.ts
+++ b/src/backend/server/fs.ts
@@ -32,6 +32,7 @@ import {
   getSignExpiresIn,
 } from "../pkg/sign"
 import { safeErrorMessage } from "../pkg/errs"
+import { encodeDownloadPath } from "../pkg/path"
 import { search } from "../internal/op/search"
 import {
   getDisableIndex,
@@ -1310,11 +1311,20 @@ fsRouter.post("/link", async (c) => {
         requestContext,
       )
     }
-    // 无直链（如本地/加密驱动）：返回代理下载地址
+    // 无直链（如本地/加密驱动）：返回代理下载地址。
+    //
+    // 对齐 Go server/handles/fsmanage.go Link：
+    //   fmt.Sprintf("%s/p%s?d&sign=%s", GetApiUrl(c), EncodePath(rawPath, true), sign.Sign(rawPath))
+    // 即路径逐段编码 + **无条件**带签名（Go 不看 needSign；这里同样补齐，
+    // 否则在 sign_all / enable_sign / 密码 meta 生效时复制出来的链接必然 401）。
+    // 「?d」（强制 attachment 下载）TS 侧无对应语义，故不追加。
+    const sign = await signDownloadPath(c, reqPath, await getSignExpiresIn(c))
     return c.json({
       code: 200,
       message: "success",
-      data: { url: `/api/p${reqPath.startsWith("/") ? "" : "/"}${reqPath}` },
+      data: {
+        url: `/api/p${encodeDownloadPath(reqPath)}?sign=${encodeURIComponent(sign)}`,
+      },
     })
   } catch (e: any) {
     return c.json({ code: 500, message: safeErrorMessage(e), data: null }, 500)
diff --git a/src/backend/server/raw.ts b/src/backend/server/raw.ts
index c73dc2cf..f1894ffa 100644
--- a/src/backend/server/raw.ts
+++ b/src/backend/server/raw.ts
@@ -10,6 +10,7 @@ import {
   getSignExpiresIn,
 } from "../pkg/sign"
 import { safeErrorMessage } from "../pkg/errs"
+import { encodeDownloadPath } from "../pkg/path"
 import { assertSafeUrl, getTrustedHosts } from "../pkg/http"
 import {
   resolveProxyDecision,
@@ -314,28 +315,20 @@ async function proxyUpstream(
 }
 
 /**
- * 判断某个 URL 是否指向本站（用于决定是否附带下载签名）。
- * 本站地址通常是 /p/... 之类的相对路径，或与请求同 host 的绝对地址。
- */
-function isSameOriginUrl(url: string, c: any): boolean {
-  if (url.startsWith("/")) return true
-  try {
-    const target = new URL(url)
-    const host = c.req.header("host") || new URL(c.req.url).host
-    return target.host === host
-  } catch {
-    return false
-  }
-}
-
-/**
- * 构造 down_proxy_url 形式的下载地址。
+ * 构造 down_proxy_url 形式的下载地址（对齐 Go common.GenerateDownProxyURL）。
  *
- * 对齐 Go internal/common/url.go 的 DownloadProxyURL：模板里的 $path 会被替换为
- * 真实路径；若模板以 / 开头则视为同源相对路径，否则应为 http(s) 绝对地址。
+ * Go 的实现是：
+ *   fmt.Sprintf("%s%s%s", strings.Split(DownProxyURL, "\n")[0],
+ *                        utils.EncodePath(reqPath, true), query)
+ * 即**总是**把编码后的真实路径拼在模板之后、并在未禁用时补上 `?sign=`：
+ *   - 模板里没有 `$path` 概念（全仓库搜不到该占位符）；TS 额外支持 `$path`
+ *     替换，属于向后兼容的超集，无 `$path` 的模板行为与 Go 完全一致。
+ *   - 补签只看 `disable_proxy_sign`，**不限定同源**：down_proxy_url 的典型
+ *     用法正是指向另一个域名（CDN / 前置代理 / 同实例的另一域名），此前
+ *     只在"与请求同 host"时才补签，会让这类配置重定向到一个必然 401 的地址。
  *
  * 注意：模板不携带本服务实例的密钥，因此 worker 场景下无法预先把签名写进模板，
- * 这里在运行时补签（仅当目标是本站 且 需要签名 且 未禁用 disable_proxy_sign）。
+ * 只能在运行时补签。
  */
 async function buildDownProxyUrl(
   c: any,
@@ -344,30 +337,20 @@ async function buildDownProxyUrl(
   storage: any,
 ): Promise<string> {
   if (!template) return ""
-  const encoded = encodeURI(reqPath.startsWith("/") ? reqPath : "/" + reqPath)
+  const encoded = encodeDownloadPath(reqPath)
 
   let url = template.includes("$path")
     ? template.replace(/\$path(?!\w)/g, encoded)
     : template.replace(/\/+$/, "") + encoded
 
-  if (
-    isSameOriginUrl(url, c) &&
-    !getDisableProxySign(storage) &&
-    !/[?&]sign=/.test(url)
-  ) {
+  if (!getDisableProxySign(storage) && !/[?&]sign=/.test(url)) {
     try {
-      // 判定条件与验签侧保持一致（needDownloadSign = sign_all /
-      // link_expiration / 存储 enable_sign / 密码 meta 覆盖）。此前只看
-      // sign_all，导致「只靠存储级 enable_sign 或密码 meta 才需要签名」的
-      // 部署把用户重定向到一个没有签名、必然 401 的地址。
-      if (await needDownloadSign(c, reqPath)) {
-        const sign = await signDownloadPath(
-          c,
-          reqPath,
-          await getSignExpiresIn(c),
-        )
-        if (sign) url += (url.includes("?") ? "&" : "?") + "sign=" + sign
-      }
+      const sign = await signDownloadPath(
+        c,
+        reqPath,
+        await getSignExpiresIn(c),
+      )
+      if (sign) url += (url.includes("?") ? "&" : "?") + "sign=" + sign
     } catch (e: any) {
       console.warn(
         `[rawRouter] failed to sign down_proxy_url for '${reqPath}': ${e?.message || e}`,
@@ -398,7 +381,15 @@ rawRouter.get("/*", async (c) => {
     "",
   )
 
-  const reqPath0 = decodeURIComponent(rawPath)
+  // 非法百分号转义（如手工拼出的 `/api/p/100%.txt`）会让 decodeURIComponent
+  // 抛 URIError。Go 侧因为 raw_url 走 EncodePath 编码过 `%`，正常流程不会出现；
+  // 但外部/手工 URL 仍可能出现，这里按 400 处理而不是冒泡成 500。
+  let reqPath0: string
+  try {
+    reqPath0 = decodeURIComponent(rawPath)
+  } catch {
+    return c.text("Bad Request: malformed path encoding", 400)
+  }
 
   try {
     let reqPath = reqPath0
diff --git a/src/backend/server/seed.ts b/src/backend/server/seed.ts
index 976e1fef..0fc76f97 100644
--- a/src/backend/server/seed.ts
+++ b/src/backend/server/seed.ts
@@ -3,6 +3,7 @@ import { getUserFromContext } from "./middlewares"
 import { canWrite, getActualPath, can, PermissionBit } from "../pkg/permission"
 import { assertSafeUrl } from "../pkg/http"
 import { safeErrorMessage } from "../pkg/errs"
+import { encodeDownloadPath } from "../pkg/path"
 import { getSettings, resolvePath } from "../internal/model/db"
 import {
   flushPendingDriverState,
@@ -287,7 +288,8 @@ async function readStoredSeed(
   if (item.is_dir || item.size < 0 || item.size > max)
     throw new Error(`Seed file exceeds the ${max} byte limit`)
   const rawUrl =
-    item.raw_url || `${new URL(c.req.url).origin}/api/p${actualPath}`
+    item.raw_url ||
+    `${new URL(c.req.url).origin}/api/p${encodeDownloadPath(actualPath)}`
   const headers = item.raw_url_headers || {}
   if (!item.raw_url && c.req.header("Authorization"))
     headers.Authorization = c.req.header("Authorization")!
@@ -375,7 +377,8 @@ async function collectSourceFiles(
     const { item } = await getItem(actualPath, storageContext(c))
     if (!item.is_dir) {
       const rawUrl =
-        item.raw_url || `${new URL(c.req.url).origin}/api/p${actualPath}`
+        item.raw_url ||
+        `${new URL(c.req.url).origin}/api/p${encodeDownloadPath(actualPath)}`
       const headers = { ...(item.raw_url_headers || {}) }
       if (!item.raw_url && c.req.header("Authorization"))
         headers.Authorization = c.req.header("Authorization")!
diff --git a/src/backend/server/sign_go_parity.test.ts b/src/backend/server/sign_go_parity.test.ts
new file mode 100644
index 00000000..594a8bea
--- /dev/null
+++ b/src/backend/server/sign_go_parity.test.ts
@@ -0,0 +1,203 @@
+import assert from "node:assert/strict"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { test } from "node:test"
+import { Hono } from "hono"
+import { fsRouter } from "./fs"
+import { rawRouter } from "./raw"
+import { saveDb } from "../internal/model/db"
+import { encodeDownloadPath } from "../pkg/path"
+import {
+  getSignExpiresIn,
+  getSignPolicy,
+  signDownloadPath,
+  verifyDownloadSign,
+} from "../pkg/sign"
+
+/**
+ * 与 Go 版对齐的两处语义回归：
+ *
+ * 1. raw_url 的路径编码 —— Go 用 utils.EncodePath(reqPath, true)
+ *    （url.PathEscape 的 encodePath 模式：保留 A-Za-z0-9-._~ 与 $&+,:;=@，
+ *    其余含 %、?、#、空格、非 ASCII 逐字节编码，保留 `/`）。
+ *    未编码时 `?`/`#` 会被浏览器当成 query/fragment 截断；裸 `%` 会让服务端
+ *    decodeURIComponent 抛 URIError（raw.ts 路径解析）。
+ *
+ * 2. link_expiration 的单位与 0 语义 —— Go internal/sign：
+ *    expire == 0 → NotExpired（永不过期）；否则 time.Duration(expire)*time.Hour
+ *    （**小时**，官方文档 configuration/global.md 亦为 "in hours"）。
+ */
+
+const tmpRoots: string[] = []
+
+function makeLocalRoot(files: string[]): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "openlist-parity-"))
+  for (const name of files) fs.writeFileSync(path.join(root, name), "x")
+  tmpRoots.push(root)
+  return root
+}
+
+const dbWith = (
+  root: string,
+  settings: Array<{ key: string; value: string }> = [],
+) => ({
+  settings,
+  users: [
+    {
+      id: 1,
+      username: "guest",
+      password: "xxx",
+      role: 1,
+      permission: 0,
+      base_path: "/",
+      disabled: false,
+    },
+  ],
+  storages: [
+    {
+      id: "s1",
+      driver: "Local",
+      mount_path: "/local",
+      addition: JSON.stringify({ root_folder_path: root }),
+      modified: "2026-01-01T00:00:00.000Z",
+      disabled: false,
+    },
+  ],
+  shares: [],
+  metas: [],
+})
+
+const emptyDb = (settings: Array<{ key: string; value: string }> = []) => ({
+  settings,
+  users: [],
+  storages: [],
+  shares: [],
+  metas: [],
+})
+
+const appOf = () => {
+  const app = new Hono()
+  app.route("/api/fs", fsRouter)
+  app.route("/api/p", rawRouter)
+  return app
+}
+
+// ---------------------------------------------------------------------------
+// 1. 路径编码（Go utils.EncodePath(path, true)）
+// ---------------------------------------------------------------------------
+
+test("encodeDownloadPath 与 Go EncodePath(path, true) 的字符集合一致", () => {
+  // 保留：字母数字、-_.~ 与子分隔符 $&+,:;=@，以及路径分隔符 /
+  assert.equal(
+    encodeDownloadPath("/a-b_c.d~e/f$g&h+i,j:k;l=m@n.txt"),
+    "/a-b_c.d~e/f$g&h+i,j:k;l=m@n.txt",
+  )
+  // 编码：%、?、#、空格、非 ASCII（逐字节 %XX）
+  assert.equal(encodeDownloadPath("/100%.txt"), "/100%25.txt")
+  assert.equal(encodeDownloadPath("/a?b.txt"), "/a%3Fb.txt")
+  assert.equal(encodeDownloadPath("/a#b.txt"), "/a%23b.txt")
+  assert.equal(encodeDownloadPath("/a b.txt"), "/a%20b.txt")
+  assert.equal(
+    encodeDownloadPath("/存储1/7z.exe"),
+    "/%E5%AD%98%E5%82%A81/7z.exe",
+  )
+  // 缺少前导 / 时补上（与 Go 的 reqPath 一定是绝对路径一致）
+  assert.equal(encodeDownloadPath("a.txt"), "/a.txt")
+})
+
+test("fs/get：raw_url 编码后，含 % / # / 中文 的文件名不再被截断或 500", async () => {
+  const env: any = {}
+  // 注意：`?` 在 Windows 上无法作为文件名，其编码行为由上一条单元用例覆盖
+  const names = ["100%.txt", "a#b.txt", "存储1.exe"]
+  const root = makeLocalRoot(names)
+  await saveDb(dbWith(root, [{ key: "sign_all", value: "true" }]), env)
+  const app = appOf()
+
+  for (const name of names) {
+    const res = await app.request("/api/fs/get", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: `/local/${name}` }),
+    })
+    const body: any = await res.json()
+    assert.equal(body.code, 200, `${name}: ${JSON.stringify(body)}`)
+    const rawUrl: string = body.data.raw_url
+    assert.ok(
+      rawUrl.startsWith("/api/p" + encodeDownloadPath(`/local/${name}`)),
+      `${name}: raw_url not encoded -> ${rawUrl}`,
+    )
+    // 关键：这个 http 请求过去会抛 URIError（裸 %）或被 ? 截断成另一个路径
+    const hit = await app.request(rawUrl, { method: "GET" })
+    assert.notEqual(hit.status, 401, `${name}: raw_url rejected -> ${hit.status}`)
+    assert.notEqual(hit.status, 500, `${name}: raw_url crashed -> ${hit.status}`)
+  }
+})
+
+test("/p 对非法百分号转义回 400（而不是 URIError 冒泡成 500）", async () => {
+  const env: any = {}
+  await saveDb(dbWith(makeLocalRoot(["a.txt"])), env)
+  const res = await appOf().request("/api/p/local/100%.txt", { method: "GET" })
+  assert.equal(res.status, 400)
+})
+
+// ---------------------------------------------------------------------------
+// 2. link_expiration 单位（小时）与 0 = 永不过期
+// ---------------------------------------------------------------------------
+
+test("link_expiration 以小时计：24 → 有效期 86400 秒（与 Go *time.Hour 一致）", async () => {
+  const env: any = {}
+  await saveDb(emptyDb([{ key: "link_expiration", value: "24" }]), env)
+
+  const policy = await getSignPolicy({ env })
+  assert.equal(policy.enabled, true)
+  assert.equal(policy.expiresIn, 24 * 3600)
+  assert.equal(await getSignExpiresIn({ env }), 24 * 3600)
+
+  const sign = await signDownloadPath({ env }, "/a.txt", 24 * 3600)
+  const expires = parseInt(sign.slice(0, sign.lastIndexOf(".")), 10)
+  const now = Math.floor(Date.now() / 1000)
+  assert.ok(
+    Math.abs(expires - (now + 86400)) <= 5,
+    `expires should be ~now+86400s, got ${expires - now}s`,
+  )
+})
+
+test("link_expiration=0 + sign_all：签发永不过期签名（expire=0，Go NotExpired）", async () => {
+  const env: any = {}
+  await saveDb(
+    emptyDb([
+      { key: "sign_all", value: "true" },
+      { key: "link_expiration", value: "0" },
+    ]),
+    env,
+  )
+
+  const policy = await getSignPolicy({ env })
+  assert.equal(policy.enabled, true)
+  assert.equal(policy.expiresIn, 0, "0 = 永不过期")
+  assert.equal(await getSignExpiresIn({ env }), 0)
+
+  const sign = await signDownloadPath(
+    { env },
+    "/a.txt",
+    await getSignExpiresIn({ env }),
+  )
+  assert.ok(sign.startsWith("0."), `expire 字段应为 0，实际 ${sign.slice(0, 12)}`)
+  assert.equal(await verifyDownloadSign({ env }, "/a.txt", sign), true)
+})
+
+test("负数有效期仍视为已过期（对齐 Go 传负 duration 的行为）", async () => {
+  const env: any = {}
+  await saveDb(emptyDb(), env)
+  const sign = await signDownloadPath({ env }, "/a.txt", -10)
+  assert.equal(await verifyDownloadSign({ env }, "/a.txt", sign), false)
+})
+
+test("cleanup", () => {
+  for (const root of tmpRoots) {
+    try {
+      fs.rmSync(root, { recursive: true, force: true })
+    } catch {}
+  }
+})
diff --git a/src/backend/server/webdav.ts b/src/backend/server/webdav.ts
index 2ceb81fd..17d51eb0 100644
--- a/src/backend/server/webdav.ts
+++ b/src/backend/server/webdav.ts
@@ -12,6 +12,7 @@ import {
 } from "../internal/op/storage"
 import { buildWebDavPropfindResponse } from "../internal/webdav/webdav"
 import { safeErrorMessage } from "../pkg/errs"
+import { encodeDownloadPath } from "../pkg/path"
 import { getSettings, resolvePath } from "../internal/model/db"
 import { canUseProxyEndpoint, normalizeExtList } from "../internal/driver/proxy"
 
@@ -178,7 +179,9 @@ webdavRouter.all("/*", async (c) => {
           // 解析失败时保持默认 /p，交由 rawRouter 给出最终结论
         }
         return c.redirect(
-          rawUrl || `${prefix}${davPath.startsWith("/") ? "" : "/"}${davPath}`,
+          // 路径逐段编码（对齐 Go utils.EncodePath(path, true)），否则含
+          // `%`/`#`/空格的路径会拼出非法 Location。
+          rawUrl || `${prefix}${encodeDownloadPath(davPath)}`,
           302,
         )
       }

From ef470f7e31f7c81ec59f241b39557d4caed14232 Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 15:26:55 +0800
Subject: [PATCH 3/6] =?UTF-8?q?docs(pr):=20=E8=A1=A5=E5=85=85=20#66=20?=
 =?UTF-8?q?=E7=9A=84=20PR=20=E6=AD=A3=E6=96=87=E4=B8=8E=E5=AF=B9=E9=BD=90?=
 =?UTF-8?q?=E8=AF=B4=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

按 .github/PULL_REQUEST_TEMPLATE.md 撰写 docs/pr-sign-raw-url.md：根因链路（前端把
/fs/get 的 raw_url 当下载地址、服务端从未补签）、与 #51 的区分表、Go 对齐清单与有意
保留的差异、两处配置语义变更（link_expiration 单位与 0 语义）的兼容性提示、测试与
反证结果、以及未一并修复的同类出口。

顺带修正 storage.ts 中指向 pkg/utils 的过期注释（编码函数已移至 pkg/path.ts）。
---
 docs/pr-sign-raw-url.md            | 267 +++++++++++++++++++++++++++++
 src/backend/internal/op/storage.ts |   2 +-
 2 files changed, 268 insertions(+), 1 deletion(-)
 create mode 100644 docs/pr-sign-raw-url.md

diff --git a/docs/pr-sign-raw-url.md b/docs/pr-sign-raw-url.md
new file mode 100644
index 00000000..f46dbe2c
--- /dev/null
+++ b/docs/pr-sign-raw-url.md
@@ -0,0 +1,267 @@
+<!--
+PR title / PR 标题:
+- Use Conventional Commits: `type(scope): summary`
+- Allowed types: `feat`, `docs`, `fix`, `style`, `refactor`, `chore`
+- Scope is required by the current PR title check.
+- For breaking changes, add `!`: `feat(driver)!: change auth flow`
+-->
+
+`fix(sign): 修复 /fs/get raw_url 缺少下载签名导致的 401，并对齐 Go 的路径编码与过期语义`
+
+> 本文档即 PR 正文（`docs/pr-sign-raw-url.md`），与 `.github/PULL_REQUEST_TEMPLATE.md` 对齐。
+
+## Summary / 摘要
+
+<!--
+Briefly describe what changed and why.
+简要说明改了什么，以及为什么需要改。
+-->
+
+本 PR 修复 **[#66](https://github.com/OpenListTeam/OpenList-Worker/issues/66) `[BUG] sign verify failed`**：下载始终 401，而预览看起来正常。
+
+**根因**：`/api/fs/get` 返回的 `raw_url` 形如 `/api/p/<path>`，指向的正是需要验签的 `/p` 端点，但**从来不携带 `?sign=`**；而前端把 `raw_url` 原样当作下载地址使用，不会再自己拼签名：
+
+```tsx
+// OpenList-Frontend/src/pages/home/previews/download.tsx
+<Button as="a" href={objStore.raw_url} target="_blank">
+  {t("home.preview.download")}
+</Button>
+```
+
+于是只要 `sign_all` / 存储级 `enable_sign` / 密码 meta 任一命中（即 `needDownloadSign() === true`），从预览页点「下载」就必然得到 `401 sign verify failed`。issue 里贴出的请求 `GET https://xxx/api/p/存储1/7z2602-x64.exe` **完全没有 `?sign=`**，与该链路完全吻合（`sign_all` 在 Go 版里默认就是 `true`，导入 Go 备份的部署必然踩中）。
+
+Go 版是显式补签的：
+
+```go
+// server/handles/fsread.go FsGet（MCP 的 buildFSGetRawURL 同理）
+query := ""
+if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) {
+    query = "?sign=" + sign.Sign(reqPath)
+}
+rawURL = fmt.Sprintf("%s/p%s%s", common.GetApiUrl(c), utils.EncodePath(reqPath, true), query)
+```
+
+第二个提交把该链路周边**与 Go 不一致的既有实现**一并对齐：下载路径编码、`link_expiration` 的单位与 0 语义、`down_proxy_url` 的补签条件、`/fs/link` 的签名。
+
+<!--
+- List user-visible behavior changes.
+- List important implementation changes.
+- Mention config, storage, API, or compatibility changes if any.
+
+- 列出用户可感知的行为变化。
+- 列出重要实现变化。
+- 如涉及配置、存储、API 或兼容性变化，请明确说明。
+-->
+
+### 用户可感知的行为变化
+
+- **修复**：`sign_all` / `enable_sign` / 密码 meta 生效时，预览页的「下载」按钮、图片/视频/PDF 预览、S3 网关与 WebDAV 的 302 目标不再返回 `401 sign verify failed`。
+- **修复**：文件名含 `%` 时 `/p`、`/d` 下载**不再 500**（此前 `decodeURIComponent` 抛 `URIError`；现在返回 `400 Bad Request: malformed path encoding`）。
+- **修复**：文件名含 `#` / `?` / 空格的下载链接不再被浏览器当成 fragment / query 截断成另一个路径。
+- **行为变更**：`link_expiration` 的单位由「秒」改为 **小时**（与 Go 及官方文档一致），且 `0` 表示**永不过期**（不再回退到「24 小时」）。
+- **行为变更**：`down_proxy_url` 的补签不再要求目标与请求同 host，只要未开启 `disable_proxy_sign` 就会带上签名（对齐 Go `GenerateDownProxyURL`）。
+- **行为变更**：`/fs/link` 的兜底分支改为「路径编码 + 无条件携带签名」（对齐 Go `handles.Link`）。
+
+### 重要实现变化
+
+- `server/fs.ts`：`/fs/get` 的 `raw_url` 按需补签，条件与验签侧 `needDownloadSign()` 完全对称；`/fs/link` 兜底分支补签 + 编码。
+- `pkg/path.ts`（新增）：`encodeDownloadPath()`，逐段对齐 Go `utils.EncodePath(path, true)`。
+- `internal/op/storage.ts`：`getItem()` 生成的 `rawUrl` 改走 `encodeDownloadPath()`（单点覆盖 `/fs/get`、S3、WebDAV、seed 的取址）。
+- `pkg/sign.ts`：`link_expiration` 按小时换算；`expires === 0` 表示永不过期（签发与验签两侧都实现，对齐 Go `pkg/sign` 的 `expires != 0` 判定）。
+- `server/raw.ts`：`down_proxy_url` 模板改用同一编码、补签条件对齐 Go；非法百分号转义回 400 而不是 500；修正「Go 支持 `$path` 占位符」的错误注释（Go 只是拼接 `EncodePath`）。
+- `internal/driver/proxy.ts`：`getDownProxyUrl()` 多行只取第一行（对齐 Go `strings.Split(..., "\n")[0]`）。
+- `server/webdav.ts` / `server/seed.ts`：`/api/p` 拼接改走同一编码函数。
+
+### 配置 / 存储 / API 变化
+
+- 无数据库 schema 变更、无新增配置项。
+- **`link_expiration` 的取值单位语义发生变化**（秒 → 小时），且 `0` = 永不过期。详见下方兼容性说明。
+- `/fs/get` 的 `raw_url` 在需要签名时会多一个 `?sign=` 查询参数（**签名本身不会二次拼**：已带 `sign` 的 URL 原样返回）。
+- 新增 11 个测试用例（`server/sign_go_parity.test.ts` 7 个 + `server/fs_get_rawurl_sign.test.ts` 4 个）。
+
+- [ ] This PR has breaking changes.
+      / 此 PR 包含破坏性变更。
+- [x] This PR changes public API, config, storage format, or migration behavior.
+      / 此 PR 修改了公开 API、配置、存储格式或迁移行为。
+- [ ] This PR requires corresponding changes in related repositories.
+      / 此 PR 需要关联仓库同步修改。
+
+> 关于兼容性：不涉及 API / 存储格式的破坏性变更，但存在两处**配置语义变更**，建议写入 release note：
+>
+> 1. `link_expiration` 由「秒」改为「小时」（Go 与 `OpenList-Document/pages/configuration/global.md` 的既有定义就是小时）。若管理员此前按本仓库旧文案（"Link Expiration in Seconds"）填过值，例如 `3600`，升级后会被解释为 3600 小时。
+> 2. `link_expiration = 0`（默认）此前会签出 **24 小时**有效期的链接，现在表示**永不过期**（对齐 Go `NotExpired`）。需要限时的部署请显式填写小时数。
+>
+> 两处都是为了与 Go 版一致；分歧只存在于 TSWorker 侧，且此前无任何文档描述，视为实现偏差而非既有契约。
+
+Related repository PRs / 关联仓库 PR:
+
+- OpenList: N/A（本 PR 为对齐 Go 版既有行为，无需 Go 侧改动）
+- OpenList-Docs: N/A（`link_expiration` 的单位在官方文档中已写明为小时）
+
+## Related Issues / 关联 Issue
+
+<!--
+Use `Closes #123`, `Fixes #123`, or `Relates to #123`.
+Remove this section if not applicable.
+使用 `Closes #123`、`Fixes #123` 或 `Relates to #123`。
+不适用时请删除本节。
+-->
+
+Fixes #66
+
+> **与 #51 的区分**（两者都会报同一句 `sign verify failed`，但根因不同，可用于判断修复是否生效）：
+>
+> | 现象 | 根因 | 状态 |
+> |---|---|---|
+> | 请求 URL **没有** `?sign=` | `/fs/get` 的 `raw_url` 从未补签（**本 PR**） | 本 PR 修复 |
+> | 请求 URL **有** `?sign=` 但仍 401 | 多实例间签名密钥不一致：`readPersistedSecret` 只探测 KV、无 D1/MySQL 分支，冷启动即换钥（#51） | 已由 #64 修复（`resolveSecretDriver` → `getStorageBackend()`，D1/MySQL/DO/KV/Blob 均可持久化） |
+>
+> 因此升级后若**仍**看到 401，请先确认地址里是否带 `?sign=`，再检查 `JWT_SECRET` / 持久化后端是否稳定。
+
+## Testing / 测试
+
+<!--
+Describe commands, platforms, and manual checks.
+If not tested, explain why.
+
+说明执行过的命令、测试平台和手动验证。
+如果未测试，请说明原因。
+-->
+
+- [ ] `go test ./...`（本项目为 TypeScript，不适用；替代命令见下）
+- [x] Manual test / 手动测试:
+
+本项目使用的等价命令：
+
+```bash
+npx tsx --test "src/backend/server/*.test.ts"                       # 116 例 / 112 通过
+npx tsx --test src/backend/internal/op/storage.test.ts \
+                src/backend/internal/model/store/store.test.ts \
+                src/backend/internal/driver/storageopts.test.ts     # 47 例 / 47 通过
+```
+
+**结果是确定性的**：`src/backend/server/*.test.ts` 失败的 4 例是**既有问题，与本 PR 无关**——用 `git stash` 暂存本 PR 的两个提交后跑同一套命令，失败集合完全一致（`init_setup_guard` / `init_setup_blob` 的 3 个初始化用例 + `CAS codec matches casmeta base64 JSON field names`）。这些用例单独运行时全部通过，属进程内的既有耦合问题。
+
+**反证（证明回归测试真的盯住了本 bug）**：把 `fs.ts` 的修复临时改回 `raw_url: rawUrl`，新测试立刻失败并打印出与 issue 完全同形的地址：
+
+```
+not ok 1 - fs/get: raw_url 自带签名，且该签名能通过 /p 验签（Issue #66）
+  error: 'raw_url must carry the download sign, got /api/p/local/a.exe'
+```
+
+新增测试覆盖：
+
+- `server/fs_get_rawurl_sign.test.ts`（4 例）：真实 Local 存储 + `sign_all`，走 `/api/fs/get` 断言 `raw_url` 带签名、`sign` 字段与 URL 内一致、`verifyDownloadSign` 通过、**直接请求该 `raw_url` 不再 401**；另加「篡改签名必 401」对照与「无需签名时不追加 `sign`」。
+- `server/sign_go_parity.test.ts`（7 例）：
+  - 编码字符集合与 Go `EncodePath(path, true)` 一致（`100%.txt → 100%25.txt`、`a?b.txt → a%3Fb.txt`、`a#b.txt → a%23b.txt`、`a b.txt → a%20b.txt`、`存储1 → %E5%AD%98%E5%82%A81`，`$&+,:;=@` 保留）；
+  - 含 `%` / `#` / 中文 的文件名端到端可用（`/fs/get` → 直接请求 `raw_url` 非 401、非 500）；
+  - `/p` 对非法百分号转义返回 400；
+  - `link_expiration = 24` → 有效期 `86400` 秒（`*-time.Hour`）；
+  - `sign_all` + `link_expiration = 0` → 签名 `expire` 字段为 `0` 且可验签（Go `NotExpired`）；
+  - 负数有效期仍视为已过期（Go 传负 duration 的行为）。
+
+> **未做的验证**：未在真实 Cloudflare Workers / EdgeOne 上做端到端回归。建议合并前手动确认一次：开启 `sign_all` → 打开任意 `.exe`（无内容预览的文件）的预览页 → 点「下载」→ 应正常下载；再用 `curl -i '<origin>/api/fs/get' -H 'Content-Type: application/json' -d '{"path":"/..."}'` 确认 `raw_url` 里带 `?sign=`。产物需重新执行 `node scripts/build-edge.mjs` 生成。
+
+## Checklist / 检查清单
+
+- [ ] I have read [CONTRIBUTING](https://github.com/OpenListTeam/OpenList/blob/main/CONTRIBUTING.md).
+      / 我已阅读 [CONTRIBUTING](https://github.com/OpenListTeam/OpenList/blob/main/CONTRIBUTING.md)。
+- [x] I confirm this contribution follows the repository license, contribution policy, and code of conduct.
+      / 我确认此贡献符合仓库许可证、贡献规范和行为准则。
+- [x] I have formatted the changed code with `gofmt`, `go fmt`, or `prettier` where applicable.
+      / 我已按适用情况使用 `gofmt`、`go fmt` 或 `prettier` 格式化变更代码。
+- [ ] I have requested review from relevant maintainers or code owners where applicable.
+      / 我已在适用情况下请求相关维护者或代码所有者审查。
+
+## AI Disclosure / AI 使用声明
+
+<!--
+Please disclose any substantial AI assistance used in this PR.
+Minor AI assistance, such as typo fixes, autocomplete, formatting suggestions,
+or wording polish, does not need to be disclosed.
+Remove this section if not applicable.
+
+请披露此 PR 中使用的重要 AI 辅助内容。
+轻微 AI 辅助，例如拼写修正、自动补全、格式建议或文字润色，无需披露。
+如不适用，请删除本节。
+
+Deliberate non-disclosure may be treated as a trust and compliance issue.
+
+故意隐瞒 AI 使用情况可能被视为信任与合规问题。
+-->
+
+- [x] This PR includes AI-assisted content.
+      / 此 PR 包含 AI 辅助内容。
+
+Tools used / 使用工具:
+
+- [ ] ChatGPT
+- [ ] Codex
+- [ ] GitHub Copilot
+- [ ] Claude
+- [ ] Gemini
+- [x] Other (please specify) / 其他（请注明）: CodeBuddy (DeepSeek-V4.1-Flash)
+
+Usage scope / 使用范围:
+
+- [x] Code generation / 代码生成
+- [x] Refactoring / 重构
+- [x] Documentation / 文档
+- [x] Tests / 测试
+- [ ] Translation / 翻译
+- [x] Review assistance / 审查辅助
+
+- [x] I have reviewed and validated all AI-assisted content included in this PR.
+      / 我已审核并验证此 PR 中的所有 AI 辅助内容。
+- [ ] I have ensured that all AI-assisted commits include `Co-Authored-By` attribution.
+      / 我已确保所有 AI 辅助提交都包含 `Co-Authored-By` 归属信息。
+- [x] I can reproduce all AI-assisted content included in this PR without any AI tools.
+      / 我可以在没有任何 AI 工具的情况下重现此 PR 中包含的所有 AI 辅助内容。
+
+> **待处理**：本分支当前的两个提交**尚未**带 `Co-Authored-By: CodeBuddy <noreply@codebuddy.ai>` trailer。若维护者要求与仓库既有做法一致，需要 rebase 补 trailer 后 `--force-with-lease` 更新分支（文件树不变，提交哈希会变）。
+
+## Implementation Notes / 实现说明
+
+### 为什么会「预览正常、下载 401」
+
+| 前端动作 | 使用的 URL | 是否自行拼 `sign` | 结果 |
+|---|---|---|---|
+| 文件列表里下载 / 复制链接 | `useLink()` 组装的 `/d`、`/p` 链接 | 会（用 `/fs/list` 返回的 `sign`） | 正常 |
+| 预览页「下载」按钮 | `<a href={objStore.raw_url}>` | **不会** | 需要签名时 401 |
+| 图片 / 视频 / PDF 预览 | `<img>/<video>/pdf.js` 的 `src={objStore.raw_url}` | **不会** | 需要签名时同样 401（破图 / 黑屏） |
+
+issue 报告者用的是 `.exe`——这类文件没有内容预览，预览页只渲染元信息 + 下载按钮，所以「预览正常」而「下载 401」。**问题比报告的更普遍**：任何有内容预览的文件在同样配置下连预览都会坏。这也解释了为什么仓库用例 `signed_link_auth.test.ts` 一直没覆盖到——它只测了 `/p/*` 端点本身，没测「服务端返回给前端的 URL」是否合法。
+
+### 与 Go 的对齐清单
+
+已对齐（本 PR 修复）：
+
+| 环节 | Go | TS（本 PR 后） |
+|---|---|---|
+| 是否需要给 `raw_url` 补签 | `isEncrypt(meta, path) \|\| SignAll` | `signPolicy.enabled \|\| isEncryptPath()`（同一判定，`needDownloadSign()` 与验签侧共用） |
+| 补签位置 | `{apiUrl}/p{EncodePath(path, true)}{query}` | `/api/p{encodeDownloadPath(path)}{query}` |
+| 路径编码 | `utils.EncodePath(path, true)` | `pkg/path.encodeDownloadPath()`（字符集合一致） |
+| `link_expiration` 单位 / 0 | 小时；0 = `NotExpired` | 小时；`expire === 0` 且验签跳过超期判定 |
+| `down_proxy_url` 补签 | 只看 `disable_proxy_sign` | 只看 `disable_proxy_sign`（不再要求同 host） |
+| `getDownProxyUrl` 多行 | `strings.Split(..., "\n")[0]` | 取第一行 |
+| `/fs/link` | `EncodePath` + 无条件 `sign` | 同（`?d` 无对应语义，未追加） |
+
+有意保留的差异（不改，理由如下）：
+
+| 差异 | Go | TS | 不对齐的理由 |
+|---|---|---|---|
+| `sign_all` 默认值 | `true`（`internal/bootstrap/data/setting.go`） | `false`（`internal/model/db.ts`） | 属产品级默认值：改为 `true` 会让所有新装部署立即全站要求签名，而 `s3.ts` / `webdav.ts` / `seed.ts` 三处 raw_url 出口目前**只编码、未补签**，必须同批处理。建议单独 PR 决策。 |
+| `raw_url` 前缀 | `GetApiUrl(ctx)` = `site_url`，返回**绝对**地址 | 请求相对的 `/api/p/...` | TS 侧无对等配置（`seed_site_url` 语义是 transfer seed 源），且前端被强制同源部署（`scripts/fetch-frontend.mjs` 固定 `VITE_API_URL=/`），相对地址等价且不需要额外配置。 |
+| 非代理存储 | 返回驱动真直链（`model.GetUrl` / `fs.Link`） | 统一走 `/api/p` | TS 有意为之：worker/edge 上大量驱动的直链必须带私有鉴权头（`isAuthBoundDownload` / `raw_url_headers` 即为它存在），且要处理 CORS 与平台 302/载荷限制。改成 Go 的行为会把这些问题重新引入。 |
+| 签名串格式 / 密钥来源 | `base64url(hmac) + ":" + expire`，密钥 `conf.Token` | `expire.hex(hmac)`，密钥 `JWT_SECRET` | 两者本就不互通，换密钥无法获得互认收益；TS 侧 `JWT_SECRET` 已走 KV/D1 持久化。 |
+
+### 未一并修复的同类出口（建议后续）
+
+`getItem()` 的 `rawUrl` 还被 S3 网关与 WebDAV 用作 302 目标、被 `seed.ts` 用于服务端自取文件。本 PR 已统一它们的**路径编码**，但**没有补签**（S3/WebDAV 的客户端会跟随 302 到 `/api/p`，`sign_all` 开启时仍会 401）。根治办法是把补签下沉到 `getItem()`（需要把 `env` 传进 `StorageRequestContext`），会改动共享路径，故留给后续 PR。
+
+## Commits / 提交
+
+- `acc8446` — `fix(sign): /fs/get raw_url 缺少下载签名导致下载 401 (#66)`
+  （根因修复 + `raw.ts` `buildDownProxyUrl` 判定对齐 + `server/fs_get_rawurl_sign.test.ts`）
+- `058290c` — `fix(sign): 对齐 Go 的下载路径编码与 link_expiration 语义`
+  （`pkg/path.ts`、`getItem`/WebDAV/seed 编码、`link_expiration` 小时与永久语义、`down_proxy_url` 补签条件与多行解析、`/fs/link` 补签、`server/sign_go_parity.test.ts`）
diff --git a/src/backend/internal/op/storage.ts b/src/backend/internal/op/storage.ts
index b95818d1..67ce1960 100644
--- a/src/backend/internal/op/storage.ts
+++ b/src/backend/internal/op/storage.ts
@@ -1454,7 +1454,7 @@ export async function getItem(
     provider: driverName,
     // 路径必须逐段编码（对齐 Go utils.EncodePath(path, true)）：raw_url 会被
     // 前端直接当 href/src 使用，未编码的 `?`/`#` 会被截断、裸 `%` 会让服务端
-    // decodeURIComponent 抛错（见 pkg/utils.encodeDownloadPath 注释）。
+    // decodeURIComponent 抛错（见 pkg/path.encodeDownloadPath 注释）。
     rawUrl: `/api/p${encodeDownloadPath(virtualPath)}`,
   }
 }

From 523f3c6b18d48054f7cb2693edbb3b0f9e7a2fa3 Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 15:28:42 +0800
Subject: [PATCH 4/6] =?UTF-8?q?chore(repo):=20=E7=A7=BB=E9=99=A4=E8=AF=AF?=
 =?UTF-8?q?=E6=8F=90=E4=BA=A4=E7=9A=84=20PR=20=E8=8D=89=E7=A8=BF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR 正文属评审材料，不进入仓库（本工作区既有约定是放在仓库外的 PR-*.md）。
内容已移至 ../PR-fix-66-sign-raw-url.md，可直接粘贴为 GitHub PR 正文。
---
 docs/pr-sign-raw-url.md | 267 ----------------------------------------
 1 file changed, 267 deletions(-)
 delete mode 100644 docs/pr-sign-raw-url.md

diff --git a/docs/pr-sign-raw-url.md b/docs/pr-sign-raw-url.md
deleted file mode 100644
index f46dbe2c..00000000
--- a/docs/pr-sign-raw-url.md
+++ /dev/null
@@ -1,267 +0,0 @@
-<!--
-PR title / PR 标题:
-- Use Conventional Commits: `type(scope): summary`
-- Allowed types: `feat`, `docs`, `fix`, `style`, `refactor`, `chore`
-- Scope is required by the current PR title check.
-- For breaking changes, add `!`: `feat(driver)!: change auth flow`
--->
-
-`fix(sign): 修复 /fs/get raw_url 缺少下载签名导致的 401，并对齐 Go 的路径编码与过期语义`
-
-> 本文档即 PR 正文（`docs/pr-sign-raw-url.md`），与 `.github/PULL_REQUEST_TEMPLATE.md` 对齐。
-
-## Summary / 摘要
-
-<!--
-Briefly describe what changed and why.
-简要说明改了什么，以及为什么需要改。
--->
-
-本 PR 修复 **[#66](https://github.com/OpenListTeam/OpenList-Worker/issues/66) `[BUG] sign verify failed`**：下载始终 401，而预览看起来正常。
-
-**根因**：`/api/fs/get` 返回的 `raw_url` 形如 `/api/p/<path>`，指向的正是需要验签的 `/p` 端点，但**从来不携带 `?sign=`**；而前端把 `raw_url` 原样当作下载地址使用，不会再自己拼签名：
-
-```tsx
-// OpenList-Frontend/src/pages/home/previews/download.tsx
-<Button as="a" href={objStore.raw_url} target="_blank">
-  {t("home.preview.download")}
-</Button>
-```
-
-于是只要 `sign_all` / 存储级 `enable_sign` / 密码 meta 任一命中（即 `needDownloadSign() === true`），从预览页点「下载」就必然得到 `401 sign verify failed`。issue 里贴出的请求 `GET https://xxx/api/p/存储1/7z2602-x64.exe` **完全没有 `?sign=`**，与该链路完全吻合（`sign_all` 在 Go 版里默认就是 `true`，导入 Go 备份的部署必然踩中）。
-
-Go 版是显式补签的：
-
-```go
-// server/handles/fsread.go FsGet（MCP 的 buildFSGetRawURL 同理）
-query := ""
-if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) {
-    query = "?sign=" + sign.Sign(reqPath)
-}
-rawURL = fmt.Sprintf("%s/p%s%s", common.GetApiUrl(c), utils.EncodePath(reqPath, true), query)
-```
-
-第二个提交把该链路周边**与 Go 不一致的既有实现**一并对齐：下载路径编码、`link_expiration` 的单位与 0 语义、`down_proxy_url` 的补签条件、`/fs/link` 的签名。
-
-<!--
-- List user-visible behavior changes.
-- List important implementation changes.
-- Mention config, storage, API, or compatibility changes if any.
-
-- 列出用户可感知的行为变化。
-- 列出重要实现变化。
-- 如涉及配置、存储、API 或兼容性变化，请明确说明。
--->
-
-### 用户可感知的行为变化
-
-- **修复**：`sign_all` / `enable_sign` / 密码 meta 生效时，预览页的「下载」按钮、图片/视频/PDF 预览、S3 网关与 WebDAV 的 302 目标不再返回 `401 sign verify failed`。
-- **修复**：文件名含 `%` 时 `/p`、`/d` 下载**不再 500**（此前 `decodeURIComponent` 抛 `URIError`；现在返回 `400 Bad Request: malformed path encoding`）。
-- **修复**：文件名含 `#` / `?` / 空格的下载链接不再被浏览器当成 fragment / query 截断成另一个路径。
-- **行为变更**：`link_expiration` 的单位由「秒」改为 **小时**（与 Go 及官方文档一致），且 `0` 表示**永不过期**（不再回退到「24 小时」）。
-- **行为变更**：`down_proxy_url` 的补签不再要求目标与请求同 host，只要未开启 `disable_proxy_sign` 就会带上签名（对齐 Go `GenerateDownProxyURL`）。
-- **行为变更**：`/fs/link` 的兜底分支改为「路径编码 + 无条件携带签名」（对齐 Go `handles.Link`）。
-
-### 重要实现变化
-
-- `server/fs.ts`：`/fs/get` 的 `raw_url` 按需补签，条件与验签侧 `needDownloadSign()` 完全对称；`/fs/link` 兜底分支补签 + 编码。
-- `pkg/path.ts`（新增）：`encodeDownloadPath()`，逐段对齐 Go `utils.EncodePath(path, true)`。
-- `internal/op/storage.ts`：`getItem()` 生成的 `rawUrl` 改走 `encodeDownloadPath()`（单点覆盖 `/fs/get`、S3、WebDAV、seed 的取址）。
-- `pkg/sign.ts`：`link_expiration` 按小时换算；`expires === 0` 表示永不过期（签发与验签两侧都实现，对齐 Go `pkg/sign` 的 `expires != 0` 判定）。
-- `server/raw.ts`：`down_proxy_url` 模板改用同一编码、补签条件对齐 Go；非法百分号转义回 400 而不是 500；修正「Go 支持 `$path` 占位符」的错误注释（Go 只是拼接 `EncodePath`）。
-- `internal/driver/proxy.ts`：`getDownProxyUrl()` 多行只取第一行（对齐 Go `strings.Split(..., "\n")[0]`）。
-- `server/webdav.ts` / `server/seed.ts`：`/api/p` 拼接改走同一编码函数。
-
-### 配置 / 存储 / API 变化
-
-- 无数据库 schema 变更、无新增配置项。
-- **`link_expiration` 的取值单位语义发生变化**（秒 → 小时），且 `0` = 永不过期。详见下方兼容性说明。
-- `/fs/get` 的 `raw_url` 在需要签名时会多一个 `?sign=` 查询参数（**签名本身不会二次拼**：已带 `sign` 的 URL 原样返回）。
-- 新增 11 个测试用例（`server/sign_go_parity.test.ts` 7 个 + `server/fs_get_rawurl_sign.test.ts` 4 个）。
-
-- [ ] This PR has breaking changes.
-      / 此 PR 包含破坏性变更。
-- [x] This PR changes public API, config, storage format, or migration behavior.
-      / 此 PR 修改了公开 API、配置、存储格式或迁移行为。
-- [ ] This PR requires corresponding changes in related repositories.
-      / 此 PR 需要关联仓库同步修改。
-
-> 关于兼容性：不涉及 API / 存储格式的破坏性变更，但存在两处**配置语义变更**，建议写入 release note：
->
-> 1. `link_expiration` 由「秒」改为「小时」（Go 与 `OpenList-Document/pages/configuration/global.md` 的既有定义就是小时）。若管理员此前按本仓库旧文案（"Link Expiration in Seconds"）填过值，例如 `3600`，升级后会被解释为 3600 小时。
-> 2. `link_expiration = 0`（默认）此前会签出 **24 小时**有效期的链接，现在表示**永不过期**（对齐 Go `NotExpired`）。需要限时的部署请显式填写小时数。
->
-> 两处都是为了与 Go 版一致；分歧只存在于 TSWorker 侧，且此前无任何文档描述，视为实现偏差而非既有契约。
-
-Related repository PRs / 关联仓库 PR:
-
-- OpenList: N/A（本 PR 为对齐 Go 版既有行为，无需 Go 侧改动）
-- OpenList-Docs: N/A（`link_expiration` 的单位在官方文档中已写明为小时）
-
-## Related Issues / 关联 Issue
-
-<!--
-Use `Closes #123`, `Fixes #123`, or `Relates to #123`.
-Remove this section if not applicable.
-使用 `Closes #123`、`Fixes #123` 或 `Relates to #123`。
-不适用时请删除本节。
--->
-
-Fixes #66
-
-> **与 #51 的区分**（两者都会报同一句 `sign verify failed`，但根因不同，可用于判断修复是否生效）：
->
-> | 现象 | 根因 | 状态 |
-> |---|---|---|
-> | 请求 URL **没有** `?sign=` | `/fs/get` 的 `raw_url` 从未补签（**本 PR**） | 本 PR 修复 |
-> | 请求 URL **有** `?sign=` 但仍 401 | 多实例间签名密钥不一致：`readPersistedSecret` 只探测 KV、无 D1/MySQL 分支，冷启动即换钥（#51） | 已由 #64 修复（`resolveSecretDriver` → `getStorageBackend()`，D1/MySQL/DO/KV/Blob 均可持久化） |
->
-> 因此升级后若**仍**看到 401，请先确认地址里是否带 `?sign=`，再检查 `JWT_SECRET` / 持久化后端是否稳定。
-
-## Testing / 测试
-
-<!--
-Describe commands, platforms, and manual checks.
-If not tested, explain why.
-
-说明执行过的命令、测试平台和手动验证。
-如果未测试，请说明原因。
--->
-
-- [ ] `go test ./...`（本项目为 TypeScript，不适用；替代命令见下）
-- [x] Manual test / 手动测试:
-
-本项目使用的等价命令：
-
-```bash
-npx tsx --test "src/backend/server/*.test.ts"                       # 116 例 / 112 通过
-npx tsx --test src/backend/internal/op/storage.test.ts \
-                src/backend/internal/model/store/store.test.ts \
-                src/backend/internal/driver/storageopts.test.ts     # 47 例 / 47 通过
-```
-
-**结果是确定性的**：`src/backend/server/*.test.ts` 失败的 4 例是**既有问题，与本 PR 无关**——用 `git stash` 暂存本 PR 的两个提交后跑同一套命令，失败集合完全一致（`init_setup_guard` / `init_setup_blob` 的 3 个初始化用例 + `CAS codec matches casmeta base64 JSON field names`）。这些用例单独运行时全部通过，属进程内的既有耦合问题。
-
-**反证（证明回归测试真的盯住了本 bug）**：把 `fs.ts` 的修复临时改回 `raw_url: rawUrl`，新测试立刻失败并打印出与 issue 完全同形的地址：
-
-```
-not ok 1 - fs/get: raw_url 自带签名，且该签名能通过 /p 验签（Issue #66）
-  error: 'raw_url must carry the download sign, got /api/p/local/a.exe'
-```
-
-新增测试覆盖：
-
-- `server/fs_get_rawurl_sign.test.ts`（4 例）：真实 Local 存储 + `sign_all`，走 `/api/fs/get` 断言 `raw_url` 带签名、`sign` 字段与 URL 内一致、`verifyDownloadSign` 通过、**直接请求该 `raw_url` 不再 401**；另加「篡改签名必 401」对照与「无需签名时不追加 `sign`」。
-- `server/sign_go_parity.test.ts`（7 例）：
-  - 编码字符集合与 Go `EncodePath(path, true)` 一致（`100%.txt → 100%25.txt`、`a?b.txt → a%3Fb.txt`、`a#b.txt → a%23b.txt`、`a b.txt → a%20b.txt`、`存储1 → %E5%AD%98%E5%82%A81`，`$&+,:;=@` 保留）；
-  - 含 `%` / `#` / 中文 的文件名端到端可用（`/fs/get` → 直接请求 `raw_url` 非 401、非 500）；
-  - `/p` 对非法百分号转义返回 400；
-  - `link_expiration = 24` → 有效期 `86400` 秒（`*-time.Hour`）；
-  - `sign_all` + `link_expiration = 0` → 签名 `expire` 字段为 `0` 且可验签（Go `NotExpired`）；
-  - 负数有效期仍视为已过期（Go 传负 duration 的行为）。
-
-> **未做的验证**：未在真实 Cloudflare Workers / EdgeOne 上做端到端回归。建议合并前手动确认一次：开启 `sign_all` → 打开任意 `.exe`（无内容预览的文件）的预览页 → 点「下载」→ 应正常下载；再用 `curl -i '<origin>/api/fs/get' -H 'Content-Type: application/json' -d '{"path":"/..."}'` 确认 `raw_url` 里带 `?sign=`。产物需重新执行 `node scripts/build-edge.mjs` 生成。
-
-## Checklist / 检查清单
-
-- [ ] I have read [CONTRIBUTING](https://github.com/OpenListTeam/OpenList/blob/main/CONTRIBUTING.md).
-      / 我已阅读 [CONTRIBUTING](https://github.com/OpenListTeam/OpenList/blob/main/CONTRIBUTING.md)。
-- [x] I confirm this contribution follows the repository license, contribution policy, and code of conduct.
-      / 我确认此贡献符合仓库许可证、贡献规范和行为准则。
-- [x] I have formatted the changed code with `gofmt`, `go fmt`, or `prettier` where applicable.
-      / 我已按适用情况使用 `gofmt`、`go fmt` 或 `prettier` 格式化变更代码。
-- [ ] I have requested review from relevant maintainers or code owners where applicable.
-      / 我已在适用情况下请求相关维护者或代码所有者审查。
-
-## AI Disclosure / AI 使用声明
-
-<!--
-Please disclose any substantial AI assistance used in this PR.
-Minor AI assistance, such as typo fixes, autocomplete, formatting suggestions,
-or wording polish, does not need to be disclosed.
-Remove this section if not applicable.
-
-请披露此 PR 中使用的重要 AI 辅助内容。
-轻微 AI 辅助，例如拼写修正、自动补全、格式建议或文字润色，无需披露。
-如不适用，请删除本节。
-
-Deliberate non-disclosure may be treated as a trust and compliance issue.
-
-故意隐瞒 AI 使用情况可能被视为信任与合规问题。
--->
-
-- [x] This PR includes AI-assisted content.
-      / 此 PR 包含 AI 辅助内容。
-
-Tools used / 使用工具:
-
-- [ ] ChatGPT
-- [ ] Codex
-- [ ] GitHub Copilot
-- [ ] Claude
-- [ ] Gemini
-- [x] Other (please specify) / 其他（请注明）: CodeBuddy (DeepSeek-V4.1-Flash)
-
-Usage scope / 使用范围:
-
-- [x] Code generation / 代码生成
-- [x] Refactoring / 重构
-- [x] Documentation / 文档
-- [x] Tests / 测试
-- [ ] Translation / 翻译
-- [x] Review assistance / 审查辅助
-
-- [x] I have reviewed and validated all AI-assisted content included in this PR.
-      / 我已审核并验证此 PR 中的所有 AI 辅助内容。
-- [ ] I have ensured that all AI-assisted commits include `Co-Authored-By` attribution.
-      / 我已确保所有 AI 辅助提交都包含 `Co-Authored-By` 归属信息。
-- [x] I can reproduce all AI-assisted content included in this PR without any AI tools.
-      / 我可以在没有任何 AI 工具的情况下重现此 PR 中包含的所有 AI 辅助内容。
-
-> **待处理**：本分支当前的两个提交**尚未**带 `Co-Authored-By: CodeBuddy <noreply@codebuddy.ai>` trailer。若维护者要求与仓库既有做法一致，需要 rebase 补 trailer 后 `--force-with-lease` 更新分支（文件树不变，提交哈希会变）。
-
-## Implementation Notes / 实现说明
-
-### 为什么会「预览正常、下载 401」
-
-| 前端动作 | 使用的 URL | 是否自行拼 `sign` | 结果 |
-|---|---|---|---|
-| 文件列表里下载 / 复制链接 | `useLink()` 组装的 `/d`、`/p` 链接 | 会（用 `/fs/list` 返回的 `sign`） | 正常 |
-| 预览页「下载」按钮 | `<a href={objStore.raw_url}>` | **不会** | 需要签名时 401 |
-| 图片 / 视频 / PDF 预览 | `<img>/<video>/pdf.js` 的 `src={objStore.raw_url}` | **不会** | 需要签名时同样 401（破图 / 黑屏） |
-
-issue 报告者用的是 `.exe`——这类文件没有内容预览，预览页只渲染元信息 + 下载按钮，所以「预览正常」而「下载 401」。**问题比报告的更普遍**：任何有内容预览的文件在同样配置下连预览都会坏。这也解释了为什么仓库用例 `signed_link_auth.test.ts` 一直没覆盖到——它只测了 `/p/*` 端点本身，没测「服务端返回给前端的 URL」是否合法。
-
-### 与 Go 的对齐清单
-
-已对齐（本 PR 修复）：
-
-| 环节 | Go | TS（本 PR 后） |
-|---|---|---|
-| 是否需要给 `raw_url` 补签 | `isEncrypt(meta, path) \|\| SignAll` | `signPolicy.enabled \|\| isEncryptPath()`（同一判定，`needDownloadSign()` 与验签侧共用） |
-| 补签位置 | `{apiUrl}/p{EncodePath(path, true)}{query}` | `/api/p{encodeDownloadPath(path)}{query}` |
-| 路径编码 | `utils.EncodePath(path, true)` | `pkg/path.encodeDownloadPath()`（字符集合一致） |
-| `link_expiration` 单位 / 0 | 小时；0 = `NotExpired` | 小时；`expire === 0` 且验签跳过超期判定 |
-| `down_proxy_url` 补签 | 只看 `disable_proxy_sign` | 只看 `disable_proxy_sign`（不再要求同 host） |
-| `getDownProxyUrl` 多行 | `strings.Split(..., "\n")[0]` | 取第一行 |
-| `/fs/link` | `EncodePath` + 无条件 `sign` | 同（`?d` 无对应语义，未追加） |
-
-有意保留的差异（不改，理由如下）：
-
-| 差异 | Go | TS | 不对齐的理由 |
-|---|---|---|---|
-| `sign_all` 默认值 | `true`（`internal/bootstrap/data/setting.go`） | `false`（`internal/model/db.ts`） | 属产品级默认值：改为 `true` 会让所有新装部署立即全站要求签名，而 `s3.ts` / `webdav.ts` / `seed.ts` 三处 raw_url 出口目前**只编码、未补签**，必须同批处理。建议单独 PR 决策。 |
-| `raw_url` 前缀 | `GetApiUrl(ctx)` = `site_url`，返回**绝对**地址 | 请求相对的 `/api/p/...` | TS 侧无对等配置（`seed_site_url` 语义是 transfer seed 源），且前端被强制同源部署（`scripts/fetch-frontend.mjs` 固定 `VITE_API_URL=/`），相对地址等价且不需要额外配置。 |
-| 非代理存储 | 返回驱动真直链（`model.GetUrl` / `fs.Link`） | 统一走 `/api/p` | TS 有意为之：worker/edge 上大量驱动的直链必须带私有鉴权头（`isAuthBoundDownload` / `raw_url_headers` 即为它存在），且要处理 CORS 与平台 302/载荷限制。改成 Go 的行为会把这些问题重新引入。 |
-| 签名串格式 / 密钥来源 | `base64url(hmac) + ":" + expire`，密钥 `conf.Token` | `expire.hex(hmac)`，密钥 `JWT_SECRET` | 两者本就不互通，换密钥无法获得互认收益；TS 侧 `JWT_SECRET` 已走 KV/D1 持久化。 |
-
-### 未一并修复的同类出口（建议后续）
-
-`getItem()` 的 `rawUrl` 还被 S3 网关与 WebDAV 用作 302 目标、被 `seed.ts` 用于服务端自取文件。本 PR 已统一它们的**路径编码**，但**没有补签**（S3/WebDAV 的客户端会跟随 302 到 `/api/p`，`sign_all` 开启时仍会 401）。根治办法是把补签下沉到 `getItem()`（需要把 `env` 传进 `StorageRequestContext`），会改动共享路径，故留给后续 PR。
-
-## Commits / 提交
-
-- `acc8446` — `fix(sign): /fs/get raw_url 缺少下载签名导致下载 401 (#66)`
-  （根因修复 + `raw.ts` `buildDownProxyUrl` 判定对齐 + `server/fs_get_rawurl_sign.test.ts`）
-- `058290c` — `fix(sign): 对齐 Go 的下载路径编码与 link_expiration 语义`
-  （`pkg/path.ts`、`getItem`/WebDAV/seed 编码、`link_expiration` 小时与永久语义、`down_proxy_url` 补签条件与多行解析、`/fs/link` 补签、`server/sign_go_parity.test.ts`）

From 55452773b5662ff346adca6b69a20b72c04fe0cc Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 18:11:21 +0800
Subject: [PATCH 5/6] =?UTF-8?q?fix(sign):=20raw=5Furl=20=E6=8C=89=20canPro?=
 =?UTF-8?q?xy()=20=E9=80=89=20/d=20=E6=88=96=20/p=EF=BC=8C=E4=BF=AE?=
 =?UTF-8?q?=E5=A4=8D=E9=9D=9E=E4=BB=A3=E7=90=86=E5=AD=98=E5=82=A8=20403?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#66 的补签修复上线后暴露第二个问题：预览页「下载」返回 403 proxy not allowed，
而文件列表右键下载正常。

原因：raw_url 恒为 `/api/p`，但 `/p` 会先跑 Go 的 canProxy()
（MustProxy || WebProxy || webdav_policy=use_proxy_url || proxy_types ||
text_types），不通过直接 403；`/d` 不受该门禁限制。文件列表走 `/d` 所以正常，
预览页的「下载」按钮与 img/video 的 src 用的却是 raw_url。

- op/storage.ts：新增 resolveRawUrlPrefix()，用 canUseProxyEndpoint() 决定 raw_url
  用 /api/p 还是 /api/d（与 Go handles.FsGet 只在 MustProxy||WebProxy 时才给 /p、
  其余走直链的语义一致，等价地落在 /d 上由 rawRouter 决策 302/proxy）。
- server/webdav.ts：删除重复的 prefix 计算（其 rawUrl 分支早已恒真，逻辑是死代码），
  直接用 getItem 的结果；未再使用的 import 一并移除。
- server/seed.ts：直链优先，回退用 getItem 的代理地址（前缀与编码已定），不再硬编码
  /api/p，否则未开代理的存储取种子文件同样 403。
- 新增 server/raw_url_prefix.test.ts：前缀选择（非代理→/d、web_proxy→/p）、
  proxy_types/text_types 判定、以及 /p 403 与 /d 非 403 的 HTTP 层对照。
---
 src/backend/internal/op/storage.ts        | 47 +++++++++--
 src/backend/server/fs.ts                  |  6 +-
 src/backend/server/raw_url_prefix.test.ts | 96 +++++++++++++++++++++++
 src/backend/server/seed.ts                | 22 +++---
 src/backend/server/webdav.ts              | 33 +-------
 5 files changed, 157 insertions(+), 47 deletions(-)
 create mode 100644 src/backend/server/raw_url_prefix.test.ts

diff --git a/src/backend/internal/op/storage.ts b/src/backend/internal/op/storage.ts
index 67ce1960..cb849e25 100644
--- a/src/backend/internal/op/storage.ts
+++ b/src/backend/internal/op/storage.ts
@@ -1,5 +1,6 @@
-import { resolvePath, getDb, saveDb } from "../model/db"
+import { resolvePath, getDb, getSettings, saveDb } from "../model/db"
 import { encodeDownloadPath } from "../../pkg/path"
+import { canUseProxyEndpoint, normalizeExtList } from "../driver/proxy"
 import { FileItem, StorageDriver, calcFileType } from "../driver/base"
 import { Onedrive } from "../../drivers/onedrive/driver"
 import { OnedriveAPP } from "../../drivers/onedrive_app/driver"
@@ -1394,6 +1395,39 @@ export async function listItems(
   return { content: items, provider: driverName, storage: resolved.storage }
 }
 
+/**
+ * raw_url 使用哪个端点前缀（`/api/p` 还是 `/api/d`）。
+ *
+ * Go 的 `/p` 在取链接前先跑 `canProxy()`，不通过直接 403 `proxy not allowed`；
+ * `/d` 不受该限制（走 `ShouldProxy`）。因此 raw_url 必须与存储自身的代理配置匹配：
+ * 拿 `/p` 去请求一个既没开 `web_proxy`、扩展名也不在 `proxy_types` / `text_types`
+ * 里的存储，必然 403。
+ *
+ * 这是 #66 修复后暴露的第二个问题：文件列表走 `/d` 所以正常，而预览页的「下载」
+ * 按钮与 `img/video` 的 src 用的是 raw_url（此前恒为 `/api/p`）。
+ */
+async function resolveRawUrlPrefix(
+  storage: any,
+  virtualPath: string,
+): Promise<string> {
+  try {
+    const settings: Record<string, any> = await getSettings().catch(
+      () => ({}) as Record<string, any>,
+    )
+    const allowProxy = canUseProxyEndpoint({
+      storage,
+      driver: storage?.driver || "",
+      filename: virtualPath,
+      proxyTypes: normalizeExtList(settings.proxy_types),
+      textTypes: normalizeExtList(settings.text_types),
+    })
+    return allowProxy ? "/api/p" : "/api/d"
+  } catch {
+    // 设置读不到时保持旧行为（/p），由 rawRouter 给出最终结论
+    return "/api/p"
+  }
+}
+
 export async function getItem(
   virtualPath: string,
   requestContext?: StorageRequestContext,
@@ -1429,7 +1463,7 @@ export async function getItem(
         raw_url: "",
       },
       provider: resolved.storage.driver,
-      rawUrl: `/api/p${encodeDownloadPath(virtualPath)}`,
+      rawUrl: `${await resolveRawUrlPrefix(resolved.storage, virtualPath)}${encodeDownloadPath(virtualPath)}`,
     }
   }
 
@@ -1452,10 +1486,11 @@ export async function getItem(
   return {
     item,
     provider: driverName,
-    // 路径必须逐段编码（对齐 Go utils.EncodePath(path, true)）：raw_url 会被
-    // 前端直接当 href/src 使用，未编码的 `?`/`#` 会被截断、裸 `%` 会让服务端
-    // decodeURIComponent 抛错（见 pkg/path.encodeDownloadPath 注释）。
-    rawUrl: `/api/p${encodeDownloadPath(virtualPath)}`,
+    // 端点前缀按 canProxy() 选（见 resolveRawUrlPrefix），路径必须逐段编码
+    // （对齐 Go utils.EncodePath(path, true)）：raw_url 会被前端直接当 href/src
+    // 使用，未编码的 `?`/`#` 会被截断、裸 `%` 会让服务端 decodeURIComponent 抛错
+    // （见 pkg/path.encodeDownloadPath 注释）。
+    rawUrl: `${await resolveRawUrlPrefix(resolved.storage, virtualPath)}${encodeDownloadPath(virtualPath)}`,
   }
 }
 
diff --git a/src/backend/server/fs.ts b/src/backend/server/fs.ts
index 822a6487..ac90cef6 100644
--- a/src/backend/server/fs.ts
+++ b/src/backend/server/fs.ts
@@ -561,9 +561,9 @@ fsRouter.post("/get", async (c) => {
     // 前端把本接口的 raw_url 直接当下载地址使用：预览页的「下载」按钮就是
     // <a href={raw_url}>（pages/home/previews/download.tsx），图片/视频预览也
     // 直接把它塞进 <img>/<video> 的 src，都不会再自己拼 ?sign=。而 raw_url
-    // 指向的正是需要验签的 /p 端点：sign_all、存储级 enable_sign、密码 meta
-    // 覆盖任一命中时，缺签名一律 401 "sign verify failed"——外部表现就是
-    // 「预览页能正常打开，一点下载就 401」。
+    // 指向的是需要验签的 /p 或 /d 端点（前缀由 getItem 按 canProxy() 选定）：
+    // sign_all、存储级 enable_sign、密码 meta 覆盖任一命中时，缺签名一律
+    // 401 "sign verify failed"——外部表现就是「预览页能正常打开，一点下载就 401」。
     //
     // 对齐 Go server/handles/fsread.go FsGet：
     //   if isEncrypt(meta, reqPath) || setting.GetBool(conf.SignAll) {
diff --git a/src/backend/server/raw_url_prefix.test.ts b/src/backend/server/raw_url_prefix.test.ts
new file mode 100644
index 00000000..d9a5493a
--- /dev/null
+++ b/src/backend/server/raw_url_prefix.test.ts
@@ -0,0 +1,96 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { Hono } from "hono"
+import { getItem } from "../internal/op/storage"
+import { saveDb } from "../internal/model/db"
+import { canUseProxyEndpoint } from "../internal/driver/proxy"
+import { rawRouter } from "./raw"
+
+/**
+ * #66 后续：`raw_url` 的端点前缀必须与存储自身的代理配置匹配。
+ *
+ * `/p` 与 `/d` 不是等价的：
+ *   - `/p` 会先跑 Go 的 `canProxy()`（`MustProxy || WebProxy || webdav_policy=
+ *     use_proxy_url || proxy_types || text_types`），不通过直接
+ *     `403 proxy not allowed`；
+ *   - `/d` 不受该门禁限制（Go 的 `/d` 走 `ShouldProxy`）。
+ *
+ * 因此 raw_url 恒为 `/api/p` 时，凡是没有开启代理的存储，只要从预览页点「下载」
+ * （或让 `img/video` 去取 raw_url）就会 403；而文件列表右键下载走 `/d`，所以看起来
+ * 「只有预览页下载坏掉」。
+ */
+
+const storageRow = (driver: string, extra: Record<string, any> = {}) => ({
+  id: "s1",
+  driver,
+  mount_path: "/np",
+  addition: "{}",
+  modified: "2026-01-01T00:00:00.000Z",
+  disabled: false,
+  ...extra,
+})
+
+const dbWith = (storages: any[], settings: any[] = []) => ({
+  settings,
+  users: [],
+  storages,
+  shares: [],
+  metas: [],
+})
+
+const appOf = () => {
+  const app = new Hono()
+  app.route("/api/p", rawRouter)
+  app.route("/api/d", rawRouter)
+  return app
+}
+
+test("非代理存储：raw_url 用 /api/d（/p 会被 canProxy 拒绝）", async () => {
+  const env: any = {}
+  await saveDb(dbWith([storageRow("gen")]), env)
+
+  const { rawUrl } = await getItem("/np", { env })
+  assert.equal(rawUrl, "/api/d/np")
+})
+
+test("web_proxy=true 的存储：raw_url 用 /api/p", async () => {
+  const env: any = {}
+  await saveDb(dbWith([storageRow("gen", { web_proxy: true })]), env)
+
+  const { rawUrl } = await getItem("/np", { env })
+  assert.equal(rawUrl, "/api/p/np")
+})
+
+test("扩展名命中 proxy_types / text_types 时才允许 /p", () => {
+  const storage = storageRow("gen")
+  const check = (filename: string, proxyTypes: unknown, textTypes: unknown) =>
+    canUseProxyEndpoint({
+      storage,
+      driver: "gen",
+      filename,
+      proxyTypes,
+      textTypes,
+    })
+
+  assert.equal(check("/np/a.exe", [], []), false)
+  assert.equal(check("/np/a.exe", ["exe"], []), true)
+  assert.equal(check("/np/a.txt", [], ["txt"]), true)
+})
+
+test("HTTP 层面：/p 对非代理存储回 403 proxy not allowed，/d 不受该门禁限制", async () => {
+  const env: any = {}
+  await saveDb(dbWith([storageRow("gen")]), env)
+  const app = appOf()
+
+  const viaProxy = await app.request("/api/p/np/a.exe", { method: "GET" })
+  assert.equal(viaProxy.status, 403)
+  assert.match(await viaProxy.text(), /proxy not allowed/)
+
+  // 同一路径走 /d：不触发 canProxy 门禁（这里会因驱动不存在而 404，但不能是 403）
+  const viaDirect = await app.request("/api/d/np/a.exe", { method: "GET" })
+  assert.notEqual(
+    viaDirect.status,
+    403,
+    "/d 不应受 canProxy() 限制，否则非代理存储的下载/预览会全部 403",
+  )
+})
diff --git a/src/backend/server/seed.ts b/src/backend/server/seed.ts
index 0fc76f97..e5781b80 100644
--- a/src/backend/server/seed.ts
+++ b/src/backend/server/seed.ts
@@ -3,7 +3,6 @@ import { getUserFromContext } from "./middlewares"
 import { canWrite, getActualPath, can, PermissionBit } from "../pkg/permission"
 import { assertSafeUrl } from "../pkg/http"
 import { safeErrorMessage } from "../pkg/errs"
-import { encodeDownloadPath } from "../pkg/path"
 import { getSettings, resolvePath } from "../internal/model/db"
 import {
   flushPendingDriverState,
@@ -283,13 +282,16 @@ async function readStoredSeed(
   path: string,
 ): Promise<Uint8Array> {
   const actualPath = getActualPath(user, normalizeVirtualPath(path))
-  const { item } = await getItem(actualPath, storageContext(c))
+  const { item, rawUrl: apiRawUrl } = await getItem(
+    actualPath,
+    storageContext(c),
+  )
   const max = envNumber(c, "SEED_MAX_METADATA_SIZE", DEFAULT_MAX_SEED_BYTES)
   if (item.is_dir || item.size < 0 || item.size > max)
     throw new Error(`Seed file exceeds the ${max} byte limit`)
-  const rawUrl =
-    item.raw_url ||
-    `${new URL(c.req.url).origin}/api/p${encodeDownloadPath(actualPath)}`
+  // 驱动直链优先；否则回退到 getItem 给出的代理地址（前缀已按 canProxy() 选好，
+  // 路径已编码，不能在这里硬编码 /api/p，否则未开代理的存储会 403）。
+  const rawUrl = item.raw_url || new URL(apiRawUrl, c.req.url).toString()
   const headers = item.raw_url_headers || {}
   if (!item.raw_url && c.req.header("Authorization"))
     headers.Authorization = c.req.header("Authorization")!
@@ -374,11 +376,13 @@ async function collectSourceFiles(
     if (result.length >= maxFiles)
       throw new Error(`Seed file count exceeds the ${maxFiles} file limit`)
     const actualPath = getActualPath(user, virtualPath)
-    const { item } = await getItem(actualPath, storageContext(c))
+    const { item, rawUrl: apiRawUrl } = await getItem(
+      actualPath,
+      storageContext(c),
+    )
     if (!item.is_dir) {
-      const rawUrl =
-        item.raw_url ||
-        `${new URL(c.req.url).origin}/api/p${encodeDownloadPath(actualPath)}`
+      // 同 readStoredSeed：直链优先，否则用 getItem 的代理地址（前缀/编码已定）
+      const rawUrl = item.raw_url || new URL(apiRawUrl, c.req.url).toString()
       const headers = { ...(item.raw_url_headers || {}) }
       if (!item.raw_url && c.req.header("Authorization"))
         headers.Authorization = c.req.header("Authorization")!
diff --git a/src/backend/server/webdav.ts b/src/backend/server/webdav.ts
index 17d51eb0..eefbcff8 100644
--- a/src/backend/server/webdav.ts
+++ b/src/backend/server/webdav.ts
@@ -13,8 +13,6 @@ import {
 import { buildWebDavPropfindResponse } from "../internal/webdav/webdav"
 import { safeErrorMessage } from "../pkg/errs"
 import { encodeDownloadPath } from "../pkg/path"
-import { getSettings, resolvePath } from "../internal/model/db"
-import { canUseProxyEndpoint, normalizeExtList } from "../internal/driver/proxy"
 
 /**
  * WebDAV 协议服务（挂载于 /dav/*）。
@@ -154,34 +152,11 @@ webdavRouter.all("/*", async (c) => {
         // 重定向到 rawRouter 实际下载；rawRouter 已处理所有驱动的下载协议
         // （proxy/redirect/stream + Range + SSRF 防护）。
         //
-        // 走 /p 还是 /d 取决于存储的代理策略：/p 是受限的公开代理端点
-        // （对齐 Go handles.canProxy()，未开启代理的存储会 403），而 WebDAV 协议
-        // 拉流必须能拿到字节——不能拿直链的存储（如 WebDav 自身）才需要 /p。
-        // 因此这里按同一个判据选择端点，避免 WebDAV 客户端读到 403。
-        let prefix = "/api/p"
-        try {
-          const resolved: any = await resolvePath(davPath)
-          const storage = resolved?.storage
-          if (storage) {
-            const settings: Record<string, any> = await getSettings().catch(
-              () => ({}) as Record<string, any>,
-            )
-            const allowProxy = canUseProxyEndpoint({
-              storage,
-              driver: storage.driver,
-              filename: davPath,
-              proxyTypes: normalizeExtList(settings.proxy_types),
-              textTypes: normalizeExtList(settings.text_types),
-            })
-            if (!allowProxy) prefix = "/api/d"
-          }
-        } catch {
-          // 解析失败时保持默认 /p，交由 rawRouter 给出最终结论
-        }
+        // 端点前缀（/p 还是 /d）与路径编码都由 getItem 决定（见
+        // op/storage.ts resolveRawUrlPrefix）：/p 受 Go canProxy() 限制，未开启
+        // 代理的存储会 403 proxy not allowed，因此不能在这里硬编码 /p。
         return c.redirect(
-          // 路径逐段编码（对齐 Go utils.EncodePath(path, true)），否则含
-          // `%`/`#`/空格的路径会拼出非法 Location。
-          rawUrl || `${prefix}${encodeDownloadPath(davPath)}`,
+          rawUrl || `/api/d${encodeDownloadPath(davPath)}`,
           302,
         )
       }

From e99dcdd2ca402ec331ace437ddb2e47c5633f5c1 Mon Sep 17 00:00:00 2001
From: PIKACHUIM <PIKACHUIM@users.noreply.github.com>
Date: Sun, 20 Sep 2026 18:29:33 +0800
Subject: [PATCH 6/6] =?UTF-8?q?fix(server):=20=E4=BF=AE=E5=A4=8D=E9=A2=84?=
 =?UTF-8?q?=E8=A7=88=E9=A1=B5=E5=88=B7=E6=96=B0=20404=20=E4=B8=8E=E5=90=8E?=
 =?UTF-8?q?=E5=8F=B0=E5=AD=98=E5=82=A8=E3=80=8C=E5=BA=8F=E5=8F=B7=E3=80=8D?=
 =?UTF-8?q?=E5=A4=B1=E6=95=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

实机报告的两个问题：

1. 文件预览页刷新报 Static resource not found（实测 404）
   assets.ts 里的「CDN 静态资源重定向」路由写成了 `/:folder/:filepath*`，
   它会吞掉**任意两段路径**。而文件预览页的地址正是 `<域名>/<挂载点>/<文件>`
   （例如 /存储2/xxx.exe），刷新时被它拦下，未配置 ASSET_URLS 时直接返回
   404 `Static resource not found`，请求永远走不到 SPA 兜底。
   改为对齐 Go server/static/static.go：只对固定目录白名单
   （assets / images / streamer / static）做 CDN 重定向；未配置 ASSET_URLS 时
   调用 next() 放行给本地静态资源（Workers ASSETS 绑定）与 SPA 兜底，
   不再回 404。logo / favicon 的重定向保持不变。

2. 后台存储编辑页的「序号」（storage.order）设置后排序不变
   - internal/op/storage.ts：虚拟根目录合并挂载点时直接沿用数据库数组顺序，
     现按 Go op.getStorageVirtualFilesByPath 的比较器排序：Order 升序，
     Order 相同时按 MountPath 升序；
   - server/admin.ts：/storage/list 按 Go db.GetStorages（addStorageOrder =
     `order, id`）排序返回，此前是数组原始顺序。

新增测试：
- server/assets_route.test.ts（5 例）：`<挂载点>/<文件>` 刷新落到 SPA 兜底、
  未配置 ASSET_URLS 时 /assets/* 不再 404、配置后仅四个目录 302 且 $version
  被替换、logo/favicon 仍重定向；
- server/storage_order.test.ts（4 例）：根目录挂载顺序（order / mount_path /
  跳过 disabled）、后台存储列表 order,id 顺序。
---
 src/backend/internal/op/storage.ts       |  14 ++-
 src/backend/server/admin.ts              |   9 +-
 src/backend/server/assets.ts             |  86 +++++++++-------
 src/backend/server/assets_route.test.ts  |  91 +++++++++++++++++
 src/backend/server/storage_order.test.ts | 123 +++++++++++++++++++++++
 5 files changed, 282 insertions(+), 41 deletions(-)
 create mode 100644 src/backend/server/assets_route.test.ts
 create mode 100644 src/backend/server/storage_order.test.ts

diff --git a/src/backend/internal/op/storage.ts b/src/backend/internal/op/storage.ts
index cb849e25..ef235a8d 100644
--- a/src/backend/internal/op/storage.ts
+++ b/src/backend/internal/op/storage.ts
@@ -1364,7 +1364,19 @@ export async function listItems(
   const activeStorages = (db.storages || []).filter((s: any) => !s.disabled)
   const cleanListedPath = resolved.cleanPath
 
-  activeStorages.forEach((s: any) => {
+  // 挂载点顺序对齐 Go op.getStorageVirtualFilesByPath：
+  //   Order 升序；Order 相同时按 MountPath 升序。
+  // 此前直接沿用数据库数组顺序，后台存储编辑页里的「序号」因此完全不生效。
+  const orderedStorages = [...activeStorages].sort((a: any, b: any) => {
+    const orderA = Number(a.order) || 0
+    const orderB = Number(b.order) || 0
+    if (orderA !== orderB) return orderA - orderB
+    const mountA = String(a.mount_path || "")
+    const mountB = String(b.mount_path || "")
+    return mountA < mountB ? -1 : mountA > mountB ? 1 : 0
+  })
+
+  orderedStorages.forEach((s: any) => {
     const mount =
       "/" + (s.mount_path || "").split("/").filter(Boolean).join("/")
     if (mount === cleanListedPath || mount === "/") return
diff --git a/src/backend/server/admin.ts b/src/backend/server/admin.ts
index 4e9479a1..9b4145bc 100644
--- a/src/backend/server/admin.ts
+++ b/src/backend/server/admin.ts
@@ -54,7 +54,14 @@ function generateSecureToken(length = 32): string {
 
 adminRouter.get("/storage/list", async (c) => {
   const db = await getDb(c.env)
-  const content = db.storages || []
+  // 排序对齐 Go internal/db.GetStorages（addStorageOrder = `order, id`）：
+  // 后台存储列表按「序号」升序、同序号按 id 升序，此前是按数组原始顺序返回。
+  const content = [...(db.storages || [])].sort((a: any, b: any) => {
+    const orderA = Number(a.order) || 0
+    const orderB = Number(b.order) || 0
+    if (orderA !== orderB) return orderA - orderB
+    return (Number(a.id) || 0) - (Number(b.id) || 0)
+  })
   return c.json({
     code: 200,
     message: "success",
diff --git a/src/backend/server/assets.ts b/src/backend/server/assets.ts
index 4ef03e2e..df9b297f 100644
--- a/src/backend/server/assets.ts
+++ b/src/backend/server/assets.ts
@@ -2,7 +2,7 @@ import { Hono } from "hono"
 import { getDb } from "../internal/model/db"
 
 /**
- * 品牌资源路由。
+ * 品牌资源 + CDN 静态资源路由。
  *
  * 背景：老前端（含 logo.svg / logo.png / favicon 静态文件）已移除，前端统一
  * 由官方 OpenList-Frontend 产物提供，但官方产物不包含 /logo.png、/favicon.png
@@ -29,48 +29,56 @@ assetsRouter.get("/favicon.png", redirectToLogo)
 assetsRouter.get("/favicon.ico", redirectToLogo)
 
 /**
- * CDN 静态资源重定向路由。
- * 
- * 当配置了 ASSET_URLS 时，前端静态资源（assets/、images/ 等）将重定向到 CDN 加载。
- * 支持 $version 占位符自动替换为前端版本号。
- * 
- * 参考原版 OpenList 实现：https://github.com/OpenListTeam/OpenList/blob/main/server/static/static.go
- * 
- * 示例：ASSET_URLS = https://registry.npmmirror.com/@openlist-frontend/openlist-frontend/$version/files/dist
+ * 允许重定向到 CDN 的静态资源目录（对齐 Go server/static/static.go 的
+ * `folders := []string{"assets", "images", "streamer", "static"}`）。
+ *
+ * ⚠️ 这里**必须**是固定前缀白名单。此前用的是 `/:folder/:filepath*`——
+ * 它会吞掉**任意两段路径**，于是「存储挂载点/文件」这种路由（例如
+ * `<域名>/存储2/xxx.exe`，即文件预览页的地址）在刷新时会被它拦下，
+ * 未配置 ASSET_URLS 时直接返回 `Static resource not found`（404），
+ * 前端来不及走到 SPA 兜底，表现为「进预览页后刷新白屏/404」。
  */
-assetsRouter.get("/:folder/:filepath*", async (c) => {
-  const env = c.env as any
-  const cdnUrl = env?.ASSET_URLS || process.env.ASSET_URLS
-  
-  if (!cdnUrl) {
-    // 未配置 CDN，返回 404
-    return c.text("Static resource not found", 404)
-  }
-  
-  // 获取前端版本号
-  const db = await getDb()
+const CDN_FOLDERS = ["assets", "images", "streamer", "static"]
+
+/** 解析 CDN 模板：`$version` 占位符会替换为前端版本号（取不到则 latest） */
+async function resolveCdnBase(cdnUrl: string): Promise<string> {
   let version = "latest"
   try {
-    const versionItem = db.get("SELECT * FROM x_settings WHERE key = 'version'") as any
+    const db = await getDb()
+    const versionItem = db.get(
+      "SELECT * FROM x_settings WHERE key = 'version'",
+    ) as any
     if (versionItem && versionItem.value) {
-      // 从版本字符串提取 frontend 版本，如 "v4.2.3 (Commit: xxx) - Frontend: v1.0.0 - Build at: xxx"
+      // 从版本字符串提取 frontend 版本，如
+      // "v4.2.3 (Commit: xxx) - Frontend: v1.0.0 - Build at: xxx"
       const match = versionItem.value.match(/Frontend:\s*([^\s-]+)/)
-      if (match) {
-        version = match[1]
-      }
+      if (match) version = match[1]
     }
-  } catch (e) {
-    // 忽略错误，使用默认值
+  } catch {
+    // 读不到版本号时退回 latest（与 Go 的 $version 缺省行为一致）
   }
-  
-  // 替换 $version 占位符
-  const resolvedCdnUrl = cdnUrl.replace(/\$version/g, version)
-  
-  // 构建 CDN 资源完整 URL
-  const folder = c.req.param("folder")
-  const filepath = c.req.param("filepath") || ""
-  const resourceUrl = `${resolvedCdnUrl}/${folder}/${filepath}`
-  
-  // 重定向到 CDN 资源
-  return c.redirect(resourceUrl, 302)
-})
+  return cdnUrl.replace(/\$version/g, version)
+}
+
+for (const folder of CDN_FOLDERS) {
+  assetsRouter.get(`/${folder}/*`, async (c, next) => {
+    const env = c.env as any
+    const cdnUrl =
+      env?.ASSET_URLS ||
+      (typeof process !== "undefined" ? process.env?.ASSET_URLS : "") ||
+      ""
+
+    // 未配置 CDN：不能在这里 404，必须放行给后面的本地静态资源
+    //（Workers 的 ASSETS 绑定 / SPA 兜底），否则这些目录之外的请求不会受影响，
+    // 但 `/assets/...` 这类真实静态资源会直接 404。
+    if (!cdnUrl) return await next()
+
+    const resolvedCdnUrl = await resolveCdnBase(cdnUrl)
+    const prefix = `/${folder}/`
+    const filepath = c.req.path.startsWith(prefix)
+      ? c.req.path.slice(prefix.length)
+      : ""
+
+    return c.redirect(`${resolvedCdnUrl}/${folder}/${filepath}`, 302)
+  })
+}
diff --git a/src/backend/server/assets_route.test.ts b/src/backend/server/assets_route.test.ts
new file mode 100644
index 00000000..0313e051
--- /dev/null
+++ b/src/backend/server/assets_route.test.ts
@@ -0,0 +1,91 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { Hono } from "hono"
+import { assetsRouter } from "./assets"
+
+/**
+ * 静态资源路由的回归：CDN 重定向**只能**匹配固定目录前缀。
+ *
+ * 背景（实机复现）：进入文件预览页后刷新，地址形如 `<域名>/存储2/xxx.exe`，
+ * 会被原先的贪婪路由 `/:folder/:filepath*` 拦下，未配置 ASSET_URLS 时直接
+ * 返回 404 `Static resource not found`，前端来不及走到 SPA 兜底。
+ *
+ * Go 的对应实现（server/static/static.go）只对
+ * `assets / images / streamer / static` 四个目录做 CDN 重定向，其余一律
+ * 交给 `noRoute`（返回 index.html）。
+ */
+
+/** 模拟 index.ts 的挂载顺序：assetsRouter 位于 SPA 兜底之前 */
+const appWithSpaFallback = () => {
+  const app = new Hono()
+  app.route("/", assetsRouter)
+  app.all("*", (c) => c.html("<!doctype html><title>index</title>"))
+  return app
+}
+
+test("刷新文件预览页（<挂载点>/<文件>）必须落到 SPA 兜底，而不是 404", async () => {
+  const app = appWithSpaFallback()
+  for (const path of [
+    "/%E5%AD%98%E5%82%A82/xxx.exe",
+    "/存储2/xxx.exe",
+    "/存储2/sub/dir/file.mp4",
+  ]) {
+    const res = await app.request(path, {
+      method: "GET",
+      headers: { Accept: "text/html,application/xhtml+xml" },
+    })
+    assert.equal(res.status, 200, `${path} -> ${res.status}`)
+    const body = await res.text()
+    assert.match(body, /<title>index<\/title>/, `${path} 未返回 SPA 壳`)
+    assert.doesNotMatch(body, /Static resource not found/, `${path} 被 CDN 路由吞掉`)
+  }
+})
+
+test("未配置 ASSET_URLS 时，/assets/* 放行给本地静态资源（不返回 404 文案）", async () => {
+  const res = await appWithSpaFallback().request("/assets/index-abc.js", {
+    method: "GET",
+  })
+  // 单测里没有 ASSETS 绑定，因此会落到 SPA 兜底；关键是不能再返回那句 404
+  assert.notEqual(res.status, 404)
+  assert.doesNotMatch(await res.text(), /Static resource not found/)
+})
+
+test("配置 ASSET_URLS 时，仅四个静态目录 302 到 CDN，且 $version 被替换", async () => {
+  const env = { ASSET_URLS: "https://cdn.example.com/dist" }
+  const app = appWithSpaFallback()
+
+  for (const folder of ["assets", "images", "streamer", "static"]) {
+    const res = await app.request(`/${folder}/a/b.js`, { method: "GET" }, env)
+    assert.equal(res.status, 302, `${folder} 未重定向`)
+    assert.equal(
+      res.headers.get("location"),
+      `https://cdn.example.com/dist/${folder}/a/b.js`,
+    )
+  }
+
+  // 非静态目录不受影响（仍是 SPA 壳）
+  const spa = await app.request("/存储2/xxx.exe", { method: "GET" }, env)
+  assert.equal(spa.status, 200)
+  assert.match(await spa.text(), /<title>index<\/title>/)
+})
+
+test("ASSET_URLS 含 $version 占位符时不留占位符（取不到版本则 latest）", async () => {
+  const env = {
+    ASSET_URLS: "https://cdn.example.com/openlist/$version/files/dist",
+  }
+  const res = await appWithSpaFallback().request(
+    "/assets/app.js",
+    { method: "GET" },
+    env,
+  )
+  assert.equal(res.status, 302)
+  const location = res.headers.get("location") || ""
+  assert.doesNotMatch(location, /\$version/)
+  assert.match(location, /\/assets\/app\.js$/)
+})
+
+test("logo / favicon 仍然重定向到官方 logo", async () => {
+  const res = await appWithSpaFallback().request("/favicon.ico", { method: "GET" })
+  assert.equal(res.status, 302)
+  assert.equal(res.headers.get("location"), "https://res.oplist.org/logo/logo.svg")
+})
diff --git a/src/backend/server/storage_order.test.ts b/src/backend/server/storage_order.test.ts
new file mode 100644
index 00000000..628e5c14
--- /dev/null
+++ b/src/backend/server/storage_order.test.ts
@@ -0,0 +1,123 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { Hono } from "hono"
+import { listItems } from "../internal/op/storage"
+import { saveDb } from "../internal/model/db"
+import { adminRouter } from "./admin"
+
+/**
+ * 存储「序号」（storage.order）必须真实生效 —— 对齐 Go：
+ *
+ * - 虚拟根目录的挂载点顺序：`op.getStorageVirtualFilesByPath`
+ *     先按 `Order` 升序，`Order` 相同时按 `MountPath` 升序；
+ * - 后台存储列表：`internal/db.GetStorages`（`addStorageOrder` = `order, id`）。
+ *
+ * 此前 TS 两处都直接沿用数据库数组顺序，后台改「序号」后排序完全不变。
+ */
+
+const storageRow = (
+  id: number,
+  mount: string,
+  order: number,
+  extra: Record<string, any> = {},
+) => ({
+  id,
+  driver: "gen",
+  mount_path: mount,
+  addition: "{}",
+  modified: "2026-01-01T00:00:00.000Z",
+  disabled: false,
+  order,
+  ...extra,
+})
+
+const dbWith = (storages: any[], settings: any[] = []) => ({
+  settings,
+  users: [],
+  storages,
+  shares: [],
+  metas: [],
+})
+
+test("根目录挂载点按 storage.order 升序、同序号按 mount_path 升序", async () => {
+  const env: any = {}
+  await saveDb(
+    dbWith([
+      // 数据库里的顺序刻意与 order 相反，确保测的是 order 而不是数组下标
+      storageRow(11, "/c", 2),
+      storageRow(12, "/a", 1),
+      storageRow(13, "/b", 2),
+    ]),
+    env,
+  )
+
+  const { content } = await listItems("/", { env })
+  assert.deepEqual(
+    content.map((i) => i.name),
+    ["a", "b", "c"],
+  )
+})
+
+test("序号相同时按 mount_path 升序（不依赖 id / 插入顺序）", async () => {
+  const env: any = {}
+  await saveDb(
+    dbWith([
+      storageRow(21, "/zzz", 0),
+      storageRow(22, "/aaa", 0),
+      storageRow(23, "/mmm", 0),
+    ]),
+    env,
+  )
+
+  const { content } = await listItems("/", { env })
+  assert.deepEqual(
+    content.map((i) => i.name),
+    ["aaa", "mmm", "zzz"],
+  )
+})
+
+test("被禁用的存储不参与挂载点合并", async () => {
+  const env: any = {}
+  await saveDb(
+    dbWith([
+      storageRow(31, "/keep", 1),
+      storageRow(32, "/gone", 2, { disabled: true }),
+    ]),
+    env,
+  )
+
+  const { content } = await listItems("/", { env })
+  assert.deepEqual(
+    content.map((i) => i.name),
+    ["keep"],
+  )
+})
+
+test("后台存储列表按 order, id 升序返回（对齐 Go db.GetStorages）", async () => {
+  const env: any = { }
+  await saveDb(
+    dbWith(
+      [
+        storageRow(42, "/b", 5),
+        storageRow(41, "/a", 5),
+        storageRow(43, "/c", 1),
+      ],
+      [{ key: "token", value: "admin-token" }],
+    ),
+    env,
+  )
+
+  const app = new Hono()
+  app.route("/api/admin", adminRouter)
+  const res = await app.request(
+    "/api/admin/storage/list",
+    { method: "GET", headers: { Authorization: "Bearer admin-token" } },
+    env,
+  )
+  assert.equal(res.status, 200)
+  const body: any = await res.json()
+  assert.deepEqual(
+    body.data.content.map((s: any) => s.mount_path),
+    ["/c", "/a", "/b"],
+  )
+})