@tool-bridge/server 0.15.0 → 0.16.0

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

@@ -3,6 +3,7 @@ import {
   CONTEXT_CAPABILITIES,
   CONTEXT_DIRECT_UPLOAD_CAPABILITY,
   DEFAULT_MAX_NODES,
+  DEFAULT_STORE_DRIVER_KEY_ROOT,
   DEVICE_CALL_TIMEOUT_MS,
   DeviceGatewaySession,
   FEEDBACK_HIDE_SCORE,
@@ -32,6 +33,7 @@ import {
   SKRegistryStore,
   SecretStoreImpl,
   SqlSearchIndex,
+  StoreService,
   TBError,
   TB_ERROR_CODES,
   TOOL_SEARCH_AUDIT_NODE_LIMIT,
@@ -79,6 +81,7 @@ import {
   createObjectContextProvider,
   createObjectContextUploadGrant,
   createSkillhubProvider,
+  createStoreModule,
   decodeDeviceFrame,
   derivePresence,
   deviceDirectoryHelpModel,
@@ -136,6 +139,7 @@ import {
   shouldRefresh,
   skillhubHelpModel,
   skillhubScopeForCmd,
+  storeUri,
   string,
   toJSONSchema,
   toolHelpModel,
@@ -146,12 +150,13 @@ import {
   url,
   validatePath,
   virtualizeTools
-} from "./chunk-DXXYNIXV.js";
+} from "./chunk-YB2FLNWI.js";
 
 // src/config.ts
 var DEFAULT_PORT = 8787;
 var DEFAULT_MAX_HOPS = 4;
 var DEFAULT_DEVICE_RECLAIM_SEC = 24 * 60 * 60;
+var DEFAULT_STORE_CLEANUP_INTERVAL_SEC = 15 * 60;
 function positiveIntEnv(value) {
   const n = Number(value);
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
@@ -183,6 +188,7 @@ function configFromEnv(env = process.env) {
       allowInsecure
     },
     deviceReclaimSec: positiveIntEnv(env.TB_DEVICE_RECLAIM_SEC) ?? DEFAULT_DEVICE_RECLAIM_SEC,
+    storeCleanupIntervalSec: positiveIntEnv(env.TB_STORE_CLEANUP_INTERVAL_SEC) ?? DEFAULT_STORE_CLEANUP_INTERVAL_SEC,
     // 0 合法(立即关停,本地/单机默认);positiveIntEnv 拒 0,故单独解析。
     shutdownDrainSec: (() => {
       const n = Number(env.TB_SHUTDOWN_DRAIN_SEC);
@@ -237,6 +243,34 @@ function configFromEnv(env = process.env) {
   if (refTtl !== void 0) config.refTtlSec = refTtl;
   const uploadGrantTtl = presignTtlEnv(env.TB_UPLOAD_GRANT_TTL_SEC);
   if (uploadGrantTtl !== void 0) config.uploadGrantTtlSec = uploadGrantTtl;
+  const storeMaxObjectBytes = positiveIntEnv(env.TB_STORE_MAX_OBJECT_BYTES);
+  if (storeMaxObjectBytes !== void 0) config.storeMaxObjectBytes = storeMaxObjectBytes;
+  const storeRelayMaxBytes = positiveIntEnv(env.TB_STORE_RELAY_MAX_BYTES);
+  if (storeRelayMaxBytes !== void 0) config.storeRelayMaxBytes = storeRelayMaxBytes;
+  const storeUploadTtlSec = presignTtlEnv(env.TB_STORE_UPLOAD_TTL_SEC);
+  if (storeUploadTtlSec !== void 0) config.storeUploadTtlSec = storeUploadTtlSec;
+  const storeShareTtlSec = presignTtlEnv(env.TB_STORE_SHARE_TTL_SEC);
+  if (storeShareTtlSec !== void 0) config.storeShareTtlSec = storeShareTtlSec;
+  const storeReadTtlSec = presignTtlEnv(env.TB_STORE_READ_TTL_SEC);
+  if (storeReadTtlSec !== void 0) config.storeReadTtlSec = storeReadTtlSec;
+  const storeCallMaxBytes = positiveIntEnv(env.TB_STORE_CALL_MAX_BYTES);
+  if (storeCallMaxBytes !== void 0) config.storeCallMaxBytes = storeCallMaxBytes;
+  const storeCallMaxObjectBytes = positiveIntEnv(env.TB_STORE_CALL_MAX_OBJECT_BYTES);
+  if (storeCallMaxObjectBytes !== void 0) {
+    config.storeCallMaxObjectBytes = storeCallMaxObjectBytes;
+  }
+  const storeCallMaxObjects = positiveIntEnv(env.TB_STORE_CALL_MAX_OBJECTS);
+  if (storeCallMaxObjects !== void 0) config.storeCallMaxObjects = storeCallMaxObjects;
+  const storeCallAllowedContentTypes = (env.TB_STORE_CALL_ALLOWED_CONTENT_TYPES ?? "").split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  if (storeCallAllowedContentTypes.length > 0) {
+    config.storeCallAllowedContentTypes = storeCallAllowedContentTypes;
+  }
+  if (env.TB_STORE_TOKEN_SECRET !== void 0 && env.TB_STORE_TOKEN_SECRET.length > 0) {
+    if (env.TB_STORE_TOKEN_SECRET.length < 16) {
+      throw new Error("TB_STORE_TOKEN_SECRET \u81F3\u5C11\u9700\u8981 16 \u4E2A\u5B57\u7B26");
+    }
+    config.storeTokenSecret = env.TB_STORE_TOKEN_SECRET;
+  }
   return config;
 }
 
@@ -439,7 +473,8 @@ var BUILTIN_MODULES = [
   "plugin",
   "catalog",
   "federation",
-  "annotation"
+  "annotation",
+  "store"
 ];
 var BUILTIN_DESCRIPTIONS = {
   sk: "SecretKey registry",
@@ -449,7 +484,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 +590,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(
@@ -602,12 +642,19 @@ function createS3ObjectStore(cfg, opts) {
     service: "s3",
     region: cfg.region ?? "auto"
   });
+  const putClient = new AwsClient({
+    accessKeyId: cfg.accessKeyId,
+    secretAccessKey: cfg.secretAccessKey,
+    service: "s3",
+    region: cfg.region ?? "auto",
+    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 +662,47 @@ 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);
+    }
+    const source = body;
+    const reader = source.getReader();
+    return new ReadableStream({
+      async pull(controller) {
+        try {
+          const chunk = await reader.read();
+          if (chunk.done) {
+            reader.releaseLock();
+            controller.close();
+          } else if (chunk.value !== void 0) {
+            controller.enqueue(chunk.value);
+          }
+        } catch (error) {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        try {
+          if (reader.cancel !== void 0) await reader.cancel(reason);
+          else await source.cancel?.(reason);
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+        }
+      }
+    }, { highWaterMark: 0 });
+  };
   const metaFromHeaders = (key, headers) => {
     const metadata = {};
     headers.forEach((value, name) => {
@@ -633,13 +721,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 +742,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 s3FetchWith(putClient, 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 +823,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 +1125,461 @@ 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 requestOrigin(runtime, deps) {
+  const raw = deps.canonicalOrigin ?? runtime?.requestOrigin;
+  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 });
+  }
+  return url2.origin;
+}
+function storeUploadGrant(start, origin2) {
+  const useRelay = start.alreadyCompleted || start.signedRequest === void 0;
+  const url2 = useRelay ? `${origin2}/~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, origin2) {
+  const store = await defaultStoreRuntime(deps);
+  const start = await store.service.beginCallUpload(input, capabilityToken);
+  return storeUploadGrant(start, origin2);
+}
+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 reader = got.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          reader.releaseLock();
+          controller.close();
+        } else if (chunk.value !== void 0) {
+          controller.enqueue(chunk.value);
+        }
+      } catch (error) {
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      try {
+        if (reader.cancel !== void 0) await reader.cancel(reason);
+        else await got.body.cancel?.(reason);
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+      }
+    }
+  });
+  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",
+    "driverObjects",
+    "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,
+    deletedOrphans: 0,
+    deletedStaging: 0,
+    expiredCallCapabilities: 0,
+    expiredIdempotencyBindings: 0,
+    expiredShares: 0,
+    expiredUploads: 0
+  };
+}
+function addCleanupResult(target, page) {
+  target.abandonedObjects += page.abandonedObjects;
+  target.deletedBytes += page.deletedBytes;
+  target.deletedOrphans += page.deletedOrphans;
+  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 +1592,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");
   }
@@ -7158,9 +7721,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 +7740,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 +7801,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 +7828,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 +7880,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 +7906,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 +7943,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 +7984,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 +8237,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 +8247,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) {
@@ -18725,8 +19288,8 @@ var GatewayMcpOAuthProvider = class {
   }
   get redirectUrl() {
     if (this.opts.redirectUri !== void 0) return this.opts.redirectUri;
-    const origin = this.opts.origin ?? "https://tool-bridge.invalid";
-    return `${origin}${OAUTH_CALLBACK_PATH}`;
+    const origin2 = this.opts.origin ?? "https://tool-bridge.invalid";
+    return `${origin2}${OAUTH_CALLBACK_PATH}`;
   }
   get clientMetadata() {
     return {
@@ -19608,7 +20171,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 +20185,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 +20202,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)
@@ -19750,11 +20313,11 @@ async function contextProviderFor(node, cfg, deps, requestUrl) {
   if (deps.refTtlSec !== void 0) opts.presignTtlSec = deps.refTtlSec;
   const encKey = deps.encryptionKey;
   if (encKey !== void 0) {
-    const origin = new URL(requestUrl).origin;
+    const origin2 = new URL(requestUrl).origin;
     const relayTtlSec = deps.refTtlSec ?? PRESIGN_TTL_SEC_DEFAULT;
     opts.relayRefUrl = async (key) => {
       const exp = Math.floor(Date.now() / 1e3) + relayTtlSec;
-      return `${origin}/~ref/${await signRefToken({ p: node.path, k: key, exp }, encKey)}`;
+      return `${origin2}/~ref/${await signRefToken({ p: node.path, k: key, exp }, encKey)}`;
     };
   }
   return createObjectContextProvider(objects, opts);
@@ -19775,11 +20338,11 @@ async function skillhubProviderFor(node, cfg, deps, requestUrl) {
   if (deps.refTtlSec !== void 0) opts.presignTtlSec = deps.refTtlSec;
   const encKey = deps.encryptionKey;
   if (encKey !== void 0) {
-    const origin = new URL(requestUrl).origin;
+    const origin2 = new URL(requestUrl).origin;
     const relayTtlSec = deps.refTtlSec ?? PRESIGN_TTL_SEC_DEFAULT;
     opts.relayRefUrl = async (key) => {
       const exp = Math.floor(Date.now() / 1e3) + relayTtlSec;
-      return `${origin}/~ref/${await signRefToken({ p: node.path, k: key, exp }, encKey)}`;
+      return `${origin2}/~ref/${await signRefToken({ p: node.path, k: key, exp }, encKey)}`;
     };
   }
   return createSkillhubProvider(objects, opts);
@@ -23282,8 +23845,8 @@ var LADDER_ERROR_HTTP_STATUS2 = {
   [ProtocolErrorCode2.MissingRequiredClientCapability]: 400,
   [HEADER_MISMATCH_ERROR_CODE2]: 400
 };
-function httpStatusForErrorCode(code, origin) {
-  if (origin === "in-band") return code === ProtocolErrorCode2.MissingRequiredClientCapability ? 400 : 200;
+function httpStatusForErrorCode(code, origin2) {
+  if (origin2 === "in-band") return code === ProtocolErrorCode2.MissingRequiredClientCapability ? 400 : 200;
   return LADDER_ERROR_HTTP_STATUS2[code] ?? 400;
 }
 function rejection(rung, cell, httpStatus, error, settled) {
@@ -25335,9 +25898,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 +25917,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 +25978,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 +26005,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 +26057,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 +26083,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 +26120,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 +26161,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 +26414,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 +26424,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) {
@@ -32091,9 +32654,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 +32712,7 @@ data: ${JSON.stringify({
       }
       if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
       abortCleanup?.();
-      open.delete(teardown);
+      open2.delete(teardown);
       try {
         controller.close();
       } catch {
@@ -32169,7 +32732,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 +32757,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;
     }
   };
 }
@@ -36538,6 +37101,147 @@ 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 origin(c, canonicalOrigin) {
+  let url2;
+  try {
+    url2 = new URL(canonicalOrigin ?? c.req.url);
+  } 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 });
+  return url2.origin;
+}
+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,
+        origin(c, 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;
@@ -37479,6 +38183,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 +38227,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: deps.canonicalOrigin ?? new URL(c.req.url).origin
+    });
   } catch (error) {
     await searchSync?.abort(registryMarker);
     await Promise.all(pluginMounts.map(async (mount) => await searchSync?.abort(mount.marker)));
@@ -37573,17 +38280,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 [];
@@ -37724,6 +38435,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 +38962,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 +39074,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 +39085,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 +39226,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 +39243,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 +39355,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 +39435,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 +39575,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 +39780,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 +39841,7 @@ import { join as join4 } from "path";
 // package.json
 var package_default = {
   name: "@tool-bridge/server",
-  version: "0.15.0",
+  version: "0.16.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 +39914,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 +39947,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 +39974,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);
@@ -39196,8 +40156,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 +40215,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 +40226,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;