@archipelagolab/lobi 1.0.5 → 1.0.6

package/dist/chunk-4OXPPDV6.js

@@ -0,0 +1,676 @@
+import {
+  resolveMatrixTargets
+} from "./chunk-R7ZBOXPS.js";
+import {
+  listMatrixDirectoryGroupsLive
+} from "./chunk-CEKNTCJD.js";
+import {
+  moveSingleMatrixAccountConfigToNamedAccount
+} from "./chunk-XR7DPSNX.js";
+import {
+  updateMatrixAccountConfig
+} from "./chunk-XOZPOHLG.js";
+import {
+  addWildcardAllowFrom,
+  formatDocsLink,
+  hasConfiguredSecretInput,
+  isPrivateOrLoopbackHost,
+  mergeAllowFromEntries,
+  normalizeAccountId,
+  promptAccountId,
+  promptChannelAccessConfig,
+  splitSetupEntries
+} from "./chunk-HGHU3TVL.js";
+import {
+  listMatrixAccountIds,
+  resolveDefaultMatrixAccountId,
+  resolveMatrixAccount
+} from "./chunk-MJ2GW6SU.js";
+import {
+  resolveMatrixEnvAuthReadiness,
+  resolveValidatedMatrixHomeserverUrl,
+  validateMatrixHomeserverUrl
+} from "./chunk-OKDOVX4B.js";
+import {
+  resolveMatrixConfigFieldPath
+} from "./chunk-SPNSM6SB.js";
+import {
+  resolveMatrixAccountConfig
+} from "./chunk-3OXOEMBS.js";
+import {
+  ensureMatrixSdkInstalled,
+  isMatrixSdkAvailable
+} from "./chunk-Q6H5OV2R.js";
+import {
+  requiresExplicitMatrixDefaultAccount
+} from "./chunk-3R4ATE4Q.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/onboarding.ts
+init_shims();
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { isPrivateNetworkOptInEnabled } from "openclaw/plugin-sdk/ssrf-runtime";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+  normalizeStringifiedOptionalString
+} from "openclaw/plugin-sdk/text-runtime";
+var channel = "matrix";
+var matrixInviteAutoJoinOptions = [
+  { value: "allowlist", label: "Allowlist (recommended)" },
+  { value: "always", label: "Always (join every invite)" },
+  { value: "off", label: "Off (do not auto-join invites)" }
+];
+function isMatrixInviteAutoJoinPolicy(value) {
+  return value === "allowlist" || value === "always" || value === "off";
+}
+function isMatrixInviteAutoJoinTarget(entry) {
+  return entry === "*" || entry.startsWith("!") && entry.includes(":") || entry.startsWith("#") && entry.includes(":");
+}
+function normalizeMatrixInviteAutoJoinTargets(entries) {
+  return [
+    ...new Set(
+      entries.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry))
+    )
+  ];
+}
+function resolveMatrixOnboardingAccountId(cfg, accountId) {
+  return normalizeAccountId(
+    normalizeOptionalString(accountId) || resolveDefaultMatrixAccountId(cfg) || DEFAULT_ACCOUNT_ID
+  );
+}
+function setMatrixDmPolicy(cfg, policy, accountId) {
+  const resolvedAccountId = resolveMatrixOnboardingAccountId(cfg, accountId);
+  const existing = resolveMatrixAccountConfig({
+    cfg,
+    accountId: resolvedAccountId
+  });
+  const allowFrom = policy === "open" ? addWildcardAllowFrom(existing.dm?.allowFrom) : void 0;
+  return updateMatrixAccountConfig(cfg, resolvedAccountId, {
+    dm: {
+      ...existing.dm,
+      policy,
+      ...allowFrom ? { allowFrom } : {}
+    }
+  });
+}
+async function noteMatrixAuthHelp(prompter) {
+  await prompter.note(
+    [
+      "Matrix requires a homeserver URL.",
+      "Use an access token (recommended) or password login to an existing account.",
+      "With access token: user ID is fetched automatically.",
+      "Env vars supported: LOBI_HOMESERVER, LOBI_USER_ID, LOBI_ACCESS_TOKEN, LOBI_PASSWORD, LOBI_DEVICE_ID, LOBI_DEVICE_NAME.",
+      "Per-account env vars: MATRIX_<ACCOUNT_ID>_HOMESERVER, MATRIX_<ACCOUNT_ID>_USER_ID, MATRIX_<ACCOUNT_ID>_ACCESS_TOKEN, MATRIX_<ACCOUNT_ID>_PASSWORD, MATRIX_<ACCOUNT_ID>_DEVICE_ID, MATRIX_<ACCOUNT_ID>_DEVICE_NAME.",
+      `Docs: ${formatDocsLink("/channels/matrix", "channels/matrix")}`
+    ].join("\n"),
+    "Matrix setup"
+  );
+}
+function requiresMatrixPrivateNetworkOptIn(homeserver) {
+  try {
+    const parsed = new URL(homeserver);
+    return parsed.protocol === "http:" && !isPrivateOrLoopbackHost(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+async function promptMatrixAllowFrom(params) {
+  const { cfg, prompter } = params;
+  const accountId = resolveMatrixOnboardingAccountId(cfg, params.accountId);
+  const existingConfig = resolveMatrixAccountConfig({ cfg, accountId });
+  const existingAllowFrom = existingConfig.dm?.allowFrom ?? [];
+  const account = resolveMatrixAccount({ cfg, accountId });
+  const canResolve = account.configured;
+  const isFullUserId = (value) => value.startsWith("@") && value.includes(":");
+  while (true) {
+    const entry = await prompter.text({
+      message: "Matrix allowFrom (full @user:server; display name only if unique)",
+      placeholder: "@user:server",
+      initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : void 0,
+      validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+    });
+    const parts = splitSetupEntries(entry);
+    const resolvedIds = [];
+    const pending = [];
+    const unresolved = [];
+    const unresolvedNotes = [];
+    for (const part of parts) {
+      if (isFullUserId(part)) {
+        resolvedIds.push(part);
+        continue;
+      }
+      if (!canResolve) {
+        unresolved.push(part);
+        continue;
+      }
+      pending.push(part);
+    }
+    if (pending.length > 0) {
+      const results = await resolveMatrixTargets({
+        cfg,
+        accountId,
+        inputs: pending,
+        kind: "user"
+      }).catch(() => []);
+      for (const result of results) {
+        if (result?.resolved && result.id) {
+          resolvedIds.push(result.id);
+          continue;
+        }
+        if (result?.input) {
+          unresolved.push(result.input);
+          if (result.note) {
+            unresolvedNotes.push(`${result.input}: ${result.note}`);
+          }
+        }
+      }
+    }
+    if (unresolved.length > 0) {
+      const details = unresolvedNotes.length > 0 ? unresolvedNotes : unresolved;
+      await prompter.note(
+        `Could not resolve:
+${details.join("\n")}
+Use full @user:server IDs.`,
+        "Matrix allowlist"
+      );
+      continue;
+    }
+    const unique = mergeAllowFromEntries(existingAllowFrom, resolvedIds);
+    return updateMatrixAccountConfig(cfg, accountId, {
+      dm: {
+        ...existingConfig.dm,
+        policy: "allowlist",
+        allowFrom: unique
+      }
+    });
+  }
+}
+function setMatrixGroupPolicy(cfg, groupPolicy, accountId) {
+  return updateMatrixAccountConfig(cfg, resolveMatrixOnboardingAccountId(cfg, accountId), {
+    groupPolicy
+  });
+}
+function setMatrixGroupRooms(cfg, roomKeys, accountId) {
+  const groups = Object.fromEntries(roomKeys.map((key) => [key, { enabled: true }]));
+  return updateMatrixAccountConfig(cfg, resolveMatrixOnboardingAccountId(cfg, accountId), {
+    groups,
+    rooms: null
+  });
+}
+function setMatrixAutoJoin(cfg, autoJoin, autoJoinAllowlist, accountId) {
+  return updateMatrixAccountConfig(cfg, resolveMatrixOnboardingAccountId(cfg, accountId), {
+    autoJoin,
+    autoJoinAllowlist: autoJoin === "allowlist" ? autoJoinAllowlist : null
+  });
+}
+async function configureMatrixInviteAutoJoin(params) {
+  const accountId = resolveMatrixOnboardingAccountId(params.cfg, params.accountId);
+  const existingConfig = resolveMatrixAccountConfig({ cfg: params.cfg, accountId });
+  const currentPolicy = existingConfig.autoJoin ?? "off";
+  const currentAllowlist = (existingConfig.autoJoinAllowlist ?? []).map((entry) => String(entry));
+  const hasExistingConfig = existingConfig.autoJoin !== void 0 || currentAllowlist.length > 0;
+  await params.prompter.note(
+    [
+      "WARNING: Matrix invite auto-join defaults to off.",
+      "OpenClaw agents will not join invited rooms or fresh DM-style invites unless you set autoJoin.",
+      'Choose "allowlist" to restrict joins or "always" to join every invite.'
+    ].join("\n"),
+    "Matrix invite auto-join"
+  );
+  const wants = await params.prompter.confirm({
+    message: hasExistingConfig ? "Update Matrix invite auto-join?" : "Configure Matrix invite auto-join?",
+    initialValue: hasExistingConfig ? currentPolicy !== "off" : true
+  });
+  if (!wants) {
+    return params.cfg;
+  }
+  const selectedPolicy = await params.prompter.select({
+    message: "Matrix invite auto-join",
+    options: matrixInviteAutoJoinOptions,
+    initialValue: currentPolicy
+  });
+  if (!isMatrixInviteAutoJoinPolicy(selectedPolicy)) {
+    throw new Error(`Unsupported Matrix invite auto-join policy: ${String(selectedPolicy)}`);
+  }
+  const policy = selectedPolicy;
+  if (policy === "off") {
+    await params.prompter.note(
+      [
+        "Matrix invite auto-join remains off.",
+        "Agents will not join invited rooms or fresh DM-style invites until you change autoJoin."
+      ].join("\n"),
+      "Matrix invite auto-join"
+    );
+    return setMatrixAutoJoin(params.cfg, policy, [], accountId);
+  }
+  if (policy === "always") {
+    return setMatrixAutoJoin(params.cfg, policy, [], accountId);
+  }
+  while (true) {
+    const rawAllowlist = await params.prompter.text({
+      message: "Matrix invite auto-join allowlist (comma-separated)",
+      placeholder: "!roomId:server, #alias:server, *",
+      initialValue: currentAllowlist[0] ? currentAllowlist.join(", ") : void 0,
+      validate: (value) => {
+        const entries = splitSetupEntries(value);
+        return entries.length > 0 ? void 0 : "Required";
+      }
+    });
+    const allowlist = normalizeMatrixInviteAutoJoinTargets(splitSetupEntries(rawAllowlist));
+    const invalidEntries = allowlist.filter((entry) => !isMatrixInviteAutoJoinTarget(entry));
+    if (allowlist.length === 0 || invalidEntries.length > 0) {
+      await params.prompter.note(
+        [
+          "Use only stable Matrix invite targets for auto-join: !roomId:server, #alias:server, or *.",
+          invalidEntries.length > 0 ? `Invalid: ${invalidEntries.join(", ")}` : void 0
+        ].filter(Boolean).join("\n"),
+        "Matrix invite auto-join"
+      );
+      continue;
+    }
+    return setMatrixAutoJoin(params.cfg, "allowlist", allowlist, accountId);
+  }
+}
+async function configureMatrixAccessPrompts(params) {
+  let next = params.cfg;
+  if (params.forceAllowFrom) {
+    next = await promptMatrixAllowFrom({
+      cfg: next,
+      prompter: params.prompter,
+      accountId: params.accountId
+    });
+  }
+  const existingAccountConfig = resolveMatrixAccountConfig({
+    cfg: next,
+    accountId: params.accountId
+  });
+  const existingGroups = existingAccountConfig.groups ?? existingAccountConfig.rooms;
+  const accessConfig = await promptChannelAccessConfig({
+    prompter: params.prompter,
+    label: "Matrix rooms",
+    currentPolicy: existingAccountConfig.groupPolicy ?? "allowlist",
+    currentEntries: Object.keys(existingGroups ?? {}),
+    placeholder: "!roomId:server, #alias:server, Project Room",
+    updatePrompt: Boolean(existingGroups)
+  });
+  if (accessConfig) {
+    if (accessConfig.policy !== "allowlist") {
+      next = setMatrixGroupPolicy(next, accessConfig.policy, params.accountId);
+    } else {
+      let roomKeys = accessConfig.entries;
+      if (accessConfig.entries.length > 0) {
+        try {
+          const resolvedIds = [];
+          const unresolved = [];
+          for (const entry of accessConfig.entries) {
+            const trimmed = normalizeOptionalString(entry) ?? "";
+            if (!trimmed) {
+              continue;
+            }
+            const cleaned = trimmed.replace(/^(room|channel):/i, "").trim();
+            if (cleaned.startsWith("!") && cleaned.includes(":")) {
+              resolvedIds.push(cleaned);
+              continue;
+            }
+            const matches = await listMatrixDirectoryGroupsLive({
+              cfg: next,
+              accountId: params.accountId,
+              query: trimmed,
+              limit: 10
+            });
+            const exact = matches.find(
+              (match) => normalizeLowercaseStringOrEmpty(match.name) === normalizeLowercaseStringOrEmpty(trimmed)
+            );
+            const best = exact ?? matches[0];
+            if (best?.id) {
+              resolvedIds.push(best.id);
+            } else {
+              unresolved.push(entry);
+            }
+          }
+          roomKeys = [
+            ...resolvedIds,
+            ...unresolved.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry))
+          ];
+          if (resolvedIds.length > 0 || unresolved.length > 0) {
+            await params.prompter.note(
+              [
+                resolvedIds.length > 0 ? `Resolved: ${resolvedIds.join(", ")}` : void 0,
+                unresolved.length > 0 ? `Unresolved (kept as typed): ${unresolved.join(", ")}` : void 0
+              ].filter(Boolean).join("\n"),
+              "Matrix rooms"
+            );
+          }
+        } catch (err) {
+          await params.prompter.note(
+            `Room lookup failed; keeping entries as typed. ${String(err)}`,
+            "Matrix rooms"
+          );
+        }
+      }
+      next = setMatrixGroupPolicy(next, "allowlist", params.accountId);
+      next = setMatrixGroupRooms(next, roomKeys, params.accountId);
+    }
+  }
+  return await configureMatrixInviteAutoJoin({
+    cfg: next,
+    prompter: params.prompter,
+    accountId: params.accountId
+  });
+}
+var dmPolicy = {
+  label: "Matrix",
+  channel,
+  policyKey: "channels.lobi.dm.policy",
+  allowFromKey: "channels.lobi.dm.allowFrom",
+  resolveConfigKeys: (cfg, accountId) => {
+    const effectiveAccountId = resolveMatrixOnboardingAccountId(cfg, accountId);
+    return {
+      policyKey: resolveMatrixConfigFieldPath(cfg, effectiveAccountId, "dm.policy"),
+      allowFromKey: resolveMatrixConfigFieldPath(
+        cfg,
+        effectiveAccountId,
+        "dm.allowFrom"
+      )
+    };
+  },
+  getCurrent: (cfg, accountId) => resolveMatrixAccountConfig({
+    cfg,
+    accountId: resolveMatrixOnboardingAccountId(cfg, accountId)
+  }).dm?.policy ?? "pairing",
+  setPolicy: (cfg, policy, accountId) => setMatrixDmPolicy(cfg, policy, accountId),
+  promptAllowFrom: promptMatrixAllowFrom
+};
+async function runMatrixConfigure(params) {
+  let next = params.cfg;
+  await ensureMatrixSdkInstalled({
+    runtime: params.runtime,
+    confirm: async (message) => await params.prompter.confirm({
+      message,
+      initialValue: true
+    })
+  });
+  const defaultAccountId = resolveDefaultMatrixAccountId(next);
+  let accountId = defaultAccountId || DEFAULT_ACCOUNT_ID;
+  if (params.intent === "add-account") {
+    const enteredName = normalizeStringifiedOptionalString(
+      await params.prompter.text({
+        message: "Matrix account name",
+        validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+      })
+    ) ?? "";
+    accountId = normalizeAccountId(enteredName);
+    if (enteredName !== accountId) {
+      await params.prompter.note(`Account id will be "${accountId}".`, "Matrix account");
+    }
+    if (accountId !== DEFAULT_ACCOUNT_ID) {
+      next = moveSingleMatrixAccountConfigToNamedAccount(next);
+    }
+    next = updateMatrixAccountConfig(next, accountId, { name: enteredName, enabled: true });
+  } else {
+    const override = normalizeOptionalString(params.accountOverrides?.[channel]);
+    if (override) {
+      accountId = normalizeAccountId(override);
+    } else if (params.shouldPromptAccountIds) {
+      accountId = await promptAccountId({
+        cfg: next,
+        prompter: params.prompter,
+        label: "Matrix",
+        currentId: accountId,
+        listAccountIds: (inputCfg) => listMatrixAccountIds(inputCfg),
+        defaultAccountId
+      });
+    }
+  }
+  const existing = resolveMatrixAccountConfig({ cfg: next, accountId });
+  const account = resolveMatrixAccount({ cfg: next, accountId });
+  if (!account.configured) {
+    await noteMatrixAuthHelp(params.prompter);
+  }
+  const envReadiness = resolveMatrixEnvAuthReadiness(accountId, process.env);
+  const envReady = envReadiness.ready;
+  const envHomeserver = envReadiness.homeserver;
+  const envUserId = envReadiness.userId;
+  if (envReady && !existing.homeserver && !existing.userId && !existing.accessToken && !existing.password) {
+    const useEnv = await params.prompter.confirm({
+      message: `Matrix env vars detected (${envReadiness.sourceHint}). Use env values?`,
+      initialValue: true
+    });
+    if (useEnv) {
+      next = updateMatrixAccountConfig(next, accountId, { enabled: true });
+      next = await configureMatrixAccessPrompts({
+        cfg: next,
+        prompter: params.prompter,
+        forceAllowFrom: params.forceAllowFrom,
+        accountId
+      });
+      return { cfg: next, accountId };
+    }
+  }
+  const homeserver = normalizeStringifiedOptionalString(
+    await params.prompter.text({
+      message: "Matrix homeserver URL",
+      initialValue: existing.homeserver ?? envHomeserver,
+      validate: (value) => {
+        try {
+          validateMatrixHomeserverUrl(value, {
+            allowPrivateNetwork: true
+          });
+          return void 0;
+        } catch (error) {
+          return error instanceof Error ? error.message : "Invalid Matrix homeserver URL";
+        }
+      }
+    })
+  ) ?? "";
+  const requiresAllowPrivateNetwork = requiresMatrixPrivateNetworkOptIn(homeserver);
+  const shouldPromptAllowPrivateNetwork = requiresAllowPrivateNetwork || isPrivateNetworkOptInEnabled(existing);
+  const allowPrivateNetwork = shouldPromptAllowPrivateNetwork ? await params.prompter.confirm({
+    message: "Allow private/internal Matrix homeserver traffic for this account?",
+    initialValue: isPrivateNetworkOptInEnabled(existing) || requiresAllowPrivateNetwork
+  }) : false;
+  if (requiresAllowPrivateNetwork && !allowPrivateNetwork) {
+    throw new Error("Matrix homeserver requires explicit private-network opt-in");
+  }
+  await resolveValidatedMatrixHomeserverUrl(homeserver, {
+    dangerouslyAllowPrivateNetwork: allowPrivateNetwork
+  });
+  let accessToken = existing.accessToken;
+  let password = existing.password;
+  let userId = existing.userId ?? "";
+  if (hasConfiguredSecretInput(accessToken) || hasConfiguredSecretInput(password)) {
+    const keep = await params.prompter.confirm({
+      message: "Matrix credentials already configured. Keep them?",
+      initialValue: true
+    });
+    if (!keep) {
+      accessToken = void 0;
+      password = void 0;
+      userId = "";
+    }
+  }
+  if (!hasConfiguredSecretInput(accessToken) && !hasConfiguredSecretInput(password)) {
+    const authMode = await params.prompter.select({
+      message: "Matrix auth method",
+      options: [
+        { value: "token", label: "Access token (user ID fetched automatically)" },
+        { value: "password", label: "Password (requires user ID)" }
+      ]
+    });
+    if (authMode === "token") {
+      accessToken = normalizeStringifiedOptionalString(
+        await params.prompter.text({
+          message: "Matrix access token",
+          validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+        })
+      ) ?? "";
+      password = void 0;
+      userId = "";
+    } else {
+      userId = normalizeStringifiedOptionalString(
+        await params.prompter.text({
+          message: "Matrix user ID",
+          initialValue: existing.userId ?? envUserId,
+          validate: (value) => {
+            const raw = normalizeOptionalString(value) ?? "";
+            if (!raw) {
+              return "Required";
+            }
+            if (!raw.startsWith("@")) {
+              return "Matrix user IDs should start with @";
+            }
+            if (!raw.includes(":")) {
+              return "Matrix user IDs should include a server (:server)";
+            }
+            return void 0;
+          }
+        })
+      ) ?? "";
+      password = normalizeStringifiedOptionalString(
+        await params.prompter.text({
+          message: "Matrix password",
+          validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+        })
+      ) ?? "";
+      accessToken = void 0;
+    }
+  }
+  const deviceName = normalizeStringifiedOptionalString(
+    await params.prompter.text({
+      message: "Matrix device name (optional)",
+      initialValue: existing.deviceName ?? "OpenClaw Gateway"
+    })
+  ) ?? "";
+  const enableEncryption = await params.prompter.confirm({
+    message: "Enable end-to-end encryption (E2EE)?",
+    initialValue: existing.encryption ?? false
+  });
+  next = updateMatrixAccountConfig(next, accountId, {
+    enabled: true,
+    homeserver,
+    ...shouldPromptAllowPrivateNetwork ? { allowPrivateNetwork: allowPrivateNetwork ? true : null } : {},
+    userId: userId || null,
+    accessToken: accessToken ?? null,
+    password: password ?? null,
+    deviceName: deviceName || null,
+    encryption: enableEncryption
+  });
+  next = await configureMatrixAccessPrompts({
+    cfg: next,
+    prompter: params.prompter,
+    forceAllowFrom: params.forceAllowFrom,
+    accountId
+  });
+  return { cfg: next, accountId };
+}
+var matrixOnboardingAdapter = {
+  channel,
+  getStatus: async ({ cfg, accountOverrides }) => {
+    const resolvedCfg = cfg;
+    const sdkReady = isMatrixSdkAvailable();
+    if (!accountOverrides[channel] && requiresExplicitMatrixDefaultAccount(resolvedCfg)) {
+      return {
+        channel,
+        configured: false,
+        statusLines: ['Matrix: set "channels.lobi.defaultAccount" to select a named account'],
+        selectionHint: !sdkReady ? "install Matrix deps" : "set defaultAccount"
+      };
+    }
+    const account = resolveMatrixAccount({
+      cfg: resolvedCfg,
+      accountId: resolveMatrixOnboardingAccountId(resolvedCfg, accountOverrides[channel])
+    });
+    const configured = account.configured;
+    return {
+      channel,
+      configured,
+      statusLines: [
+        `Matrix: ${configured ? "configured" : "needs homeserver + access token or password"}`
+      ],
+      selectionHint: !sdkReady ? "install Matrix deps" : configured ? "configured" : "needs auth"
+    };
+  },
+  configure: async ({
+    cfg,
+    runtime,
+    prompter,
+    forceAllowFrom,
+    accountOverrides,
+    shouldPromptAccountIds
+  }) => await runMatrixConfigure({
+    cfg,
+    runtime,
+    prompter,
+    forceAllowFrom,
+    accountOverrides,
+    shouldPromptAccountIds,
+    intent: "update"
+  }),
+  configureInteractive: async ({
+    cfg,
+    runtime,
+    prompter,
+    forceAllowFrom,
+    accountOverrides,
+    shouldPromptAccountIds,
+    configured
+  }) => {
+    if (!configured) {
+      return await runMatrixConfigure({
+        cfg,
+        runtime,
+        prompter,
+        forceAllowFrom,
+        accountOverrides,
+        shouldPromptAccountIds,
+        intent: "update"
+      });
+    }
+    const action = await prompter.select({
+      message: "Matrix already configured. What do you want to do?",
+      options: [
+        { value: "update", label: "Modify settings" },
+        { value: "add-account", label: "Add account" },
+        { value: "skip", label: "Skip (leave as-is)" }
+      ],
+      initialValue: "update"
+    });
+    if (action === "skip") {
+      return "skip";
+    }
+    return await runMatrixConfigure({
+      cfg,
+      runtime,
+      prompter,
+      forceAllowFrom,
+      accountOverrides,
+      shouldPromptAccountIds,
+      intent: action === "add-account" ? "add-account" : "update"
+    });
+  },
+  afterConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
+    const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./src/setup-bootstrap.js");
+    await runMatrixSetupBootstrapAfterConfigWrite({
+      previousCfg,
+      cfg,
+      accountId,
+      runtime
+    });
+  },
+  dmPolicy,
+  disable: (cfg) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      matrix: { ...cfg.channels?.["matrix"], enabled: false }
+    }
+  })
+};
+
+export {
+  matrixOnboardingAdapter
+};
+//# sourceMappingURL=chunk-4OXPPDV6.js.map