@gakr-gakr/matrix 0.1.0

package/src/auth-precedence.ts

@@ -0,0 +1,61 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "autobot/plugin-sdk/account-id";
+
+export type MatrixResolvedStringField =
+  | "homeserver"
+  | "userId"
+  | "accessToken"
+  | "password"
+  | "deviceId"
+  | "deviceName";
+
+export type MatrixResolvedStringValues = Record<MatrixResolvedStringField, string>;
+
+type MatrixStringSourceMap = Partial<Record<MatrixResolvedStringField, string>>;
+
+const MATRIX_DEFAULT_ACCOUNT_AUTH_ONLY_FIELDS = new Set<MatrixResolvedStringField>([
+  "userId",
+  "accessToken",
+  "password",
+  "deviceId",
+]);
+
+function resolveMatrixStringSourceValue(value: string | undefined): string {
+  return typeof value === "string" ? value : "";
+}
+
+function shouldAllowBaseAuthFallback(accountId: string, field: MatrixResolvedStringField): boolean {
+  return (
+    normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID ||
+    !MATRIX_DEFAULT_ACCOUNT_AUTH_ONLY_FIELDS.has(field)
+  );
+}
+
+export function resolveMatrixAccountStringValues(params: {
+  accountId: string;
+  account?: MatrixStringSourceMap;
+  scopedEnv?: MatrixStringSourceMap;
+  channel?: MatrixStringSourceMap;
+  globalEnv?: MatrixStringSourceMap;
+}): MatrixResolvedStringValues {
+  const fields: MatrixResolvedStringField[] = [
+    "homeserver",
+    "userId",
+    "accessToken",
+    "password",
+    "deviceId",
+    "deviceName",
+  ];
+  const resolved = {} as MatrixResolvedStringValues;
+
+  for (const field of fields) {
+    resolved[field] =
+      resolveMatrixStringSourceValue(params.account?.[field]) ||
+      resolveMatrixStringSourceValue(params.scopedEnv?.[field]) ||
+      (shouldAllowBaseAuthFallback(params.accountId, field)
+        ? resolveMatrixStringSourceValue(params.channel?.[field]) ||
+          resolveMatrixStringSourceValue(params.globalEnv?.[field])
+        : "");
+  }
+
+  return resolved;
+}

package/src/channel-account-paths.ts

@@ -0,0 +1,97 @@
+import { createPairingPrefixStripper } from "autobot/plugin-sdk/channel-pairing";
+import { PAIRING_APPROVED_MESSAGE } from "autobot/plugin-sdk/channel-status";
+import type { PinnedDispatcherPolicy, SsrFPolicy } from "autobot/plugin-sdk/ssrf-dispatcher";
+import { formatMatrixErrorMessage } from "./matrix/errors.js";
+import type { MatrixProbe } from "./matrix/probe.js";
+import type { CoreConfig } from "./types.js";
+
+type ResolveMatrixAuth = (params: { cfg: CoreConfig; accountId?: string }) => Promise<{
+  homeserver: string;
+  accessToken: string;
+  userId: string;
+  deviceId?: string;
+  allowPrivateNetwork?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  dispatcherPolicy?: PinnedDispatcherPolicy;
+}>;
+
+type ProbeMatrix = (params: {
+  homeserver: string;
+  accessToken: string;
+  userId: string;
+  deviceId?: string;
+  timeoutMs: number;
+  accountId?: string;
+  allowPrivateNetwork?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  dispatcherPolicy?: PinnedDispatcherPolicy;
+}) => Promise<MatrixProbe>;
+
+type SendMessageMatrix = (
+  to: string,
+  message: string,
+  options: { cfg: CoreConfig; accountId?: string },
+) => Promise<unknown>;
+
+export function createMatrixProbeAccount(params: {
+  resolveMatrixAuth: ResolveMatrixAuth;
+  probeMatrix: ProbeMatrix;
+}) {
+  return async ({
+    account,
+    timeoutMs,
+    cfg,
+  }: {
+    account: { accountId?: string };
+    timeoutMs?: number;
+    cfg: unknown;
+  }): Promise<MatrixProbe> => {
+    try {
+      const auth = await params.resolveMatrixAuth({
+        cfg: cfg as CoreConfig,
+        accountId: account.accountId,
+      });
+      return await params.probeMatrix({
+        homeserver: auth.homeserver,
+        accessToken: auth.accessToken,
+        userId: auth.userId,
+        deviceId: auth.deviceId,
+        timeoutMs: timeoutMs ?? 5_000,
+        accountId: account.accountId,
+        allowPrivateNetwork: auth.allowPrivateNetwork,
+        ssrfPolicy: auth.ssrfPolicy,
+        dispatcherPolicy: auth.dispatcherPolicy,
+      });
+    } catch (err) {
+      return {
+        ok: false,
+        error: formatMatrixErrorMessage(err),
+        elapsedMs: 0,
+      };
+    }
+  };
+}
+
+export function createMatrixPairingText(sendMessageMatrix: SendMessageMatrix) {
+  return {
+    idLabel: "matrixUserId",
+    message: PAIRING_APPROVED_MESSAGE,
+    normalizeAllowEntry: createPairingPrefixStripper(/^matrix:/i),
+    notify: async ({
+      id,
+      message,
+      cfg,
+      accountId,
+    }: {
+      id: string;
+      message: string;
+      cfg: CoreConfig;
+      accountId?: string;
+    }) => {
+      await sendMessageMatrix(`user:${id}`, message, {
+        cfg,
+        ...(accountId ? { accountId } : {}),
+      });
+    },
+  };
+}

package/src/channel.runtime.ts

@@ -0,0 +1,17 @@
+import { listMatrixDirectoryGroupsLive, listMatrixDirectoryPeersLive } from "./directory-live.js";
+import { resolveMatrixAuth } from "./matrix/client.js";
+import { probeMatrix } from "./matrix/probe.js";
+import { sendMessageMatrix, sendTypingMatrix } from "./matrix/send.js";
+import { matrixOutbound } from "./outbound.js";
+import { resolveMatrixTargets } from "./resolve-targets.js";
+
+export const matrixChannelRuntime = {
+  listMatrixDirectoryGroupsLive,
+  listMatrixDirectoryPeersLive,
+  matrixOutbound,
+  probeMatrix,
+  resolveMatrixAuth,
+  resolveMatrixTargets,
+  sendMessageMatrix,
+  sendTypingMatrix,
+};

package/src/channel.setup.ts

@@ -0,0 +1,48 @@
+import { describeAccountSnapshot } from "autobot/plugin-sdk/account-helpers";
+import type { ChannelPlugin } from "autobot/plugin-sdk/channel-core";
+import { matrixConfigAdapter } from "./config-adapter.js";
+import { MatrixChannelConfigSchema } from "./config-schema.js";
+import { resolveMatrixAccount, type ResolvedMatrixAccount } from "./matrix/accounts.js";
+import { createMatrixSetupWizardProxy, matrixSetupAdapter } from "./setup-core.js";
+
+const matrixSetupWizard = createMatrixSetupWizardProxy(async () => ({
+  matrixSetupWizard: (await import("./setup-surface.js")).matrixSetupWizard,
+}));
+
+export const matrixSetupPlugin: ChannelPlugin<ResolvedMatrixAccount> = {
+  id: "matrix",
+  meta: {
+    id: "matrix",
+    label: "Matrix",
+    selectionLabel: "Matrix (plugin)",
+    docsPath: "/channels/matrix",
+    docsLabel: "matrix",
+    blurb: "open protocol; configure a homeserver + access token.",
+    order: 70,
+    quickstartAllowFrom: true,
+  },
+  setupWizard: matrixSetupWizard,
+  setup: matrixSetupAdapter,
+  capabilities: {
+    chatTypes: ["direct", "group", "thread"],
+    polls: true,
+    reactions: true,
+    threads: true,
+    media: true,
+  },
+  reload: { configPrefixes: ["channels.matrix"] },
+  configSchema: MatrixChannelConfigSchema,
+  config: {
+    ...matrixConfigAdapter,
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) =>
+      describeAccountSnapshot({
+        account,
+        configured: account.configured,
+        extra: {
+          baseUrl: account.homeserver,
+        },
+      }),
+    hasConfiguredState: ({ cfg }) => resolveMatrixAccount({ cfg }).configured,
+  },
+};