loudmouth-ai 0.1.0 → 0.2.0

package/extensions/matrix/src/channel.ts

@@ -1,417 +0,0 @@
-import {
-  applyAccountNameToChannelSection,
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID,
-  deleteAccountFromConfigSection,
-  formatPairingApproveHint,
-  normalizeAccountId,
-  PAIRING_APPROVED_MESSAGE,
-  setAccountEnabledInConfigSection,
-  type ChannelPlugin,
-} from "clawdbot/plugin-sdk";
-
-import { matrixMessageActions } from "./actions.js";
-import { MatrixConfigSchema } from "./config-schema.js";
-import { resolveMatrixGroupRequireMention, resolveMatrixGroupToolPolicy } from "./group-mentions.js";
-import type { CoreConfig } from "./types.js";
-import {
-  listMatrixAccountIds,
-  resolveDefaultMatrixAccountId,
-  resolveMatrixAccount,
-  type ResolvedMatrixAccount,
-} from "./matrix/accounts.js";
-import { resolveMatrixAuth } from "./matrix/client.js";
-import { normalizeAllowListLower } from "./matrix/monitor/allowlist.js";
-import { probeMatrix } from "./matrix/probe.js";
-import { sendMessageMatrix } from "./matrix/send.js";
-import { matrixOnboardingAdapter } from "./onboarding.js";
-import { matrixOutbound } from "./outbound.js";
-import { resolveMatrixTargets } from "./resolve-targets.js";
-import {
-  listMatrixDirectoryGroupsLive,
-  listMatrixDirectoryPeersLive,
-} from "./directory-live.js";
-
-const 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,
-};
-
-function normalizeMatrixMessagingTarget(raw: string): string | undefined {
-  let normalized = raw.trim();
-  if (!normalized) return undefined;
-  const lowered = normalized.toLowerCase();
-  if (lowered.startsWith("matrix:")) {
-    normalized = normalized.slice("matrix:".length).trim();
-  }
-  const stripped = normalized.replace(/^(room|channel|user):/i, "").trim();
-  return stripped || undefined;
-}
-
-function buildMatrixConfigUpdate(
-  cfg: CoreConfig,
-  input: {
-    homeserver?: string;
-    userId?: string;
-    accessToken?: string;
-    password?: string;
-    deviceName?: string;
-    initialSyncLimit?: number;
-  },
-): CoreConfig {
-  const existing = cfg.channels?.matrix ?? {};
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      matrix: {
-        ...existing,
-        enabled: true,
-        ...(input.homeserver ? { homeserver: input.homeserver } : {}),
-        ...(input.userId ? { userId: input.userId } : {}),
-        ...(input.accessToken ? { accessToken: input.accessToken } : {}),
-        ...(input.password ? { password: input.password } : {}),
-        ...(input.deviceName ? { deviceName: input.deviceName } : {}),
-        ...(typeof input.initialSyncLimit === "number"
-          ? { initialSyncLimit: input.initialSyncLimit }
-          : {}),
-      },
-    },
-  };
-}
-
-export const matrixPlugin: ChannelPlugin<ResolvedMatrixAccount> = {
-  id: "matrix",
-  meta,
-  onboarding: matrixOnboardingAdapter,
-  pairing: {
-    idLabel: "matrixUserId",
-    normalizeAllowEntry: (entry) => entry.replace(/^matrix:/i, ""),
-    notifyApproval: async ({ id }) => {
-      await sendMessageMatrix(`user:${id}`, PAIRING_APPROVED_MESSAGE);
-    },
-  },
-  capabilities: {
-    chatTypes: ["direct", "group", "thread"],
-    polls: true,
-    reactions: true,
-    threads: true,
-    media: true,
-  },
-  reload: { configPrefixes: ["channels.matrix"] },
-  configSchema: buildChannelConfigSchema(MatrixConfigSchema),
-  config: {
-    listAccountIds: (cfg) => listMatrixAccountIds(cfg as CoreConfig),
-    resolveAccount: (cfg, accountId) =>
-      resolveMatrixAccount({ cfg: cfg as CoreConfig, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultMatrixAccountId(cfg as CoreConfig),
-    setAccountEnabled: ({ cfg, accountId, enabled }) =>
-      setAccountEnabledInConfigSection({
-        cfg: cfg as CoreConfig,
-        sectionKey: "matrix",
-        accountId,
-        enabled,
-        allowTopLevel: true,
-      }),
-    deleteAccount: ({ cfg, accountId }) =>
-      deleteAccountFromConfigSection({
-        cfg: cfg as CoreConfig,
-        sectionKey: "matrix",
-        accountId,
-        clearBaseFields: [
-          "name",
-          "homeserver",
-          "userId",
-          "accessToken",
-          "password",
-          "deviceName",
-          "initialSyncLimit",
-        ],
-      }),
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      baseUrl: account.homeserver,
-    }),
-    resolveAllowFrom: ({ cfg }) =>
-      ((cfg as CoreConfig).channels?.matrix?.dm?.allowFrom ?? []).map((entry) => String(entry)),
-    formatAllowFrom: ({ allowFrom }) => normalizeAllowListLower(allowFrom),
-  },
-  security: {
-    resolveDmPolicy: ({ account }) => ({
-      policy: account.config.dm?.policy ?? "pairing",
-      allowFrom: account.config.dm?.allowFrom ?? [],
-      policyPath: "channels.matrix.dm.policy",
-      allowFromPath: "channels.matrix.dm.allowFrom",
-      approveHint: formatPairingApproveHint("matrix"),
-      normalizeEntry: (raw) => raw.replace(/^matrix:/i, "").trim().toLowerCase(),
-    }),
-    collectWarnings: ({ account, cfg }) => {
-      const defaultGroupPolicy = (cfg as CoreConfig).channels?.defaults?.groupPolicy;
-      const groupPolicy =
-        account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-      if (groupPolicy !== "open") return [];
-      return [
-        "- Matrix rooms: groupPolicy=\"open\" allows any room to trigger (mention-gated). Set channels.matrix.groupPolicy=\"allowlist\" + channels.matrix.groups (and optionally channels.matrix.groupAllowFrom) to restrict rooms.",
-      ];
-    },
-  },
-  groups: {
-    resolveRequireMention: resolveMatrixGroupRequireMention,
-    resolveToolPolicy: resolveMatrixGroupToolPolicy,
-  },
-  threading: {
-    resolveReplyToMode: ({ cfg }) =>
-      (cfg as CoreConfig).channels?.matrix?.replyToMode ?? "off",
-    buildToolContext: ({ context, hasRepliedRef }) => {
-      const currentTarget = context.To;
-      return {
-        currentChannelId: currentTarget?.trim() || undefined,
-        currentThreadTs:
-          context.MessageThreadId != null
-            ? String(context.MessageThreadId)
-            : context.ReplyToId,
-        hasRepliedRef,
-      };
-    },
-  },
-  messaging: {
-    normalizeTarget: normalizeMatrixMessagingTarget,
-    targetResolver: {
-      looksLikeId: (raw) => {
-        const trimmed = raw.trim();
-        if (!trimmed) return false;
-        if (/^(matrix:)?[!#@]/i.test(trimmed)) return true;
-        return trimmed.includes(":");
-      },
-      hint: "<room|alias|user>",
-    },
-  },
-  directory: {
-    self: async () => null,
-    listPeers: async ({ cfg, accountId, query, limit }) => {
-      const account = resolveMatrixAccount({ cfg: cfg as CoreConfig, accountId });
-      const q = query?.trim().toLowerCase() || "";
-      const ids = new Set<string>();
-
-      for (const entry of account.config.dm?.allowFrom ?? []) {
-        const raw = String(entry).trim();
-        if (!raw || raw === "*") continue;
-        ids.add(raw.replace(/^matrix:/i, ""));
-      }
-
-      for (const entry of account.config.groupAllowFrom ?? []) {
-        const raw = String(entry).trim();
-        if (!raw || raw === "*") continue;
-        ids.add(raw.replace(/^matrix:/i, ""));
-      }
-
-      const groups = account.config.groups ?? account.config.rooms ?? {};
-      for (const room of Object.values(groups)) {
-        for (const entry of room.users ?? []) {
-          const raw = String(entry).trim();
-          if (!raw || raw === "*") continue;
-          ids.add(raw.replace(/^matrix:/i, ""));
-        }
-      }
-
-      return Array.from(ids)
-        .map((raw) => raw.trim())
-        .filter(Boolean)
-        .map((raw) => {
-          const lowered = raw.toLowerCase();
-          const cleaned = lowered.startsWith("user:") ? raw.slice("user:".length).trim() : raw;
-          if (cleaned.startsWith("@")) return `user:${cleaned}`;
-          return cleaned;
-        })
-        .filter((id) => (q ? id.toLowerCase().includes(q) : true))
-        .slice(0, limit && limit > 0 ? limit : undefined)
-        .map((id) => {
-          const raw = id.startsWith("user:") ? id.slice("user:".length) : id;
-          const incomplete = !raw.startsWith("@") || !raw.includes(":");
-          return {
-            kind: "user",
-            id,
-            ...(incomplete ? { name: "incomplete id; expected @user:server" } : {}),
-          };
-        });
-    },
-    listGroups: async ({ cfg, accountId, query, limit }) => {
-      const account = resolveMatrixAccount({ cfg: cfg as CoreConfig, accountId });
-      const q = query?.trim().toLowerCase() || "";
-      const groups = account.config.groups ?? account.config.rooms ?? {};
-      const ids = Object.keys(groups)
-        .map((raw) => raw.trim())
-        .filter((raw) => Boolean(raw) && raw !== "*")
-        .map((raw) => raw.replace(/^matrix:/i, ""))
-        .map((raw) => {
-          const lowered = raw.toLowerCase();
-          if (lowered.startsWith("room:") || lowered.startsWith("channel:")) return raw;
-          if (raw.startsWith("!")) return `room:${raw}`;
-          return raw;
-        })
-        .filter((id) => (q ? id.toLowerCase().includes(q) : true))
-        .slice(0, limit && limit > 0 ? limit : undefined)
-        .map((id) => ({ kind: "group", id }) as const);
-      return ids;
-    },
-    listPeersLive: async ({ cfg, query, limit }) =>
-      listMatrixDirectoryPeersLive({ cfg, query, limit }),
-    listGroupsLive: async ({ cfg, query, limit }) =>
-      listMatrixDirectoryGroupsLive({ cfg, query, limit }),
-  },
-  resolver: {
-    resolveTargets: async ({ cfg, inputs, kind, runtime }) =>
-      resolveMatrixTargets({ cfg, inputs, kind, runtime }),
-  },
-  actions: matrixMessageActions,
-  setup: {
-    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-    applyAccountName: ({ cfg, accountId, name }) =>
-      applyAccountNameToChannelSection({
-        cfg: cfg as CoreConfig,
-        channelKey: "matrix",
-        accountId,
-        name,
-      }),
-    validateInput: ({ input }) => {
-      if (input.useEnv) return null;
-      if (!input.homeserver?.trim()) return "Matrix requires --homeserver";
-      const accessToken = input.accessToken?.trim();
-      const password = input.password?.trim();
-      const userId = input.userId?.trim();
-      if (!accessToken && !password) {
-        return "Matrix requires --access-token or --password";
-      }
-      if (!accessToken) {
-        if (!userId) return "Matrix requires --user-id when using --password";
-        if (!password) return "Matrix requires --password when using --user-id";
-      }
-      return null;
-    },
-    applyAccountConfig: ({ cfg, input }) => {
-      const namedConfig = applyAccountNameToChannelSection({
-        cfg: cfg as CoreConfig,
-        channelKey: "matrix",
-        accountId: DEFAULT_ACCOUNT_ID,
-        name: input.name,
-      });
-      if (input.useEnv) {
-        return {
-          ...namedConfig,
-          channels: {
-            ...namedConfig.channels,
-            matrix: {
-              ...namedConfig.channels?.matrix,
-              enabled: true,
-            },
-          },
-        } as CoreConfig;
-      }
-      return buildMatrixConfigUpdate(namedConfig as CoreConfig, {
-        homeserver: input.homeserver?.trim(),
-        userId: input.userId?.trim(),
-        accessToken: input.accessToken?.trim(),
-        password: input.password?.trim(),
-        deviceName: input.deviceName?.trim(),
-        initialSyncLimit: input.initialSyncLimit,
-      });
-    },
-  },
-  outbound: matrixOutbound,
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    collectStatusIssues: (accounts) =>
-      accounts.flatMap((account) => {
-        const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
-        if (!lastError) return [];
-        return [
-          {
-            channel: "matrix",
-            accountId: account.accountId,
-            kind: "runtime",
-            message: `Channel error: ${lastError}`,
-          },
-        ];
-      }),
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      baseUrl: snapshot.baseUrl ?? null,
-      running: snapshot.running ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? null,
-    }),
-    probeAccount: async ({ account, timeoutMs, cfg }) => {
-      try {
-        const auth = await resolveMatrixAuth({ cfg: cfg as CoreConfig });
-        return await probeMatrix({
-          homeserver: auth.homeserver,
-          accessToken: auth.accessToken,
-          userId: auth.userId,
-          timeoutMs,
-        });
-      } catch (err) {
-        return {
-          ok: false,
-          error: err instanceof Error ? err.message : String(err),
-          elapsedMs: 0,
-        };
-      }
-    },
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      baseUrl: account.homeserver,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      probe,
-      lastProbeAt: runtime?.lastProbeAt ?? null,
-      lastInboundAt: runtime?.lastInboundAt ?? null,
-      lastOutboundAt: runtime?.lastOutboundAt ?? null,
-    }),
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      ctx.setStatus({
-        accountId: account.accountId,
-        baseUrl: account.homeserver,
-      });
-      ctx.log?.info(
-        `[${account.accountId}] starting provider (${account.homeserver ?? "matrix"})`,
-      );
-      // Lazy import: the monitor pulls the reply pipeline; avoid ESM init cycles.
-      const { monitorMatrixProvider } = await import("./matrix/index.js");
-      return monitorMatrixProvider({
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        mediaMaxMb: account.config.mediaMaxMb,
-        initialSyncLimit: account.config.initialSyncLimit,
-        replyToMode: account.config.replyToMode,
-        accountId: account.accountId,
-      });
-    },
-  },
-};

package/extensions/matrix/src/config-schema.ts

@@ -1,62 +0,0 @@
-import { MarkdownConfigSchema, ToolPolicySchema } from "clawdbot/plugin-sdk";
-import { z } from "zod";
-
-const allowFromEntry = z.union([z.string(), z.number()]);
-
-const matrixActionSchema = z
-  .object({
-    reactions: z.boolean().optional(),
-    messages: z.boolean().optional(),
-    pins: z.boolean().optional(),
-    memberInfo: z.boolean().optional(),
-    channelInfo: z.boolean().optional(),
-  })
-  .optional();
-
-const matrixDmSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
-    allowFrom: z.array(allowFromEntry).optional(),
-  })
-  .optional();
-
-const matrixRoomSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    allow: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    autoReply: z.boolean().optional(),
-    users: z.array(allowFromEntry).optional(),
-    skills: z.array(z.string()).optional(),
-    systemPrompt: z.string().optional(),
-  })
-  .optional();
-
-export const MatrixConfigSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  markdown: MarkdownConfigSchema,
-  homeserver: z.string().optional(),
-  userId: z.string().optional(),
-  accessToken: z.string().optional(),
-  password: z.string().optional(),
-  deviceName: z.string().optional(),
-  initialSyncLimit: z.number().optional(),
-  encryption: z.boolean().optional(),
-  allowlistOnly: z.boolean().optional(),
-  groupPolicy: z.enum(["open", "disabled", "allowlist"]).optional(),
-  replyToMode: z.enum(["off", "first", "all"]).optional(),
-  threadReplies: z.enum(["off", "inbound", "always"]).optional(),
-  textChunkLimit: z.number().optional(),
-  chunkMode: z.enum(["length", "newline"]).optional(),
-  mediaMaxMb: z.number().optional(),
-  autoJoin: z.enum(["always", "allowlist", "off"]).optional(),
-  autoJoinAllowlist: z.array(allowFromEntry).optional(),
-  groupAllowFrom: z.array(allowFromEntry).optional(),
-  dm: matrixDmSchema,
-  groups: z.object({}).catchall(matrixRoomSchema).optional(),
-  rooms: z.object({}).catchall(matrixRoomSchema).optional(),
-  actions: matrixActionSchema,
-});

package/extensions/matrix/src/directory-live.ts

@@ -1,175 +0,0 @@
-import type { ChannelDirectoryEntry } from "clawdbot/plugin-sdk";
-
-import { resolveMatrixAuth } from "./matrix/client.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;
-};
-
-async function fetchMatrixJson<T>(params: {
-  homeserver: string;
-  path: string;
-  accessToken: string;
-  method?: "GET" | "POST";
-  body?: unknown;
-}): Promise<T> {
-  const res = await fetch(`${params.homeserver}${params.path}`, {
-    method: params.method ?? "GET",
-    headers: {
-      Authorization: `Bearer ${params.accessToken}`,
-      "Content-Type": "application/json",
-    },
-    body: params.body ? JSON.stringify(params.body) : undefined,
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Matrix API ${params.path} failed (${res.status}): ${text || "unknown error"}`);
-  }
-  return (await res.json()) as T;
-}
-
-function normalizeQuery(value?: string | null): string {
-  return value?.trim().toLowerCase() ?? "";
-}
-
-export async function listMatrixDirectoryPeersLive(params: {
-  cfg: unknown;
-  query?: string | null;
-  limit?: number | null;
-}): Promise<ChannelDirectoryEntry[]> {
-  const query = normalizeQuery(params.query);
-  if (!query) return [];
-  const auth = await resolveMatrixAuth({ cfg: params.cfg as never });
-  const res = await fetchMatrixJson<MatrixUserDirectoryResponse>({
-    homeserver: auth.homeserver,
-    accessToken: auth.accessToken,
-    path: "/_matrix/client/v3/user_directory/search",
-    method: "POST",
-    body: {
-      search_term: query,
-      limit: typeof params.limit === "number" && params.limit > 0 ? params.limit : 20,
-    },
-  });
-  const results = res.results ?? [];
-  return results
-    .map((entry) => {
-      const userId = entry.user_id?.trim();
-      if (!userId) return null;
-      return {
-        kind: "user",
-        id: userId,
-        name: entry.display_name?.trim() || undefined,
-        handle: entry.display_name ? `@${entry.display_name.trim()}` : undefined,
-        raw: entry,
-      } satisfies ChannelDirectoryEntry;
-    })
-    .filter(Boolean) as ChannelDirectoryEntry[];
-}
-
-async function resolveMatrixRoomAlias(
-  homeserver: string,
-  accessToken: string,
-  alias: string,
-): Promise<string | null> {
-  try {
-    const res = await fetchMatrixJson<MatrixAliasLookup>({
-      homeserver,
-      accessToken,
-      path: `/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`,
-    });
-    return res.room_id?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-async function fetchMatrixRoomName(
-  homeserver: string,
-  accessToken: string,
-  roomId: string,
-): Promise<string | null> {
-  try {
-    const res = await fetchMatrixJson<MatrixRoomNameState>({
-      homeserver,
-      accessToken,
-      path: `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`,
-    });
-    return res.name?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-export async function listMatrixDirectoryGroupsLive(params: {
-  cfg: unknown;
-  query?: string | null;
-  limit?: number | null;
-}): Promise<ChannelDirectoryEntry[]> {
-  const query = normalizeQuery(params.query);
-  if (!query) return [];
-  const auth = await resolveMatrixAuth({ cfg: params.cfg as never });
-  const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : 20;
-
-  if (query.startsWith("#")) {
-    const roomId = await resolveMatrixRoomAlias(auth.homeserver, auth.accessToken, query);
-    if (!roomId) return [];
-    return [
-      {
-        kind: "group",
-        id: roomId,
-        name: query,
-        handle: query,
-      } satisfies ChannelDirectoryEntry,
-    ];
-  }
-
-  if (query.startsWith("!")) {
-    return [
-      {
-        kind: "group",
-        id: query,
-        name: query,
-      } satisfies ChannelDirectoryEntry,
-    ];
-  }
-
-  const joined = await fetchMatrixJson<MatrixJoinedRoomsResponse>({
-    homeserver: auth.homeserver,
-    accessToken: auth.accessToken,
-    path: "/_matrix/client/v3/joined_rooms",
-  });
-  const rooms = joined.joined_rooms ?? [];
-  const results: ChannelDirectoryEntry[] = [];
-
-  for (const roomId of rooms) {
-    const name = await fetchMatrixRoomName(auth.homeserver, auth.accessToken, roomId);
-    if (!name) continue;
-    if (!name.toLowerCase().includes(query)) continue;
-    results.push({
-      kind: "group",
-      id: roomId,
-      name,
-      handle: `#${name}`,
-    });
-    if (results.length >= limit) break;
-  }
-
-  return results;
-}