@tool-bridge/server 0.15.0 → 0.17.0

package/dist/{chunk-NLPTB3IL.js → chunk-TLNUIPFZ.js}

@@ -1,8 +1,12 @@
+import {
+  createGuardedFetch
+} from "./chunk-U5UHT7CX.js";
 import {
   AnnotationStore,
   CONTEXT_CAPABILITIES,
   CONTEXT_DIRECT_UPLOAD_CAPABILITY,
   DEFAULT_MAX_NODES,
+  DEFAULT_STORE_DRIVER_KEY_ROOT,
   DEVICE_CALL_TIMEOUT_MS,
   DeviceGatewaySession,
   FEEDBACK_HIDE_SCORE,
@@ -26,12 +30,12 @@ import {
   PG_SEARCH_TOOLS_TABLE,
   PG_SEARCH_WRITE_LOCK_KEY,
   PRESIGN_TTL_SEC_DEFAULT,
-  PRESIGN_TTL_SEC_MAX,
   RemoteAllowlistStore,
   SKILLHUB_CAPABILITIES,
   SKRegistryStore,
   SecretStoreImpl,
   SqlSearchIndex,
+  StoreService,
   TBError,
   TB_ERROR_CODES,
   TOOL_SEARCH_AUDIT_NODE_LIMIT,
@@ -79,17 +83,31 @@ import {
   createObjectContextProvider,
   createObjectContextUploadGrant,
   createSkillhubProvider,
+  createStoreModule,
   decodeDeviceFrame,
   derivePresence,
   deviceDirectoryHelpModel,
   deviceFsHelpModel,
   deviceShellHelpModel,
   discriminatedUnion,
+  dispatchContextCmd,
+  dispatchContextUploadCmd,
+  dispatchSkillhubCmd,
   effectFor,
   email,
   encodeCallContext,
   encodeDeviceFrame,
   encodePluginCall,
+  external_exports,
+  feedbackDetailSchema,
+  feedbackListSchema,
+  feedbackRemoveResponseSchema,
+  feedbackSubmitRequestSchema,
+  feedbackSubmitResponseSchema,
+  feedbackViewSchema,
+  feedbackVoteRequestSchema,
+  healthResponseSchema,
+  helpJsonSchema,
   identify,
   intersection,
   isContextExpired,
@@ -98,23 +116,30 @@ import {
   iso_exports,
   lazy,
   literal,
+  livenessResponseSchema,
   looseObject,
   mintKey,
   negotiate,
-  normalizeCanonicalOrigin,
+  nodeInputSchema,
   normalizeEntryPath,
   normalizePath,
   normalizeToolSearchLimit,
   normalizeToolSearchPath,
   normalizeUpstreamError,
   number,
+  oauthAuthorizeRequestSchema,
+  oauthAuthorizeResponseSchema,
   object,
   objectBodyToBytes,
   optional,
   optionalMethodsForCapabilities,
+  parseContextCmdArgs,
   parseCredentialValues,
   parseFeedbackEntries,
   parseNodeInput,
+  parseNonNegativeIntEnv,
+  parsePortEnv,
+  parseRuntimeEnv,
   parseTokenResponse,
   parseVia,
   pgBulkInsertSql,
@@ -122,7 +147,9 @@ import {
   pluginTokenSecretName,
   prefixUpperBound,
   preprocess,
+  readinessResponseSchema,
   record,
+  registryNodeSchema,
   renderHelpDsl,
   renderHelpJson,
   renderHelpMarkdown,
@@ -136,58 +163,41 @@ import {
   shouldRefresh,
   skillhubHelpModel,
   skillhubScopeForCmd,
+  storeUri,
   string,
+  tbErrorBodySchema,
   toJSONSchema,
   toolHelpModel,
+  toolSearchPageSchema,
+  toolSearchRequestSchema,
   toolSearchSnapshotDigest,
   toolsToHelpModel,
+  treeJsonSchema,
   union,
   unknown,
   url,
   validatePath,
   virtualizeTools
-} from "./chunk-DXXYNIXV.js";
+} from "./chunk-RVWZN3CI.js";
 
 // src/config.ts
 var DEFAULT_PORT = 8787;
-var DEFAULT_MAX_HOPS = 4;
 var DEFAULT_DEVICE_RECLAIM_SEC = 24 * 60 * 60;
-function positiveIntEnv(value) {
-  const n = Number(value);
-  return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
-}
-function presignTtlEnv(value) {
-  const ttl = positiveIntEnv(value);
-  return ttl === void 0 ? void 0 : Math.min(ttl, PRESIGN_TTL_SEC_MAX);
-}
-function portEnv(value) {
-  if (value === void 0 || value === "") return void 0;
-  const n = Number(value);
-  return Number.isInteger(n) && n >= 0 && n <= 65535 ? n : void 0;
-}
+var DEFAULT_STORE_CLEANUP_INTERVAL_SEC = 15 * 60;
 function configFromEnv(env = process.env) {
-  const allowInsecure = env.TB_ALLOW_INSECURE_HTTP === "true";
-  const allowlist = (env.TB_REMOTE_ALLOWLIST ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const runtime = parseRuntimeEnv(env);
   const config = {
+    ...runtime,
     // TB_PORT 优先,PORT 兜底:Railway / Fly / Cloud Run / CF Container 等 PaaS 只注入
     // PORT,不认识 TB_PORT —— 不兜底的话容器会监听 8787 而平台探活另一个端口,部署直接失败。
-    port: portEnv(env.TB_PORT) ?? portEnv(env.PORT) ?? DEFAULT_PORT,
+    port: parsePortEnv(env.TB_PORT) ?? parsePortEnv(env.PORT) ?? DEFAULT_PORT,
     host: env.TB_HOST !== void 0 && env.TB_HOST.length > 0 ? env.TB_HOST : "0.0.0.0",
     dataDir: env.TB_DATA_DIR !== void 0 && env.TB_DATA_DIR.length > 0 ? env.TB_DATA_DIR : "./data",
-    allowInsecureHttp: allowInsecure,
     allowInsecureBootstrap: env.TB_ALLOW_INSECURE_BOOTSTRAP === "true",
-    remote: {
-      allowlist,
-      maxHops: positiveIntEnv(env.TB_MAX_HOPS) ?? DEFAULT_MAX_HOPS,
-      ...env.TB_INSTANCE_ID !== void 0 && env.TB_INSTANCE_ID.length > 0 ? { instanceId: env.TB_INSTANCE_ID } : {},
-      allowInsecure
-    },
-    deviceReclaimSec: positiveIntEnv(env.TB_DEVICE_RECLAIM_SEC) ?? DEFAULT_DEVICE_RECLAIM_SEC,
-    // 0 合法(立即关停,本地/单机默认);positiveIntEnv 拒 0,故单独解析。
-    shutdownDrainSec: (() => {
-      const n = Number(env.TB_SHUTDOWN_DRAIN_SEC);
-      return Number.isInteger(n) && n >= 0 ? n : 0;
-    })()
+    deviceReclaimSec: runtime.deviceReclaimSec ?? DEFAULT_DEVICE_RECLAIM_SEC,
+    storeCleanupIntervalSec: runtime.storeCleanupIntervalSec ?? DEFAULT_STORE_CLEANUP_INTERVAL_SEC,
+    // 0 合法(立即关停，本地/单机默认)。
+    shutdownDrainSec: parseNonNegativeIntEnv(env.TB_SHUTDOWN_DRAIN_SEC) ?? 0
   };
   if (env.TB_UI_DIR !== void 0 && env.TB_UI_DIR.length > 0) config.uiDir = env.TB_UI_DIR;
   if (env.TB_DATABASE_URL !== void 0 && env.TB_DATABASE_URL.length > 0) {
@@ -224,19 +234,9 @@ function configFromEnv(env = process.env) {
   if (env.TB_BOOTSTRAP_ADMIN_SK !== void 0 && env.TB_BOOTSTRAP_ADMIN_SK.length > 0) {
     config.adminSk = env.TB_BOOTSTRAP_ADMIN_SK;
   }
-  const canonicalOrigin = normalizeCanonicalOrigin(env.TB_CANONICAL_ORIGIN);
-  if (canonicalOrigin !== void 0) config.canonicalOrigin = canonicalOrigin;
   if (env.TB_SECRET_ENCRYPTION_KEY !== void 0 && env.TB_SECRET_ENCRYPTION_KEY.length > 0) {
     config.encryptionKey = env.TB_SECRET_ENCRYPTION_KEY;
   }
-  const ttl = positiveIntEnv(env.TB_TOOL_CACHE_TTL);
-  if (ttl !== void 0) config.toolCacheTtlSec = ttl;
-  const refThreshold = positiveIntEnv(env.TB_REF_THRESHOLD_BYTES);
-  if (refThreshold !== void 0) config.refThresholdBytes = refThreshold;
-  const refTtl = presignTtlEnv(env.TB_REF_TTL_SEC);
-  if (refTtl !== void 0) config.refTtlSec = refTtl;
-  const uploadGrantTtl = presignTtlEnv(env.TB_UPLOAD_GRANT_TTL_SEC);
-  if (uploadGrantTtl !== void 0) config.uploadGrantTtlSec = uploadGrantTtl;
   return config;
 }
 
@@ -439,7 +439,8 @@ var BUILTIN_MODULES = [
   "plugin",
   "catalog",
   "federation",
-  "annotation"
+  "annotation",
+  "store"
 ];
 var BUILTIN_DESCRIPTIONS = {
   sk: "SecretKey registry",
@@ -449,7 +450,8 @@ var BUILTIN_DESCRIPTIONS = {
   plugin: "Plugin registry (external plugins)",
   catalog: "Built-in integration catalog (read-only)",
   federation: "Remote federation host allowlist",
-  annotation: "Admin notes shown in ~help of any path"
+  annotation: "Admin notes shown in ~help of any path",
+  store: "Deployment-level private object Store"
 };
 async function mintAdminWithPlaintext(store, plaintext, now) {
   const { key } = await mintKey(adminBootstrapInput(), now);
@@ -554,10 +556,14 @@ async function presignS3Url(client, url2, ttlSec) {
 }
 async function presignS3Put(client, url2, ttlSec, opts) {
   assertPresignTtlSec(ttlSec);
+  if ("contentLength" in opts && (!Number.isSafeInteger(opts.contentLength) || opts.contentLength < 0)) {
+    throw new TBError("invalid_argument", "presigned PUT contentLength \u5FC5\u987B\u662F\u975E\u8D1F\u5B89\u5168\u6574\u6570");
+  }
   const target = new URL(url2);
   target.searchParams.set("X-Amz-Expires", String(ttlSec));
   const headers = {
     "content-type": opts.contentType,
+    ..."contentLength" in opts ? { "content-length": String(opts.contentLength) } : {},
     ...opts.ifNoneMatch === void 0 ? {} : { "if-none-match": opts.ifNoneMatch }
   };
   const signed = await client.sign(
@@ -567,6 +573,48 @@ async function presignS3Put(client, url2, ttlSec, opts) {
   return { method: "PUT", url: signed.url, headers };
 }
 
+// ../app/src/objectBodyStream.ts
+function toWebObjectBodyStream(source, options = {}) {
+  const reader = source.getReader();
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const strategy = options.highWaterMark === void 0 ? void 0 : { highWaterMark: options.highWaterMark };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          release();
+          controller.close();
+        } else if (value !== void 0) {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        try {
+          release();
+        } catch {
+        }
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      try {
+        if (reader.cancel !== void 0) await reader.cancel(reason);
+        else await source.cancel?.(reason);
+      } finally {
+        try {
+          release();
+        } catch {
+        }
+      }
+    }
+  }, strategy);
+}
+
 // ../app/src/providers/s3Object.ts
 var META_HEADER_PREFIX = "x-amz-meta-";
 function stripEtagQuotes(etag) {
@@ -600,14 +648,17 @@ function createS3ObjectStore(cfg, opts) {
     accessKeyId: cfg.accessKeyId,
     secretAccessKey: cfg.secretAccessKey,
     service: "s3",
-    region: cfg.region ?? "auto"
+    region: cfg.region ?? "auto",
+    // Store 的重试由上层按操作幂等性统一决定。传输层不得自动重放写入，
+    // 也不能让读/删路径悄悄继承 aws4fetch 的默认 10 次重试。
+    retries: 0
   });
   const base = cfg.endpoint.replace(/\/+$/, "");
   const bucketUrl = `${base}/${cfg.bucket}`;
   const urlFor = (key) => `${bucketUrl}/${encodeObjectKey(key)}`;
-  const s3Fetch = async (url2, init) => {
+  const s3FetchWith = async (aws, url2, init) => {
     try {
-      return await client.fetch(url2, init);
+      return await aws.fetch(url2, init);
     } catch (err) {
       throw normalizeUpstreamError({
         kind: "network",
@@ -615,6 +666,16 @@ function createS3ObjectStore(cfg, opts) {
       });
     }
   };
+  const s3Fetch = async (url2, init) => {
+    return await s3FetchWith(client, url2, init);
+  };
+  const fetchBody = (body) => {
+    if (typeof body === "string" || body instanceof ArrayBuffer) return body;
+    if (body instanceof Uint8Array) {
+      return body.buffer instanceof ArrayBuffer ? new Uint8Array(body.buffer, body.byteOffset, body.byteLength) : new Uint8Array(body);
+    }
+    return toWebObjectBodyStream(body, { highWaterMark: 0 });
+  };
   const metaFromHeaders = (key, headers) => {
     const metadata = {};
     headers.forEach((value, name) => {
@@ -633,13 +694,14 @@ function createS3ObjectStore(cfg, opts) {
     if (contentType !== null) meta.contentType = contentType;
     return meta;
   };
+  const headObject = async (key) => {
+    const resp = await s3Fetch(urlFor(key), { method: "HEAD" });
+    if (resp.status === 404) return null;
+    if (!resp.ok) throw s3Error("head", resp.status);
+    return metaFromHeaders(key, resp.headers);
+  };
   return {
-    async head(key) {
-      const resp = await s3Fetch(urlFor(key), { method: "HEAD" });
-      if (resp.status === 404) return null;
-      if (!resp.ok) throw s3Error("head", resp.status);
-      return metaFromHeaders(key, resp.headers);
-    },
+    head: headObject,
     async get(key) {
       const resp = await s3Fetch(urlFor(key), { method: "GET" });
       if (resp.status === 404) {
@@ -653,27 +715,31 @@ function createS3ObjectStore(cfg, opts) {
       return { meta: metaFromHeaders(key, resp.headers), body: resp.body ?? EMPTY_STREAM };
     },
     async put(key, body, putOpts) {
-      const bytes = await objectBodyToBytes(body);
       const headers = {};
+      headers["x-amz-content-sha256"] = "UNSIGNED-PAYLOAD";
       if (putOpts?.contentType !== void 0) headers["content-type"] = putOpts.contentType;
       for (const [name, value] of Object.entries(putOpts?.metadata ?? {})) {
         headers[`${META_HEADER_PREFIX}${name}`] = value;
       }
       if (putOpts?.ifMatchEtag !== void 0) headers["if-match"] = `"${putOpts.ifMatchEtag}"`;
-      const resp = await s3Fetch(urlFor(key), { method: "PUT", headers, body: bytes });
+      if (putOpts?.ifNoneMatch !== void 0) headers["if-none-match"] = putOpts.ifNoneMatch;
+      const resp = await s3Fetch(urlFor(key), {
+        method: "PUT",
+        headers,
+        body: fetchBody(body)
+      });
       await resp.body?.cancel();
-      if (resp.status === 412 || putOpts?.ifMatchEtag !== void 0 && resp.status === 404) {
-        throw new TBError("conflict", `etag \u4E0D\u5339\u914D:'${key}'`);
+      const conditional = putOpts?.ifMatchEtag !== void 0 || putOpts?.ifNoneMatch !== void 0;
+      if (conditional && (resp.status === 409 || resp.status === 412) || putOpts?.ifMatchEtag !== void 0 && resp.status === 404) {
+        throw new TBError("conflict", `\u5BF9\u8C61\u6761\u4EF6\u5199\u51B2\u7A81:'${key}'`);
       }
       if (!resp.ok) throw s3Error("put", resp.status);
-      const meta = {
-        key,
-        etag: stripEtagQuotes(resp.headers.get("etag") ?? ""),
-        size: bytes.byteLength,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: putOpts?.metadata ?? {}
-      };
-      if (putOpts?.contentType !== void 0) meta.contentType = putOpts.contentType;
+      const meta = await headObject(key);
+      if (meta === null) {
+        throw new TBError("unavailable", "s3 put succeeded but HEAD did not observe the object", {
+          retryable: true
+        });
+      }
       return meta;
     },
     async delete(key) {
@@ -730,6 +796,9 @@ function createS3ObjectStore(cfg, opts) {
     },
     presignPut(key, ttlSec, putOpts) {
       return presignS3Put(client, urlFor(key), ttlSec, putOpts);
+    },
+    presignPutExact(key, ttlSec, putOpts) {
+      return presignS3Put(client, urlFor(key), ttlSec, putOpts);
     }
   };
 }
@@ -1029,6 +1098,443 @@ var SearchSynchronizer = class {
 // ../app/src/deps.ts
 var TOOL_CACHE_TTL_DEFAULT = 300;
 
+// ../app/src/storeRefToken.ts
+async function hmacKey(secret) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(`tb-store-read-ref:v1:${secret}`)
+  );
+  return crypto.subtle.importKey("raw", digest, { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign",
+    "verify"
+  ]);
+}
+async function signStoreRefToken(payload, secret) {
+  const body = base64urlEncode(new TextEncoder().encode(JSON.stringify(payload)));
+  const mac = await crypto.subtle.sign(
+    "HMAC",
+    await hmacKey(secret),
+    new TextEncoder().encode(body)
+  );
+  return `${body}.${base64urlEncode(new Uint8Array(mac))}`;
+}
+async function verifyStoreRefToken(token, secret) {
+  const dot = token.indexOf(".");
+  if (dot <= 0) return null;
+  const body = token.slice(0, dot);
+  let signature;
+  try {
+    signature = base64urlDecode(token.slice(dot + 1));
+  } catch {
+    return null;
+  }
+  const valid = await crypto.subtle.verify(
+    "HMAC",
+    await hmacKey(secret),
+    signature,
+    new TextEncoder().encode(body)
+  );
+  if (!valid) return null;
+  try {
+    const payload = JSON.parse(
+      new TextDecoder().decode(base64urlDecode(body))
+    );
+    if (payload.v !== 1 || typeof payload.objectId !== "string" || payload.objectId.length < 1 || typeof payload.exp !== "number" || !Number.isSafeInteger(payload.exp)) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+// ../app/src/store.ts
+var STORE_CALL_CAPABILITY_HEADER = "x-tb-store-capability";
+var STORE_UPLOAD_HEADER = "x-tb-store-upload";
+var KEY_STORE_TOKEN_SECRET = "sys:store-token-secret:v1";
+var KEY_STORE_CLEANUP_PROGRESS = "sys:store-cleanup-progress:v1";
+var STORE_READ_TTL_SEC_DEFAULT = 15 * 60;
+var STORE_CALL_MAX_OBJECTS_DEFAULT = 4;
+var STORE_CALL_MAX_OBJECT_BYTES_DEFAULT = 256 * 1024 * 1024;
+var STORE_CALL_MAX_BYTES_DEFAULT = 512 * 1024 * 1024;
+function positiveInt(value, fallback, field) {
+  const actual = value ?? fallback;
+  if (!Number.isSafeInteger(actual) || actual < 1) {
+    throw new TBError("invalid_argument", `${field} must be a positive integer`);
+  }
+  return actual;
+}
+function randomSecret() {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+async function derivedTokenSecret(root) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(`tb-store-capability-root:v1:${root}`)
+  );
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function storeTokenSecret(state, configured) {
+  if (configured !== void 0) {
+    if (configured.length < 16) {
+      throw new TBError("invalid_argument", "storeTokenSecret must contain at least 16 characters");
+    }
+    return await derivedTokenSecret(configured);
+  }
+  const current = await state.get(KEY_STORE_TOKEN_SECRET);
+  if (typeof current === "string" && current.length >= 16) return current;
+  if (current !== null) {
+    throw new TBError("internal", "default Store token secret state is invalid", {
+      retryable: false
+    });
+  }
+  if (state.compareAndSwap === void 0) {
+    throw new TBError("unavailable", "default Store requires StateStore.compareAndSwap", {
+      retryable: false
+    });
+  }
+  const candidate = randomSecret();
+  if (await state.compareAndSwap(KEY_STORE_TOKEN_SECRET, null, candidate)) return candidate;
+  const winner = await state.get(KEY_STORE_TOKEN_SECRET);
+  if (typeof winner !== "string" || winner.length < 16) {
+    throw new TBError("unavailable", "default Store token secret initialization conflicted", {
+      retryable: true
+    });
+  }
+  return winner;
+}
+function serviceOptions(deps, tokenSecret) {
+  return {
+    tokenSecret,
+    ...deps.storeMaxObjectBytes === void 0 ? {} : { maxObjectBytes: deps.storeMaxObjectBytes },
+    ...deps.storeRelayMaxBytes === void 0 ? {} : { relayMaxBytes: deps.storeRelayMaxBytes },
+    ...deps.storeUploadTtlSec === void 0 ? {} : { uploadTtlSec: deps.storeUploadTtlSec },
+    ...deps.storeShareTtlSec === void 0 ? {} : { shareTtlSec: deps.storeShareTtlSec }
+  };
+}
+async function defaultStoreRuntime(deps) {
+  if (deps.objects === void 0) {
+    throw new TBError("unavailable", "default Store object driver is not configured", {
+      retryable: false
+    });
+  }
+  const [objects, tokenSecret] = await Promise.all([
+    deps.objects(),
+    storeTokenSecret(deps.state, deps.storeTokenSecret ?? deps.encryptionKey)
+  ]);
+  return {
+    objects,
+    tokenSecret,
+    service: new StoreService(deps.state, objects, serviceOptions(deps, tokenSecret))
+  };
+}
+function resolveStoreRequestOrigin(rawRequestOrigin, canonicalOrigin) {
+  const raw = rawRequestOrigin ?? canonicalOrigin;
+  if (raw === void 0) {
+    throw new TBError("unavailable", "request origin is unavailable", { retryable: false });
+  }
+  let url2;
+  try {
+    url2 = new URL(raw);
+  } catch {
+    throw new TBError("unavailable", "request origin is invalid", { retryable: false });
+  }
+  if (url2.protocol !== "https:" && url2.protocol !== "http:" || url2.username !== "" || url2.password !== "") {
+    throw new TBError("unavailable", "request origin is invalid", { retryable: false });
+  }
+  if (rawRequestOrigin !== void 0 && canonicalOrigin !== void 0) {
+    let canonical;
+    try {
+      canonical = new URL(canonicalOrigin);
+    } catch {
+      throw new TBError("unavailable", "canonical origin is invalid", { retryable: false });
+    }
+    if (canonical.protocol !== "https:" && canonical.protocol !== "http:" || canonical.username !== "" || canonical.password !== "") {
+      throw new TBError("unavailable", "canonical origin is invalid", { retryable: false });
+    }
+    url2.protocol = canonical.protocol;
+  }
+  return url2.origin;
+}
+function requestOrigin(runtime, deps) {
+  return resolveStoreRequestOrigin(runtime?.requestOrigin, deps.canonicalOrigin);
+}
+function storeUploadGrant(start, origin) {
+  const useRelay = start.alreadyCompleted || start.signedRequest === void 0;
+  const url2 = useRelay ? `${origin}/~store/uploads/${encodeURIComponent(start.uploadId)}` : start.signedRequest.url;
+  const headers = useRelay ? { [STORE_UPLOAD_HEADER]: start.uploadToken } : start.signedRequest.headers;
+  return {
+    uploadId: start.uploadId,
+    objectUri: start.objectUri,
+    transport: useRelay ? "relay" : "presigned-put",
+    method: "PUT",
+    url: url2,
+    headers,
+    expiresAt: start.expiresAt,
+    maxBytes: start.maxBytes,
+    uploadToken: start.uploadToken,
+    ...start.alreadyCompleted && start.descriptor !== void 0 ? { alreadyCompleted: true, descriptor: start.descriptor } : {}
+  };
+}
+function readTtlSec(deps) {
+  return positiveInt(
+    deps.storeReadTtlSec,
+    deps.refTtlSec ?? STORE_READ_TTL_SEC_DEFAULT,
+    "storeReadTtlSec"
+  );
+}
+async function ownerReadGrant(object2, runtime, deps, tokenSecret) {
+  if (object2.status !== "ready" || object2.size === void 0) {
+    throw TBError.notFound("Store object not found");
+  }
+  const ttlSec = readTtlSec(deps);
+  const expiresAt = new Date(Date.now() + ttlSec * 1e3).toISOString();
+  const token = await signStoreRefToken({
+    v: 1,
+    objectId: object2.id,
+    exp: Math.floor(Date.parse(expiresAt) / 1e3)
+  }, tokenSecret);
+  return {
+    $ref: `${requestOrigin(runtime, deps)}/~store/refs/${encodeURIComponent(token)}`,
+    uri: storeUri(object2.id),
+    contentType: object2.contentType,
+    size: object2.size,
+    expiresAt
+  };
+}
+function shareReadGrant(result, runtime, deps) {
+  return {
+    shareId: result.shareId,
+    uri: result.uri,
+    expiresAt: result.expiresAt,
+    $ref: `${requestOrigin(runtime, deps)}/~store/shares/${encodeURIComponent(result.token)}`
+  };
+}
+function defaultStoreModuleDeps(deps, store) {
+  return {
+    service: store.service,
+    callbacks: {
+      createUpload: (start, runtime) => storeUploadGrant(start, requestOrigin(runtime, deps)),
+      read: async (object2, runtime) => await ownerReadGrant(
+        object2,
+        runtime,
+        deps,
+        store.tokenSecret
+      ),
+      share: (result, runtime) => shareReadGrant(result, runtime, deps)
+    }
+  };
+}
+function lazyDefaultStoreModule(deps) {
+  const helpOnly = createStoreModule({
+    // createStoreModule.help is static and never reads these placeholders.
+    service: void 0,
+    callbacks: {
+      createUpload: () => {
+        throw new TBError("unavailable", "default Store is unavailable");
+      },
+      read: () => {
+        throw new TBError("unavailable", "default Store is unavailable");
+      },
+      share: () => {
+        throw new TBError("unavailable", "default Store is unavailable");
+      }
+    }
+  });
+  return {
+    module: helpOnly.module,
+    description: helpOnly.description,
+    help: (path) => helpOnly.help(path),
+    async dispatch(cmd, args, ctx, runtime) {
+      const store = await defaultStoreRuntime(deps);
+      return await createStoreModule(defaultStoreModuleDeps(deps, store)).dispatch(
+        cmd,
+        args,
+        ctx,
+        runtime
+      );
+    }
+  };
+}
+async function beginCapabilityUpload(deps, input, capabilityToken, origin) {
+  const store = await defaultStoreRuntime(deps);
+  const start = await store.service.beginCallUpload(input, capabilityToken);
+  return storeUploadGrant(start, origin);
+}
+async function completeCapabilityUpload(deps, uploadId2, uploadToken) {
+  return await (await defaultStoreRuntime(deps)).service.completeUploadWithToken(
+    uploadId2,
+    uploadToken
+  );
+}
+async function abortCapabilityUpload(deps, uploadId2, uploadToken) {
+  return await (await defaultStoreRuntime(deps)).service.abortUploadWithToken(
+    uploadId2,
+    uploadToken
+  );
+}
+async function relayStoreUpload(deps, uploadId2, uploadToken, body) {
+  const store = await defaultStoreRuntime(deps);
+  const session = await store.service.verifyUploadToken(uploadToken);
+  if (session.id !== uploadId2) {
+    throw new TBError("permission_denied", "upload capability does not match the URL");
+  }
+  return await store.service.commitRelayUpload({
+    uploadToken,
+    body: body ?? new Uint8Array()
+  });
+}
+async function storeObjectResponse(objects, object2) {
+  const got = await objects.get(object2.driverKey);
+  if (got === null) throw TBError.notFound("not found");
+  const body = toWebObjectBodyStream(got.body);
+  return new Response(body, {
+    headers: {
+      "content-type": object2.contentType,
+      "content-length": String(got.meta.size),
+      "cache-control": "private, no-store"
+    }
+  });
+}
+async function issueDeviceCallUpload(deps, deviceId, callId, context) {
+  if (deps.objects === void 0) return null;
+  const store = await defaultStoreRuntime(deps);
+  const maxObjects = positiveInt(
+    deps.storeCallMaxObjects,
+    STORE_CALL_MAX_OBJECTS_DEFAULT,
+    "storeCallMaxObjects"
+  );
+  const maxBytes = positiveInt(
+    deps.storeCallMaxBytes,
+    STORE_CALL_MAX_BYTES_DEFAULT,
+    "storeCallMaxBytes"
+  );
+  const maxObjectBytes = Math.min(
+    positiveInt(
+      deps.storeCallMaxObjectBytes,
+      deps.storeMaxObjectBytes ?? STORE_CALL_MAX_OBJECT_BYTES_DEFAULT,
+      "storeCallMaxObjectBytes"
+    ),
+    maxBytes
+  );
+  const issued = await store.service.issueCallUploadCapability({
+    callId,
+    owner: context.caller.owner,
+    producer: `device:${deviceId}`,
+    expiresAt: context.expiresAt,
+    maxObjects,
+    maxBytes,
+    maxObjectBytes,
+    allowedContentTypes: deps.storeCallAllowedContentTypes ?? ["*/*"]
+  });
+  return {
+    context: {
+      ...context,
+      upload: {
+        token: issued.token,
+        expiresAt: issued.capability.expiresAt,
+        // The SDK uses this as an early per-object check; the server remains
+        // authoritative for the aggregate call budget.
+        maxBytes: issued.capability.maxObjectBytes,
+        maxObjects: issued.capability.maxObjects
+      }
+    },
+    revoke: async () => await store.service.revokeCallUploadCapability(issued.token)
+  };
+}
+function cleanupProgress(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TBError("internal", "default Store cleanup progress is invalid");
+  }
+  const record2 = value;
+  if (!Number.isSafeInteger(record2.revision) || record2.revision < 1) {
+    throw new TBError("internal", "default Store cleanup progress is invalid");
+  }
+  const cursors = record2.cursors;
+  if (cursors === null || typeof cursors !== "object" || Array.isArray(cursors)) {
+    throw new TBError("internal", "default Store cleanup progress is invalid");
+  }
+  for (const field of [
+    "uploads",
+    "objects",
+    "shares",
+    "callCapabilities",
+    "idempotencyBindings"
+  ]) {
+    const cursor = cursors[field];
+    if (cursor !== null && typeof cursor !== "string") {
+      throw new TBError("internal", "default Store cleanup progress is invalid");
+    }
+  }
+  return value;
+}
+function emptyCleanupResult() {
+  return {
+    abandonedObjects: 0,
+    deletedBytes: 0,
+    deletedStaging: 0,
+    expiredCallCapabilities: 0,
+    expiredIdempotencyBindings: 0,
+    expiredShares: 0,
+    expiredUploads: 0
+  };
+}
+function addCleanupResult(target, page) {
+  target.abandonedObjects += page.abandonedObjects;
+  target.deletedBytes += page.deletedBytes;
+  target.deletedStaging += page.deletedStaging;
+  target.expiredCallCapabilities += page.expiredCallCapabilities;
+  target.expiredIdempotencyBindings += page.expiredIdempotencyBindings;
+  target.expiredShares += page.expiredShares;
+  target.expiredUploads += page.expiredUploads;
+}
+async function cleanupDefaultStore(deps, opts = {}) {
+  await deps.ensureReady?.();
+  const store = await defaultStoreRuntime(deps);
+  const maxPages = Math.min(positiveInt(opts.maxPages, 8, "maxPages"), 64);
+  const limit = opts.limit === void 0 ? void 0 : positiveInt(opts.limit, 200, "limit");
+  const rawProgress = await deps.state.get(KEY_STORE_CLEANUP_PROGRESS);
+  let progress = rawProgress === null ? null : cleanupProgress(rawProgress);
+  let cursors = progress?.cursors;
+  const aggregate = emptyCleanupResult();
+  for (let pageNumber = 0; pageNumber < maxPages; pageNumber++) {
+    const page = await store.service.cleanup({
+      ...limit === void 0 ? {} : { limit },
+      ...cursors === void 0 ? {} : { cursors },
+      // staging 不使用权威状态 cursor；同一 host tick 只运行一次，避免
+      // maxPages 内重复扫描同一 driver maintenance 范围。
+      runDriverMaintenance: pageNumber === 0
+    });
+    addCleanupResult(aggregate, page);
+    if (page.cursors === void 0) {
+      if (progress !== null) {
+        await deps.state.compareAndSwap(
+          KEY_STORE_CLEANUP_PROGRESS,
+          progress.revision,
+          null
+        );
+      }
+      return aggregate;
+    }
+    const next = {
+      cursors: page.cursors,
+      revision: (progress?.revision ?? 0) + 1
+    };
+    const advanced = await deps.state.compareAndSwap(
+      KEY_STORE_CLEANUP_PROGRESS,
+      progress?.revision ?? null,
+      next
+    );
+    if (!advanced) {
+      return aggregate;
+    }
+    progress = next;
+    cursors = next.cursors;
+  }
+  return { ...aggregate, ...cursors === void 0 ? {} : { cursors } };
+}
+
 // ../app/src/deviceNodes.ts
 function tbErrorFromBody(body) {
   return new TBError(body.code, body.message, { retryable: body.retryable });
@@ -1041,7 +1547,19 @@ function requireDevice(deps) {
 }
 async function invokeDevice(deps, deviceId, req) {
   const id = crypto.randomUUID();
-  const body = await requireDevice(deps).invoke(deviceId, { id, ...req });
+  const upload = req.context === void 0 ? null : await issueDeviceCallUpload(deps, deviceId, id, req.context);
+  let body;
+  try {
+    body = await requireDevice(deps).invoke(deviceId, {
+      id,
+      path: req.path,
+      arguments: req.arguments,
+      ...req.context === void 0 ? {} : { context: upload?.context ?? req.context }
+    });
+  } finally {
+    await upload?.revoke().catch(() => {
+    });
+  }
   if (!body || !("ok" in body)) {
     throw new TBError("unavailable", "device session returned invalid result");
   }
@@ -5241,8 +5759,8 @@ var LADDER_ERROR_HTTP_STATUS = {
 function parseSchema(schema, data) {
   return safeParse(schema, data);
 }
-function shapeKeys(schemas) {
-  return new Set(schemas.flatMap((schema) => Object.keys(schema.shape)));
+function shapeKeys(schemas2) {
+  return new Set(schemas2.flatMap((schema) => Object.keys(schema.shape)));
 }
 function isStandardSchema(schema) {
   if (schema == null) return false;
@@ -7158,9 +7676,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (!names[this.name.str]) return;
-      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants);
+      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -7177,9 +7695,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
-      this.rhs = optimizeExpr(this.rhs, names, constants);
+      this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -7238,8 +7756,8 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : void 0;
     }
-    optimizeNames(names, constants) {
-      this.code = optimizeExpr(this.code, names, constants);
+    optimizeNames(names, constants2) {
+      this.code = optimizeExpr(this.code, names, constants2);
       return this;
     }
     get names() {
@@ -7265,12 +7783,12 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       }
       return nodes.length > 0 ? this : void 0;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n = nodes[i];
-        if (n.optimizeNames(names, constants)) continue;
+        if (n.optimizeNames(names, constants2)) continue;
         subtractNames(names, n.names);
         nodes.splice(i, 1);
       }
@@ -7317,11 +7835,11 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       if (cond === false || !this.nodes.length) return void 0;
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a;
-      this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
-      if (!(super.optimizeNames(names, constants) || this.else)) return;
-      this.condition = optimizeExpr(this.condition, names, constants);
+      this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
+      if (!(super.optimizeNames(names, constants2) || this.else)) return;
+      this.condition = optimizeExpr(this.condition, names, constants2);
       return this;
     }
     get names() {
@@ -7343,9 +7861,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants)) return;
-      this.iteration = optimizeExpr(this.iteration, names, constants);
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2)) return;
+      this.iteration = optimizeExpr(this.iteration, names, constants2);
       return this;
     }
     get names() {
@@ -7380,9 +7898,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants)) return;
-      this.iterable = optimizeExpr(this.iterable, names, constants);
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2)) return;
+      this.iterable = optimizeExpr(this.iterable, names, constants2);
       return this;
     }
     get names() {
@@ -7421,11 +7939,11 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       (_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a, _b;
-      super.optimizeNames(names, constants);
-      (_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants);
-      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants);
+      super.optimizeNames(names, constants2);
+      (_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants2);
+      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants2);
       return this;
     }
     get names() {
@@ -7674,7 +8192,7 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants) {
+  function optimizeExpr(expr, names, constants2) {
     if (expr instanceof code_1.Name) return replaceName(expr);
     if (!canOptimize(expr)) return expr;
     return new code_1._Code(expr._items.reduce((items, c) => {
@@ -7684,13 +8202,13 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants[n.str];
+      const c = constants2[n.str];
       if (c === void 0 || names[n.str] !== 1) return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e) {
-      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
+      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
     }
   }
   function subtractNames(names, from) {
@@ -10417,14 +10935,14 @@ var require_core$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
       }
       return metaSchema;
     }
-    _removeAllSchemas(schemas, regex3) {
-      for (const keyRef in schemas) {
-        const sch = schemas[keyRef];
+    _removeAllSchemas(schemas2, regex3) {
+      for (const keyRef in schemas2) {
+        const sch = schemas2[keyRef];
         if (!regex3 || regex3.test(keyRef)) {
-          if (typeof sch == "string") delete schemas[keyRef];
+          if (typeof sch == "string") delete schemas2[keyRef];
           else if (sch && !sch.meta) {
             this._cache.delete(sch.schema);
-            delete schemas[keyRef];
+            delete schemas2[keyRef];
           }
         }
       }
@@ -19175,15 +19693,6 @@ async function clientCredential(secrets, authRef) {
     ...values.clientSecret === void 0 ? {} : { clientSecret: values.clientSecret }
   };
 }
-function parseTokenErrorMessage(payload) {
-  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
-  const record2 = payload;
-  for (const key of ["error_description", "error", "msg", "message"]) {
-    const value = record2[key];
-    if (typeof value === "string" && value !== "") return value;
-  }
-  return void 0;
-}
 async function writeTokens(store, nodePath, next, previous) {
   const merged = {
     ...next,
@@ -19207,10 +19716,10 @@ async function requestTokens(opts) {
   let response;
   try {
     response = await opts.fetcher(endpoint, { method: "POST", headers, body });
-  } catch (err) {
+  } catch {
     throw new TBError(
       "unavailable",
-      `\u4EE4\u724C\u7AEF\u70B9\u4E0D\u53EF\u8FBE:${err instanceof Error ? err.message : String(err)}`,
+      "\u4EE4\u724C\u7AEF\u70B9\u4E0D\u53EF\u8FBE",
       { retryable: true }
     );
   }
@@ -19222,14 +19731,20 @@ async function requestTokens(opts) {
     payload = null;
   }
   if (!response.ok) {
-    const parsed = payload === null ? void 0 : parseTokenErrorMessage(payload);
-    const detail = parsed ?? `HTTP ${response.status}`;
+    const detail = `HTTP ${response.status}`;
     if (response.status >= 500) {
       throw new TBError("unavailable", `\u4EE4\u724C\u7AEF\u70B9\u8FD4\u56DE ${detail}`, { retryable: true });
     }
     throw new TBError("invalid_argument", `\u4EE4\u724C\u7AEF\u70B9\u62D2\u7EDD\u4E86\u8BF7\u6C42:${detail}`);
   }
-  return parseTokenResponse(payload, opts.config, opts.now);
+  try {
+    return parseTokenResponse(payload, opts.config, opts.now);
+  } catch (err) {
+    if (isTBError(err) && err.code === "invalid_argument") {
+      throw new TBError("invalid_argument", "\u4EE4\u724C\u7AEF\u70B9\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94");
+    }
+    throw err;
+  }
 }
 function base64url(bytes) {
   let binary = "";
@@ -19241,7 +19756,14 @@ async function createPkce() {
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
   return { verifier, challenge: base64url(new Uint8Array(digest)) };
 }
+function requireProviderOAuthFetch(fetcher) {
+  if (fetcher === void 0) {
+    throw new TBError("unavailable", "Provider OAuth \u51FA\u7AD9\u901A\u9053\u672A\u914D\u7F6E", { retryable: false });
+  }
+  return fetcher;
+}
 async function startProviderAuthorization(opts) {
+  const fetcher = requireProviderOAuthFetch(opts.fetcher);
   const existing = await readTokens(opts.store, opts.nodePath);
   if (existing !== void 0 && !shouldRefresh(existing, opts.now)) {
     return { status: "authorized" };
@@ -19251,7 +19773,7 @@ async function startProviderAuthorization(opts) {
       const client2 = await clientCredential(opts.secrets, opts.authRef);
       const refreshed = await requestTokens({
         config: opts.config,
-        fetcher: opts.fetcher,
+        fetcher,
         now: opts.now,
         grant: { refreshToken: existing.refreshToken },
         ...client2
@@ -19284,10 +19806,11 @@ async function startProviderAuthorization(opts) {
   };
 }
 async function finishProviderAuthorization(opts) {
+  const fetcher = requireProviderOAuthFetch(opts.fetcher);
   const client = await clientCredential(opts.secrets, opts.authRef);
   const tokens = await requestTokens({
     config: opts.config,
-    fetcher: opts.fetcher,
+    fetcher,
     now: opts.now,
     grant: { code: opts.code, redirectUri: opts.origin + PROVIDER_OAUTH_CALLBACK_PATH },
     ...opts.codeVerifier === "" ? {} : { codeVerifier: opts.codeVerifier },
@@ -19296,6 +19819,7 @@ async function finishProviderAuthorization(opts) {
   await writeTokens(opts.store, opts.nodePath, tokens);
 }
 async function resolveProviderAccessToken(opts) {
+  const fetcher = requireProviderOAuthFetch(opts.fetcher);
   const tokens = await readTokens(opts.store, opts.nodePath);
   if (tokens === void 0) throw providerReauthorizeRequired(opts.nodePath);
   if (opts.force !== true && !shouldRefresh(tokens, opts.now)) return tokens.accessToken;
@@ -19305,7 +19829,7 @@ async function resolveProviderAccessToken(opts) {
   try {
     refreshed = await requestTokens({
       config: opts.config,
-      fetcher: opts.fetcher,
+      fetcher,
       now: opts.now,
       grant: { refreshToken: tokens.refreshToken },
       ...client
@@ -19409,7 +19933,7 @@ async function providerAccessTokenFor(opts) {
     config: opts.config,
     encryptionKey,
     ...opts.force === true ? { force: true } : {},
-    fetcher: fetch,
+    fetcher: opts.deps.providerOAuthFetch,
     nodePath: opts.nodePath,
     now: /* @__PURE__ */ new Date(),
     // 调用期不需要 origin(只在构造授权 URL 时用);传空串会被 buildAuthorizationUrl 用到,
@@ -19608,7 +20132,7 @@ async function assertToolConfig(config, deps, ctx, mountPath) {
 }
 
 // ../app/src/refToken.ts
-async function hmacKey(secret) {
+async function hmacKey2(secret) {
   const digest = await crypto.subtle.digest(
     "SHA-256",
     new TextEncoder().encode(`tb-ref-token:${secret}`)
@@ -19622,7 +20146,7 @@ async function signRefToken(payload, secret) {
   const body = base64urlEncode(new TextEncoder().encode(JSON.stringify(payload)));
   const mac = await crypto.subtle.sign(
     "HMAC",
-    await hmacKey(secret),
+    await hmacKey2(secret),
     new TextEncoder().encode(body)
   );
   return `${body}.${base64urlEncode(new Uint8Array(mac))}`;
@@ -19639,7 +20163,7 @@ async function verifyRefToken(token, secret) {
   }
   const ok = await crypto.subtle.verify(
     "HMAC",
-    await hmacKey(secret),
+    await hmacKey2(secret),
     // Node 的 WebCrypto 类型要求 Uint8Array<ArrayBuffer>;base64urlDecode 的产物满足但类型面是 ArrayBufferLike。
     sig,
     new TextEncoder().encode(body)
@@ -19784,60 +20308,11 @@ async function skillhubProviderFor(node, cfg, deps, requestUrl) {
   }
   return createSkillhubProvider(objects, opts);
 }
-async function dispatchSkillhubCmd(provider, command, args) {
-  switch (command.toLowerCase()) {
-    case "list":
-      return await provider.list(args.opts);
-    case "get":
-      return typeof args.file === "string" ? await provider.get_file(args.id, args.file) : await provider.get(args.id);
-    case "search":
-      return await provider.search(args.query, args.opts);
-    case "publish":
-      if (!Array.isArray(args.files)) {
-        throw new TBError("invalid_argument", "publish \u9700\u8981\u6570\u7EC4 'files'");
-      }
-      return await provider.publish({
-        ...typeof args.id === "string" ? { id: args.id } : {},
-        files: args.files
-      });
-    case "remove":
-      return await provider.remove(args.id);
-    default:
-      throw new TBError("invalid_argument", `unknown cmd '${command}'`);
-  }
-}
-async function dispatchContextCmd(provider, command, args) {
-  const unimplemented = () => {
-    throw new TBError("invalid_argument", `unknown cmd '${command}'(provider \u672A\u5B9E\u73B0)`);
-  };
-  switch (command.toLowerCase()) {
-    case "list":
-      if (provider.list === void 0) return unimplemented();
-      return await provider.list(args.path ?? "", args.opts);
-    case "get":
-      if (provider.get === void 0) return unimplemented();
-      return await provider.get(args.path);
-    case "write":
-      if (provider.write === void 0) return unimplemented();
-      if (typeof args.entry !== "object" || args.entry === null) {
-        throw new TBError("invalid_argument", "write \u9700\u8981\u5BF9\u8C61 'entry'");
-      }
-      return await provider.write(args.path, args.entry);
-    case "update":
-      if (provider.update === void 0) return unimplemented();
-      if (typeof args.patch !== "object" || args.patch === null) {
-        throw new TBError("invalid_argument", "update \u9700\u8981\u5BF9\u8C61 'patch'");
-      }
-      return await provider.update(args.path, args.patch);
-    case "delete":
-      if (provider.delete === void 0) return unimplemented();
-      return await provider.delete(args.path);
-    case "search":
-      if (provider.search === void 0) return unimplemented();
-      return await provider.search(args.query, args.opts);
-    default:
-      throw new TBError("invalid_argument", `unknown cmd '${command}'`);
-  }
+async function dispatchSkillhubCmd2(provider, command, args) {
+  return await dispatchSkillhubCmd(provider, command, args);
+}
+async function dispatchContextCmd2(provider, command, args) {
+  return await dispatchContextCmd(provider, command, args);
 }
 async function assertContextAlive(node, cfg, registry) {
   if (!isContextExpired(node.createdAt, cfg.ttl, Date.now())) return;
@@ -23496,8 +23971,8 @@ function modernOnlyStrictRejection(route, supportedVersions) {
 function parseSchema2(schema, data) {
   return safeParse(schema, data);
 }
-function shapeKeys2(schemas) {
-  return new Set(schemas.flatMap((schema) => Object.keys(schema.shape)));
+function shapeKeys2(schemas2) {
+  return new Set(schemas2.flatMap((schema) => Object.keys(schema.shape)));
 }
 function isStandardSchema2(schema) {
   if (schema == null) return false;
@@ -25335,9 +25810,9 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (!names[this.name.str]) return;
-      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants);
+      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -25354,9 +25829,9 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
-      this.rhs = optimizeExpr(this.rhs, names, constants);
+      this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -25415,8 +25890,8 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : void 0;
     }
-    optimizeNames(names, constants) {
-      this.code = optimizeExpr(this.code, names, constants);
+    optimizeNames(names, constants2) {
+      this.code = optimizeExpr(this.code, names, constants2);
       return this;
     }
     get names() {
@@ -25442,12 +25917,12 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       }
       return nodes.length > 0 ? this : void 0;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n = nodes[i];
-        if (n.optimizeNames(names, constants)) continue;
+        if (n.optimizeNames(names, constants2)) continue;
         subtractNames(names, n.names);
         nodes.splice(i, 1);
       }
@@ -25494,11 +25969,11 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       if (cond === false || !this.nodes.length) return void 0;
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a;
-      this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
-      if (!(super.optimizeNames(names, constants) || this.else)) return;
-      this.condition = optimizeExpr(this.condition, names, constants);
+      this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
+      if (!(super.optimizeNames(names, constants2) || this.else)) return;
+      this.condition = optimizeExpr(this.condition, names, constants2);
       return this;
     }
     get names() {
@@ -25520,9 +25995,9 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants)) return;
-      this.iteration = optimizeExpr(this.iteration, names, constants);
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2)) return;
+      this.iteration = optimizeExpr(this.iteration, names, constants2);
       return this;
     }
     get names() {
@@ -25557,9 +26032,9 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants)) return;
-      this.iterable = optimizeExpr(this.iterable, names, constants);
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2)) return;
+      this.iterable = optimizeExpr(this.iterable, names, constants2);
       return this;
     }
     get names() {
@@ -25598,11 +26073,11 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       (_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a, _b;
-      super.optimizeNames(names, constants);
-      (_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants);
-      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants);
+      super.optimizeNames(names, constants2);
+      (_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants2);
+      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants2);
       return this;
     }
     get names() {
@@ -25851,7 +26326,7 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants) {
+  function optimizeExpr(expr, names, constants2) {
     if (expr instanceof code_1.Name) return replaceName(expr);
     if (!canOptimize(expr)) return expr;
     return new code_1._Code(expr._items.reduce((items, c) => {
@@ -25861,13 +26336,13 @@ var require_codegen2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants[n.str];
+      const c = constants2[n.str];
       if (c === void 0 || names[n.str] !== 1) return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e) {
-      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
+      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
     }
   }
   function subtractNames(names, from) {
@@ -28594,14 +29069,14 @@ var require_core$32 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       }
       return metaSchema;
     }
-    _removeAllSchemas(schemas, regex3) {
-      for (const keyRef in schemas) {
-        const sch = schemas[keyRef];
+    _removeAllSchemas(schemas2, regex3) {
+      for (const keyRef in schemas2) {
+        const sch = schemas2[keyRef];
         if (!regex3 || regex3.test(keyRef)) {
-          if (typeof sch == "string") delete schemas[keyRef];
+          if (typeof sch == "string") delete schemas2[keyRef];
           else if (sch && !sch.meta) {
             this._cache.delete(sch.schema);
-            delete schemas[keyRef];
+            delete schemas2[keyRef];
           }
         }
       }
@@ -32091,9 +32566,9 @@ function createListenRouter(options) {
   const { bus, onerror } = options;
   const maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS;
   const keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
-  const open = /* @__PURE__ */ new Set();
+  const open2 = /* @__PURE__ */ new Set();
   function serve2(message, signal, capabilities, serverInfo) {
-    if (open.size >= maxSubscriptions) {
+    if (open2.size >= maxSubscriptions) {
       onerror?.(/* @__PURE__ */ new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));
       return jsonRpcError(message.id, -32603, "Subscription limit reached");
     }
@@ -32149,7 +32624,7 @@ data: ${JSON.stringify({
       }
       if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
       abortCleanup?.();
-      open.delete(teardown);
+      open2.delete(teardown);
       try {
         controller.close();
       } catch {
@@ -32169,7 +32644,7 @@ data: ${JSON.stringify({
           writeNotification(note.method, note.params);
         });
         keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(": keepalive\n\n"));
-        open.add(teardown);
+        open2.add(teardown);
       },
       cancel() {
         teardown(false);
@@ -32194,10 +32669,10 @@ data: ${JSON.stringify({
   return {
     serve: serve2,
     closeAll() {
-      for (const teardown of open) teardown(true);
+      for (const teardown of open2) teardown(true);
     },
     get openCount() {
-      return open.size;
+      return open2.size;
     }
   };
 }
@@ -35960,6 +36435,273 @@ async function passthroughRemote(opts) {
 // ../app/src/tbApp.ts
 import { Hono } from "hono";
 
+// ../core/src/protocol/openapi.ts
+var schemaRegistry = external_exports.registry();
+var schemas = {
+  Error: tbErrorBodySchema,
+  FeedbackDetail: feedbackDetailSchema,
+  FeedbackList: feedbackListSchema,
+  FeedbackRemoveResponse: feedbackRemoveResponseSchema,
+  FeedbackSubmitRequest: feedbackSubmitRequestSchema,
+  FeedbackSubmitResponse: feedbackSubmitResponseSchema,
+  FeedbackView: feedbackViewSchema,
+  FeedbackVoteRequest: feedbackVoteRequestSchema,
+  Health: healthResponseSchema,
+  Help: helpJsonSchema,
+  Liveness: livenessResponseSchema,
+  NodeInput: nodeInputSchema,
+  OAuthAuthorizeRequest: oauthAuthorizeRequestSchema,
+  OAuthAuthorizeResponse: oauthAuthorizeResponseSchema,
+  Readiness: readinessResponseSchema,
+  RegistryNode: registryNodeSchema,
+  SearchRequest: toolSearchRequestSchema,
+  SearchResponse: toolSearchPageSchema,
+  Tree: treeJsonSchema
+};
+for (const [id, schema] of Object.entries(schemas)) schemaRegistry.add(schema, { id });
+function asOpenApiSchema(value) {
+  if (Array.isArray(value)) return value.map(asOpenApiSchema);
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "$schema") continue;
+    if (key === "$ref" && typeof entry === "string" && !entry.startsWith("#/")) {
+      out[key] = `#/components/schemas/${entry}`;
+    } else {
+      out[key] = asOpenApiSchema(entry);
+    }
+  }
+  return out;
+}
+var generated = external_exports.toJSONSchema(schemaRegistry);
+var componentSchemas = Object.fromEntries(
+  Object.entries(generated.schemas).map(([name, schema]) => [name, asOpenApiSchema(schema)])
+);
+var jsonContent = (schema) => ({
+  "application/json": { schema: { $ref: `#/components/schemas/${schema}` } }
+});
+var jsonResponse = (description, schema) => ({
+  description,
+  content: jsonContent(schema)
+});
+var errorResponses = {
+  400: jsonResponse("Invalid request", "Error"),
+  401: jsonResponse("Unauthenticated", "Error"),
+  403: jsonResponse("Permission denied", "Error"),
+  404: jsonResponse("Not found or not visible", "Error"),
+  409: jsonResponse("Conflict", "Error"),
+  429: jsonResponse("Rate limited", "Error"),
+  500: jsonResponse("Internal error", "Error"),
+  503: jsonResponse("Unavailable", "Error")
+};
+var bearerSecurity = [{ bearerAuth: [] }];
+var pathParameter = {
+  in: "path",
+  name: "path",
+  required: true,
+  description: "Slash-delimited Tool Bridge tree path; each segment is URL encoded.",
+  schema: { type: "string" }
+};
+var fixedControlPlaneOpenApi = {
+  openapi: "3.1.0",
+  info: {
+    title: "Tool Bridge fixed control plane",
+    version: "1.0.0"
+  },
+  components: {
+    securitySchemes: {
+      bearerAuth: { type: "http", scheme: "bearer" }
+    },
+    schemas: componentSchemas
+  },
+  paths: {
+    "/healthz": {
+      get: {
+        operationId: "getHealth",
+        security: [],
+        responses: { 200: jsonResponse("Deployment health", "Health") }
+      }
+    },
+    "/livez": {
+      get: {
+        operationId: "getLiveness",
+        security: [],
+        responses: { 200: jsonResponse("Process liveness", "Liveness") }
+      }
+    },
+    "/readyz": {
+      get: {
+        operationId: "getReadiness",
+        security: [],
+        responses: {
+          200: jsonResponse("Ready", "Readiness"),
+          503: jsonResponse("Not ready", "Readiness")
+        }
+      }
+    },
+    "/~help": {
+      get: {
+        operationId: "getRootHelp",
+        security: bearerSecurity,
+        parameters: [{
+          in: "query",
+          name: "schemas",
+          schema: { type: "string", enum: ["1"] }
+        }],
+        responses: { 200: jsonResponse("Root HTBP help", "Help"), ...errorResponses }
+      }
+    },
+    "/{path}/~help": {
+      get: {
+        "operationId": "getHelp",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, {
+          in: "query",
+          name: "schemas",
+          schema: { type: "string", enum: ["1"] }
+        }],
+        "responses": { 200: jsonResponse("HTBP help", "Help"), ...errorResponses },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/~tree": {
+      get: {
+        operationId: "getRootTree",
+        security: bearerSecurity,
+        parameters: [{ in: "query", name: "depth", schema: { type: "integer", minimum: 1, maximum: 8 } }],
+        responses: { 200: jsonResponse("Root tree", "Tree"), ...errorResponses }
+      }
+    },
+    "/{path}/~tree": {
+      get: {
+        "operationId": "getTree",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, {
+          in: "query",
+          name: "depth",
+          schema: { type: "integer", minimum: 1, maximum: 8 }
+        }],
+        "responses": { 200: jsonResponse("Subtree", "Tree"), ...errorResponses },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/~search": {
+      post: {
+        operationId: "searchTools",
+        security: bearerSecurity,
+        requestBody: { required: true, content: jsonContent("SearchRequest") },
+        responses: { 200: jsonResponse("Visible tool page", "SearchResponse"), ...errorResponses }
+      }
+    },
+    "/{path}/~authorize": {
+      post: {
+        "operationId": "startOAuthAuthorization",
+        "security": bearerSecurity,
+        "parameters": [pathParameter],
+        "requestBody": { required: false, content: jsonContent("OAuthAuthorizeRequest") },
+        "responses": {
+          200: jsonResponse("Authorization status or redirect", "OAuthAuthorizeResponse"),
+          ...errorResponses
+        },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/{path}/~register": {
+      post: {
+        "operationId": "registerNode",
+        "security": bearerSecurity,
+        "parameters": [pathParameter],
+        "requestBody": { required: true, content: jsonContent("NodeInput") },
+        "responses": {
+          200: jsonResponse("Registered node", "RegistryNode"),
+          ...errorResponses
+        },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/{path}/~feedback": {
+      get: {
+        "operationId": "listFeedback",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, {
+          in: "query",
+          name: "hidden",
+          schema: { type: "string", enum: ["1"] }
+        }],
+        "responses": { 200: jsonResponse("Feedback list", "FeedbackList"), ...errorResponses },
+        "x-tool-bridge-greedy-path": true
+      },
+      post: {
+        "operationId": "submitFeedback",
+        "security": bearerSecurity,
+        "parameters": [pathParameter],
+        "requestBody": { required: true, content: jsonContent("FeedbackSubmitRequest") },
+        "responses": {
+          200: jsonResponse("Submitted feedback", "FeedbackSubmitResponse"),
+          ...errorResponses
+        },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/{path}/~feedback/{id}": {
+      get: {
+        "operationId": "getFeedback",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, { in: "path", name: "id", required: true, schema: { type: "string" } }],
+        "responses": { 200: jsonResponse("Feedback detail", "FeedbackDetail"), ...errorResponses },
+        "x-tool-bridge-greedy-path": true
+      },
+      post: {
+        "operationId": "voteFeedback",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, { in: "path", name: "id", required: true, schema: { type: "string" } }],
+        "requestBody": { required: true, content: jsonContent("FeedbackVoteRequest") },
+        "responses": { 200: jsonResponse("Updated feedback", "FeedbackView"), ...errorResponses },
+        "x-tool-bridge-greedy-path": true
+      },
+      delete: {
+        "operationId": "removeFeedback",
+        "security": bearerSecurity,
+        "parameters": [pathParameter, { in: "path", name: "id", required: true, schema: { type: "string" } }],
+        "responses": {
+          200: jsonResponse("Feedback removed", "FeedbackRemoveResponse"),
+          ...errorResponses
+        },
+        "x-tool-bridge-greedy-path": true
+      }
+    },
+    "/{commandPath}": {
+      post: {
+        "operationId": "invoke",
+        "security": bearerSecurity,
+        "parameters": [{
+          in: "path",
+          name: "commandPath",
+          required: true,
+          schema: { type: "string" },
+          description: "Complete HTBP command path, including the command/tool leaf."
+        }],
+        "requestBody": {
+          required: true,
+          description: "Raw command arguments; there is no {tool, arguments} envelope.",
+          content: { "application/json": { schema: {} } }
+        },
+        "responses": {
+          200: {
+            description: "Raw JSON or Markdown according to Accept.",
+            content: {
+              "application/json": { schema: {} },
+              "text/markdown": { schema: { type: "string" } }
+            }
+          },
+          ...errorResponses
+        },
+        "x-tool-bridge-greedy-path": true
+      }
+    }
+  }
+};
+
 // ../app/src/paths.ts
 function scopeForCmd(mod, nodePath, cmd) {
   return mod.help(nodePath).cmds.find((c) => c.name === cmd);
@@ -36043,7 +36785,9 @@ function indexByParent(nodes) {
 }
 
 // ../app/src/routes/feedback.ts
-var feedbackJson = (value) => new Response(JSON.stringify(value), { headers: { "content-type": contentTypeFor("json") } });
+var feedbackJson = (schema, value) => new Response(JSON.stringify(schema.parse(value)), {
+  headers: { "content-type": contentTypeFor("json") }
+});
 async function handleFeedbackGet(c) {
   const target = splitFeedback(new URL(c.req.url).pathname);
   if (target === null || target.path === "") throw TBError.notFound("no such path");
@@ -36052,7 +36796,7 @@ async function handleFeedbackGet(c) {
   const fb = new FeedbackStore(c.get("store"));
   if (target.id !== void 0) {
     const e = await fb.get(target.path, target.id);
-    return feedbackJson({
+    return feedbackJson(feedbackDetailSchema, {
       id: e.id,
       path: target.path,
       title: e.title,
@@ -36066,7 +36810,7 @@ async function handleFeedbackGet(c) {
   }
   const views = await fb.listViews(target.path);
   const items = c.req.query("hidden") === "1" ? views : views.filter((v) => v.score > FEEDBACK_HIDE_SCORE);
-  return feedbackJson({ items });
+  return feedbackJson(feedbackListSchema, { items });
 }
 async function handleFeedbackPost(c, env) {
   const { searchSync } = env;
@@ -36088,23 +36832,32 @@ async function handleFeedbackPost(c, env) {
       await searchSync?.reconcileNodeQuietly(path, { feedback: entries, marker });
     });
     if (target.id !== void 0) {
-      const vote = body.vote;
-      if (vote !== "up" && vote !== "down" && vote !== "clear") {
+      const input2 = feedbackVoteRequestSchema.safeParse(body);
+      if (!input2.success) {
         throw new TBError("invalid_argument", `body.vote must be 'up' | 'down' | 'clear'`);
       }
-      return feedbackJson(await fb.vote(target.path, target.id, ctx.owner, vote));
+      return feedbackJson(
+        feedbackViewSchema,
+        await fb.vote(target.path, target.id, ctx.owner, input2.data.vote)
+      );
     }
-    if (typeof body.title !== "string" || typeof body.detail !== "string") {
+    const input = feedbackSubmitRequestSchema.safeParse(body);
+    if (!input.success) {
       throw new TBError("invalid_argument", "body must be { title: string, detail: string }");
     }
     await new NodeRegistryStore(store).resolve(target.path);
     const entry = await fb.submit(
       target.path,
-      { title: body.title, detail: body.detail },
+      input.data,
       ctx.owner,
       (/* @__PURE__ */ new Date()).toISOString()
     );
-    return feedbackJson({ id: entry.id, path: target.path, title: entry.title, at: entry.at });
+    return feedbackJson(feedbackSubmitResponseSchema, {
+      id: entry.id,
+      path: target.path,
+      title: entry.title,
+      at: entry.at
+    });
   } catch (error) {
     await searchSync?.abort(marker);
     throw error;
@@ -36130,12 +36883,12 @@ async function handleFeedbackDelete(c, env) {
     await searchSync?.abort(marker);
     throw error;
   }
-  return feedbackJson({ ok: true });
+  return feedbackJson(feedbackRemoveResponseSchema, { ok: true });
 }
 
 // ../app/src/responses.ts
 function tbErrorResponse(err) {
-  return new Response(JSON.stringify(err.toJSON()), {
+  return new Response(JSON.stringify(tbErrorBodySchema.parse(err.toJSON())), {
     status: err.httpStatus,
     headers: { "content-type": "application/json; charset=utf-8" }
   });
@@ -36172,7 +36925,7 @@ async function runHandler(fn) {
 }
 function renderHelp(model, rep) {
   if (rep === "json") {
-    return new Response(JSON.stringify(renderHelpJson(model)), {
+    return new Response(JSON.stringify(helpJsonSchema.parse(renderHelpJson(model))), {
       headers: { "content-type": contentTypeFor("json") }
     });
   }
@@ -36376,14 +37129,14 @@ async function authorizeToolNode(c, env, node, encryptionKey) {
     authRef: config.authRef,
     config: exported.oauth,
     encryptionKey,
-    fetcher: fetch,
+    fetcher: deps.providerOAuthFetch,
     nodePath: node.path,
     now: /* @__PURE__ */ new Date(),
     origin: deps.canonicalOrigin ?? new URL(c.req.url).origin,
     secrets: deps.secrets,
     store: deps.state
   });
-  return new Response(JSON.stringify(result), {
+  return new Response(JSON.stringify(oauthAuthorizeResponseSchema.parse(result)), {
     headers: { "content-type": contentTypeFor("json") }
   });
 }
@@ -36430,7 +37183,7 @@ async function handleRegister(c, env) {
   await invalidateProviderOAuth(store, body.path);
   await searchSync?.reconcileNodeQuietly(body.path, { marker });
   if (await refreshDynamicSearchNode(node, ctx, deps)) await searchSync?.abort(marker);
-  return new Response(JSON.stringify(node), {
+  return new Response(JSON.stringify(registryNodeSchema.parse(node)), {
     headers: { "content-type": contentTypeFor("json") }
   });
 }
@@ -36457,6 +37210,11 @@ async function handleAuthorize(c, env) {
   } catch {
     throw TBError.notFound("not found");
   }
+  const rawBody = await c.req.json().catch(() => ({}));
+  const body = oauthAuthorizeRequestSchema.safeParse(rawBody);
+  if (!body.success) {
+    throw new TBError("invalid_argument", "body only accepts optional redirectUri string");
+  }
   if (node.kind === "tool" && node.config?.kind === "tool") {
     return await authorizeToolNode(c, env, node, encKey);
   }
@@ -36466,8 +37224,7 @@ async function handleAuthorize(c, env) {
       `'${path}' \u65E2\u4E0D\u662F auth:'oauth' \u7684 mcp \u6302\u8F7D,\u4E5F\u4E0D\u662F\u58F0\u660E\u4E86 oauth \u7684 tool \u6302\u8F7D`
     );
   }
-  const body = await c.req.json().catch(() => null);
-  const redirectUri = body !== null && typeof body.redirectUri === "string" ? body.redirectUri : void 0;
+  const redirectUri = body.data.redirectUri;
   const result = await startMcpAuthorization({
     store,
     encryptionKey: encKey,
@@ -36476,7 +37233,7 @@ async function handleAuthorize(c, env) {
     origin: deps.canonicalOrigin ?? new URL(c.req.url).origin,
     ...redirectUri !== void 0 ? { redirectUri } : {}
   });
-  return new Response(JSON.stringify(result), {
+  return new Response(JSON.stringify(oauthAuthorizeResponseSchema.parse(result)), {
     headers: { "content-type": contentTypeFor("json") }
   });
 }
@@ -36538,6 +37295,137 @@ async function handleDescribe(c, env) {
   throw TBError.notFound(`no capabilities for kind '${node.kind}'`);
 }
 
+// ../app/src/routes/store.ts
+var SECRET_BODY_FIELDS = [
+  "callCapability",
+  "capability",
+  "uploadToken",
+  "shareToken"
+];
+function hideCapabilityFailure(error) {
+  if (isTBError(error) && error.code !== "permission_denied" && error.code !== "not_found") throw error;
+  throw TBError.notFound("not found");
+}
+async function jsonObject(c) {
+  const parsed = await c.req.json().catch(() => null);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new TBError("invalid_argument", "body must be a JSON object");
+  }
+  const body = parsed;
+  for (const field of SECRET_BODY_FIELDS) {
+    if (field in body) {
+      throw new TBError(
+        "invalid_argument",
+        `${field} is not accepted in the request body; use the dedicated capability header`
+      );
+    }
+  }
+  return body;
+}
+function requiredHeader(c, name) {
+  const value = c.req.header(name);
+  if (value === void 0 || value.trim() === "") {
+    throw new TBError("permission_denied", "Store capability is missing or invalid");
+  }
+  return value;
+}
+function uploadId(body) {
+  if (typeof body.uploadId !== "string" || body.uploadId.trim() === "") {
+    throw new TBError("invalid_argument", "uploadId must be a non-empty string");
+  }
+  return body.uploadId;
+}
+function registerStoreCapabilityRoutes(app, deps) {
+  app.post("/system/store/create_upload", async (c, next) => {
+    if (c.req.header(STORE_CALL_CAPABILITY_HEADER) === void 0) return await next();
+    return await runHandler(async () => {
+      await deps.ensureReady?.();
+      const body = await jsonObject(c);
+      const capability = requiredHeader(c, STORE_CALL_CAPABILITY_HEADER);
+      const result = await beginCapabilityUpload(
+        deps,
+        body,
+        capability,
+        resolveStoreRequestOrigin(c.req.url, deps.canonicalOrigin)
+      );
+      return c.json(result);
+    });
+  });
+  for (const command of ["complete_upload", "abort_upload"]) {
+    app.post(`/system/store/${command}`, async (c, next) => {
+      if (c.req.header(STORE_UPLOAD_HEADER) === void 0) return await next();
+      return await runHandler(async () => {
+        await deps.ensureReady?.();
+        const body = await jsonObject(c);
+        const token = requiredHeader(c, STORE_UPLOAD_HEADER);
+        const result = command === "complete_upload" ? await completeCapabilityUpload(deps, uploadId(body), token) : await abortCapabilityUpload(deps, uploadId(body), token);
+        return c.json(result);
+      });
+    });
+  }
+  app.put(
+    "/~store/uploads/:uploadId",
+    (c) => runHandler(async () => {
+      await deps.ensureReady?.();
+      const descriptor = await relayStoreUpload(
+        deps,
+        c.req.param("uploadId"),
+        requiredHeader(c, STORE_UPLOAD_HEADER),
+        c.req.raw.body
+      );
+      return c.json(descriptor);
+    })
+  );
+  app.get(
+    "/~store/refs/:token",
+    (c) => runHandler(async () => {
+      await deps.ensureReady?.();
+      const store = await defaultStoreRuntime(deps);
+      const payload = await verifyStoreRefToken(c.req.param("token"), store.tokenSecret);
+      if (payload === null || payload.exp * 1e3 <= Date.now()) {
+        throw TBError.notFound("not found");
+      }
+      let object2;
+      try {
+        object2 = await store.service.authorizeRead(storeUri(payload.objectId), {
+          admin: true
+        });
+      } catch (error) {
+        hideCapabilityFailure(error);
+      }
+      return await storeObjectResponse(store.objects, object2);
+    })
+  );
+  app.get(
+    "/~store/shares/:token",
+    (c) => runHandler(async () => {
+      await deps.ensureReady?.();
+      const token = c.req.param("token");
+      const store = await defaultStoreRuntime(deps);
+      let object2;
+      try {
+        const grant = await store.service.verifyShareToken(token);
+        const uri3 = storeUri(grant.objectId);
+        object2 = await store.service.authorizeSharedRead(uri3, token);
+      } catch (error) {
+        hideCapabilityFailure(error);
+      }
+      return await storeObjectResponse(store.objects, object2);
+    })
+  );
+}
+function rejectStoreCapabilityBodyFields(module, args) {
+  if (module !== "store") return;
+  for (const field of SECRET_BODY_FIELDS) {
+    if (field in args) {
+      throw new TBError(
+        "invalid_argument",
+        `${field} is not accepted in the request body; use the dedicated capability header`
+      );
+    }
+  }
+}
+
 // ../app/src/routes/publicRoutes.ts
 async function finishToolAuthorization(opts) {
   const config = opts.node.config;
@@ -36558,7 +37446,7 @@ async function finishToolAuthorization(opts) {
       codeVerifier: opts.verifier,
       config: exported.oauth,
       encryptionKey: opts.encryptionKey,
-      fetcher: fetch,
+      fetcher: opts.deps.providerOAuthFetch,
       nodePath: opts.node.path,
       now: /* @__PURE__ */ new Date(),
       origin: opts.origin,
@@ -36575,21 +37463,23 @@ function registerPublicRoutes(app, env) {
   app.get("/healthz", async (c) => {
     const catalog = deps.pluginCatalog;
     const digest = await env.pluginCatalogDigest();
-    return c.json({
+    return c.json(healthResponseSchema.parse({
       healthy: true,
       version: deps.version,
       ...catalog !== void 0 && digest !== void 0 ? { catalog: { count: Object.keys(catalog).length, digest } } : {}
-    });
+    }));
   });
-  app.get("/livez", (c) => c.json({ live: true }));
+  app.get("/livez", (c) => c.json(livenessResponseSchema.parse({ live: true })));
   app.get("/readyz", async (c) => {
     const probe = deps.readiness;
-    if (probe === void 0) return c.json({ checks: {}, ready: true });
+    if (probe === void 0) {
+      return c.json(readinessResponseSchema.parse({ checks: {}, ready: true }));
+    }
     try {
-      const report = await probe();
+      const report = readinessResponseSchema.parse(await probe());
       return c.json(report, report.ready ? 200 : 503);
     } catch {
-      return c.json({ checks: {}, ready: false }, 503);
+      return c.json(readinessResponseSchema.parse({ checks: {}, ready: false }), 503);
     }
   });
   app.get(
@@ -36749,7 +37639,11 @@ function registerSearchRoute(app, env) {
       if (opts.cursor !== void 0 && typeof opts.cursor !== "string") {
         throw new TBError("invalid_argument", "opts.cursor must be a string");
       }
-      const query = body.query.trim();
+      const wireRequest = toolSearchRequestSchema.parse({
+        query: body.query,
+        ...rawOpts === void 0 ? {} : { opts }
+      });
+      const query = wireRequest.query;
       await searchSync?.ensureReady();
       const ctx = c.get("ctx");
       const registry = new NodeRegistryStore(c.get("store"));
@@ -36827,7 +37721,7 @@ function registerSearchRoute(app, env) {
       }
       if (items.length === 0) responseCursor = void 0;
       const result = responseCursor === void 0 ? { items } : { items, cursor: responseCursor };
-      return new Response(JSON.stringify(result), {
+      return new Response(JSON.stringify(toolSearchPageSchema.parse(result)), {
         headers: { "content-type": contentTypeFor("json") }
       });
     })
@@ -37398,27 +38292,27 @@ async function handleInvoke(c, env) {
       throw new TBError("permission_denied", `readOnly \u6302\u8F7D\u62D2\u7EDD '${command}'`);
     }
     if (directUpload) {
-      const result3 = await createContextUploadGrant(
-        node,
-        cfg,
-        deps,
-        args2
+      const result3 = await dispatchContextUploadCmd(
+        args2,
+        (input) => createContextUploadGrant(node, cfg, deps, input)
       );
       return renderResult(result3, negotiate(c.req.header("accept")));
     }
     if (cfg.provider === "device-fs") {
+      const forwardedArgs = parseContextCmdArgs(command, args2);
       const result3 = await invokeDevice(deps, deviceIdForDeviceFs(cfg), {
         path: `fs/${command}`,
-        arguments: args2,
+        arguments: forwardedArgs,
         context: deviceCallContextFrom(ctx)
       });
       return renderResult(result3, negotiate(c.req.header("accept")));
     }
     const contextMarker = deviceMarkerOf(cfg.providerConfig);
     if (cfg.provider !== "r2" && cfg.provider !== "s3" && contextMarker !== null) {
+      const forwardedArgs = parseContextCmdArgs(command, args2);
       const result3 = await invokeDevice(deps, contextMarker.deviceId, {
         path: `${relativeDevicePath(node.path, contextMarker.mountPath)}/${command}`,
-        arguments: args2,
+        arguments: forwardedArgs,
         context: deviceCallContextFrom(ctx)
       });
       return renderResult(result3, negotiate(c.req.header("accept")));
@@ -37426,7 +38320,7 @@ async function handleInvoke(c, env) {
     if (cfg.provider !== "r2" && cfg.provider !== "s3") {
       const local = localContext(deps, node);
       if (local !== null) {
-        const result4 = await dispatchContextCmd(local, command, args2);
+        const result4 = await dispatchContextCmd2(local, command, args2);
         return renderResult(result4, negotiate(c.req.header("accept")));
       }
       const { manifest, export: exported } = await requirePluginExport(
@@ -37446,11 +38340,11 @@ async function handleInvoke(c, env) {
         ...cfg.authRef !== void 0 ? { upstreamAuthRef: cfg.authRef } : {},
         ...deps.pluginBindings !== void 0 ? { bindings: deps.pluginBindings } : {}
       });
-      const result3 = await dispatchContextCmd(provider2, command, args2);
+      const result3 = await dispatchContextCmd2(provider2, command, args2);
       return renderResult(result3, negotiate(c.req.header("accept")));
     }
     const provider = await contextProviderFor(node, cfg, deps, c.req.url);
-    const result2 = await dispatchContextCmd(provider, command, args2);
+    const result2 = await dispatchContextCmd2(provider, command, args2);
     return renderResult(result2, negotiate(c.req.header("accept")));
   }
   if (node.kind === "skillhub" && node.config?.kind === "skillhub") {
@@ -37468,7 +38362,7 @@ async function handleInvoke(c, env) {
       throw new TBError("permission_denied", `readOnly \u6302\u8F7D\u62D2\u7EDD '${command}'`);
     }
     const provider = await skillhubProviderFor(node, cfg, deps, c.req.url);
-    const result2 = await dispatchSkillhubCmd(provider, command, args2);
+    const result2 = await dispatchSkillhubCmd2(provider, command, args2);
     return renderResult(result2, negotiate(c.req.header("accept")));
   }
   if (node.kind !== "builtin" || node.config?.kind !== "builtin") {
@@ -37479,6 +38373,7 @@ async function handleInvoke(c, env) {
   if (!mod) throw TBError.unimplemented(`builtin module '${node.config.module}' not available`);
   const args = await readInvokeBody();
   const cmd = command;
+  rejectStoreCapabilityBodyFields(node.config.module, args);
   const spec = scopeForCmd(mod, node.path, cmd);
   if (!spec) throw new TBError("invalid_argument", `unknown cmd '${cmd}' on '${node.path}'`);
   if (!check(ctx, node.path, spec.scope).allow) {
@@ -37522,7 +38417,9 @@ async function handleInvoke(c, env) {
   const registryMarker = registryTarget === void 0 ? void 0 : await searchSync?.markNode(registryTarget);
   let result;
   try {
-    result = await mod.dispatch(cmd, args, ctx);
+    result = await mod.dispatch(cmd, args, ctx, {
+      requestOrigin: resolveStoreRequestOrigin(c.req.url, deps.canonicalOrigin)
+    });
   } catch (error) {
     await searchSync?.abort(registryMarker);
     await Promise.all(pluginMounts.map(async (mount) => await searchSync?.abort(mount.marker)));
@@ -37573,17 +38470,21 @@ async function handleInvoke(c, env) {
 // ../app/src/routes/env.ts
 function createRouteEnv(deps) {
   const searchSync = isMutableSearchIndex(deps.search) ? new SearchSynchronizer(deps.state, deps.search) : void 0;
-  const builtinsOf = (store) => createBuiltins(
-    buildDeps({
-      store,
-      secrets: deps.secrets,
-      version: deps.version,
-      allowInsecureHttp: deps.allowInsecureHttp,
-      remoteAllowlistBase: deps.remote.allowlist,
-      ...deps.pluginBindings !== void 0 ? { pluginBindings: deps.pluginBindings } : {},
-      ...deps.pluginCatalog !== void 0 ? { pluginCatalog: deps.pluginCatalog } : {}
-    })
-  );
+  const builtinsOf = (store) => {
+    const builtins = createBuiltins(
+      buildDeps({
+        store,
+        secrets: deps.secrets,
+        version: deps.version,
+        allowInsecureHttp: deps.allowInsecureHttp,
+        remoteAllowlistBase: deps.remote.allowlist,
+        ...deps.pluginBindings !== void 0 ? { pluginBindings: deps.pluginBindings } : {},
+        ...deps.pluginCatalog !== void 0 ? { pluginCatalog: deps.pluginCatalog } : {}
+      })
+    );
+    builtins.set("store", lazyDefaultStoreModule(deps));
+    return builtins;
+  };
   const globalSearchCapabilities = () => {
     const declared = new Set(deps.search?.capabilities ?? []);
     if (!declared.has("search")) return [];
@@ -37629,7 +38530,7 @@ async function handleHelp(c, env) {
   if (remote) return remote;
   const builtins = builtinsOf(store);
   const refresh = c.req.query("refresh") === "1";
-  const schemas = c.req.query("schemas") === "1";
+  const schemas2 = c.req.query("schemas") === "1";
   let node;
   try {
     node = await registry.get(path);
@@ -37638,14 +38539,14 @@ async function handleHelp(c, env) {
     if (toolModel !== null) return renderHelp(await enrichHelp(toolModel, path, store), rep);
     const cmdModel = await commandHelpModelFor(registry, ctx, builtins, deps, path, {
       refresh,
-      schemas
+      schemas: schemas2
     });
     if (cmdModel !== null) return renderHelp(await enrichHelp(cmdModel, path, store), rep);
     throw TBError.notFound("not found");
   }
   const model = await helpModelFor(node, registry, ctx, builtins, deps, {
     refresh,
-    schemas,
+    schemas: schemas2,
     now: (/* @__PURE__ */ new Date()).toISOString()
   });
   return renderHelp(await enrichHelp(model, path, store), rep);
@@ -37697,7 +38598,7 @@ async function handleTree(c, env) {
   });
   const rep = negotiate(c.req.header("accept"));
   if (rep === "json") {
-    return new Response(JSON.stringify(tree), {
+    return new Response(JSON.stringify(treeJsonSchema.parse(tree)), {
       headers: { "content-type": contentTypeFor("json") }
     });
   }
@@ -37724,6 +38625,7 @@ function createTbApp(deps) {
     if (secured !== response) c.res = secured;
   });
   registerPublicRoutes(app, env);
+  registerStoreCapabilityRoutes(app, deps);
   app.use("*", async (c, next) => {
     const store = deps.state;
     try {
@@ -38250,6 +39152,19 @@ var DeviceRouter = class _DeviceRouter {
   }
 };
 
+// src/objects.ts
+import {
+  link,
+  mkdir as mkdir2,
+  open,
+  readdir as readdir2,
+  realpath as realpath2,
+  rename,
+  rm as rm2,
+  stat as stat2
+} from "fs/promises";
+import { constants, mkdirSync } from "fs";
+
 // ../core/src/node/fsObjectStore.ts
 import { mkdir, readdir, readFile, realpath, rm, stat, writeFile } from "fs/promises";
 import { basename, dirname, join, resolve, sep } from "path";
@@ -38349,6 +39264,9 @@ var FsObjectStore = class {
       throw new TBError("invalid_argument", `\u975E\u6CD5 entry \u8DEF\u5F84 '${key}':\u672A\u77E5\u6839\u6216\u7F3A\u76F8\u5BF9\u8DEF\u5F84`);
     }
     await this.assertInRoot(r.root, r.full, key);
+    if (opts?.ifMatchEtag !== void 0 && opts.ifNoneMatch !== void 0) {
+      throw new TBError("invalid_argument", "ifMatchEtag \u4E0E ifNoneMatch \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+    }
     if (opts?.ifMatchEtag !== void 0) {
       const existing = await this.head(key);
       if (opts.ifMatchEtag !== existing?.etag) {
@@ -38357,7 +39275,14 @@ var FsObjectStore = class {
     }
     const bytes = await objectBodyToBytes(body);
     await mkdir(dirname(r.full), { recursive: true });
-    await writeFile(r.full, bytes);
+    try {
+      await writeFile(r.full, bytes, opts?.ifNoneMatch === "*" ? { flag: "wx" } : void 0);
+    } catch (e) {
+      if (opts?.ifNoneMatch === "*" && isErrnoCode(e, "EEXIST")) {
+        throw new TBError("conflict", `\u5BF9\u8C61\u5DF2\u5B58\u5728:'${key}'`);
+      }
+      throw e;
+    }
     const st = await stat(r.full);
     return this.metaOf(r.key, st);
   }
@@ -38491,9 +39416,14 @@ import { spawn as nodeSpawn } from "child_process";
 var SHELL_OUTPUT_LIMIT_BYTES = 1024 * 1024;
 
 // src/objects.ts
-import { mkdirSync } from "fs";
-import { join as join2 } from "path";
+import { dirname as dirname2, join as join2, sep as sep2 } from "path";
+import { randomUUID } from "crypto";
+import { Readable } from "stream";
 var INTERNAL_ROOT = "objects";
+var TEMP_PREFIX = ".tb-object-upload-";
+var STORE_KEY_PREFIX = `${DEFAULT_STORE_DRIVER_KEY_ROOT}/`;
+var STORE_STAGING_DIR = ".tb-store-staging-v1";
+var UPLOAD_TEMP_NAME_RE = /^\.tb-object-upload-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/i;
 function toInternal(key) {
   return `${INTERNAL_ROOT}/${key}`;
 }
@@ -38503,6 +39433,108 @@ function toExternal(key) {
 function externalMeta(meta) {
   return { ...meta, key: toExternal(meta.key) };
 }
+function isErrnoCode2(error, code) {
+  return typeof error === "object" && error !== null && error.code === code;
+}
+function isUploadTempKey(key) {
+  return key.split("/").some((segment) => segment.startsWith(TEMP_PREFIX));
+}
+async function writeChunk(handle, chunk) {
+  let offset = 0;
+  while (offset < chunk.byteLength) {
+    const { bytesWritten } = await handle.write(chunk, offset, chunk.byteLength - offset, null);
+    if (bytesWritten === 0) throw new Error("\u5BF9\u8C61\u4E34\u65F6\u6587\u4EF6\u5199\u5165\u672A\u53D6\u5F97\u8FDB\u5C55");
+    offset += bytesWritten;
+  }
+}
+async function writeStream(handle, stream) {
+  const reader = stream.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value !== void 0 && value.byteLength > 0) await writeChunk(handle, value);
+    }
+  } catch (error) {
+    try {
+      await reader.cancel?.(error);
+    } catch {
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function writeBody(handle, body) {
+  if (typeof body === "string") {
+    await writeChunk(handle, Buffer.from(body));
+    return;
+  }
+  if (body instanceof Uint8Array) {
+    await writeChunk(handle, body);
+    return;
+  }
+  if (body instanceof ArrayBuffer) {
+    await writeChunk(handle, new Uint8Array(body));
+    return;
+  }
+  await writeStream(handle, body);
+}
+async function assertParentInRoot(root, full, key) {
+  const rootReal = await realpath2(root);
+  const parentReal = await realpath2(dirname2(full));
+  if (parentReal !== rootReal && !parentReal.startsWith(rootReal + sep2)) {
+    throw new TBError("invalid_argument", `\u975E\u6CD5 entry \u8DEF\u5F84 '${key}':symlink \u9003\u9038\u6839\u76EE\u5F55`);
+  }
+}
+async function assertAncestorInRoot(root, full, key) {
+  const rootReal = await realpath2(root);
+  let probe = dirname2(full);
+  for (; ; ) {
+    try {
+      const ancestorReal = await realpath2(probe);
+      if (ancestorReal !== rootReal && !ancestorReal.startsWith(rootReal + sep2)) {
+        throw new TBError("invalid_argument", `\u975E\u6CD5 entry \u8DEF\u5F84 '${key}':symlink \u9003\u9038\u6839\u76EE\u5F55`);
+      }
+      return;
+    } catch (error) {
+      if (error instanceof TBError) throw error;
+      if (!isErrnoCode2(error, "ENOENT")) throw error;
+      const parent = dirname2(probe);
+      if (parent === probe) {
+        throw new TBError("invalid_argument", `\u975E\u6CD5 entry \u8DEF\u5F84 '${key}':symlink \u9003\u9038\u6839\u76EE\u5F55`);
+      }
+      probe = parent;
+    }
+  }
+}
+async function cleanupStagingTree(dir, cutoffMs) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isErrnoCode2(error, "ENOENT")) return 0;
+    throw error;
+  }
+  let deleted = 0;
+  for (const entry of entries) {
+    const path = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      deleted += await cleanupStagingTree(path, cutoffMs);
+      continue;
+    }
+    if (!entry.isFile() || !UPLOAD_TEMP_NAME_RE.test(entry.name)) continue;
+    try {
+      const info = await stat2(path);
+      if (info.mtimeMs > cutoffMs) continue;
+      await rm2(path);
+      deleted++;
+    } catch (error) {
+      if (!isErrnoCode2(error, "ENOENT")) throw error;
+    }
+  }
+  return deleted;
+}
 function createDataObjectStore(dataDir) {
   const root = join2(dataDir, INTERNAL_ROOT);
   mkdirSync(root, { recursive: true });
@@ -38513,11 +39545,77 @@ function createDataObjectStore(dataDir) {
       return meta === null ? null : externalMeta(meta);
     },
     async get(key) {
-      const got = await fs.get(toInternal(key));
-      return got === null ? null : { meta: externalMeta(got.meta), body: got.body };
+      const normalizedKey = normalizeEntryPath(key);
+      const meta = await fs.head(toInternal(normalizedKey));
+      if (meta === null) return null;
+      const finalPath = join2(root, ...normalizedKey.split("/"));
+      let handle;
+      try {
+        handle = await open(finalPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+      } catch (error) {
+        if (isErrnoCode2(error, "ENOENT")) return null;
+        if (isErrnoCode2(error, "ELOOP")) {
+          throw new TBError("invalid_argument", `\u975E\u6CD5 entry \u8DEF\u5F84 '${key}':symlink \u9003\u9038\u6839\u76EE\u5F55`);
+        }
+        throw error;
+      }
+      const body = Readable.toWeb(handle.createReadStream());
+      return { meta: externalMeta(meta), body };
     },
     async put(key, body, opts) {
-      return externalMeta(await fs.put(toInternal(key), body, opts));
+      const normalizedKey = normalizeEntryPath(key);
+      const internalKey = toInternal(normalizedKey);
+      const finalPath = join2(root, ...normalizedKey.split("/"));
+      const existing = await fs.head(internalKey);
+      if (opts?.ifMatchEtag !== void 0 && opts.ifNoneMatch !== void 0) {
+        throw new TBError("invalid_argument", "ifMatchEtag \u4E0E ifNoneMatch \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+      }
+      if (opts?.ifMatchEtag !== void 0) {
+        if (opts.ifMatchEtag !== existing?.etag) {
+          throw new TBError("conflict", `etag \u4E0D\u5339\u914D:'${key}'`);
+        }
+      }
+      await assertAncestorInRoot(root, finalPath, key);
+      await mkdir2(dirname2(finalPath), { recursive: true });
+      await assertParentInRoot(root, finalPath, key);
+      const tempDir = normalizedKey.startsWith(STORE_KEY_PREFIX) ? join2(root, STORE_STAGING_DIR) : dirname2(finalPath);
+      await assertAncestorInRoot(root, join2(tempDir, "staging-probe"), key);
+      await mkdir2(tempDir, { recursive: true });
+      const tempPath = join2(tempDir, `${TEMP_PREFIX}${randomUUID()}.tmp`);
+      await assertParentInRoot(root, tempPath, key);
+      let handle;
+      try {
+        handle = await open(tempPath, "wx");
+        await writeBody(handle, body);
+        await handle.sync();
+        await handle.close();
+        handle = void 0;
+        if (opts?.ifNoneMatch === "*") {
+          try {
+            await link(tempPath, finalPath);
+          } catch (error) {
+            if (isErrnoCode2(error, "EEXIST")) {
+              throw new TBError("conflict", `\u5BF9\u8C61\u5DF2\u5B58\u5728:'${key}'`);
+            }
+            throw error;
+          }
+          await rm2(tempPath);
+        } else {
+          await rename(tempPath, finalPath);
+        }
+      } catch (error) {
+        if (handle !== void 0) {
+          try {
+            await handle.close();
+          } catch {
+          }
+        }
+        await rm2(tempPath, { force: true });
+        throw error;
+      }
+      const meta = await fs.head(internalKey);
+      if (meta === null) throw new TBError("unavailable", `\u5BF9\u8C61\u63D0\u4EA4\u540E\u4E0D\u53EF\u89C1:'${key}'`);
+      return externalMeta(meta);
     },
     async delete(key) {
       await fs.delete(toInternal(key));
@@ -38527,9 +39625,24 @@ function createDataObjectStore(dataDir) {
       return {
         items: result.items.map(
           (item) => "prefix" in item ? { prefix: toExternal(item.prefix) } : externalMeta(item)
-        ),
+        ).filter((item) => !isUploadTempKey("prefix" in item ? item.prefix : item.key)),
         ...result.cursor !== void 0 ? { cursor: result.cursor } : {}
       };
+    },
+    async cleanupStaging(prefix, olderThan) {
+      const cutoffMs = Date.parse(olderThan);
+      if (!Number.isFinite(cutoffMs)) {
+        throw new TBError("invalid_argument", "cleanupStaging olderThan \u5FC5\u987B\u662F ISO timestamp");
+      }
+      const normalizedPrefix = normalizeEntryPath(prefix.replace(/\/+$/, ""));
+      const isDefaultStore = normalizedPrefix === STORE_KEY_PREFIX.slice(0, -1);
+      const prefixDir = isDefaultStore ? join2(root, STORE_STAGING_DIR) : join2(root, ...normalizedPrefix.split("/"));
+      await assertAncestorInRoot(root, join2(prefixDir, "staging-probe"), prefix);
+      if (isDefaultStore) {
+        await mkdir2(prefixDir, { recursive: true });
+        await assertParentInRoot(root, join2(prefixDir, "staging-probe"), prefix);
+      }
+      return await cleanupStagingTree(prefixDir, cutoffMs);
     }
   };
 }
@@ -38652,6 +39765,29 @@ var PgStateStore = class {
       ON CONFLICT (key) DO UPDATE SET value = excluded.value
     `;
   }
+  async compareAndSwap(key, expectedRevision, value) {
+    if (expectedRevision === null) {
+      if (value === null) return false;
+      const result2 = await this.sql`
+        INSERT INTO tb_kv (key, value) VALUES (${key}, ${this.sql.json(value)})
+        ON CONFLICT (key) DO NOTHING
+      `;
+      return result2.count > 0;
+    }
+    if (!Number.isInteger(expectedRevision) || expectedRevision < 0) return false;
+    const predicate = this.sql`
+      key = ${key}
+      AND jsonb_typeof(value) = 'object'
+      AND jsonb_typeof(value -> 'revision') = 'number'
+      AND (value ->> 'revision') ~ '^(0|[1-9][0-9]*)$'
+      AND (value ->> 'revision')::numeric = ${expectedRevision}
+    `;
+    const result = value === null ? await this.sql`DELETE FROM tb_kv WHERE ${predicate}` : await this.sql`
+          UPDATE tb_kv SET value = ${this.sql.json(value)}
+          WHERE ${predicate}
+        `;
+    return result.count > 0;
+  }
   async putIfAbsent(key, value) {
     const result = await this.sql`
       INSERT INTO tb_kv (key, value) VALUES (${key}, ${this.sql.json(value)})
@@ -38834,6 +39970,20 @@ var SqliteStateStore = class {
   async put(key, value) {
     this.stmtPut.run(key, JSON.stringify(value));
   }
+  async compareAndSwap(key, expectedRevision, value) {
+    if (expectedRevision === null) {
+      if (value === null) return false;
+      const info2 = this.db.prepare("INSERT OR IGNORE INTO kv (key, value) VALUES (?, ?)").run(key, JSON.stringify(value));
+      return info2.changes > 0;
+    }
+    if (!Number.isInteger(expectedRevision) || expectedRevision < 0) return false;
+    const predicate = `key = ?
+      AND json_type(value) = 'object'
+      AND json_type(value, '$.revision') = 'integer'
+      AND json_extract(value, '$.revision') = ?`;
+    const info = value === null ? this.db.prepare(`DELETE FROM kv WHERE ${predicate}`).run(key, expectedRevision) : this.db.prepare(`UPDATE kv SET value = ? WHERE ${predicate}`).run(JSON.stringify(value), key, expectedRevision);
+    return info.changes > 0;
+  }
   async putIfAbsent(key, value) {
     const info = this.db.prepare("INSERT OR IGNORE INTO kv (key, value) VALUES (?, ?)").run(key, JSON.stringify(value));
     return info.changes > 0;
@@ -38881,7 +40031,7 @@ import { join as join4 } from "path";
 // package.json
 var package_default = {
   name: "@tool-bridge/server",
-  version: "0.15.0",
+  version: "0.17.0",
   description: "tool-bridge self-hosted server: run the HTBP gateway on Node with SQLite or PostgreSQL persistence, filesystem object storage and WebSocket device channel \u2014 single container via docker run",
   type: "module",
   license: "MIT",
@@ -38954,7 +40104,7 @@ var package_default = {
 
 // src/assets.ts
 import { brotliCompressSync, gzipSync, constants as zlibConstants } from "zlib";
-import { dirname as dirname2, join as join3, resolve as resolve2, sep as sep2 } from "path";
+import { dirname as dirname3, join as join3, resolve as resolve2, sep as sep3 } from "path";
 import { readFile as readFile2 } from "fs/promises";
 import { createRequire } from "module";
 import { existsSync } from "fs";
@@ -38987,7 +40137,7 @@ function resolveUiDir(uiDirOverride) {
   try {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@tool-bridge/dashboard/package.json");
-    const dist = join3(dirname2(pkgPath), "dist");
+    const dist = join3(dirname3(pkgPath), "dist");
     return existsSync(join3(dist, "index.html")) ? dist : void 0;
   } catch {
     return void 0;
@@ -39014,7 +40164,7 @@ function uiAssetsFetcher(uiDir) {
     let pathname = decodeURIComponent(url2.pathname);
     if (pathname.endsWith("/")) pathname += "index.html";
     const full = resolve2(join3(root, pathname));
-    if (full !== root && !full.startsWith(root + sep2)) {
+    if (full !== root && !full.startsWith(root + sep3)) {
       return new Response("not found", { status: 404 });
     }
     let asset = cache.get(full);
@@ -39063,6 +40213,7 @@ function resolveUiAssets(uiDirOverride) {
 }
 
 // src/server.ts
+var providerOAuthFetch = createGuardedFetch({ crossOriginRedirect: "error" });
 function pgBackends(databaseUrl) {
   const sql = postgres(databaseUrl, { onnotice: () => {
   } });
@@ -39176,6 +40327,7 @@ function createTbServer(config) {
   const deps = {
     state,
     secrets,
+    providerOAuthFetch,
     version: package_default.version,
     remote: config.remote,
     search,
@@ -39196,8 +40348,49 @@ function createTbServer(config) {
   if (config.uploadGrantTtlSec !== void 0) {
     deps.uploadGrantTtlSec = config.uploadGrantTtlSec;
   }
+  if (config.storeTokenSecret !== void 0) deps.storeTokenSecret = config.storeTokenSecret;
+  if (config.storeMaxObjectBytes !== void 0) {
+    deps.storeMaxObjectBytes = config.storeMaxObjectBytes;
+  }
+  if (config.storeRelayMaxBytes !== void 0) {
+    deps.storeRelayMaxBytes = config.storeRelayMaxBytes;
+  }
+  if (config.storeUploadTtlSec !== void 0) deps.storeUploadTtlSec = config.storeUploadTtlSec;
+  if (config.storeShareTtlSec !== void 0) deps.storeShareTtlSec = config.storeShareTtlSec;
+  if (config.storeReadTtlSec !== void 0) deps.storeReadTtlSec = config.storeReadTtlSec;
+  if (config.storeCallMaxBytes !== void 0) deps.storeCallMaxBytes = config.storeCallMaxBytes;
+  if (config.storeCallMaxObjectBytes !== void 0) {
+    deps.storeCallMaxObjectBytes = config.storeCallMaxObjectBytes;
+  }
+  if (config.storeCallMaxObjects !== void 0) {
+    deps.storeCallMaxObjects = config.storeCallMaxObjects;
+  }
+  if (config.storeCallAllowedContentTypes !== void 0) {
+    deps.storeCallAllowedContentTypes = config.storeCallAllowedContentTypes;
+  }
   const app = createTbApp(deps);
   let server;
+  let storeCleanupTimer;
+  let storeCleanupInFlight = false;
+  const runStoreCleanup = async () => {
+    if (storeCleanupInFlight) return;
+    storeCleanupInFlight = true;
+    try {
+      await cleanupDefaultStore(deps);
+    } finally {
+      storeCleanupInFlight = false;
+    }
+  };
+  const reportStoreCleanupFailure = () => {
+    console.warn(JSON.stringify({ event: "tool_bridge_store_cleanup_failed" }));
+  };
+  const scheduleStoreCleanup = () => {
+    void runStoreCleanup().catch(reportStoreCleanupFailure);
+    storeCleanupTimer = setInterval(() => {
+      void runStoreCleanup().catch(reportStoreCleanupFailure);
+    }, config.storeCleanupIntervalSec * 1e3);
+    storeCleanupTimer.unref?.();
+  };
   return {
     app,
     search,
@@ -39214,6 +40407,7 @@ function createTbServer(config) {
       await hub.sweepOrphans();
       return await new Promise((resolve3) => {
         server = serve({ fetch: app.fetch, port: config.port, hostname: config.host }, (info) => {
+          scheduleStoreCleanup();
           resolve3({ port: info.port });
         });
         hub.attach(server);
@@ -39224,6 +40418,10 @@ function createTbServer(config) {
     },
     async close() {
       draining = true;
+      if (storeCleanupTimer !== void 0) {
+        clearInterval(storeCleanupTimer);
+        storeCleanupTimer = void 0;
+      }
       let closed;
       if (server !== void 0) {
         const s = server;