@archipelagolab/lobi 1.0.1 → 1.0.6

package/src/exec-approvals.ts

@@ -1,290 +0,0 @@
-import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
-import {
-  createChannelExecApprovalProfile,
-  getExecApprovalReplyMetadata,
-  isChannelExecApprovalClientEnabledFromConfig,
-  isChannelExecApprovalTargetRecipient,
-  matchesApprovalRequestFilters,
-} from "openclaw/plugin-sdk/approval-client-runtime";
-import { resolveApprovalRequestChannelAccountId } from "openclaw/plugin-sdk/approval-native-runtime";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-runtime";
-import type { ExecApprovalRequest, PluginApprovalRequest } from "openclaw/plugin-sdk/infra-runtime";
-import type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-import { getMatrixApprovalAuthApprovers } from "./approval-auth.js";
-import { normalizeMatrixApproverId } from "./approval-ids.js";
-import { listMatrixAccountIds, resolveMatrixAccount } from "./matrix/accounts.js";
-import type { CoreConfig } from "./types.js";
-
-type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
-type ApprovalKind = "exec" | "plugin";
-
-export { normalizeMatrixApproverId };
-
-function normalizeMatrixExecApproverId(value: string | number): string | undefined {
-  const normalized = normalizeMatrixApproverId(value);
-  return normalized === "*" ? undefined : normalized;
-}
-
-function resolveMatrixExecApprovalConfig(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}) {
-  const account = resolveMatrixAccount(params);
-  const config = account.config.execApprovals;
-  if (!config) {
-    return undefined;
-  }
-  return {
-    ...config,
-    enabled: account.enabled && account.configured ? config.enabled : false,
-  };
-}
-
-function countMatrixExecApprovalEligibleAccounts(params: {
-  cfg: OpenClawConfig;
-  request: ApprovalRequest;
-  approvalKind: ApprovalKind;
-}): number {
-  return listMatrixAccountIds(params.cfg).filter((accountId) => {
-    const account = resolveMatrixAccount({ cfg: params.cfg, accountId });
-    if (!account.enabled || !account.configured) {
-      return false;
-    }
-    const config = resolveMatrixExecApprovalConfig({
-      cfg: params.cfg,
-      accountId,
-    });
-    const filters = config?.enabled
-      ? {
-          agentFilter: config.agentFilter,
-          sessionFilter: config.sessionFilter,
-        }
-      : {
-          agentFilter: undefined,
-          sessionFilter: undefined,
-        };
-    return (
-      isChannelExecApprovalClientEnabledFromConfig({
-        enabled: config?.enabled,
-        approverCount: getMatrixApprovalApprovers({
-          cfg: params.cfg,
-          accountId,
-          approvalKind: params.approvalKind,
-        }).length,
-      }) &&
-      matchesApprovalRequestFilters({
-        request: params.request.request,
-        agentFilter: filters.agentFilter,
-        sessionFilter: filters.sessionFilter,
-      })
-    );
-  }).length;
-}
-
-function matchesMatrixRequestAccount(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  request: ApprovalRequest;
-  approvalKind: ApprovalKind;
-}): boolean {
-  const turnSourceChannel = normalizeLowercaseStringOrEmpty(
-    params.request.request.turnSourceChannel,
-  );
-  const boundAccountId = resolveApprovalRequestChannelAccountId({
-    cfg: params.cfg,
-    request: params.request,
-    channel: "matrix",
-  });
-  if (turnSourceChannel && turnSourceChannel !== "matrix" && !boundAccountId) {
-    return (
-      countMatrixExecApprovalEligibleAccounts({
-        cfg: params.cfg,
-        request: params.request,
-        approvalKind: params.approvalKind,
-      }) <= 1
-    );
-  }
-  return (
-    !boundAccountId ||
-    !params.accountId ||
-    normalizeAccountId(boundAccountId) === normalizeAccountId(params.accountId)
-  );
-}
-
-export function getMatrixExecApprovalApprovers(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): string[] {
-  const account = resolveMatrixAccount(params).config;
-  return resolveApprovalApprovers({
-    explicit: account.execApprovals?.approvers,
-    allowFrom: account.dm?.allowFrom,
-    normalizeApprover: normalizeMatrixExecApproverId,
-  });
-}
-
-function resolveMatrixApprovalKind(request: ApprovalRequest): ApprovalKind {
-  return request.id.startsWith("plugin:") ? "plugin" : "exec";
-}
-
-export function getMatrixApprovalApprovers(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  approvalKind: ApprovalKind;
-}): string[] {
-  if (params.approvalKind === "plugin") {
-    return getMatrixApprovalAuthApprovers({
-      cfg: params.cfg as CoreConfig,
-      accountId: params.accountId,
-    });
-  }
-  return getMatrixExecApprovalApprovers(params);
-}
-
-export function isMatrixExecApprovalTargetRecipient(params: {
-  cfg: OpenClawConfig;
-  senderId?: string | null;
-  accountId?: string | null;
-}): boolean {
-  return isChannelExecApprovalTargetRecipient({
-    ...params,
-    channel: "matrix",
-    normalizeSenderId: normalizeMatrixApproverId,
-    matchTarget: ({ target, normalizedSenderId }) =>
-      normalizeMatrixApproverId(target.to) === normalizedSenderId,
-  });
-}
-
-const matrixExecApprovalProfile = createChannelExecApprovalProfile({
-  resolveConfig: resolveMatrixExecApprovalConfig,
-  resolveApprovers: getMatrixExecApprovalApprovers,
-  normalizeSenderId: normalizeMatrixApproverId,
-  isTargetRecipient: isMatrixExecApprovalTargetRecipient,
-  matchesRequestAccount: (params) =>
-    matchesMatrixRequestAccount({
-      ...params,
-      approvalKind: "exec",
-    }),
-});
-
-export const isMatrixExecApprovalClientEnabled = matrixExecApprovalProfile.isClientEnabled;
-export const isMatrixExecApprovalApprover = matrixExecApprovalProfile.isApprover;
-export const isMatrixExecApprovalAuthorizedSender = matrixExecApprovalProfile.isAuthorizedSender;
-export const resolveMatrixExecApprovalTarget = matrixExecApprovalProfile.resolveTarget;
-export const shouldHandleMatrixExecApprovalRequest = matrixExecApprovalProfile.shouldHandleRequest;
-
-export function isMatrixApprovalClientEnabled(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  approvalKind: ApprovalKind;
-}): boolean {
-  if (params.approvalKind === "exec") {
-    return isMatrixExecApprovalClientEnabled(params);
-  }
-  const config = resolveMatrixExecApprovalConfig(params);
-  return isChannelExecApprovalClientEnabledFromConfig({
-    enabled: config?.enabled,
-    approverCount: getMatrixApprovalApprovers(params).length,
-  });
-}
-
-export function isMatrixAnyApprovalClientEnabled(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): boolean {
-  return (
-    isMatrixApprovalClientEnabled({
-      ...params,
-      approvalKind: "exec",
-    }) ||
-    isMatrixApprovalClientEnabled({
-      ...params,
-      approvalKind: "plugin",
-    })
-  );
-}
-
-export function shouldHandleMatrixApprovalRequest(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  request: ApprovalRequest;
-}): boolean {
-  const approvalKind = resolveMatrixApprovalKind(params.request);
-  if (
-    !matchesMatrixRequestAccount({
-      ...params,
-      approvalKind,
-    })
-  ) {
-    return false;
-  }
-  const config = resolveMatrixExecApprovalConfig(params);
-  if (
-    !isChannelExecApprovalClientEnabledFromConfig({
-      enabled: config?.enabled,
-      approverCount: getMatrixApprovalApprovers({
-        ...params,
-        approvalKind,
-      }).length,
-    })
-  ) {
-    return false;
-  }
-  return matchesApprovalRequestFilters({
-    request: params.request.request,
-    agentFilter: config?.agentFilter,
-    sessionFilter: config?.sessionFilter,
-  });
-}
-
-function buildFilterCheckRequest(params: {
-  metadata: NonNullable<ReturnType<typeof getExecApprovalReplyMetadata>>;
-}): ApprovalRequest {
-  if (params.metadata.approvalKind === "plugin") {
-    return {
-      id: params.metadata.approvalId,
-      request: {
-        title: "Plugin Approval Required",
-        description: "",
-        agentId: params.metadata.agentId ?? null,
-        sessionKey: params.metadata.sessionKey ?? null,
-      },
-      createdAtMs: 0,
-      expiresAtMs: 0,
-    };
-  }
-  return {
-    id: params.metadata.approvalId,
-    request: {
-      command: "",
-      agentId: params.metadata.agentId ?? null,
-      sessionKey: params.metadata.sessionKey ?? null,
-    },
-    createdAtMs: 0,
-    expiresAtMs: 0,
-  };
-}
-
-export function shouldSuppressLocalMatrixExecApprovalPrompt(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  payload: ReplyPayload;
-}): boolean {
-  if (!matrixExecApprovalProfile.shouldSuppressLocalPrompt(params)) {
-    return false;
-  }
-  const metadata = getExecApprovalReplyMetadata(params.payload);
-  if (!metadata) {
-    return false;
-  }
-  const request = buildFilterCheckRequest({
-    metadata,
-  });
-  return shouldHandleMatrixApprovalRequest({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    request,
-  });
-}

package/src/group-mentions.ts

@@ -1,41 +0,0 @@
-import { resolveMatrixAccountConfig } from "./matrix/accounts.js";
-import { resolveMatrixRoomConfig } from "./matrix/monitor/rooms.js";
-import { normalizeMatrixResolvableTarget } from "./matrix/target-ids.js";
-import type { ChannelGroupContext, GroupToolPolicyConfig } from "./runtime-api.js";
-import type { CoreConfig } from "./types.js";
-
-function resolveMatrixRoomConfigForGroup(params: ChannelGroupContext) {
-  const roomId = normalizeMatrixResolvableTarget(params.groupId?.trim() ?? "");
-  const groupChannel = params.groupChannel?.trim() ?? "";
-  const aliases = groupChannel ? [normalizeMatrixResolvableTarget(groupChannel)] : [];
-  const cfg = params.cfg as CoreConfig;
-  const matrixConfig = resolveMatrixAccountConfig({ cfg, accountId: params.accountId });
-  return resolveMatrixRoomConfig({
-    rooms: matrixConfig.groups ?? matrixConfig.rooms,
-    roomId,
-    aliases,
-  }).config;
-}
-
-export function resolveMatrixGroupRequireMention(params: ChannelGroupContext): boolean {
-  const resolved = resolveMatrixRoomConfigForGroup(params);
-  if (resolved) {
-    if (resolved.autoReply === true) {
-      return false;
-    }
-    if (resolved.autoReply === false) {
-      return true;
-    }
-    if (typeof resolved.requireMention === "boolean") {
-      return resolved.requireMention;
-    }
-  }
-  return true;
-}
-
-export function resolveMatrixGroupToolPolicy(
-  params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
-  const resolved = resolveMatrixRoomConfigForGroup(params);
-  return resolved?.tools;
-}

package/src/legacy-crypto-inspector-availability.test.ts

@@ -1,81 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const availabilityState = vi.hoisted(() => ({
-  currentFilePath: "/virtual/dist/matrix-migration.runtime.js",
-  existingPaths: new Set<string>(),
-  dirEntries: [] as Array<{ name: string; isFile: () => boolean }>,
-}));
-
-vi.mock("node:fs", async () => {
-  const { mockNodeBuiltinModule } = await import("../../../test/helpers/node-builtin-mocks.js");
-  return mockNodeBuiltinModule(
-    () => vi.importActual<typeof import("node:fs")>("node:fs"),
-    {
-      existsSync: (candidate: unknown) => availabilityState.existingPaths.has(String(candidate)),
-      readdirSync: () => availabilityState.dirEntries as never,
-    },
-    { mirrorToDefault: true },
-  );
-});
-
-vi.mock("node:url", async () => {
-  const actual = await vi.importActual<typeof import("node:url")>("node:url");
-  return {
-    ...actual,
-    fileURLToPath: () => availabilityState.currentFilePath,
-  };
-});
-
-const { isMatrixLegacyCryptoInspectorAvailable } =
-  await import("./legacy-crypto-inspector-availability.js");
-
-describe("isMatrixLegacyCryptoInspectorAvailable", () => {
-  beforeEach(() => {
-    availabilityState.currentFilePath = "/virtual/dist/matrix-migration.runtime.js";
-    availabilityState.existingPaths.clear();
-    availabilityState.dirEntries = [];
-  });
-
-  it("detects the source inspector module directly", () => {
-    availabilityState.currentFilePath =
-      "/virtual/extensions/matrix/src/legacy-crypto-inspector-availability.js";
-    availabilityState.existingPaths.add(
-      "/virtual/extensions/matrix/src/matrix/legacy-crypto-inspector.ts",
-    );
-
-    expect(isMatrixLegacyCryptoInspectorAvailable()).toBe(true);
-  });
-
-  it("detects hashed built inspector chunks", () => {
-    availabilityState.dirEntries = [
-      {
-        name: "legacy-crypto-inspector-TPlLnFSE.js",
-        isFile: () => true,
-      },
-    ];
-
-    expect(isMatrixLegacyCryptoInspectorAvailable()).toBe(true);
-  });
-
-  it("does not confuse the availability helper artifact with the real inspector", () => {
-    availabilityState.dirEntries = [
-      {
-        name: "legacy-crypto-inspector-availability.js",
-        isFile: () => true,
-      },
-    ];
-
-    expect(isMatrixLegacyCryptoInspectorAvailable()).toBe(false);
-  });
-
-  it("does not confuse hashed availability helper chunks with the real inspector", () => {
-    availabilityState.dirEntries = [
-      {
-        name: "legacy-crypto-inspector-availability-TPlLnFSE.js",
-        isFile: () => true,
-      },
-    ];
-
-    expect(isMatrixLegacyCryptoInspectorAvailable()).toBe(false);
-  });
-});

package/src/legacy-crypto-inspector-availability.ts

@@ -1,60 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const LEGACY_CRYPTO_INSPECTOR_FILE = "legacy-crypto-inspector.js";
-const LEGACY_CRYPTO_INSPECTOR_CHUNK_PREFIX = "legacy-crypto-inspector-";
-const LEGACY_CRYPTO_INSPECTOR_HELPER_CHUNK_PREFIX = "availability-";
-const JAVASCRIPT_MODULE_SUFFIX = ".js";
-
-function isLegacyCryptoInspectorArtifactName(name: string): boolean {
-  if (name === LEGACY_CRYPTO_INSPECTOR_FILE) {
-    return true;
-  }
-  if (
-    !name.startsWith(LEGACY_CRYPTO_INSPECTOR_CHUNK_PREFIX) ||
-    !name.endsWith(JAVASCRIPT_MODULE_SUFFIX)
-  ) {
-    return false;
-  }
-  const chunkSuffix = name.slice(
-    LEGACY_CRYPTO_INSPECTOR_CHUNK_PREFIX.length,
-    -JAVASCRIPT_MODULE_SUFFIX.length,
-  );
-  return (
-    chunkSuffix.length > 0 &&
-    chunkSuffix !== "availability" &&
-    !chunkSuffix.startsWith(LEGACY_CRYPTO_INSPECTOR_HELPER_CHUNK_PREFIX)
-  );
-}
-
-function hasSourceInspectorArtifact(currentDir: string): boolean {
-  return [
-    path.resolve(currentDir, "matrix", "legacy-crypto-inspector.ts"),
-    path.resolve(currentDir, "matrix", "legacy-crypto-inspector.js"),
-  ].some((candidate) => fs.existsSync(candidate));
-}
-
-function hasBuiltInspectorArtifact(currentDir: string): boolean {
-  if (fs.existsSync(path.join(currentDir, "legacy-crypto-inspector.js"))) {
-    return true;
-  }
-  if (fs.existsSync(path.join(currentDir, "extensions", "matrix", "legacy-crypto-inspector.js"))) {
-    return true;
-  }
-  return fs
-    .readdirSync(currentDir, { withFileTypes: true })
-    .some((entry) => entry.isFile() && isLegacyCryptoInspectorArtifactName(entry.name));
-}
-
-export function isMatrixLegacyCryptoInspectorAvailable(): boolean {
-  const currentDir = path.dirname(fileURLToPath(import.meta.url));
-  if (hasSourceInspectorArtifact(currentDir)) {
-    return true;
-  }
-  try {
-    return hasBuiltInspectorArtifact(currentDir);
-  } catch {
-    return false;
-  }
-}

package/src/legacy-crypto.test.ts

@@ -1,234 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-runtime";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { withTempHome } from "../../../test/helpers/temp-home.js";
-
-const legacyCryptoInspectorAvailability = vi.hoisted(() => ({
-  available: true,
-}));
-
-vi.mock("./legacy-crypto-inspector-availability.js", () => ({
-  isMatrixLegacyCryptoInspectorAvailable: () => legacyCryptoInspectorAvailability.available,
-}));
-
-import { autoPrepareLegacyMatrixCrypto, detectLegacyMatrixCrypto } from "./legacy-crypto.js";
-import { resolveMatrixAccountStorageRoot } from "./storage-paths.js";
-import {
-  MATRIX_DEFAULT_ACCESS_TOKEN,
-  MATRIX_DEFAULT_DEVICE_ID,
-  MATRIX_DEFAULT_USER_ID,
-  LOBI_OPS_ACCESS_TOKEN,
-  MATRIX_OPS_ACCOUNT_ID,
-  LOBI_OPS_DEVICE_ID,
-  MATRIX_OPS_USER_ID,
-  MATRIX_TEST_HOMESERVER,
-  writeFile,
-  writeMatrixCredentials,
-} from "./test-helpers.js";
-
-function createDefaultMatrixConfig(): OpenClawConfig {
-  return {
-    channels: {
-      matrix: {
-        homeserver: MATRIX_TEST_HOMESERVER,
-        userId: MATRIX_DEFAULT_USER_ID,
-        accessToken: MATRIX_DEFAULT_ACCESS_TOKEN,
-      },
-    },
-  };
-}
-
-function writeDefaultLegacyCryptoFixture(home: string) {
-  const stateDir = path.join(home, ".openclaw");
-  const cfg = createDefaultMatrixConfig();
-  const { rootDir } = resolveMatrixAccountStorageRoot({
-    stateDir,
-    homeserver: MATRIX_TEST_HOMESERVER,
-    userId: MATRIX_DEFAULT_USER_ID,
-    accessToken: MATRIX_DEFAULT_ACCESS_TOKEN,
-  });
-  writeFile(
-    path.join(rootDir, "crypto", "bot-sdk.json"),
-    JSON.stringify({ deviceId: MATRIX_DEFAULT_DEVICE_ID }),
-  );
-  return { cfg, rootDir };
-}
-
-function createOpsLegacyCryptoFixture(params: {
-  home: string;
-  accessToken?: string;
-  includeStoredCredentials?: boolean;
-}) {
-  const stateDir = path.join(params.home, ".openclaw");
-  writeFile(
-    path.join(stateDir, "matrix", "crypto", "bot-sdk.json"),
-    JSON.stringify({ deviceId: LOBI_OPS_DEVICE_ID }),
-  );
-  if (params.includeStoredCredentials) {
-    writeMatrixCredentials(stateDir, {
-      accountId: MATRIX_OPS_ACCOUNT_ID,
-      accessToken: params.accessToken ?? LOBI_OPS_ACCESS_TOKEN,
-      deviceId: LOBI_OPS_DEVICE_ID,
-    });
-  }
-  const { rootDir } = resolveMatrixAccountStorageRoot({
-    stateDir,
-    homeserver: MATRIX_TEST_HOMESERVER,
-    userId: MATRIX_OPS_USER_ID,
-    accessToken: params.accessToken ?? LOBI_OPS_ACCESS_TOKEN,
-    accountId: MATRIX_OPS_ACCOUNT_ID,
-  });
-  return { rootDir };
-}
-
-describe("matrix legacy encrypted-state migration", () => {
-  afterEach(() => {
-    legacyCryptoInspectorAvailability.available = true;
-  });
-
-  it("extracts a saved backup key into the new recovery-key path", async () => {
-    await withTempHome(async (home) => {
-      const { cfg, rootDir } = writeDefaultLegacyCryptoFixture(home);
-
-      const detection = detectLegacyMatrixCrypto({ cfg, env: process.env });
-      expect(detection.inspectorAvailable).toBe(true);
-      expect(detection.warnings).toEqual([]);
-      expect(detection.plans).toHaveLength(1);
-
-      const result = await autoPrepareLegacyMatrixCrypto({
-        cfg,
-        env: process.env,
-        deps: {
-          inspectLegacyStore: async () => ({
-            deviceId: MATRIX_DEFAULT_DEVICE_ID,
-            roomKeyCounts: { total: 12, backedUp: 12 },
-            backupVersion: "1",
-            decryptionKeyBase64: "YWJjZA==",
-          }),
-        },
-      });
-
-      expect(result.migrated).toBe(true);
-      expect(result.warnings).toEqual([]);
-
-      const recovery = JSON.parse(
-        fs.readFileSync(path.join(rootDir, "recovery-key.json"), "utf8"),
-      ) as {
-        privateKeyBase64: string;
-      };
-      expect(recovery.privateKeyBase64).toBe("YWJjZA==");
-    });
-  });
-
-  it("skips migration when no legacy Matrix plans exist", async () => {
-    await withTempHome(async () => {
-      const result = await autoPrepareLegacyMatrixCrypto({
-        cfg: createDefaultMatrixConfig(),
-        env: process.env,
-      });
-
-      expect(result).toEqual({
-        migrated: false,
-        changes: [],
-        warnings: [],
-      });
-    });
-  });
-
-  it("warns when legacy local-only room keys cannot be recovered automatically", async () => {
-    await withTempHome(async (home) => {
-      const { cfg, rootDir } = writeDefaultLegacyCryptoFixture(home);
-
-      const result = await autoPrepareLegacyMatrixCrypto({
-        cfg,
-        env: process.env,
-        deps: {
-          inspectLegacyStore: async () => ({
-            deviceId: MATRIX_DEFAULT_DEVICE_ID,
-            roomKeyCounts: { total: 15, backedUp: 10 },
-            backupVersion: null,
-            decryptionKeyBase64: null,
-          }),
-        },
-      });
-
-      expect(result.migrated).toBe(true);
-      expect(result.warnings).toContain(
-        'Legacy Matrix encrypted state for account "default" contains 5 room key(s) that were never backed up. Backed-up keys can be restored automatically, but local-only encrypted history may remain unavailable after upgrade.',
-      );
-      expect(result.warnings).toContain(
-        'Legacy Matrix encrypted state for account "default" cannot be fully converted automatically because the old rust crypto store does not expose all local room keys for export.',
-      );
-      const state = JSON.parse(
-        fs.readFileSync(path.join(rootDir, "legacy-crypto-migration.json"), "utf8"),
-      ) as { restoreStatus: string };
-      expect(state.restoreStatus).toBe("manual-action-required");
-    });
-  });
-
-  it("prefers stored credentials for named accounts when config is token-only", async () => {
-    await withTempHome(async (home) => {
-      const { rootDir } = createOpsLegacyCryptoFixture({
-        home,
-        includeStoredCredentials: true,
-      });
-      const cfg: OpenClawConfig = {
-        channels: {
-          matrix: {
-            accounts: {
-              ops: {
-                homeserver: MATRIX_TEST_HOMESERVER,
-                accessToken: LOBI_OPS_ACCESS_TOKEN,
-              },
-            },
-          },
-        },
-      };
-
-      const result = await autoPrepareLegacyMatrixCrypto({
-        cfg,
-        env: process.env,
-        deps: {
-          inspectLegacyStore: async () => ({
-            deviceId: LOBI_OPS_DEVICE_ID,
-            roomKeyCounts: { total: 1, backedUp: 1 },
-            backupVersion: "1",
-            decryptionKeyBase64: "b3Bz",
-          }),
-        },
-      });
-
-      expect(result.migrated).toBe(true);
-      expect(fs.existsSync(path.join(rootDir, "recovery-key.json"))).toBe(true);
-    });
-  });
-
-  it("stays warning-only when the legacy crypto inspector artifact is unavailable", async () => {
-    legacyCryptoInspectorAvailability.available = false;
-
-    await withTempHome(async (home) => {
-      const { cfg } = writeDefaultLegacyCryptoFixture(home);
-
-      const detection = detectLegacyMatrixCrypto({ cfg, env: process.env });
-      expect(detection.inspectorAvailable).toBe(false);
-      expect(detection.plans).toHaveLength(1);
-      expect(detection.warnings).toContain(
-        "Legacy Matrix encrypted state was detected, but the Matrix crypto inspector is unavailable.",
-      );
-
-      const result = await autoPrepareLegacyMatrixCrypto({
-        cfg,
-        env: process.env,
-      });
-
-      expect(result).toEqual({
-        migrated: false,
-        changes: [],
-        warnings: [
-          "Legacy Matrix encrypted state was detected, but the Matrix crypto inspector is unavailable.",
-        ],
-      });
-    });
-  });
-});