@kodelyth/matrix 2026.5.42 → 2026.6.2

package/src/config-adapter.ts

@@ -1,41 +0,0 @@
-import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/account-id";
-import {
-  adaptScopedAccountAccessor,
-  createScopedChannelConfigAdapter,
-} from "klaw/plugin-sdk/channel-config-helpers";
-import {
-  listMatrixAccountIds,
-  resolveDefaultMatrixAccountId,
-  resolveMatrixAccount,
-  resolveMatrixAccountConfig,
-  type ResolvedMatrixAccount,
-} from "./matrix/accounts.js";
-import { normalizeMatrixAllowList } from "./matrix/monitor/allowlist.js";
-
-export { DEFAULT_ACCOUNT_ID };
-
-export const matrixConfigAdapter = createScopedChannelConfigAdapter<
-  ResolvedMatrixAccount,
-  ReturnType<typeof resolveMatrixAccountConfig>
->({
-  sectionKey: "matrix",
-  listAccountIds: listMatrixAccountIds,
-  resolveAccount: adaptScopedAccountAccessor(resolveMatrixAccount),
-  resolveAccessorAccount: ({ cfg, accountId }) => resolveMatrixAccountConfig({ cfg, accountId }),
-  defaultAccountId: resolveDefaultMatrixAccountId,
-  clearBaseFields: [
-    "name",
-    "homeserver",
-    "network",
-    "proxy",
-    "userId",
-    "accessToken",
-    "password",
-    "deviceId",
-    "deviceName",
-    "avatarUrl",
-    "initialSyncLimit",
-  ],
-  resolveAllowFrom: (account) => account.dm?.allowFrom,
-  formatAllowFrom: (allowFrom) => normalizeMatrixAllowList(allowFrom),
-});

package/src/config-schema.ts

@@ -1,159 +0,0 @@
-import { buildChannelConfigSchema } from "klaw/plugin-sdk/channel-config-primitives";
-import {
-  AllowFromListSchema,
-  buildNestedDmConfigSchema,
-  ContextVisibilityModeSchema,
-  GroupPolicySchema,
-  MarkdownConfigSchema,
-  ToolPolicySchema,
-} from "klaw/plugin-sdk/channel-config-schema";
-import { buildSecretInputSchema } from "klaw/plugin-sdk/secret-input";
-import { z } from "zod";
-import { matrixChannelConfigUiHints } from "./config-ui-hints.js";
-
-const matrixActionSchema = z
-  .object({
-    reactions: z.boolean().optional(),
-    messages: z.boolean().optional(),
-    pins: z.boolean().optional(),
-    profile: z.boolean().optional(),
-    memberInfo: z.boolean().optional(),
-    channelInfo: z.boolean().optional(),
-    verification: z.boolean().optional(),
-  })
-  .optional();
-
-const matrixThreadBindingsSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    idleHours: z.number().nonnegative().optional(),
-    maxAgeHours: z.number().nonnegative().optional(),
-    spawnSessions: z.boolean().optional(),
-    defaultSpawnContext: z.enum(["isolated", "fork"]).optional(),
-    spawnSubagentSessions: z.boolean().optional(),
-    spawnAcpSessions: z.boolean().optional(),
-  })
-  .optional();
-
-const matrixExecApprovalsSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    approvers: AllowFromListSchema,
-    agentFilter: z.array(z.string()).optional(),
-    sessionFilter: z.array(z.string()).optional(),
-    target: z.enum(["dm", "channel", "both"]).optional(),
-  })
-  .optional();
-
-const botLoopProtectionSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    maxEventsPerWindow: z.number().int().positive().optional(),
-    windowSeconds: z.number().int().positive().optional(),
-    cooldownSeconds: z.number().int().positive().optional(),
-  })
-  .strict()
-  .optional();
-
-const matrixRoomSchema = z
-  .object({
-    account: z.string().optional(),
-    enabled: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
-    botLoopProtection: botLoopProtectionSchema,
-    tools: ToolPolicySchema,
-    autoReply: z.boolean().optional(),
-    users: AllowFromListSchema,
-    skills: z.array(z.string()).optional(),
-    systemPrompt: z.string().optional(),
-  })
-  .optional();
-
-const matrixNetworkSchema = z
-  .object({
-    dangerouslyAllowPrivateNetwork: z.boolean().optional(),
-  })
-  .strict()
-  .optional();
-
-const matrixStreamingSchema = z
-  .object({
-    mode: z.enum(["partial", "quiet", "progress", "off"]).optional(),
-    progress: z
-      .object({
-        label: z.union([z.string(), z.literal(false)]).optional(),
-        labels: z.array(z.string()).optional(),
-        maxLines: z.number().int().positive().optional(),
-        maxLineChars: z.number().int().positive().optional(),
-        toolProgress: z.boolean().optional(),
-      })
-      .strict()
-      .optional(),
-    preview: z
-      .object({
-        toolProgress: z.boolean().optional(),
-      })
-      .strict()
-      .optional(),
-  })
-  .strict();
-
-export const MatrixConfigSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  defaultAccount: z.string().optional(),
-  accounts: z.record(z.string(), z.unknown()).optional(),
-  markdown: MarkdownConfigSchema,
-  homeserver: z.string().optional(),
-  network: matrixNetworkSchema,
-  proxy: z.string().optional(),
-  userId: z.string().optional(),
-  accessToken: buildSecretInputSchema().optional(),
-  password: buildSecretInputSchema().optional(),
-  deviceId: z.string().optional(),
-  deviceName: z.string().optional(),
-  avatarUrl: z.string().optional(),
-  initialSyncLimit: z.number().optional(),
-  encryption: z.boolean().optional(),
-  allowlistOnly: z.boolean().optional(),
-  dangerouslyAllowNameMatching: z.boolean().optional(),
-  allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
-  botLoopProtection: botLoopProtectionSchema,
-  groupPolicy: GroupPolicySchema.optional(),
-  contextVisibility: ContextVisibilityModeSchema.optional(),
-  blockStreaming: z.boolean().optional(),
-  streaming: z
-    .union([z.enum(["partial", "quiet", "progress", "off"]), z.boolean(), matrixStreamingSchema])
-    .optional(),
-  replyToMode: z.enum(["off", "first", "all", "batched"]).optional(),
-  threadReplies: z.enum(["off", "inbound", "always"]).optional(),
-  textChunkLimit: z.number().optional(),
-  chunkMode: z.enum(["length", "newline"]).optional(),
-  responsePrefix: z.string().optional(),
-  ackReaction: z.string().optional(),
-  ackReactionScope: z
-    .enum(["group-mentions", "group-all", "direct", "all", "none", "off"])
-    .optional(),
-  reactionNotifications: z.enum(["off", "own"]).optional(),
-  threadBindings: matrixThreadBindingsSchema,
-  startupVerification: z.enum(["off", "if-unverified"]).optional(),
-  startupVerificationCooldownHours: z.number().optional(),
-  mediaMaxMb: z.number().optional(),
-  historyLimit: z.number().int().min(0).optional(),
-  autoJoin: z.enum(["always", "allowlist", "off"]).optional(),
-  autoJoinAllowlist: AllowFromListSchema,
-  groupAllowFrom: AllowFromListSchema,
-  dm: buildNestedDmConfigSchema({
-    sessionScope: z.enum(["per-user", "per-room"]).optional(),
-    threadReplies: z.enum(["off", "inbound", "always"]).optional(),
-  }),
-  execApprovals: matrixExecApprovalsSchema,
-  groups: z.object({}).catchall(matrixRoomSchema).optional(),
-  rooms: z.object({}).catchall(matrixRoomSchema).optional(),
-  actions: matrixActionSchema,
-});
-
-export const MatrixChannelConfigSchema = buildChannelConfigSchema(MatrixConfigSchema, {
-  uiHints: matrixChannelConfigUiHints,
-});

package/src/config-ui-hints.ts

@@ -1,56 +0,0 @@
-import type { ChannelConfigUiHint } from "klaw/plugin-sdk/channel-core";
-
-export const matrixChannelConfigUiHints = {
-  allowBots: {
-    label: "Matrix Allow Bot Messages",
-    help: 'Allow messages from other configured Matrix bot accounts to trigger replies (default: false). Set "mentions" to require a visible room mention.',
-  },
-  botLoopProtection: {
-    label: "Matrix Bot Loop Protection",
-    help: "Sliding-window guard for accepted Matrix configured-bot loops. Default is enabled whenever allowBots lets configured bot messages reach dispatch.",
-  },
-  "botLoopProtection.enabled": {
-    label: "Matrix Bot Loop Protection Enabled",
-    help: 'Enable the bot-pair loop guard. Defaults to true when allowBots is true or "mentions", and false when configured bot messages are ignored.',
-  },
-  "botLoopProtection.maxEventsPerWindow": {
-    label: "Matrix Bot Loop Events per Window",
-    help: "Maximum accepted bot-pair messages within the sliding window before suppression starts. Default: 20.",
-  },
-  "botLoopProtection.windowSeconds": {
-    label: "Matrix Bot Loop Window Seconds",
-    help: "Sliding window length for counting bot-pair messages. Default: 60.",
-  },
-  "botLoopProtection.cooldownSeconds": {
-    label: "Matrix Bot Loop Cooldown Seconds",
-    help: "How long to suppress the bot pair after it exceeds the budget. Default: 60.",
-  },
-  dangerouslyAllowNameMatching: {
-    label: "Matrix Display Name Matching",
-    help: "Compatibility opt-in for resolving Matrix display names and joined room names in allowlists. Prefer full @user:server IDs and room IDs or aliases because names are mutable.",
-  },
-  "streaming.progress.label": {
-    label: "Matrix Progress Label",
-    help: 'Initial progress draft title. Use "auto" for built-in single-word labels, a custom string, or false to hide the title.',
-  },
-  "streaming.progress.labels": {
-    label: "Matrix Progress Label Pool",
-    help: 'Candidate labels for streaming.progress.label="auto". Leave unset to use Klaw built-in progress labels.',
-  },
-  "streaming.progress.maxLines": {
-    label: "Matrix Progress Max Lines",
-    help: "Maximum number of compact progress lines to keep below the draft label (default: 8).",
-  },
-  "streaming.progress.maxLineChars": {
-    label: "Matrix Progress Max Line Chars",
-    help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes.",
-  },
-  "streaming.progress.toolProgress": {
-    label: "Matrix Progress Tool Lines",
-    help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery.",
-  },
-  "streaming.progress.commandText": {
-    label: "Matrix Progress Command Text",
-    help: 'Command/exec detail in progress draft lines: "raw" preserves released behavior; "status" shows only the tool label.',
-  },
-} satisfies Record<string, ChannelConfigUiHint>;

package/src/directory-live.ts

@@ -1,238 +0,0 @@
-import {
-  normalizeLowercaseStringOrEmpty,
-  normalizeOptionalString,
-} from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveMatrixAuth } from "./matrix/client.js";
-import { MatrixAuthedHttpClient } from "./matrix/sdk/http-client.js";
-import { isMatrixQualifiedUserId, normalizeMatrixMessagingTarget } from "./matrix/target-ids.js";
-import type { ChannelDirectoryEntry } from "./runtime-api.js";
-
-type MatrixUserResult = {
-  user_id?: string;
-  display_name?: string;
-};
-
-type MatrixUserDirectoryResponse = {
-  results?: MatrixUserResult[];
-};
-
-type MatrixJoinedRoomsResponse = {
-  joined_rooms?: string[];
-};
-
-type MatrixRoomNameState = {
-  name?: string;
-};
-
-type MatrixAliasLookup = {
-  room_id?: string;
-};
-
-type MatrixDirectoryLiveParams = {
-  cfg: unknown;
-  accountId?: string | null;
-  query?: string | null;
-  limit?: number | null;
-};
-
-type MatrixResolvedAuth = Awaited<ReturnType<typeof resolveMatrixAuth>>;
-
-const MATRIX_DIRECTORY_TIMEOUT_MS = 10_000;
-
-function resolveMatrixDirectoryLimit(limit?: number | null): number {
-  return typeof limit === "number" && Number.isFinite(limit) && limit > 0
-    ? Math.max(1, Math.floor(limit))
-    : 20;
-}
-
-function createMatrixDirectoryClient(auth: MatrixResolvedAuth): MatrixAuthedHttpClient {
-  return new MatrixAuthedHttpClient({
-    homeserver: auth.homeserver,
-    accessToken: auth.accessToken,
-    ssrfPolicy: auth.ssrfPolicy,
-    dispatcherPolicy: auth.dispatcherPolicy,
-  });
-}
-
-async function resolveMatrixDirectoryContext(params: MatrixDirectoryLiveParams): Promise<{
-  auth: MatrixResolvedAuth;
-  client: MatrixAuthedHttpClient;
-  query: string;
-  queryLower: string;
-} | null> {
-  const query = normalizeOptionalString(params.query) ?? "";
-  if (!query) {
-    return null;
-  }
-  const auth = await resolveMatrixAuth({ cfg: params.cfg as never, accountId: params.accountId });
-  return {
-    auth,
-    client: createMatrixDirectoryClient(auth),
-    query,
-    queryLower: normalizeLowercaseStringOrEmpty(query),
-  };
-}
-
-function createGroupDirectoryEntry(params: {
-  id: string;
-  name: string;
-  handle?: string;
-}): ChannelDirectoryEntry {
-  return {
-    kind: "group",
-    id: params.id,
-    name: params.name,
-    handle: params.handle,
-  } satisfies ChannelDirectoryEntry;
-}
-
-async function requestMatrixJson<T>(
-  client: MatrixAuthedHttpClient,
-  params: {
-    method: "GET" | "POST";
-    endpoint: string;
-    body?: unknown;
-  },
-): Promise<T> {
-  return (await client.requestJson({
-    method: params.method,
-    endpoint: params.endpoint,
-    body: params.body,
-    timeoutMs: MATRIX_DIRECTORY_TIMEOUT_MS,
-  })) as T;
-}
-
-export async function listMatrixDirectoryPeersLive(
-  params: MatrixDirectoryLiveParams,
-): Promise<ChannelDirectoryEntry[]> {
-  const query = normalizeOptionalString(params.query) ?? "";
-  if (!query) {
-    return [];
-  }
-  const directUserId = normalizeMatrixMessagingTarget(query);
-  if (directUserId && isMatrixQualifiedUserId(directUserId)) {
-    return [{ kind: "user", id: directUserId }];
-  }
-  const context = await resolveMatrixDirectoryContext({
-    ...params,
-    query,
-  });
-  if (!context) {
-    return [];
-  }
-
-  const res = await requestMatrixJson<MatrixUserDirectoryResponse>(context.client, {
-    method: "POST",
-    endpoint: "/_matrix/client/v3/user_directory/search",
-    body: {
-      search_term: context.query,
-      limit: resolveMatrixDirectoryLimit(params.limit),
-    },
-  });
-  const results = res.results ?? [];
-  return results
-    .map((entry) => {
-      const userId = normalizeOptionalString(entry.user_id);
-      if (!userId) {
-        return null;
-      }
-      const displayName = normalizeOptionalString(entry.display_name);
-      return {
-        kind: "user",
-        id: userId,
-        name: displayName,
-        handle: displayName ? `@${displayName}` : undefined,
-        raw: entry,
-      } satisfies ChannelDirectoryEntry;
-    })
-    .filter(Boolean) as ChannelDirectoryEntry[];
-}
-
-async function resolveMatrixRoomAlias(
-  client: MatrixAuthedHttpClient,
-  alias: string,
-): Promise<string | null> {
-  try {
-    const res = await requestMatrixJson<MatrixAliasLookup>(client, {
-      method: "GET",
-      endpoint: `/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`,
-    });
-    return normalizeOptionalString(res.room_id) ?? null;
-  } catch {
-    return null;
-  }
-}
-
-async function fetchMatrixRoomName(
-  client: MatrixAuthedHttpClient,
-  roomId: string,
-): Promise<string | null> {
-  try {
-    const res = await requestMatrixJson<MatrixRoomNameState>(client, {
-      method: "GET",
-      endpoint: `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`,
-    });
-    return normalizeOptionalString(res.name) ?? null;
-  } catch {
-    return null;
-  }
-}
-
-export async function listMatrixDirectoryGroupsLive(
-  params: MatrixDirectoryLiveParams,
-): Promise<ChannelDirectoryEntry[]> {
-  const query = normalizeOptionalString(params.query) ?? "";
-  if (!query) {
-    return [];
-  }
-  const directTarget = normalizeMatrixMessagingTarget(query);
-
-  if (directTarget?.startsWith("!")) {
-    return [createGroupDirectoryEntry({ id: directTarget, name: directTarget })];
-  }
-
-  const context = await resolveMatrixDirectoryContext({
-    ...params,
-    query,
-  });
-  if (!context) {
-    return [];
-  }
-  const { client, queryLower } = context;
-  const limit = resolveMatrixDirectoryLimit(params.limit);
-
-  if (directTarget?.startsWith("#")) {
-    const roomId = await resolveMatrixRoomAlias(client, directTarget);
-    if (!roomId) {
-      return [];
-    }
-    return [createGroupDirectoryEntry({ id: roomId, name: directTarget, handle: directTarget })];
-  }
-
-  const joined = await requestMatrixJson<MatrixJoinedRoomsResponse>(client, {
-    method: "GET",
-    endpoint: "/_matrix/client/v3/joined_rooms",
-  });
-  const rooms = (joined.joined_rooms ?? [])
-    .map((roomId) => normalizeOptionalString(roomId))
-    .filter((roomId): roomId is string => Boolean(roomId));
-  const results: ChannelDirectoryEntry[] = [];
-
-  for (const roomId of rooms) {
-    const name = await fetchMatrixRoomName(client, roomId);
-    if (!name || !normalizeLowercaseStringOrEmpty(name).includes(queryLower)) {
-      continue;
-    }
-    results.push({
-      kind: "group",
-      id: roomId,
-      name,
-      handle: `#${name}`,
-    });
-    if (results.length >= limit) {
-      break;
-    }
-  }
-
-  return results;
-}