@kodelyth/matrix 2026.5.42 → 2026.6.1

package/src/exec-approvals.ts

@@ -1,287 +0,0 @@
-import { resolveApprovalApprovers } from "klaw/plugin-sdk/approval-auth-runtime";
-import {
-  createChannelExecApprovalProfile,
-  getExecApprovalReplyMetadata,
-  isChannelExecApprovalClientEnabledFromConfig,
-  isChannelExecApprovalTargetRecipient,
-  matchesApprovalRequestFilters,
-} from "klaw/plugin-sdk/approval-client-runtime";
-import { resolveApprovalRequestChannelAccountId } from "klaw/plugin-sdk/approval-native-runtime";
-import type { ExecApprovalRequest, PluginApprovalRequest } from "klaw/plugin-sdk/approval-runtime";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import type { ReplyPayload } from "klaw/plugin-sdk/reply-runtime";
-import { normalizeAccountId } from "klaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-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: KlawConfig; 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: KlawConfig;
-  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: KlawConfig;
-  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: KlawConfig;
-  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: KlawConfig;
-  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: KlawConfig;
-  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: KlawConfig;
-  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: KlawConfig;
-  accountId?: string | null;
-}): boolean {
-  return (
-    isMatrixApprovalClientEnabled({
-      ...params,
-      approvalKind: "exec",
-    }) ||
-    isMatrixApprovalClientEnabled({
-      ...params,
-      approvalKind: "plugin",
-    })
-  );
-}
-
-export function shouldHandleMatrixApprovalRequest(params: {
-  cfg: KlawConfig;
-  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: KlawConfig;
-  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.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;
-  }
-}