@archipelagolab/lobi 1.0.0 → 1.0.5

package/dist/chunk-XQYIIPOJ.js

@@ -0,0 +1,266 @@
+import {
+  readResponseWithLimit
+} from "./chunk-FYRKBNTI.js";
+import {
+  MatrixMediaSizeLimitError
+} from "./chunk-Z6IVJ6ZW.js";
+import {
+  buildTimeoutAbortSignal,
+  closeDispatcher,
+  createPinnedDispatcher,
+  resolvePinnedHostnameWithPolicy
+} from "./chunk-L5OUVMHK.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/sdk/transport.ts
+init_shims();
+import {
+  fetchWithRuntimeDispatcher
+} from "openclaw/plugin-sdk/infra-runtime";
+function normalizeEndpoint(endpoint) {
+  if (!endpoint) {
+    return "/";
+  }
+  return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function applyQuery(url, qs) {
+  if (!qs) {
+    return;
+  }
+  for (const [key, rawValue] of Object.entries(qs)) {
+    if (rawValue === void 0 || rawValue === null) {
+      continue;
+    }
+    if (Array.isArray(rawValue)) {
+      for (const item of rawValue) {
+        if (item === void 0 || item === null) {
+          continue;
+        }
+        url.searchParams.append(key, String(item));
+      }
+      continue;
+    }
+    url.searchParams.set(key, String(rawValue));
+  }
+}
+function isRedirectStatus(statusCode) {
+  return statusCode >= 300 && statusCode < 400;
+}
+function toFetchUrl(resource) {
+  if (resource instanceof URL) {
+    return resource.toString();
+  }
+  if (typeof resource === "string") {
+    return resource;
+  }
+  return resource.url;
+}
+function buildBufferedResponse(params) {
+  const response = new Response(params.body, {
+    status: params.source.status,
+    statusText: params.source.statusText,
+    headers: new Headers(params.source.headers)
+  });
+  try {
+    Object.defineProperty(response, "url", {
+      value: params.source.url || params.url,
+      configurable: true
+    });
+  } catch {
+  }
+  return response;
+}
+function isMockedFetch(fetchImpl) {
+  if (typeof fetchImpl !== "function") {
+    return false;
+  }
+  return typeof fetchImpl.mock === "object";
+}
+async function fetchWithMatrixDispatcher(params) {
+  if (params.init.dispatcher && !isMockedFetch(globalThis.fetch)) {
+    return await fetchWithRuntimeDispatcher(params.url, params.init);
+  }
+  return await fetch(params.url, params.init);
+}
+async function fetchWithMatrixGuardedRedirects(params) {
+  let currentUrl = new URL(params.url);
+  let method = (params.init?.method ?? "GET").toUpperCase();
+  let body = params.init?.body;
+  let headers = new Headers(params.init?.headers ?? {});
+  const maxRedirects = 5;
+  const visited = /* @__PURE__ */ new Set();
+  const { signal, cleanup } = buildTimeoutAbortSignal({
+    timeoutMs: params.timeoutMs,
+    signal: params.signal
+  });
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+    let dispatcher;
+    try {
+      const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, {
+        policy: params.ssrfPolicy
+      });
+      dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);
+      const response = await fetchWithMatrixDispatcher({
+        url: currentUrl.toString(),
+        init: {
+          ...params.init,
+          method,
+          body,
+          headers,
+          redirect: "manual",
+          signal,
+          dispatcher
+        }
+      });
+      if (!isRedirectStatus(response.status)) {
+        return {
+          response,
+          release: async () => {
+            cleanup();
+            await closeDispatcher(dispatcher);
+          },
+          finalUrl: currentUrl.toString()
+        };
+      }
+      const location = response.headers.get("location");
+      if (!location) {
+        cleanup();
+        await closeDispatcher(dispatcher);
+        throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);
+      }
+      const nextUrl = new URL(location, currentUrl);
+      if (nextUrl.protocol !== currentUrl.protocol) {
+        cleanup();
+        await closeDispatcher(dispatcher);
+        throw new Error(
+          `Blocked cross-protocol redirect (${currentUrl.protocol} -> ${nextUrl.protocol})`
+        );
+      }
+      const nextUrlString = nextUrl.toString();
+      if (visited.has(nextUrlString)) {
+        cleanup();
+        await closeDispatcher(dispatcher);
+        throw new Error("Redirect loop detected");
+      }
+      visited.add(nextUrlString);
+      if (nextUrl.origin !== currentUrl.origin) {
+        headers = new Headers(headers);
+        headers.delete("authorization");
+      }
+      if (response.status === 303 || (response.status === 301 || response.status === 302) && method !== "GET" && method !== "HEAD") {
+        method = "GET";
+        body = void 0;
+        headers = new Headers(headers);
+        headers.delete("content-type");
+        headers.delete("content-length");
+      }
+      void response.body?.cancel();
+      await closeDispatcher(dispatcher);
+      currentUrl = nextUrl;
+    } catch (error) {
+      cleanup();
+      await closeDispatcher(dispatcher);
+      throw error;
+    }
+  }
+  cleanup();
+  throw new Error(`Too many redirects while requesting ${params.url}`);
+}
+function createMatrixGuardedFetch(params) {
+  return (async (resource, init) => {
+    const url = toFetchUrl(resource);
+    const { signal, ...requestInit } = init ?? {};
+    const { response, release } = await fetchWithMatrixGuardedRedirects({
+      url,
+      init: requestInit,
+      signal: signal ?? void 0,
+      ssrfPolicy: params.ssrfPolicy,
+      dispatcherPolicy: params.dispatcherPolicy
+    });
+    try {
+      const body = await response.arrayBuffer();
+      return buildBufferedResponse({
+        source: response,
+        body,
+        url
+      });
+    } finally {
+      await release();
+    }
+  });
+}
+async function performMatrixRequest(params) {
+  const isAbsoluteEndpoint = params.endpoint.startsWith("http://") || params.endpoint.startsWith("https://");
+  if (isAbsoluteEndpoint && params.allowAbsoluteEndpoint !== true) {
+    throw new Error(
+      `Absolute Matrix endpoint is blocked by default: ${params.endpoint}. Set allowAbsoluteEndpoint=true to opt in.`
+    );
+  }
+  const baseUrl = isAbsoluteEndpoint ? new URL(params.endpoint) : new URL(normalizeEndpoint(params.endpoint), params.homeserver);
+  applyQuery(baseUrl, params.qs);
+  const headers = new Headers();
+  headers.set("Accept", params.raw ? "*/*" : "application/json");
+  if (params.accessToken) {
+    headers.set("Authorization", `Bearer ${params.accessToken}`);
+  }
+  let body;
+  if (params.body !== void 0) {
+    if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") {
+      body = params.body;
+    } else {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(params.body);
+    }
+  }
+  const { response, release } = await fetchWithMatrixGuardedRedirects({
+    url: baseUrl.toString(),
+    init: {
+      method: params.method,
+      headers,
+      body
+    },
+    timeoutMs: params.timeoutMs,
+    ssrfPolicy: params.ssrfPolicy,
+    dispatcherPolicy: params.dispatcherPolicy
+  });
+  try {
+    if (params.raw) {
+      const contentLength = response.headers.get("content-length");
+      if (params.maxBytes && contentLength) {
+        const length = Number(contentLength);
+        if (Number.isFinite(length) && length > params.maxBytes) {
+          throw new MatrixMediaSizeLimitError(
+            `Matrix media exceeds configured size limit (${length} bytes > ${params.maxBytes} bytes)`
+          );
+        }
+      }
+      const bytes = params.maxBytes ? await readResponseWithLimit(response, params.maxBytes, {
+        onOverflow: ({ maxBytes, size }) => new MatrixMediaSizeLimitError(
+          `Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`
+        ),
+        chunkTimeoutMs: params.readIdleTimeoutMs
+      }) : Buffer.from(await response.arrayBuffer());
+      return {
+        response,
+        text: bytes.toString("utf8"),
+        buffer: bytes
+      };
+    }
+    const text = await response.text();
+    return {
+      response,
+      text,
+      buffer: Buffer.from(text, "utf8")
+    };
+  } finally {
+    await release();
+  }
+}
+
+export {
+  createMatrixGuardedFetch,
+  performMatrixRequest
+};
+//# sourceMappingURL=chunk-XQYIIPOJ.js.map

package/dist/chunk-XQYIIPOJ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/sdk/transport.ts"],
+  "sourcesContent": ["import {\n  fetchWithRuntimeDispatcher,\n  type PinnedDispatcherPolicy,\n} from \"openclaw/plugin-sdk/infra-runtime\";\nimport {\n  buildTimeoutAbortSignal,\n  closeDispatcher,\n  createPinnedDispatcher,\n  resolvePinnedHostnameWithPolicy,\n  type SsrFPolicy,\n} from \"../../runtime-api.js\";\nimport { MatrixMediaSizeLimitError } from \"../media-errors.js\";\nimport { readResponseWithLimit } from \"./read-response-with-limit.js\";\n\nexport type HttpMethod = \"GET\" | \"POST\" | \"PUT\" | \"DELETE\";\n\ntype QueryValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | Array<string | number | boolean | null | undefined>;\n\nexport type QueryParams = Record<string, QueryValue> | null | undefined;\n\ntype MatrixDispatcherRequestInit = RequestInit & {\n  dispatcher?: ReturnType<typeof createPinnedDispatcher>;\n};\n\nfunction normalizeEndpoint(endpoint: string): string {\n  if (!endpoint) {\n    return \"/\";\n  }\n  return endpoint.startsWith(\"/\") ? endpoint : `/${endpoint}`;\n}\n\nfunction applyQuery(url: URL, qs: QueryParams): void {\n  if (!qs) {\n    return;\n  }\n  for (const [key, rawValue] of Object.entries(qs)) {\n    if (rawValue === undefined || rawValue === null) {\n      continue;\n    }\n    if (Array.isArray(rawValue)) {\n      for (const item of rawValue) {\n        if (item === undefined || item === null) {\n          continue;\n        }\n        url.searchParams.append(key, String(item));\n      }\n      continue;\n    }\n    url.searchParams.set(key, String(rawValue));\n  }\n}\n\nfunction isRedirectStatus(statusCode: number): boolean {\n  return statusCode >= 300 && statusCode < 400;\n}\n\nfunction toFetchUrl(resource: RequestInfo | URL): string {\n  if (resource instanceof URL) {\n    return resource.toString();\n  }\n  if (typeof resource === \"string\") {\n    return resource;\n  }\n  return resource.url;\n}\n\nfunction buildBufferedResponse(params: {\n  source: Response;\n  body: ArrayBuffer;\n  url: string;\n}): Response {\n  const response = new Response(params.body, {\n    status: params.source.status,\n    statusText: params.source.statusText,\n    headers: new Headers(params.source.headers),\n  });\n  try {\n    Object.defineProperty(response, \"url\", {\n      value: params.source.url || params.url,\n      configurable: true,\n    });\n  } catch {\n    // Response.url is read-only in some runtimes; metadata is best-effort only.\n  }\n  return response;\n}\n\nfunction isMockedFetch(fetchImpl: typeof fetch | undefined): boolean {\n  if (typeof fetchImpl !== \"function\") {\n    return false;\n  }\n  return typeof (fetchImpl as typeof fetch & { mock?: unknown }).mock === \"object\";\n}\n\nasync function fetchWithMatrixDispatcher(params: {\n  url: string;\n  init: MatrixDispatcherRequestInit;\n}): Promise<Response> {\n  // Keep this dispatcher-routing logic local to Matrix transport. Shared SSRF\n  // fetches must stay fail-closed unless a retry path can preserve the\n  // validated pinned-address binding. Route dispatcher-attached requests\n  // through undici runtime fetch so the pinned dispatcher is preserved.\n  if (params.init.dispatcher && !isMockedFetch(globalThis.fetch)) {\n    return await fetchWithRuntimeDispatcher(params.url, params.init);\n  }\n  return await fetch(params.url, params.init);\n}\n\nasync function fetchWithMatrixGuardedRedirects(params: {\n  url: string;\n  init?: RequestInit;\n  signal?: AbortSignal;\n  timeoutMs?: number;\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n}): Promise<{ response: Response; release: () => Promise<void>; finalUrl: string }> {\n  let currentUrl = new URL(params.url);\n  let method = (params.init?.method ?? \"GET\").toUpperCase();\n  let body = params.init?.body;\n  let headers = new Headers(params.init?.headers ?? {});\n  const maxRedirects = 5;\n  const visited = new Set<string>();\n  const { signal, cleanup } = buildTimeoutAbortSignal({\n    timeoutMs: params.timeoutMs,\n    signal: params.signal,\n  });\n\n  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {\n    let dispatcher: ReturnType<typeof createPinnedDispatcher> | undefined;\n    try {\n      const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, {\n        policy: params.ssrfPolicy,\n      });\n      dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);\n      const response = await fetchWithMatrixDispatcher({\n        url: currentUrl.toString(),\n        init: {\n          ...params.init,\n          method,\n          body,\n          headers,\n          redirect: \"manual\",\n          signal,\n          dispatcher,\n        } as MatrixDispatcherRequestInit,\n      });\n\n      if (!isRedirectStatus(response.status)) {\n        return {\n          response,\n          release: async () => {\n            cleanup();\n            await closeDispatcher(dispatcher);\n          },\n          finalUrl: currentUrl.toString(),\n        };\n      }\n\n      const location = response.headers.get(\"location\");\n      if (!location) {\n        cleanup();\n        await closeDispatcher(dispatcher);\n        throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);\n      }\n\n      const nextUrl = new URL(location, currentUrl);\n      if (nextUrl.protocol !== currentUrl.protocol) {\n        cleanup();\n        await closeDispatcher(dispatcher);\n        throw new Error(\n          `Blocked cross-protocol redirect (${currentUrl.protocol} -> ${nextUrl.protocol})`,\n        );\n      }\n\n      const nextUrlString = nextUrl.toString();\n      if (visited.has(nextUrlString)) {\n        cleanup();\n        await closeDispatcher(dispatcher);\n        throw new Error(\"Redirect loop detected\");\n      }\n      visited.add(nextUrlString);\n\n      if (nextUrl.origin !== currentUrl.origin) {\n        headers = new Headers(headers);\n        headers.delete(\"authorization\");\n      }\n\n      if (\n        response.status === 303 ||\n        ((response.status === 301 || response.status === 302) &&\n          method !== \"GET\" &&\n          method !== \"HEAD\")\n      ) {\n        method = \"GET\";\n        body = undefined;\n        headers = new Headers(headers);\n        headers.delete(\"content-type\");\n        headers.delete(\"content-length\");\n      }\n\n      void response.body?.cancel();\n      await closeDispatcher(dispatcher);\n      currentUrl = nextUrl;\n    } catch (error) {\n      cleanup();\n      await closeDispatcher(dispatcher);\n      throw error;\n    }\n  }\n\n  cleanup();\n  throw new Error(`Too many redirects while requesting ${params.url}`);\n}\n\nexport function createMatrixGuardedFetch(params: {\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n}): typeof fetch {\n  return (async (resource: RequestInfo | URL, init?: RequestInit) => {\n    const url = toFetchUrl(resource);\n    const { signal, ...requestInit } = init ?? {};\n    const { response, release } = await fetchWithMatrixGuardedRedirects({\n      url,\n      init: requestInit,\n      signal: signal ?? undefined,\n      ssrfPolicy: params.ssrfPolicy,\n      dispatcherPolicy: params.dispatcherPolicy,\n    });\n\n    try {\n      const body = await response.arrayBuffer();\n      return buildBufferedResponse({\n        source: response,\n        body,\n        url,\n      });\n    } finally {\n      await release();\n    }\n  }) as typeof fetch;\n}\n\nexport async function performMatrixRequest(params: {\n  homeserver: string;\n  accessToken: string;\n  method: HttpMethod;\n  endpoint: string;\n  qs?: QueryParams;\n  body?: unknown;\n  timeoutMs: number;\n  raw?: boolean;\n  maxBytes?: number;\n  readIdleTimeoutMs?: number;\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n  allowAbsoluteEndpoint?: boolean;\n}): Promise<{ response: Response; text: string; buffer: Buffer }> {\n  const isAbsoluteEndpoint =\n    params.endpoint.startsWith(\"http://\") || params.endpoint.startsWith(\"https://\");\n  if (isAbsoluteEndpoint && params.allowAbsoluteEndpoint !== true) {\n    throw new Error(\n      `Absolute Matrix endpoint is blocked by default: ${params.endpoint}. Set allowAbsoluteEndpoint=true to opt in.`,\n    );\n  }\n\n  const baseUrl = isAbsoluteEndpoint\n    ? new URL(params.endpoint)\n    : new URL(normalizeEndpoint(params.endpoint), params.homeserver);\n  applyQuery(baseUrl, params.qs);\n\n  const headers = new Headers();\n  headers.set(\"Accept\", params.raw ? \"*/*\" : \"application/json\");\n  if (params.accessToken) {\n    headers.set(\"Authorization\", `Bearer ${params.accessToken}`);\n  }\n\n  let body: BodyInit | undefined;\n  if (params.body !== undefined) {\n    if (\n      params.body instanceof Uint8Array ||\n      params.body instanceof ArrayBuffer ||\n      typeof params.body === \"string\"\n    ) {\n      body = params.body as BodyInit;\n    } else {\n      headers.set(\"Content-Type\", \"application/json\");\n      body = JSON.stringify(params.body);\n    }\n  }\n\n  const { response, release } = await fetchWithMatrixGuardedRedirects({\n    url: baseUrl.toString(),\n    init: {\n      method: params.method,\n      headers,\n      body,\n    },\n    timeoutMs: params.timeoutMs,\n    ssrfPolicy: params.ssrfPolicy,\n    dispatcherPolicy: params.dispatcherPolicy,\n  });\n\n  try {\n    if (params.raw) {\n      const contentLength = response.headers.get(\"content-length\");\n      if (params.maxBytes && contentLength) {\n        const length = Number(contentLength);\n        if (Number.isFinite(length) && length > params.maxBytes) {\n          throw new MatrixMediaSizeLimitError(\n            `Matrix media exceeds configured size limit (${length} bytes > ${params.maxBytes} bytes)`,\n          );\n        }\n      }\n      const bytes = params.maxBytes\n        ? await readResponseWithLimit(response, params.maxBytes, {\n            onOverflow: ({ maxBytes, size }) =>\n              new MatrixMediaSizeLimitError(\n                `Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`,\n              ),\n            chunkTimeoutMs: params.readIdleTimeoutMs,\n          })\n        : Buffer.from(await response.arrayBuffer());\n      return {\n        response,\n        text: bytes.toString(\"utf8\"),\n        buffer: bytes,\n      };\n    }\n    const text = await response.text();\n    return {\n      response,\n      text,\n      buffer: Buffer.from(text, \"utf8\"),\n    };\n  } finally {\n    await release();\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,EACE;AAAA,OAEK;AA2BP,SAAS,kBAAkB,UAA0B;AACnD,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AACA,SAAO,SAAS,WAAW,GAAG,IAAI,WAAW,IAAI,QAAQ;AAC3D;AAEA,SAAS,WAAW,KAAU,IAAuB;AACnD,MAAI,CAAC,IAAI;AACP;AAAA,EACF;AACA,aAAW,CAAC,KAAK,QAAQ,KAAK,OAAO,QAAQ,EAAE,GAAG;AAChD,QAAI,aAAa,UAAa,aAAa,MAAM;AAC/C;AAAA,IACF;AACA,QAAI,MAAM,QAAQ,QAAQ,GAAG;AAC3B,iBAAW,QAAQ,UAAU;AAC3B,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC;AAAA,QACF;AACA,YAAI,aAAa,OAAO,KAAK,OAAO,IAAI,CAAC;AAAA,MAC3C;AACA;AAAA,IACF;AACA,QAAI,aAAa,IAAI,KAAK,OAAO,QAAQ,CAAC;AAAA,EAC5C;AACF;AAEA,SAAS,iBAAiB,YAA6B;AACrD,SAAO,cAAc,OAAO,aAAa;AAC3C;AAEA,SAAS,WAAW,UAAqC;AACvD,MAAI,oBAAoB,KAAK;AAC3B,WAAO,SAAS,SAAS;AAAA,EAC3B;AACA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AACA,SAAO,SAAS;AAClB;AAEA,SAAS,sBAAsB,QAIlB;AACX,QAAM,WAAW,IAAI,SAAS,OAAO,MAAM;AAAA,IACzC,QAAQ,OAAO,OAAO;AAAA,IACtB,YAAY,OAAO,OAAO;AAAA,IAC1B,SAAS,IAAI,QAAQ,OAAO,OAAO,OAAO;AAAA,EAC5C,CAAC;AACD,MAAI;AACF,WAAO,eAAe,UAAU,OAAO;AAAA,MACrC,OAAO,OAAO,OAAO,OAAO,OAAO;AAAA,MACnC,cAAc;AAAA,IAChB,CAAC;AAAA,EACH,QAAQ;AAAA,EAER;AACA,SAAO;AACT;AAEA,SAAS,cAAc,WAA8C;AACnE,MAAI,OAAO,cAAc,YAAY;AACnC,WAAO;AAAA,EACT;AACA,SAAO,OAAQ,UAAgD,SAAS;AAC1E;AAEA,eAAe,0BAA0B,QAGnB;AAKpB,MAAI,OAAO,KAAK,cAAc,CAAC,cAAc,WAAW,KAAK,GAAG;AAC9D,WAAO,MAAM,2BAA2B,OAAO,KAAK,OAAO,IAAI;AAAA,EACjE;AACA,SAAO,MAAM,MAAM,OAAO,KAAK,OAAO,IAAI;AAC5C;AAEA,eAAe,gCAAgC,QAOqC;AAClF,MAAI,aAAa,IAAI,IAAI,OAAO,GAAG;AACnC,MAAI,UAAU,OAAO,MAAM,UAAU,OAAO,YAAY;AACxD,MAAI,OAAO,OAAO,MAAM;AACxB,MAAI,UAAU,IAAI,QAAQ,OAAO,MAAM,WAAW,CAAC,CAAC;AACpD,QAAM,eAAe;AACrB,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,EAAE,QAAQ,QAAQ,IAAI,wBAAwB;AAAA,IAClD,WAAW,OAAO;AAAA,IAClB,QAAQ,OAAO;AAAA,EACjB,CAAC;AAED,WAAS,gBAAgB,GAAG,iBAAiB,cAAc,iBAAiB,GAAG;AAC7E,QAAI;AACJ,QAAI;AACF,YAAM,SAAS,MAAM,gCAAgC,WAAW,UAAU;AAAA,QACxE,QAAQ,OAAO;AAAA,MACjB,CAAC;AACD,mBAAa,uBAAuB,QAAQ,OAAO,kBAAkB,OAAO,UAAU;AACtF,YAAM,WAAW,MAAM,0BAA0B;AAAA,QAC/C,KAAK,WAAW,SAAS;AAAA,QACzB,MAAM;AAAA,UACJ,GAAG,OAAO;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA,UAAU;AAAA,UACV;AAAA,UACA;AAAA,QACF;AAAA,MACF,CAAC;AAED,UAAI,CAAC,iBAAiB,SAAS,MAAM,GAAG;AACtC,eAAO;AAAA,UACL;AAAA,UACA,SAAS,YAAY;AACnB,oBAAQ;AACR,kBAAM,gBAAgB,UAAU;AAAA,UAClC;AAAA,UACA,UAAU,WAAW,SAAS;AAAA,QAChC;AAAA,MACF;AAEA,YAAM,WAAW,SAAS,QAAQ,IAAI,UAAU;AAChD,UAAI,CAAC,UAAU;AACb,gBAAQ;AACR,cAAM,gBAAgB,UAAU;AAChC,cAAM,IAAI,MAAM,4CAA4C,WAAW,SAAS,CAAC,GAAG;AAAA,MACtF;AAEA,YAAM,UAAU,IAAI,IAAI,UAAU,UAAU;AAC5C,UAAI,QAAQ,aAAa,WAAW,UAAU;AAC5C,gBAAQ;AACR,cAAM,gBAAgB,UAAU;AAChC,cAAM,IAAI;AAAA,UACR,oCAAoC,WAAW,QAAQ,OAAO,QAAQ,QAAQ;AAAA,QAChF;AAAA,MACF;AAEA,YAAM,gBAAgB,QAAQ,SAAS;AACvC,UAAI,QAAQ,IAAI,aAAa,GAAG;AAC9B,gBAAQ;AACR,cAAM,gBAAgB,UAAU;AAChC,cAAM,IAAI,MAAM,wBAAwB;AAAA,MAC1C;AACA,cAAQ,IAAI,aAAa;AAEzB,UAAI,QAAQ,WAAW,WAAW,QAAQ;AACxC,kBAAU,IAAI,QAAQ,OAAO;AAC7B,gBAAQ,OAAO,eAAe;AAAA,MAChC;AAEA,UACE,SAAS,WAAW,QAClB,SAAS,WAAW,OAAO,SAAS,WAAW,QAC/C,WAAW,SACX,WAAW,QACb;AACA,iBAAS;AACT,eAAO;AACP,kBAAU,IAAI,QAAQ,OAAO;AAC7B,gBAAQ,OAAO,cAAc;AAC7B,gBAAQ,OAAO,gBAAgB;AAAA,MACjC;AAEA,WAAK,SAAS,MAAM,OAAO;AAC3B,YAAM,gBAAgB,UAAU;AAChC,mBAAa;AAAA,IACf,SAAS,OAAO;AACd,cAAQ;AACR,YAAM,gBAAgB,UAAU;AAChC,YAAM;AAAA,IACR;AAAA,EACF;AAEA,UAAQ;AACR,QAAM,IAAI,MAAM,uCAAuC,OAAO,GAAG,EAAE;AACrE;AAEO,SAAS,yBAAyB,QAGxB;AACf,UAAQ,OAAO,UAA6B,SAAuB;AACjE,UAAM,MAAM,WAAW,QAAQ;AAC/B,UAAM,EAAE,QAAQ,GAAG,YAAY,IAAI,QAAQ,CAAC;AAC5C,UAAM,EAAE,UAAU,QAAQ,IAAI,MAAM,gCAAgC;AAAA,MAClE;AAAA,MACA,MAAM;AAAA,MACN,QAAQ,UAAU;AAAA,MAClB,YAAY,OAAO;AAAA,MACnB,kBAAkB,OAAO;AAAA,IAC3B,CAAC;AAED,QAAI;AACF,YAAM,OAAO,MAAM,SAAS,YAAY;AACxC,aAAO,sBAAsB;AAAA,QAC3B,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,UAAE;AACA,YAAM,QAAQ;AAAA,IAChB;AAAA,EACF;AACF;AAEA,eAAsB,qBAAqB,QAcuB;AAChE,QAAM,qBACJ,OAAO,SAAS,WAAW,SAAS,KAAK,OAAO,SAAS,WAAW,UAAU;AAChF,MAAI,sBAAsB,OAAO,0BAA0B,MAAM;AAC/D,UAAM,IAAI;AAAA,MACR,mDAAmD,OAAO,QAAQ;AAAA,IACpE;AAAA,EACF;AAEA,QAAM,UAAU,qBACZ,IAAI,IAAI,OAAO,QAAQ,IACvB,IAAI,IAAI,kBAAkB,OAAO,QAAQ,GAAG,OAAO,UAAU;AACjE,aAAW,SAAS,OAAO,EAAE;AAE7B,QAAM,UAAU,IAAI,QAAQ;AAC5B,UAAQ,IAAI,UAAU,OAAO,MAAM,QAAQ,kBAAkB;AAC7D,MAAI,OAAO,aAAa;AACtB,YAAQ,IAAI,iBAAiB,UAAU,OAAO,WAAW,EAAE;AAAA,EAC7D;AAEA,MAAI;AACJ,MAAI,OAAO,SAAS,QAAW;AAC7B,QACE,OAAO,gBAAgB,cACvB,OAAO,gBAAgB,eACvB,OAAO,OAAO,SAAS,UACvB;AACA,aAAO,OAAO;AAAA,IAChB,OAAO;AACL,cAAQ,IAAI,gBAAgB,kBAAkB;AAC9C,aAAO,KAAK,UAAU,OAAO,IAAI;AAAA,IACnC;AAAA,EACF;AAEA,QAAM,EAAE,UAAU,QAAQ,IAAI,MAAM,gCAAgC;AAAA,IAClE,KAAK,QAAQ,SAAS;AAAA,IACtB,MAAM;AAAA,MACJ,QAAQ,OAAO;AAAA,MACf;AAAA,MACA;AAAA,IACF;AAAA,IACA,WAAW,OAAO;AAAA,IAClB,YAAY,OAAO;AAAA,IACnB,kBAAkB,OAAO;AAAA,EAC3B,CAAC;AAED,MAAI;AACF,QAAI,OAAO,KAAK;AACd,YAAM,gBAAgB,SAAS,QAAQ,IAAI,gBAAgB;AAC3D,UAAI,OAAO,YAAY,eAAe;AACpC,cAAM,SAAS,OAAO,aAAa;AACnC,YAAI,OAAO,SAAS,MAAM,KAAK,SAAS,OAAO,UAAU;AACvD,gBAAM,IAAI;AAAA,YACR,+CAA+C,MAAM,YAAY,OAAO,QAAQ;AAAA,UAClF;AAAA,QACF;AAAA,MACF;AACA,YAAM,QAAQ,OAAO,WACjB,MAAM,sBAAsB,UAAU,OAAO,UAAU;AAAA,QACrD,YAAY,CAAC,EAAE,UAAU,KAAK,MAC5B,IAAI;AAAA,UACF,+CAA+C,IAAI,YAAY,QAAQ;AAAA,QACzE;AAAA,QACF,gBAAgB,OAAO;AAAA,MACzB,CAAC,IACD,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC;AAC5C,aAAO;AAAA,QACL;AAAA,QACA,MAAM,MAAM,SAAS,MAAM;AAAA,QAC3B,QAAQ;AAAA,MACV;AAAA,IACF;AACA,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,QAAQ,OAAO,KAAK,MAAM,MAAM;AAAA,IAClC;AAAA,EACF,UAAE;AACA,UAAM,QAAQ;AAAA,EAChB;AACF;",
+  "names": []
+}

package/dist/chunk-XZSAN55E.js

@@ -0,0 +1,58 @@
+import {
+  normalizeMatrixAllowList,
+  resolveMatrixAllowListMatch
+} from "./chunk-AH4MLRYT.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/monitor/access-state.ts
+init_shims();
+function resolveMatrixMonitorAccessState(params) {
+  const effectiveAllowFrom = normalizeMatrixAllowList([
+    ...params.allowFrom,
+    ...params.storeAllowFrom
+  ]);
+  const effectiveGroupAllowFrom = normalizeMatrixAllowList(params.groupAllowFrom);
+  const effectiveRoomUsers = normalizeMatrixAllowList(params.roomUsers);
+  const directAllowMatch = resolveMatrixAllowListMatch({
+    allowList: effectiveAllowFrom,
+    userId: params.senderId
+  });
+  const roomUserMatch = params.isRoom && effectiveRoomUsers.length > 0 ? resolveMatrixAllowListMatch({
+    allowList: effectiveRoomUsers,
+    userId: params.senderId
+  }) : null;
+  const groupAllowMatch = effectiveGroupAllowFrom.length > 0 ? resolveMatrixAllowListMatch({
+    allowList: effectiveGroupAllowFrom,
+    userId: params.senderId
+  }) : null;
+  return {
+    effectiveAllowFrom,
+    effectiveGroupAllowFrom,
+    effectiveRoomUsers,
+    groupAllowConfigured: effectiveGroupAllowFrom.length > 0,
+    directAllowMatch,
+    roomUserMatch,
+    groupAllowMatch,
+    commandAuthorizers: [
+      {
+        configured: effectiveAllowFrom.length > 0,
+        allowed: directAllowMatch.allowed
+      },
+      {
+        configured: effectiveRoomUsers.length > 0,
+        allowed: roomUserMatch?.allowed ?? false
+      },
+      {
+        configured: effectiveGroupAllowFrom.length > 0,
+        allowed: groupAllowMatch?.allowed ?? false
+      }
+    ]
+  };
+}
+
+export {
+  resolveMatrixMonitorAccessState
+};
+//# sourceMappingURL=chunk-XZSAN55E.js.map

package/dist/chunk-XZSAN55E.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/monitor/access-state.ts"],
+  "sourcesContent": ["import { normalizeMatrixAllowList, resolveMatrixAllowListMatch } from \"./allowlist.js\";\nimport type { MatrixAllowListMatch } from \"./allowlist.js\";\n\ntype MatrixCommandAuthorizer = {\n  configured: boolean;\n  allowed: boolean;\n};\n\nexport type MatrixMonitorAccessState = {\n  effectiveAllowFrom: string[];\n  effectiveGroupAllowFrom: string[];\n  effectiveRoomUsers: string[];\n  groupAllowConfigured: boolean;\n  directAllowMatch: MatrixAllowListMatch;\n  roomUserMatch: MatrixAllowListMatch | null;\n  groupAllowMatch: MatrixAllowListMatch | null;\n  commandAuthorizers: [MatrixCommandAuthorizer, MatrixCommandAuthorizer, MatrixCommandAuthorizer];\n};\n\nexport function resolveMatrixMonitorAccessState(params: {\n  allowFrom: Array<string | number>;\n  storeAllowFrom: Array<string | number>;\n  groupAllowFrom: Array<string | number>;\n  roomUsers: Array<string | number>;\n  senderId: string;\n  isRoom: boolean;\n}): MatrixMonitorAccessState {\n  const effectiveAllowFrom = normalizeMatrixAllowList([\n    ...params.allowFrom,\n    ...params.storeAllowFrom,\n  ]);\n  const effectiveGroupAllowFrom = normalizeMatrixAllowList(params.groupAllowFrom);\n  const effectiveRoomUsers = normalizeMatrixAllowList(params.roomUsers);\n\n  const directAllowMatch = resolveMatrixAllowListMatch({\n    allowList: effectiveAllowFrom,\n    userId: params.senderId,\n  });\n  const roomUserMatch =\n    params.isRoom && effectiveRoomUsers.length > 0\n      ? resolveMatrixAllowListMatch({\n          allowList: effectiveRoomUsers,\n          userId: params.senderId,\n        })\n      : null;\n  const groupAllowMatch =\n    effectiveGroupAllowFrom.length > 0\n      ? resolveMatrixAllowListMatch({\n          allowList: effectiveGroupAllowFrom,\n          userId: params.senderId,\n        })\n      : null;\n\n  return {\n    effectiveAllowFrom,\n    effectiveGroupAllowFrom,\n    effectiveRoomUsers,\n    groupAllowConfigured: effectiveGroupAllowFrom.length > 0,\n    directAllowMatch,\n    roomUserMatch,\n    groupAllowMatch,\n    commandAuthorizers: [\n      {\n        configured: effectiveAllowFrom.length > 0,\n        allowed: directAllowMatch.allowed,\n      },\n      {\n        configured: effectiveRoomUsers.length > 0,\n        allowed: roomUserMatch?.allowed ?? false,\n      },\n      {\n        configured: effectiveGroupAllowFrom.length > 0,\n        allowed: groupAllowMatch?.allowed ?? false,\n      },\n    ],\n  };\n}\n"],
+  "mappings": ";;;;;;;;;AAAA;AAmBO,SAAS,gCAAgC,QAOnB;AAC3B,QAAM,qBAAqB,yBAAyB;AAAA,IAClD,GAAG,OAAO;AAAA,IACV,GAAG,OAAO;AAAA,EACZ,CAAC;AACD,QAAM,0BAA0B,yBAAyB,OAAO,cAAc;AAC9E,QAAM,qBAAqB,yBAAyB,OAAO,SAAS;AAEpE,QAAM,mBAAmB,4BAA4B;AAAA,IACnD,WAAW;AAAA,IACX,QAAQ,OAAO;AAAA,EACjB,CAAC;AACD,QAAM,gBACJ,OAAO,UAAU,mBAAmB,SAAS,IACzC,4BAA4B;AAAA,IAC1B,WAAW;AAAA,IACX,QAAQ,OAAO;AAAA,EACjB,CAAC,IACD;AACN,QAAM,kBACJ,wBAAwB,SAAS,IAC7B,4BAA4B;AAAA,IAC1B,WAAW;AAAA,IACX,QAAQ,OAAO;AAAA,EACjB,CAAC,IACD;AAEN,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,sBAAsB,wBAAwB,SAAS;AAAA,IACvD;AAAA,IACA;AAAA,IACA;AAAA,IACA,oBAAoB;AAAA,MAClB;AAAA,QACE,YAAY,mBAAmB,SAAS;AAAA,QACxC,SAAS,iBAAiB;AAAA,MAC5B;AAAA,MACA;AAAA,QACE,YAAY,mBAAmB,SAAS;AAAA,QACxC,SAAS,eAAe,WAAW;AAAA,MACrC;AAAA,MACA;AAAA,QACE,YAAY,wBAAwB,SAAS;AAAA,QAC7C,SAAS,iBAAiB,WAAW;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/chunk-Y3KJR4OG.js

@@ -0,0 +1,64 @@
+import {
+  resolveMatrixAccountConfig
+} from "./chunk-HP5HMWOM.js";
+import {
+  getMatrixRuntime
+} from "./chunk-FHNEN6IR.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/send/client.ts
+init_shims();
+var getCore = () => getMatrixRuntime();
+var matrixSendClientRuntimePromise = null;
+async function loadMatrixSendClientRuntime() {
+  matrixSendClientRuntimePromise ??= import("./src/matrix/client-bootstrap.js");
+  return await matrixSendClientRuntimePromise;
+}
+function resolveMediaMaxBytes(accountId, cfg) {
+  const resolvedCfg = cfg ?? getCore().config.loadConfig();
+  const matrixCfg = resolveMatrixAccountConfig({ cfg: resolvedCfg, accountId });
+  const mediaMaxMb = typeof matrixCfg.mediaMaxMb === "number" ? matrixCfg.mediaMaxMb : void 0;
+  if (typeof mediaMaxMb === "number") {
+    return mediaMaxMb * 1024 * 1024;
+  }
+  return void 0;
+}
+async function withResolvedMatrixSendClient(opts, run) {
+  return await withResolvedMatrixClient(
+    {
+      ...opts,
+      // One-off outbound sends still need a started client so room encryption
+      // state and live crypto sessions are available before sendMessage/sendEvent.
+      readiness: "started"
+    },
+    run,
+    // Started one-off send clients should flush sync/crypto state before CLI
+    // shutdown paths can tear down the process.
+    "persist"
+  );
+}
+async function withResolvedMatrixControlClient(opts, run) {
+  return await withResolvedMatrixClient(
+    {
+      ...opts,
+      readiness: "none"
+    },
+    run
+  );
+}
+async function withResolvedMatrixClient(opts, run, shutdownBehavior) {
+  if (opts.client) {
+    return await run(opts.client);
+  }
+  const { withResolvedRuntimeMatrixClient } = await loadMatrixSendClientRuntime();
+  return await withResolvedRuntimeMatrixClient(opts, run, shutdownBehavior);
+}
+
+export {
+  resolveMediaMaxBytes,
+  withResolvedMatrixSendClient,
+  withResolvedMatrixControlClient
+};
+//# sourceMappingURL=chunk-Y3KJR4OG.js.map

package/dist/chunk-Y3KJR4OG.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/send/client.ts"],
+  "sourcesContent": ["import { getMatrixRuntime } from \"../../runtime.js\";\nimport type { CoreConfig } from \"../../types.js\";\nimport { resolveMatrixAccountConfig } from \"../account-config.js\";\nimport type { MatrixClient } from \"../sdk.js\";\n\nconst getCore = () => getMatrixRuntime();\n\ntype MatrixSendClientRuntime = Pick<\n  typeof import(\"../client-bootstrap.js\"),\n  \"withResolvedRuntimeMatrixClient\"\n>;\n\nlet matrixSendClientRuntimePromise: Promise<MatrixSendClientRuntime> | null = null;\n\nasync function loadMatrixSendClientRuntime(): Promise<MatrixSendClientRuntime> {\n  matrixSendClientRuntimePromise ??= import(\"../client-bootstrap.js\");\n  return await matrixSendClientRuntimePromise;\n}\n\nexport function resolveMediaMaxBytes(\n  accountId?: string | null,\n  cfg?: CoreConfig,\n): number | undefined {\n  const resolvedCfg = cfg ?? (getCore().config.loadConfig() as CoreConfig);\n  const matrixCfg = resolveMatrixAccountConfig({ cfg: resolvedCfg, accountId });\n  const mediaMaxMb = typeof matrixCfg.mediaMaxMb === \"number\" ? matrixCfg.mediaMaxMb : undefined;\n  if (typeof mediaMaxMb === \"number\") {\n    return mediaMaxMb * 1024 * 1024;\n  }\n  return undefined;\n}\n\nexport async function withResolvedMatrixSendClient<T>(\n  opts: {\n    client?: MatrixClient;\n    cfg?: CoreConfig;\n    timeoutMs?: number;\n    accountId?: string | null;\n  },\n  run: (client: MatrixClient) => Promise<T>,\n): Promise<T> {\n  return await withResolvedMatrixClient(\n    {\n      ...opts,\n      // One-off outbound sends still need a started client so room encryption\n      // state and live crypto sessions are available before sendMessage/sendEvent.\n      readiness: \"started\",\n    },\n    run,\n    // Started one-off send clients should flush sync/crypto state before CLI\n    // shutdown paths can tear down the process.\n    \"persist\",\n  );\n}\n\nexport async function withResolvedMatrixControlClient<T>(\n  opts: {\n    client?: MatrixClient;\n    cfg?: CoreConfig;\n    timeoutMs?: number;\n    accountId?: string | null;\n  },\n  run: (client: MatrixClient) => Promise<T>,\n): Promise<T> {\n  return await withResolvedMatrixClient(\n    {\n      ...opts,\n      readiness: \"none\",\n    },\n    run,\n  );\n}\n\nasync function withResolvedMatrixClient<T>(\n  opts: {\n    client?: MatrixClient;\n    cfg?: CoreConfig;\n    timeoutMs?: number;\n    accountId?: string | null;\n    readiness: \"started\" | \"none\";\n  },\n  run: (client: MatrixClient) => Promise<T>,\n  shutdownBehavior?: \"persist\",\n): Promise<T> {\n  if (opts.client) {\n    return await run(opts.client);\n  }\n  const { withResolvedRuntimeMatrixClient } = await loadMatrixSendClientRuntime();\n  return await withResolvedRuntimeMatrixClient(opts, run, shutdownBehavior);\n}\n"],
+  "mappings": ";;;;;;;;;;;AAAA;AAKA,IAAM,UAAU,MAAM,iBAAiB;AAOvC,IAAI,iCAA0E;AAE9E,eAAe,8BAAgE;AAC7E,qCAAmC,OAAO,kCAAwB;AAClE,SAAO,MAAM;AACf;AAEO,SAAS,qBACd,WACA,KACoB;AACpB,QAAM,cAAc,OAAQ,QAAQ,EAAE,OAAO,WAAW;AACxD,QAAM,YAAY,2BAA2B,EAAE,KAAK,aAAa,UAAU,CAAC;AAC5E,QAAM,aAAa,OAAO,UAAU,eAAe,WAAW,UAAU,aAAa;AACrF,MAAI,OAAO,eAAe,UAAU;AAClC,WAAO,aAAa,OAAO;AAAA,EAC7B;AACA,SAAO;AACT;AAEA,eAAsB,6BACpB,MAMA,KACY;AACZ,SAAO,MAAM;AAAA,IACX;AAAA,MACE,GAAG;AAAA;AAAA;AAAA,MAGH,WAAW;AAAA,IACb;AAAA,IACA;AAAA;AAAA;AAAA,IAGA;AAAA,EACF;AACF;AAEA,eAAsB,gCACpB,MAMA,KACY;AACZ,SAAO,MAAM;AAAA,IACX;AAAA,MACE,GAAG;AAAA,MACH,WAAW;AAAA,IACb;AAAA,IACA;AAAA,EACF;AACF;AAEA,eAAe,yBACb,MAOA,KACA,kBACY;AACZ,MAAI,KAAK,QAAQ;AACf,WAAO,MAAM,IAAI,KAAK,MAAM;AAAA,EAC9B;AACA,QAAM,EAAE,gCAAgC,IAAI,MAAM,4BAA4B;AAC9E,SAAO,MAAM,gCAAgC,MAAM,KAAK,gBAAgB;AAC1E;",
+  "names": []
+}

package/dist/chunk-Y4JKH7FF.js

@@ -0,0 +1,45 @@
+import {
+  summarizeMatrixDeviceHealth
+} from "./chunk-2Q626TDO.js";
+import {
+  withStartedActionClient
+} from "./chunk-Y6CJN4ID.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/actions/devices.ts
+init_shims();
+async function listMatrixOwnDevices(opts = {}) {
+  return await withStartedActionClient(opts, async (client) => await client.listOwnDevices());
+}
+async function pruneMatrixStaleGatewayDevices(opts = {}) {
+  return await withStartedActionClient(opts, async (client) => {
+    const devices = await client.listOwnDevices();
+    const health = summarizeMatrixDeviceHealth(devices);
+    const staleGatewayDeviceIds = health.staleOpenClawDevices.map((device) => device.deviceId);
+    const deleted = staleGatewayDeviceIds.length > 0 ? await client.deleteOwnDevices(staleGatewayDeviceIds) : {
+      currentDeviceId: devices.find((device) => device.current)?.deviceId ?? null,
+      deletedDeviceIds: [],
+      remainingDevices: devices
+    };
+    return {
+      before: devices,
+      staleGatewayDeviceIds,
+      ...deleted
+    };
+  });
+}
+async function getMatrixDeviceHealth(opts = {}) {
+  return await withStartedActionClient(
+    opts,
+    async (client) => summarizeMatrixDeviceHealth(await client.listOwnDevices())
+  );
+}
+
+export {
+  listMatrixOwnDevices,
+  pruneMatrixStaleGatewayDevices,
+  getMatrixDeviceHealth
+};
+//# sourceMappingURL=chunk-Y4JKH7FF.js.map

package/dist/chunk-Y4JKH7FF.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/actions/devices.ts"],
+  "sourcesContent": ["import { summarizeMatrixDeviceHealth } from \"../device-health.js\";\nimport { withStartedActionClient } from \"./client.js\";\nimport type { MatrixActionClientOpts } from \"./types.js\";\n\nexport async function listMatrixOwnDevices(opts: MatrixActionClientOpts = {}) {\n  return await withStartedActionClient(opts, async (client) => await client.listOwnDevices());\n}\n\nexport async function pruneMatrixStaleGatewayDevices(opts: MatrixActionClientOpts = {}) {\n  return await withStartedActionClient(opts, async (client) => {\n    const devices = await client.listOwnDevices();\n    const health = summarizeMatrixDeviceHealth(devices);\n    const staleGatewayDeviceIds = health.staleOpenClawDevices.map((device) => device.deviceId);\n    const deleted =\n      staleGatewayDeviceIds.length > 0\n        ? await client.deleteOwnDevices(staleGatewayDeviceIds)\n        : {\n            currentDeviceId: devices.find((device) => device.current)?.deviceId ?? null,\n            deletedDeviceIds: [] as string[],\n            remainingDevices: devices,\n          };\n    return {\n      before: devices,\n      staleGatewayDeviceIds,\n      ...deleted,\n    };\n  });\n}\n\nexport async function getMatrixDeviceHealth(opts: MatrixActionClientOpts = {}) {\n  return await withStartedActionClient(opts, async (client) =>\n    summarizeMatrixDeviceHealth(await client.listOwnDevices()),\n  );\n}\n"],
+  "mappings": ";;;;;;;;;;;AAAA;AAIA,eAAsB,qBAAqB,OAA+B,CAAC,GAAG;AAC5E,SAAO,MAAM,wBAAwB,MAAM,OAAO,WAAW,MAAM,OAAO,eAAe,CAAC;AAC5F;AAEA,eAAsB,+BAA+B,OAA+B,CAAC,GAAG;AACtF,SAAO,MAAM,wBAAwB,MAAM,OAAO,WAAW;AAC3D,UAAM,UAAU,MAAM,OAAO,eAAe;AAC5C,UAAM,SAAS,4BAA4B,OAAO;AAClD,UAAM,wBAAwB,OAAO,qBAAqB,IAAI,CAAC,WAAW,OAAO,QAAQ;AACzF,UAAM,UACJ,sBAAsB,SAAS,IAC3B,MAAM,OAAO,iBAAiB,qBAAqB,IACnD;AAAA,MACE,iBAAiB,QAAQ,KAAK,CAAC,WAAW,OAAO,OAAO,GAAG,YAAY;AAAA,MACvE,kBAAkB,CAAC;AAAA,MACnB,kBAAkB;AAAA,IACpB;AACN,WAAO;AAAA,MACL,QAAQ;AAAA,MACR;AAAA,MACA,GAAG;AAAA,IACL;AAAA,EACF,CAAC;AACH;AAEA,eAAsB,sBAAsB,OAA+B,CAAC,GAAG;AAC7E,SAAO,MAAM;AAAA,IAAwB;AAAA,IAAM,OAAO,WAChD,4BAA4B,MAAM,OAAO,eAAe,CAAC;AAAA,EAC3D;AACF;",
+  "names": []
+}

package/dist/chunk-Y6CJN4ID.js

@@ -0,0 +1,31 @@
+import {
+  withResolvedRuntimeMatrixClient
+} from "./chunk-XF7LD6VV.js";
+import {
+  resolveMatrixRoomId
+} from "./chunk-THM2QV25.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/actions/client.ts
+init_shims();
+async function withResolvedActionClient(opts, run, mode = "stop") {
+  return await withResolvedRuntimeMatrixClient(opts, run, mode);
+}
+async function withStartedActionClient(opts, run) {
+  return await withResolvedActionClient({ ...opts, readiness: "started" }, run, "persist");
+}
+async function withResolvedRoomAction(roomId, opts, run) {
+  return await withResolvedActionClient(opts, async (client) => {
+    const resolvedRoom = await resolveMatrixRoomId(client, roomId);
+    return await run(client, resolvedRoom);
+  });
+}
+
+export {
+  withResolvedActionClient,
+  withStartedActionClient,
+  withResolvedRoomAction
+};
+//# sourceMappingURL=chunk-Y6CJN4ID.js.map

package/dist/chunk-Y6CJN4ID.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/actions/client.ts"],
+  "sourcesContent": ["import { withResolvedRuntimeMatrixClient } from \"../client-bootstrap.js\";\nimport { resolveMatrixRoomId } from \"../send.js\";\nimport type { MatrixActionClient, MatrixActionClientOpts } from \"./types.js\";\n\ntype MatrixActionClientStopMode = \"stop\" | \"persist\";\n\nexport async function withResolvedActionClient<T>(\n  opts: MatrixActionClientOpts,\n  run: (client: MatrixActionClient[\"client\"]) => Promise<T>,\n  mode: MatrixActionClientStopMode = \"stop\",\n): Promise<T> {\n  return await withResolvedRuntimeMatrixClient(opts, run, mode);\n}\n\nexport async function withStartedActionClient<T>(\n  opts: MatrixActionClientOpts,\n  run: (client: MatrixActionClient[\"client\"]) => Promise<T>,\n): Promise<T> {\n  return await withResolvedActionClient({ ...opts, readiness: \"started\" }, run, \"persist\");\n}\n\nexport async function withResolvedRoomAction<T>(\n  roomId: string,\n  opts: MatrixActionClientOpts,\n  run: (client: MatrixActionClient[\"client\"], resolvedRoom: string) => Promise<T>,\n): Promise<T> {\n  return await withResolvedActionClient(opts, async (client) => {\n    const resolvedRoom = await resolveMatrixRoomId(client, roomId);\n    return await run(client, resolvedRoom);\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;AAAA;AAMA,eAAsB,yBACpB,MACA,KACA,OAAmC,QACvB;AACZ,SAAO,MAAM,gCAAgC,MAAM,KAAK,IAAI;AAC9D;AAEA,eAAsB,wBACpB,MACA,KACY;AACZ,SAAO,MAAM,yBAAyB,EAAE,GAAG,MAAM,WAAW,UAAU,GAAG,KAAK,SAAS;AACzF;AAEA,eAAsB,uBACpB,QACA,MACA,KACY;AACZ,SAAO,MAAM,yBAAyB,MAAM,OAAO,WAAW;AAC5D,UAAM,eAAe,MAAM,oBAAoB,QAAQ,MAAM;AAC7D,WAAO,MAAM,IAAI,QAAQ,YAAY;AAAA,EACvC,CAAC;AACH;",
+  "names": []
+}