loudmouth-ai 0.1.0 → 0.2.0

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

@@ -1,56 +0,0 @@
-import { z } from "zod";
-
-import {
-  BlockStreamingCoalesceSchema,
-  DmPolicySchema,
-  GroupPolicySchema,
-  MarkdownConfigSchema,
-  requireOpenAllowFrom,
-} from "clawdbot/plugin-sdk";
-
-const MattermostAccountSchemaBase = z
-  .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    enabled: z.boolean().optional(),
-    configWrites: z.boolean().optional(),
-    botToken: z.string().optional(),
-    baseUrl: z.string().optional(),
-    chatmode: z.enum(["oncall", "onmessage", "onchar"]).optional(),
-    oncharPrefixes: z.array(z.string()).optional(),
-    requireMention: z.boolean().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-  })
-  .strict();
-
-const MattermostAccountSchema = MattermostAccountSchemaBase.superRefine((value, ctx) => {
-  requireOpenAllowFrom({
-    policy: value.dmPolicy,
-    allowFrom: value.allowFrom,
-    ctx,
-    path: ["allowFrom"],
-    message:
-      'channels.mattermost.dmPolicy="open" requires channels.mattermost.allowFrom to include "*"',
-  });
-});
-
-export const MattermostConfigSchema = MattermostAccountSchemaBase.extend({
-  accounts: z.record(z.string(), MattermostAccountSchema.optional()).optional(),
-}).superRefine((value, ctx) => {
-  requireOpenAllowFrom({
-    policy: value.dmPolicy,
-    allowFrom: value.allowFrom,
-    ctx,
-    path: ["allowFrom"],
-    message:
-      'channels.mattermost.dmPolicy="open" requires channels.mattermost.allowFrom to include "*"',
-  });
-});

package/extensions/mattermost/src/group-mentions.ts

@@ -1,14 +0,0 @@
-import type { ChannelGroupContext } from "clawdbot/plugin-sdk";
-
-import { resolveMattermostAccount } from "./mattermost/accounts.js";
-
-export function resolveMattermostGroupRequireMention(
-  params: ChannelGroupContext,
-): boolean | undefined {
-  const account = resolveMattermostAccount({
-    cfg: params.cfg,
-    accountId: params.accountId,
-  });
-  if (typeof account.requireMention === "boolean") return account.requireMention;
-  return true;
-}

package/extensions/mattermost/src/mattermost/accounts.ts

@@ -1,115 +0,0 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "clawdbot/plugin-sdk";
-
-import type { MattermostAccountConfig, MattermostChatMode } from "../types.js";
-import { normalizeMattermostBaseUrl } from "./client.js";
-
-export type MattermostTokenSource = "env" | "config" | "none";
-export type MattermostBaseUrlSource = "env" | "config" | "none";
-
-export type ResolvedMattermostAccount = {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  botToken?: string;
-  baseUrl?: string;
-  botTokenSource: MattermostTokenSource;
-  baseUrlSource: MattermostBaseUrlSource;
-  config: MattermostAccountConfig;
-  chatmode?: MattermostChatMode;
-  oncharPrefixes?: string[];
-  requireMention?: boolean;
-  textChunkLimit?: number;
-  blockStreaming?: boolean;
-  blockStreamingCoalesce?: MattermostAccountConfig["blockStreamingCoalesce"];
-};
-
-function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
-  const accounts = cfg.channels?.mattermost?.accounts;
-  if (!accounts || typeof accounts !== "object") return [];
-  return Object.keys(accounts).filter(Boolean);
-}
-
-export function listMattermostAccountIds(cfg: ClawdbotConfig): string[] {
-  const ids = listConfiguredAccountIds(cfg);
-  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
-  return ids.sort((a, b) => a.localeCompare(b));
-}
-
-export function resolveDefaultMattermostAccountId(cfg: ClawdbotConfig): string {
-  const ids = listMattermostAccountIds(cfg);
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
-
-function resolveAccountConfig(
-  cfg: ClawdbotConfig,
-  accountId: string,
-): MattermostAccountConfig | undefined {
-  const accounts = cfg.channels?.mattermost?.accounts;
-  if (!accounts || typeof accounts !== "object") return undefined;
-  return accounts[accountId] as MattermostAccountConfig | undefined;
-}
-
-function mergeMattermostAccountConfig(
-  cfg: ClawdbotConfig,
-  accountId: string,
-): MattermostAccountConfig {
-  const { accounts: _ignored, ...base } = (cfg.channels?.mattermost ??
-    {}) as MattermostAccountConfig & { accounts?: unknown };
-  const account = resolveAccountConfig(cfg, accountId) ?? {};
-  return { ...base, ...account };
-}
-
-function resolveMattermostRequireMention(config: MattermostAccountConfig): boolean | undefined {
-  if (config.chatmode === "oncall") return true;
-  if (config.chatmode === "onmessage") return false;
-  if (config.chatmode === "onchar") return true;
-  return config.requireMention;
-}
-
-export function resolveMattermostAccount(params: {
-  cfg: ClawdbotConfig;
-  accountId?: string | null;
-}): ResolvedMattermostAccount {
-  const accountId = normalizeAccountId(params.accountId);
-  const baseEnabled = params.cfg.channels?.mattermost?.enabled !== false;
-  const merged = mergeMattermostAccountConfig(params.cfg, accountId);
-  const accountEnabled = merged.enabled !== false;
-  const enabled = baseEnabled && accountEnabled;
-
-  const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-  const envToken = allowEnv ? process.env.MATTERMOST_BOT_TOKEN?.trim() : undefined;
-  const envUrl = allowEnv ? process.env.MATTERMOST_URL?.trim() : undefined;
-  const configToken = merged.botToken?.trim();
-  const configUrl = merged.baseUrl?.trim();
-  const botToken = configToken || envToken;
-  const baseUrl = normalizeMattermostBaseUrl(configUrl || envUrl);
-  const requireMention = resolveMattermostRequireMention(merged);
-
-  const botTokenSource: MattermostTokenSource = configToken ? "config" : envToken ? "env" : "none";
-  const baseUrlSource: MattermostBaseUrlSource = configUrl ? "config" : envUrl ? "env" : "none";
-
-  return {
-    accountId,
-    enabled,
-    name: merged.name?.trim() || undefined,
-    botToken,
-    baseUrl,
-    botTokenSource,
-    baseUrlSource,
-    config: merged,
-    chatmode: merged.chatmode,
-    oncharPrefixes: merged.oncharPrefixes,
-    requireMention,
-    textChunkLimit: merged.textChunkLimit,
-    blockStreaming: merged.blockStreaming,
-    blockStreamingCoalesce: merged.blockStreamingCoalesce,
-  };
-}
-
-export function listEnabledMattermostAccounts(cfg: ClawdbotConfig): ResolvedMattermostAccount[] {
-  return listMattermostAccountIds(cfg)
-    .map((accountId) => resolveMattermostAccount({ cfg, accountId }))
-    .filter((account) => account.enabled);
-}

package/extensions/mattermost/src/mattermost/client.ts

@@ -1,208 +0,0 @@
-export type MattermostClient = {
-  baseUrl: string;
-  apiBaseUrl: string;
-  token: string;
-  request: <T>(path: string, init?: RequestInit) => Promise<T>;
-};
-
-export type MattermostUser = {
-  id: string;
-  username?: string | null;
-  nickname?: string | null;
-  first_name?: string | null;
-  last_name?: string | null;
-};
-
-export type MattermostChannel = {
-  id: string;
-  name?: string | null;
-  display_name?: string | null;
-  type?: string | null;
-  team_id?: string | null;
-};
-
-export type MattermostPost = {
-  id: string;
-  user_id?: string | null;
-  channel_id?: string | null;
-  message?: string | null;
-  file_ids?: string[] | null;
-  type?: string | null;
-  root_id?: string | null;
-  create_at?: number | null;
-  props?: Record<string, unknown> | null;
-};
-
-export type MattermostFileInfo = {
-  id: string;
-  name?: string | null;
-  mime_type?: string | null;
-  size?: number | null;
-};
-
-export function normalizeMattermostBaseUrl(raw?: string | null): string | undefined {
-  const trimmed = raw?.trim();
-  if (!trimmed) return undefined;
-  const withoutTrailing = trimmed.replace(/\/+$/, "");
-  return withoutTrailing.replace(/\/api\/v4$/i, "");
-}
-
-function buildMattermostApiUrl(baseUrl: string, path: string): string {
-  const normalized = normalizeMattermostBaseUrl(baseUrl);
-  if (!normalized) throw new Error("Mattermost baseUrl is required");
-  const suffix = path.startsWith("/") ? path : `/${path}`;
-  return `${normalized}/api/v4${suffix}`;
-}
-
-async function readMattermostError(res: Response): Promise<string> {
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    const data = (await res.json()) as { message?: string } | undefined;
-    if (data?.message) return data.message;
-    return JSON.stringify(data);
-  }
-  return await res.text();
-}
-
-export function createMattermostClient(params: {
-  baseUrl: string;
-  botToken: string;
-  fetchImpl?: typeof fetch;
-}): MattermostClient {
-  const baseUrl = normalizeMattermostBaseUrl(params.baseUrl);
-  if (!baseUrl) throw new Error("Mattermost baseUrl is required");
-  const apiBaseUrl = `${baseUrl}/api/v4`;
-  const token = params.botToken.trim();
-  const fetchImpl = params.fetchImpl ?? fetch;
-
-  const request = async <T>(path: string, init?: RequestInit): Promise<T> => {
-    const url = buildMattermostApiUrl(baseUrl, path);
-    const headers = new Headers(init?.headers);
-    headers.set("Authorization", `Bearer ${token}`);
-    if (typeof init?.body === "string" && !headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json");
-    }
-    const res = await fetchImpl(url, { ...init, headers });
-    if (!res.ok) {
-      const detail = await readMattermostError(res);
-      throw new Error(
-        `Mattermost API ${res.status} ${res.statusText}: ${detail || "unknown error"}`,
-      );
-    }
-    return (await res.json()) as T;
-  };
-
-  return { baseUrl, apiBaseUrl, token, request };
-}
-
-export async function fetchMattermostMe(client: MattermostClient): Promise<MattermostUser> {
-  return await client.request<MattermostUser>("/users/me");
-}
-
-export async function fetchMattermostUser(
-  client: MattermostClient,
-  userId: string,
-): Promise<MattermostUser> {
-  return await client.request<MattermostUser>(`/users/${userId}`);
-}
-
-export async function fetchMattermostUserByUsername(
-  client: MattermostClient,
-  username: string,
-): Promise<MattermostUser> {
-  return await client.request<MattermostUser>(`/users/username/${encodeURIComponent(username)}`);
-}
-
-export async function fetchMattermostChannel(
-  client: MattermostClient,
-  channelId: string,
-): Promise<MattermostChannel> {
-  return await client.request<MattermostChannel>(`/channels/${channelId}`);
-}
-
-export async function sendMattermostTyping(
-  client: MattermostClient,
-  params: { channelId: string; parentId?: string },
-): Promise<void> {
-  const payload: Record<string, string> = {
-    channel_id: params.channelId,
-  };
-  const parentId = params.parentId?.trim();
-  if (parentId) payload.parent_id = parentId;
-  await client.request<Record<string, unknown>>("/users/me/typing", {
-    method: "POST",
-    body: JSON.stringify(payload),
-  });
-}
-
-export async function createMattermostDirectChannel(
-  client: MattermostClient,
-  userIds: string[],
-): Promise<MattermostChannel> {
-  return await client.request<MattermostChannel>("/channels/direct", {
-    method: "POST",
-    body: JSON.stringify(userIds),
-  });
-}
-
-export async function createMattermostPost(
-  client: MattermostClient,
-  params: {
-    channelId: string;
-    message: string;
-    rootId?: string;
-    fileIds?: string[];
-  },
-): Promise<MattermostPost> {
-  const payload: Record<string, string> = {
-    channel_id: params.channelId,
-    message: params.message,
-  };
-  if (params.rootId) payload.root_id = params.rootId;
-  if (params.fileIds?.length) {
-    (payload as Record<string, unknown>).file_ids = params.fileIds;
-  }
-  return await client.request<MattermostPost>("/posts", {
-    method: "POST",
-    body: JSON.stringify(payload),
-  });
-}
-
-export async function uploadMattermostFile(
-  client: MattermostClient,
-  params: {
-    channelId: string;
-    buffer: Buffer;
-    fileName: string;
-    contentType?: string;
-  },
-): Promise<MattermostFileInfo> {
-  const form = new FormData();
-  const fileName = params.fileName?.trim() || "upload";
-  const bytes = Uint8Array.from(params.buffer);
-  const blob = params.contentType
-    ? new Blob([bytes], { type: params.contentType })
-    : new Blob([bytes]);
-  form.append("files", blob, fileName);
-  form.append("channel_id", params.channelId);
-
-  const res = await fetch(`${client.apiBaseUrl}/files`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${client.token}`,
-    },
-    body: form,
-  });
-
-  if (!res.ok) {
-    const detail = await readMattermostError(res);
-    throw new Error(`Mattermost API ${res.status} ${res.statusText}: ${detail || "unknown error"}`);
-  }
-
-  const data = (await res.json()) as { file_infos?: MattermostFileInfo[] };
-  const info = data.file_infos?.[0];
-  if (!info?.id) {
-    throw new Error("Mattermost file upload failed");
-  }
-  return info;
-}

package/extensions/mattermost/src/mattermost/index.ts

@@ -1,9 +0,0 @@
-export {
-  listEnabledMattermostAccounts,
-  listMattermostAccountIds,
-  resolveDefaultMattermostAccountId,
-  resolveMattermostAccount,
-} from "./accounts.js";
-export { monitorMattermostProvider } from "./monitor.js";
-export { probeMattermost } from "./probe.js";
-export { sendMessageMattermost } from "./send.js";

package/extensions/mattermost/src/mattermost/monitor-helpers.ts

@@ -1,150 +0,0 @@
-import { Buffer } from "node:buffer";
-
-import type WebSocket from "ws";
-
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
-
-export type ResponsePrefixContext = {
-  model?: string;
-  modelFull?: string;
-  provider?: string;
-  thinkingLevel?: string;
-  identityName?: string;
-};
-
-export function extractShortModelName(fullModel: string): string {
-  const slash = fullModel.lastIndexOf("/");
-  const modelPart = slash >= 0 ? fullModel.slice(slash + 1) : fullModel;
-  return modelPart.replace(/-\d{8}$/, "").replace(/-latest$/, "");
-}
-
-export function formatInboundFromLabel(params: {
-  isGroup: boolean;
-  groupLabel?: string;
-  groupId?: string;
-  directLabel: string;
-  directId?: string;
-  groupFallback?: string;
-}): string {
-  if (params.isGroup) {
-    const label = params.groupLabel?.trim() || params.groupFallback || "Group";
-    const id = params.groupId?.trim();
-    return id ? `${label} id:${id}` : label;
-  }
-
-  const directLabel = params.directLabel.trim();
-  const directId = params.directId?.trim();
-  if (!directId || directId === directLabel) return directLabel;
-  return `${directLabel} id:${directId}`;
-}
-
-type DedupeCache = {
-  check: (key: string | undefined | null, now?: number) => boolean;
-};
-
-export function createDedupeCache(options: { ttlMs: number; maxSize: number }): DedupeCache {
-  const ttlMs = Math.max(0, options.ttlMs);
-  const maxSize = Math.max(0, Math.floor(options.maxSize));
-  const cache = new Map<string, number>();
-
-  const touch = (key: string, now: number) => {
-    cache.delete(key);
-    cache.set(key, now);
-  };
-
-  const prune = (now: number) => {
-    const cutoff = ttlMs > 0 ? now - ttlMs : undefined;
-    if (cutoff !== undefined) {
-      for (const [entryKey, entryTs] of cache) {
-        if (entryTs < cutoff) {
-          cache.delete(entryKey);
-        }
-      }
-    }
-    if (maxSize <= 0) {
-      cache.clear();
-      return;
-    }
-    while (cache.size > maxSize) {
-      const oldestKey = cache.keys().next().value as string | undefined;
-      if (!oldestKey) break;
-      cache.delete(oldestKey);
-    }
-  };
-
-  return {
-    check: (key, now = Date.now()) => {
-      if (!key) return false;
-      const existing = cache.get(key);
-      if (existing !== undefined && (ttlMs <= 0 || now - existing < ttlMs)) {
-        touch(key, now);
-        return true;
-      }
-      touch(key, now);
-      prune(now);
-      return false;
-    },
-  };
-}
-
-export function rawDataToString(
-  data: WebSocket.RawData,
-  encoding: BufferEncoding = "utf8",
-): string {
-  if (typeof data === "string") return data;
-  if (Buffer.isBuffer(data)) return data.toString(encoding);
-  if (Array.isArray(data)) return Buffer.concat(data).toString(encoding);
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data).toString(encoding);
-  }
-  return Buffer.from(String(data)).toString(encoding);
-}
-
-function normalizeAgentId(value: string | undefined | null): string {
-  const trimmed = (value ?? "").trim();
-  if (!trimmed) return "main";
-  if (/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(trimmed)) return trimmed;
-  return (
-    trimmed
-      .toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/^-+/, "")
-      .replace(/-+$/, "")
-      .slice(0, 64) || "main"
-  );
-}
-
-type AgentEntry = NonNullable<NonNullable<ClawdbotConfig["agents"]>["list"]>[number];
-
-function listAgents(cfg: ClawdbotConfig): AgentEntry[] {
-  const list = cfg.agents?.list;
-  if (!Array.isArray(list)) return [];
-  return list.filter((entry): entry is AgentEntry => Boolean(entry && typeof entry === "object"));
-}
-
-function resolveAgentEntry(cfg: ClawdbotConfig, agentId: string): AgentEntry | undefined {
-  const id = normalizeAgentId(agentId);
-  return listAgents(cfg).find((entry) => normalizeAgentId(entry.id) === id);
-}
-
-export function resolveIdentityName(cfg: ClawdbotConfig, agentId: string): string | undefined {
-  const entry = resolveAgentEntry(cfg, agentId);
-  return entry?.identity?.name?.trim() || undefined;
-}
-
-export function resolveThreadSessionKeys(params: {
-  baseSessionKey: string;
-  threadId?: string | null;
-  parentSessionKey?: string;
-  useSuffix?: boolean;
-}): { sessionKey: string; parentSessionKey?: string } {
-  const threadId = (params.threadId ?? "").trim();
-  if (!threadId) {
-    return { sessionKey: params.baseSessionKey, parentSessionKey: undefined };
-  }
-  const useSuffix = params.useSuffix ?? true;
-  const sessionKey = useSuffix
-    ? `${params.baseSessionKey}:thread:${threadId}`
-    : params.baseSessionKey;
-  return { sessionKey, parentSessionKey: params.parentSessionKey };
-}