@archipelagolab/lobi 1.0.5 → 1.0.6

package/dist/chunk-K3HEWOHN.js

@@ -0,0 +1,30 @@
+import {
+  resolveMatrixConfigFieldPath
+} from "./chunk-SPNSM6SB.js";
+import {
+  resolveMatrixDefaultOrOnlyAccountId
+} from "./chunk-3R4ATE4Q.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/encryption-guidance.ts
+init_shims();
+import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
+function resolveMatrixEncryptionConfigPath(cfg, accountId) {
+  const effectiveAccountId = normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg);
+  return resolveMatrixConfigFieldPath(cfg, effectiveAccountId, "encryption");
+}
+function formatMatrixEncryptionUnavailableError(cfg, accountId) {
+  return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;
+}
+function formatMatrixEncryptedEventDisabledWarning(cfg, accountId) {
+  return `matrix: encrypted event received without encryption enabled; set ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true and verify the device to decrypt`;
+}
+
+export {
+  resolveMatrixEncryptionConfigPath,
+  formatMatrixEncryptionUnavailableError,
+  formatMatrixEncryptedEventDisabledWarning
+};
+//# sourceMappingURL=chunk-K3HEWOHN.js.map

package/dist/chunk-K3HEWOHN.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/encryption-guidance.ts"],
+  "sourcesContent": ["import { normalizeOptionalAccountId } from \"openclaw/plugin-sdk/account-id\";\nimport { resolveMatrixDefaultOrOnlyAccountId } from \"../account-selection.js\";\nimport type { CoreConfig } from \"../types.js\";\nimport { resolveMatrixConfigFieldPath } from \"./config-paths.js\";\n\nexport function resolveMatrixEncryptionConfigPath(\n  cfg: CoreConfig,\n  accountId?: string | null,\n): string {\n  const effectiveAccountId =\n    normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg);\n  return resolveMatrixConfigFieldPath(cfg, effectiveAccountId, \"encryption\");\n}\n\nexport function formatMatrixEncryptionUnavailableError(\n  cfg: CoreConfig,\n  accountId?: string | null,\n): string {\n  return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;\n}\n\nexport function formatMatrixEncryptedEventDisabledWarning(\n  cfg: CoreConfig,\n  accountId?: string | null,\n): string {\n  return `matrix: encrypted event received without encryption enabled; set ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true and verify the device to decrypt`;\n}\n"],
+  "mappings": ";;;;;;;;;;;AAAA;AAAA,SAAS,kCAAkC;AAKpC,SAAS,kCACd,KACA,WACQ;AACR,QAAM,qBACJ,2BAA2B,SAAS,KAAK,oCAAoC,GAAG;AAClF,SAAO,6BAA6B,KAAK,oBAAoB,YAAY;AAC3E;AAEO,SAAS,uCACd,KACA,WACQ;AACR,SAAO,8CAA8C,kCAAkC,KAAK,SAAS,CAAC;AACxG;AAEO,SAAS,0CACd,KACA,WACQ;AACR,SAAO,oEAAoE,kCAAkC,KAAK,SAAS,CAAC;AAC9H;",
+  "names": []
+}

package/dist/chunk-K5EK4WZV.js

@@ -0,0 +1,7 @@
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix-migration.runtime.ts
+init_shims();
+//# sourceMappingURL=chunk-K5EK4WZV.js.map

package/dist/chunk-K5EK4WZV.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix-migration.runtime.ts"],
+  "sourcesContent": ["export { autoMigrateLegacyMatrixState, detectLegacyMatrixState } from \"./legacy-state.js\";\nexport { autoPrepareLegacyMatrixCrypto, detectLegacyMatrixCrypto } from \"./legacy-crypto.js\";\nexport {\n  hasActionableMatrixMigration,\n  hasPendingMatrixMigration,\n  resolveMatrixMigrationStatus,\n  type MatrixMigrationStatus,\n} from \"./migration-snapshot.js\";\nexport { maybeCreateMatrixMigrationSnapshot } from \"./migration-snapshot-backup.js\";\n"],
+  "mappings": ";;;;;AAAA;",
+  "names": []
+}

package/dist/chunk-KAWXMSYC.js

@@ -0,0 +1,58 @@
+import {
+  normalizeMatrixAllowList,
+  resolveMatrixAllowListMatch
+} from "./chunk-U44IVNP2.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.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-KAWXMSYC.js.map

package/dist/chunk-KAWXMSYC.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-KEGPHS4C.js

@@ -0,0 +1,80 @@
+import {
+  resolveValidatedMatrixHomeserverUrl
+} from "./chunk-OKDOVX4B.js";
+import {
+  maybeMigrateLegacyStorage,
+  resolveMatrixStoragePaths,
+  writeStorageMeta
+} from "./chunk-HKF5EBER.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/client/create-client.ts
+init_shims();
+import fs from "node:fs";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+var matrixCreateClientRuntimeDepsPromise;
+async function loadMatrixCreateClientRuntimeDeps() {
+  matrixCreateClientRuntimeDepsPromise ??= Promise.all([
+    import("./src/matrix/sdk.js"),
+    import("./src/matrix/client/logging.js")
+  ]).then(([sdkModule, loggingModule]) => ({
+    MatrixClient: sdkModule.MatrixClient,
+    ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
+  }));
+  return await matrixCreateClientRuntimeDepsPromise;
+}
+async function createMatrixClient(params) {
+  const { MatrixClient, ensureMatrixSdkLoggingConfigured } = await loadMatrixCreateClientRuntimeDeps();
+  ensureMatrixSdkLoggingConfigured();
+  const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, {
+    dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork
+  });
+  const matrixClientUserId = normalizeOptionalString(params.userId);
+  const userId = matrixClientUserId ?? "unknown";
+  const persistStorage = params.persistStorage !== false;
+  const storagePaths = persistStorage ? resolveMatrixStoragePaths({
+    homeserver,
+    userId,
+    accessToken: params.accessToken,
+    accountId: params.accountId,
+    deviceId: params.deviceId,
+    env: process.env
+  }) : null;
+  if (storagePaths) {
+    await maybeMigrateLegacyStorage({
+      storagePaths,
+      env: process.env
+    });
+    fs.mkdirSync(storagePaths.rootDir, { recursive: true });
+    writeStorageMeta({
+      storagePaths,
+      homeserver,
+      userId,
+      accountId: params.accountId,
+      deviceId: params.deviceId
+    });
+  }
+  const cryptoDatabasePrefix = storagePaths ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}` : void 0;
+  return new MatrixClient(homeserver, params.accessToken, {
+    userId: matrixClientUserId,
+    password: params.password,
+    deviceId: params.deviceId,
+    encryption: params.encryption,
+    localTimeoutMs: params.localTimeoutMs,
+    initialSyncLimit: params.initialSyncLimit,
+    storagePath: storagePaths?.storagePath,
+    recoveryKeyPath: storagePaths?.recoveryKeyPath,
+    idbSnapshotPath: storagePaths?.idbSnapshotPath,
+    cryptoDatabasePrefix,
+    autoBootstrapCrypto: params.autoBootstrapCrypto,
+    ssrfPolicy: params.ssrfPolicy,
+    dispatcherPolicy: params.dispatcherPolicy
+  });
+}
+
+export {
+  createMatrixClient
+};
+//# sourceMappingURL=chunk-KEGPHS4C.js.map

package/dist/chunk-KEGPHS4C.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/client/create-client.ts"],
+  "sourcesContent": ["import fs from \"node:fs\";\nimport type { PinnedDispatcherPolicy } from \"openclaw/plugin-sdk/infra-runtime\";\nimport { normalizeOptionalString } from \"openclaw/plugin-sdk/text-runtime\";\nimport type { SsrFPolicy } from \"../../runtime-api.js\";\nimport type { MatrixClient } from \"../sdk.js\";\nimport { resolveValidatedMatrixHomeserverUrl } from \"./config.js\";\nimport {\n  maybeMigrateLegacyStorage,\n  resolveMatrixStoragePaths,\n  writeStorageMeta,\n} from \"./storage.js\";\n\ntype MatrixCreateClientRuntimeDeps = {\n  MatrixClient: typeof import(\"../sdk.js\").MatrixClient;\n  ensureMatrixSdkLoggingConfigured: typeof import(\"./logging.js\").ensureMatrixSdkLoggingConfigured;\n};\n\nlet matrixCreateClientRuntimeDepsPromise: Promise<MatrixCreateClientRuntimeDeps> | undefined;\n\nasync function loadMatrixCreateClientRuntimeDeps(): Promise<MatrixCreateClientRuntimeDeps> {\n  matrixCreateClientRuntimeDepsPromise ??= Promise.all([\n    import(\"../sdk.js\"),\n    import(\"./logging.js\"),\n  ]).then(([sdkModule, loggingModule]) => ({\n    MatrixClient: sdkModule.MatrixClient,\n    ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured,\n  }));\n  return await matrixCreateClientRuntimeDepsPromise;\n}\n\nexport async function createMatrixClient(params: {\n  homeserver: string;\n  userId?: string;\n  accessToken: string;\n  password?: string;\n  deviceId?: string;\n  persistStorage?: boolean;\n  encryption?: boolean;\n  localTimeoutMs?: number;\n  initialSyncLimit?: number;\n  accountId?: string | null;\n  autoBootstrapCrypto?: boolean;\n  allowPrivateNetwork?: boolean;\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n}): Promise<MatrixClient> {\n  const { MatrixClient, ensureMatrixSdkLoggingConfigured } =\n    await loadMatrixCreateClientRuntimeDeps();\n  ensureMatrixSdkLoggingConfigured();\n  const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, {\n    dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork,\n  });\n  const matrixClientUserId = normalizeOptionalString(params.userId);\n  const userId = matrixClientUserId ?? \"unknown\";\n  const persistStorage = params.persistStorage !== false;\n  const storagePaths = persistStorage\n    ? resolveMatrixStoragePaths({\n        homeserver,\n        userId,\n        accessToken: params.accessToken,\n        accountId: params.accountId,\n        deviceId: params.deviceId,\n        env: process.env,\n      })\n    : null;\n\n  if (storagePaths) {\n    await maybeMigrateLegacyStorage({\n      storagePaths,\n      env: process.env,\n    });\n    fs.mkdirSync(storagePaths.rootDir, { recursive: true });\n    writeStorageMeta({\n      storagePaths,\n      homeserver,\n      userId,\n      accountId: params.accountId,\n      deviceId: params.deviceId,\n    });\n  }\n\n  const cryptoDatabasePrefix = storagePaths\n    ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}`\n    : undefined;\n\n  return new MatrixClient(homeserver, params.accessToken, {\n    userId: matrixClientUserId,\n    password: params.password,\n    deviceId: params.deviceId,\n    encryption: params.encryption,\n    localTimeoutMs: params.localTimeoutMs,\n    initialSyncLimit: params.initialSyncLimit,\n    storagePath: storagePaths?.storagePath,\n    recoveryKeyPath: storagePaths?.recoveryKeyPath,\n    idbSnapshotPath: storagePaths?.idbSnapshotPath,\n    cryptoDatabasePrefix,\n    autoBootstrapCrypto: params.autoBootstrapCrypto,\n    ssrfPolicy: params.ssrfPolicy,\n    dispatcherPolicy: params.dispatcherPolicy,\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;AAAA;AAAA,OAAO,QAAQ;AAEf,SAAS,+BAA+B;AAexC,IAAI;AAEJ,eAAe,oCAA4E;AACzF,2CAAyC,QAAQ,IAAI;AAAA,IACnD,OAAO,qBAAW;AAAA,IAClB,OAAO,gCAAc;AAAA,EACvB,CAAC,EAAE,KAAK,CAAC,CAAC,WAAW,aAAa,OAAO;AAAA,IACvC,cAAc,UAAU;AAAA,IACxB,kCAAkC,cAAc;AAAA,EAClD,EAAE;AACF,SAAO,MAAM;AACf;AAEA,eAAsB,mBAAmB,QAef;AACxB,QAAM,EAAE,cAAc,iCAAiC,IACrD,MAAM,kCAAkC;AAC1C,mCAAiC;AACjC,QAAM,aAAa,MAAM,oCAAoC,OAAO,YAAY;AAAA,IAC9E,gCAAgC,OAAO;AAAA,EACzC,CAAC;AACD,QAAM,qBAAqB,wBAAwB,OAAO,MAAM;AAChE,QAAM,SAAS,sBAAsB;AACrC,QAAM,iBAAiB,OAAO,mBAAmB;AACjD,QAAM,eAAe,iBACjB,0BAA0B;AAAA,IACxB;AAAA,IACA;AAAA,IACA,aAAa,OAAO;AAAA,IACpB,WAAW,OAAO;AAAA,IAClB,UAAU,OAAO;AAAA,IACjB,KAAK,QAAQ;AAAA,EACf,CAAC,IACD;AAEJ,MAAI,cAAc;AAChB,UAAM,0BAA0B;AAAA,MAC9B;AAAA,MACA,KAAK,QAAQ;AAAA,IACf,CAAC;AACD,OAAG,UAAU,aAAa,SAAS,EAAE,WAAW,KAAK,CAAC;AACtD,qBAAiB;AAAA,MACf;AAAA,MACA;AAAA,MACA;AAAA,MACA,WAAW,OAAO;AAAA,MAClB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH;AAEA,QAAM,uBAAuB,eACzB,mBAAmB,aAAa,UAAU,IAAI,aAAa,SAAS,KACpE;AAEJ,SAAO,IAAI,aAAa,YAAY,OAAO,aAAa;AAAA,IACtD,QAAQ;AAAA,IACR,UAAU,OAAO;AAAA,IACjB,UAAU,OAAO;AAAA,IACjB,YAAY,OAAO;AAAA,IACnB,gBAAgB,OAAO;AAAA,IACvB,kBAAkB,OAAO;AAAA,IACzB,aAAa,cAAc;AAAA,IAC3B,iBAAiB,cAAc;AAAA,IAC/B,iBAAiB,cAAc;AAAA,IAC/B;AAAA,IACA,qBAAqB,OAAO;AAAA,IAC5B,YAAY,OAAO;AAAA,IACnB,kBAAkB,OAAO;AAAA,EAC3B,CAAC;AACH;",
+  "names": []
+}

package/dist/chunk-KXXVR3DC.js

@@ -0,0 +1,244 @@
+import {
+  resolveMatrixMigrationStatus
+} from "./chunk-ZFGRQIB6.js";
+import {
+  maybeCreateMatrixMigrationSnapshot
+} from "./chunk-FYSARMGS.js";
+import {
+  autoPrepareLegacyMatrixCrypto
+} from "./chunk-IJ6Y4W7F.js";
+import {
+  autoMigrateLegacyMatrixState
+} from "./chunk-2IQWKATM.js";
+import {
+  legacyConfigRules,
+  normalizeCompatibilityConfig
+} from "./chunk-GGWS7NQP.js";
+import {
+  isRecord
+} from "./chunk-R5S76YR5.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/doctor.ts
+init_shims();
+import {
+  detectPluginInstallPathIssue,
+  formatPluginInstallPathIssue,
+  removePluginFromConfig
+} from "openclaw/plugin-sdk/runtime-doctor";
+function hasConfiguredMatrixChannel(cfg) {
+  const channels = cfg.channels;
+  return isRecord(channels?.matrix);
+}
+function hasConfiguredMatrixPluginSurface(cfg) {
+  return Boolean(
+    cfg.plugins?.installs?.matrix || cfg.plugins?.entries?.matrix || cfg.plugins?.allow?.includes("matrix") || cfg.plugins?.deny?.includes("matrix")
+  );
+}
+function hasConfiguredMatrixEnv(env) {
+  return Object.entries(env).some(
+    ([key, value]) => key.startsWith("MATRIX_") && typeof value === "string" && value.trim()
+  );
+}
+function configMayNeedMatrixDoctorSequence(cfg, env) {
+  return hasConfiguredMatrixChannel(cfg) || hasConfiguredMatrixPluginSurface(cfg) || hasConfiguredMatrixEnv(env);
+}
+function formatMatrixLegacyStatePreview(detection) {
+  return [
+    "- Matrix plugin upgraded in place.",
+    `- Legacy sync store: ${detection.legacyStoragePath} -> ${detection.targetStoragePath}`,
+    `- Legacy crypto store: ${detection.legacyCryptoPath} -> ${detection.targetCryptoPath}`,
+    ...detection.selectionNote ? [`- ${detection.selectionNote}`] : [],
+    '- Run "openclaw doctor --fix" to migrate this Matrix state now.'
+  ].join("\n");
+}
+function formatMatrixLegacyCryptoPreview(detection) {
+  const notes = [];
+  for (const warning of detection.warnings) {
+    notes.push(`- ${warning}`);
+  }
+  for (const plan of detection.plans) {
+    notes.push(
+      [
+        `- Matrix encrypted-state migration is pending for account "${plan.accountId}".`,
+        `- Legacy crypto store: ${plan.legacyCryptoPath}`,
+        `- New recovery key file: ${plan.recoveryKeyPath}`,
+        `- Migration state file: ${plan.statePath}`,
+        '- Run "openclaw doctor --fix" to extract any saved backup key now. Backed-up room keys will restore automatically on next gateway start.'
+      ].join("\n")
+    );
+  }
+  return notes;
+}
+async function collectMatrixInstallPathWarnings(cfg) {
+  const issue = await detectPluginInstallPathIssue({
+    pluginId: "matrix",
+    install: cfg.plugins?.installs?.matrix
+  });
+  if (!issue) {
+    return [];
+  }
+  return formatPluginInstallPathIssue({
+    issue,
+    pluginLabel: "Matrix",
+    defaultInstallCommand: "openclaw plugins install @openclaw/matrix"
+  }).map((entry) => `- ${entry}`);
+}
+async function cleanStaleMatrixPluginConfig(cfg) {
+  const issue = await detectPluginInstallPathIssue({
+    pluginId: "matrix",
+    install: cfg.plugins?.installs?.matrix
+  });
+  if (!issue || issue.kind !== "missing-path") {
+    return { config: cfg, changes: [] };
+  }
+  const { config, actions } = removePluginFromConfig(cfg, "matrix");
+  const removed = [];
+  if (actions.install) {
+    removed.push("install record");
+  }
+  if (actions.loadPath) {
+    removed.push("load path");
+  }
+  if (actions.entry) {
+    removed.push("plugin entry");
+  }
+  if (actions.allowlist) {
+    removed.push("allowlist entry");
+  }
+  if (removed.length === 0) {
+    return { config: cfg, changes: [] };
+  }
+  return {
+    config,
+    changes: [
+      `Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`
+    ]
+  };
+}
+async function applyMatrixDoctorRepair(params) {
+  const changes = [];
+  const warnings = [];
+  const migrationStatus = resolveMatrixMigrationStatus({
+    cfg: params.cfg,
+    env: params.env
+  });
+  let matrixSnapshotReady = true;
+  if (migrationStatus.actionable) {
+    try {
+      const snapshot = await maybeCreateMatrixMigrationSnapshot({
+        trigger: "doctor-fix",
+        env: params.env
+      });
+      changes.push(
+        `Matrix migration snapshot ${snapshot.created ? "created" : "reused"} before applying Matrix upgrades.
+- ${snapshot.archivePath}`
+      );
+    } catch (error) {
+      matrixSnapshotReady = false;
+      warnings.push(
+        `- Failed creating a Matrix migration snapshot before repair: ${String(error)}`
+      );
+      warnings.push(
+        '- Skipping Matrix migration changes for now. Resolve the snapshot failure, then rerun "openclaw doctor --fix".'
+      );
+    }
+  } else if (migrationStatus.pending) {
+    warnings.push(
+      "- Matrix migration warnings are present, but no on-disk Matrix mutation is actionable yet. No pre-migration snapshot was needed."
+    );
+  }
+  if (!matrixSnapshotReady) {
+    return { changes, warnings };
+  }
+  const matrixStateRepair = await autoMigrateLegacyMatrixState({
+    cfg: params.cfg,
+    env: params.env
+  });
+  if (matrixStateRepair.changes.length > 0) {
+    changes.push(
+      [
+        "Matrix plugin upgraded in place.",
+        ...matrixStateRepair.changes.map((entry) => `- ${entry}`),
+        "- No user action required."
+      ].join("\n")
+    );
+  }
+  if (matrixStateRepair.warnings.length > 0) {
+    warnings.push(matrixStateRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+  }
+  const matrixCryptoRepair = await autoPrepareLegacyMatrixCrypto({
+    cfg: params.cfg,
+    env: params.env
+  });
+  if (matrixCryptoRepair.changes.length > 0) {
+    changes.push(
+      [
+        "Matrix encrypted-state migration prepared.",
+        ...matrixCryptoRepair.changes.map((entry) => `- ${entry}`)
+      ].join("\n")
+    );
+  }
+  if (matrixCryptoRepair.warnings.length > 0) {
+    warnings.push(matrixCryptoRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+  }
+  return { changes, warnings };
+}
+async function runMatrixDoctorSequence(params) {
+  const warningNotes = [];
+  const changeNotes = [];
+  const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
+  if (installWarnings.length > 0) {
+    warningNotes.push(installWarnings.join("\n"));
+  }
+  if (!configMayNeedMatrixDoctorSequence(params.cfg, params.env)) {
+    return { changeNotes, warningNotes };
+  }
+  if (params.shouldRepair) {
+    const repair = await applyMatrixDoctorRepair({
+      cfg: params.cfg,
+      env: params.env
+    });
+    changeNotes.push(...repair.changes);
+    warningNotes.push(...repair.warnings);
+  } else {
+    const migrationStatus = resolveMatrixMigrationStatus({
+      cfg: params.cfg,
+      env: params.env
+    });
+    if (migrationStatus.legacyState) {
+      if ("warning" in migrationStatus.legacyState) {
+        warningNotes.push(`- ${migrationStatus.legacyState.warning}`);
+      } else {
+        warningNotes.push(formatMatrixLegacyStatePreview(migrationStatus.legacyState));
+      }
+    }
+    if (migrationStatus.legacyCrypto.warnings.length > 0 || migrationStatus.legacyCrypto.plans.length > 0) {
+      warningNotes.push(...formatMatrixLegacyCryptoPreview(migrationStatus.legacyCrypto));
+    }
+  }
+  return { changeNotes, warningNotes };
+}
+var matrixDoctor = {
+  dmAllowFromMode: "nestedOnly",
+  groupModel: "sender",
+  groupAllowFromFallbackToAllowFrom: false,
+  warnOnEmptyGroupSenderAllowlist: true,
+  legacyConfigRules,
+  normalizeCompatibilityConfig,
+  runConfigSequence: async ({ cfg, env, shouldRepair }) => await runMatrixDoctorSequence({ cfg, env, shouldRepair }),
+  cleanStaleConfig: async ({ cfg }) => await cleanStaleMatrixPluginConfig(cfg)
+};
+
+export {
+  formatMatrixLegacyStatePreview,
+  formatMatrixLegacyCryptoPreview,
+  collectMatrixInstallPathWarnings,
+  cleanStaleMatrixPluginConfig,
+  applyMatrixDoctorRepair,
+  runMatrixDoctorSequence,
+  matrixDoctor
+};
+//# sourceMappingURL=chunk-KXXVR3DC.js.map

package/dist/chunk-KXXVR3DC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/doctor.ts"],
+  "sourcesContent": ["import { type ChannelDoctorAdapter } from \"openclaw/plugin-sdk/channel-contract\";\nimport type { OpenClawConfig } from \"openclaw/plugin-sdk/config-runtime\";\nimport {\n  detectPluginInstallPathIssue,\n  formatPluginInstallPathIssue,\n  removePluginFromConfig,\n} from \"openclaw/plugin-sdk/runtime-doctor\";\nimport {\n  legacyConfigRules as MATRIX_LEGACY_CONFIG_RULES,\n  normalizeCompatibilityConfig as normalizeMatrixCompatibilityConfig,\n} from \"./doctor-contract.js\";\nimport {\n  autoMigrateLegacyMatrixState,\n  autoPrepareLegacyMatrixCrypto,\n  detectLegacyMatrixCrypto,\n  detectLegacyMatrixState,\n  maybeCreateMatrixMigrationSnapshot,\n  resolveMatrixMigrationStatus,\n} from \"./matrix-migration.runtime.js\";\nimport { isRecord } from \"./record-shared.js\";\n\nfunction hasConfiguredMatrixChannel(cfg: OpenClawConfig): boolean {\n  const channels = cfg.channels as Record<string, unknown> | undefined;\n  return isRecord(channels?.matrix);\n}\n\nfunction hasConfiguredMatrixPluginSurface(cfg: OpenClawConfig): boolean {\n  return Boolean(\n    cfg.plugins?.installs?.matrix ||\n    cfg.plugins?.entries?.matrix ||\n    cfg.plugins?.allow?.includes(\"matrix\") ||\n    cfg.plugins?.deny?.includes(\"matrix\"),\n  );\n}\n\nfunction hasConfiguredMatrixEnv(env: NodeJS.ProcessEnv): boolean {\n  return Object.entries(env).some(\n    ([key, value]) => key.startsWith(\"MATRIX_\") && typeof value === \"string\" && value.trim(),\n  );\n}\n\nfunction configMayNeedMatrixDoctorSequence(cfg: OpenClawConfig, env: NodeJS.ProcessEnv): boolean {\n  return (\n    hasConfiguredMatrixChannel(cfg) ||\n    hasConfiguredMatrixPluginSurface(cfg) ||\n    hasConfiguredMatrixEnv(env)\n  );\n}\n\nexport function formatMatrixLegacyStatePreview(\n  detection: Exclude<ReturnType<typeof detectLegacyMatrixState>, null | { warning: string }>,\n): string {\n  return [\n    \"- Matrix plugin upgraded in place.\",\n    `- Legacy sync store: ${detection.legacyStoragePath} -> ${detection.targetStoragePath}`,\n    `- Legacy crypto store: ${detection.legacyCryptoPath} -> ${detection.targetCryptoPath}`,\n    ...(detection.selectionNote ? [`- ${detection.selectionNote}`] : []),\n    '- Run \"openclaw doctor --fix\" to migrate this Matrix state now.',\n  ].join(\"\\n\");\n}\n\nexport function formatMatrixLegacyCryptoPreview(\n  detection: ReturnType<typeof detectLegacyMatrixCrypto>,\n): string[] {\n  const notes: string[] = [];\n  for (const warning of detection.warnings) {\n    notes.push(`- ${warning}`);\n  }\n  for (const plan of detection.plans) {\n    notes.push(\n      [\n        `- Matrix encrypted-state migration is pending for account \"${plan.accountId}\".`,\n        `- Legacy crypto store: ${plan.legacyCryptoPath}`,\n        `- New recovery key file: ${plan.recoveryKeyPath}`,\n        `- Migration state file: ${plan.statePath}`,\n        '- Run \"openclaw doctor --fix\" to extract any saved backup key now. Backed-up room keys will restore automatically on next gateway start.',\n      ].join(\"\\n\"),\n    );\n  }\n  return notes;\n}\n\nexport async function collectMatrixInstallPathWarnings(cfg: OpenClawConfig): Promise<string[]> {\n  const issue = await detectPluginInstallPathIssue({\n    pluginId: \"matrix\",\n    install: cfg.plugins?.installs?.matrix,\n  });\n  if (!issue) {\n    return [];\n  }\n  return formatPluginInstallPathIssue({\n    issue,\n    pluginLabel: \"Matrix\",\n    defaultInstallCommand: \"openclaw plugins install @openclaw/matrix\",\n  }).map((entry) => `- ${entry}`);\n}\n\nexport async function cleanStaleMatrixPluginConfig(cfg: OpenClawConfig) {\n  const issue = await detectPluginInstallPathIssue({\n    pluginId: \"matrix\",\n    install: cfg.plugins?.installs?.matrix,\n  });\n  if (!issue || issue.kind !== \"missing-path\") {\n    return { config: cfg, changes: [] };\n  }\n  const { config, actions } = removePluginFromConfig(cfg, \"matrix\");\n  const removed: string[] = [];\n  if (actions.install) {\n    removed.push(\"install record\");\n  }\n  if (actions.loadPath) {\n    removed.push(\"load path\");\n  }\n  if (actions.entry) {\n    removed.push(\"plugin entry\");\n  }\n  if (actions.allowlist) {\n    removed.push(\"allowlist entry\");\n  }\n  if (removed.length === 0) {\n    return { config: cfg, changes: [] };\n  }\n  return {\n    config,\n    changes: [\n      `Removed stale Matrix plugin references (${removed.join(\", \")}). The previous install path no longer exists: ${issue.path}`,\n    ],\n  };\n}\n\nexport async function applyMatrixDoctorRepair(params: {\n  cfg: OpenClawConfig;\n  env: NodeJS.ProcessEnv;\n}): Promise<{ changes: string[]; warnings: string[] }> {\n  const changes: string[] = [];\n  const warnings: string[] = [];\n  const migrationStatus = resolveMatrixMigrationStatus({\n    cfg: params.cfg,\n    env: params.env,\n  });\n\n  let matrixSnapshotReady = true;\n  if (migrationStatus.actionable) {\n    try {\n      const snapshot = await maybeCreateMatrixMigrationSnapshot({\n        trigger: \"doctor-fix\",\n        env: params.env,\n      });\n      changes.push(\n        `Matrix migration snapshot ${snapshot.created ? \"created\" : \"reused\"} before applying Matrix upgrades.\\n- ${snapshot.archivePath}`,\n      );\n    } catch (error) {\n      matrixSnapshotReady = false;\n      warnings.push(\n        `- Failed creating a Matrix migration snapshot before repair: ${String(error)}`,\n      );\n      warnings.push(\n        '- Skipping Matrix migration changes for now. Resolve the snapshot failure, then rerun \"openclaw doctor --fix\".',\n      );\n    }\n  } else if (migrationStatus.pending) {\n    warnings.push(\n      \"- Matrix migration warnings are present, but no on-disk Matrix mutation is actionable yet. No pre-migration snapshot was needed.\",\n    );\n  }\n\n  if (!matrixSnapshotReady) {\n    return { changes, warnings };\n  }\n\n  const matrixStateRepair = await autoMigrateLegacyMatrixState({\n    cfg: params.cfg,\n    env: params.env,\n  });\n  if (matrixStateRepair.changes.length > 0) {\n    changes.push(\n      [\n        \"Matrix plugin upgraded in place.\",\n        ...matrixStateRepair.changes.map((entry) => `- ${entry}`),\n        \"- No user action required.\",\n      ].join(\"\\n\"),\n    );\n  }\n  if (matrixStateRepair.warnings.length > 0) {\n    warnings.push(matrixStateRepair.warnings.map((entry) => `- ${entry}`).join(\"\\n\"));\n  }\n\n  const matrixCryptoRepair = await autoPrepareLegacyMatrixCrypto({\n    cfg: params.cfg,\n    env: params.env,\n  });\n  if (matrixCryptoRepair.changes.length > 0) {\n    changes.push(\n      [\n        \"Matrix encrypted-state migration prepared.\",\n        ...matrixCryptoRepair.changes.map((entry) => `- ${entry}`),\n      ].join(\"\\n\"),\n    );\n  }\n  if (matrixCryptoRepair.warnings.length > 0) {\n    warnings.push(matrixCryptoRepair.warnings.map((entry) => `- ${entry}`).join(\"\\n\"));\n  }\n\n  return { changes, warnings };\n}\n\nexport async function runMatrixDoctorSequence(params: {\n  cfg: OpenClawConfig;\n  env: NodeJS.ProcessEnv;\n  shouldRepair: boolean;\n}): Promise<{ changeNotes: string[]; warningNotes: string[] }> {\n  const warningNotes: string[] = [];\n  const changeNotes: string[] = [];\n  const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);\n  if (installWarnings.length > 0) {\n    warningNotes.push(installWarnings.join(\"\\n\"));\n  }\n  if (!configMayNeedMatrixDoctorSequence(params.cfg, params.env)) {\n    return { changeNotes, warningNotes };\n  }\n\n  if (params.shouldRepair) {\n    const repair = await applyMatrixDoctorRepair({\n      cfg: params.cfg,\n      env: params.env,\n    });\n    changeNotes.push(...repair.changes);\n    warningNotes.push(...repair.warnings);\n  } else {\n    const migrationStatus = resolveMatrixMigrationStatus({\n      cfg: params.cfg,\n      env: params.env,\n    });\n    if (migrationStatus.legacyState) {\n      if (\"warning\" in migrationStatus.legacyState) {\n        warningNotes.push(`- ${migrationStatus.legacyState.warning}`);\n      } else {\n        warningNotes.push(formatMatrixLegacyStatePreview(migrationStatus.legacyState));\n      }\n    }\n    if (\n      migrationStatus.legacyCrypto.warnings.length > 0 ||\n      migrationStatus.legacyCrypto.plans.length > 0\n    ) {\n      warningNotes.push(...formatMatrixLegacyCryptoPreview(migrationStatus.legacyCrypto));\n    }\n  }\n\n  return { changeNotes, warningNotes };\n}\n\nexport const matrixDoctor: ChannelDoctorAdapter = {\n  dmAllowFromMode: \"nestedOnly\",\n  groupModel: \"sender\",\n  groupAllowFromFallbackToAllowFrom: false,\n  warnOnEmptyGroupSenderAllowlist: true,\n  legacyConfigRules: MATRIX_LEGACY_CONFIG_RULES,\n  normalizeCompatibilityConfig: normalizeMatrixCompatibilityConfig,\n  runConfigSequence: async ({ cfg, env, shouldRepair }) =>\n    await runMatrixDoctorSequence({ cfg, env, shouldRepair }),\n  cleanStaleConfig: async ({ cfg }) => await cleanStaleMatrixPluginConfig(cfg),\n};\n"],
+  "mappings": "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",
+  "names": []
+}