loudmouth-ai 0.1.0 → 0.2.0

package/extensions/matrix/src/matrix/client/storage.ts

@@ -1,131 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { getMatrixRuntime } from "../../runtime.js";
-import type { MatrixStoragePaths } from "./types.js";
-
-export const DEFAULT_ACCOUNT_KEY = "default";
-const STORAGE_META_FILENAME = "storage-meta.json";
-
-function sanitizePathSegment(value: string): string {
-  const cleaned = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, "_")
-    .replace(/^_+|_+$/g, "");
-  return cleaned || "unknown";
-}
-
-function resolveHomeserverKey(homeserver: string): string {
-  try {
-    const url = new URL(homeserver);
-    if (url.host) return sanitizePathSegment(url.host);
-  } catch {
-    // fall through
-  }
-  return sanitizePathSegment(homeserver);
-}
-
-function hashAccessToken(accessToken: string): string {
-  return crypto.createHash("sha256").update(accessToken).digest("hex").slice(0, 16);
-}
-
-function resolveLegacyStoragePaths(env: NodeJS.ProcessEnv = process.env): {
-  storagePath: string;
-  cryptoPath: string;
-} {
-  const stateDir = getMatrixRuntime().state.resolveStateDir(env, os.homedir);
-  return {
-    storagePath: path.join(stateDir, "matrix", "bot-storage.json"),
-    cryptoPath: path.join(stateDir, "matrix", "crypto"),
-  };
-}
-
-export function resolveMatrixStoragePaths(params: {
-  homeserver: string;
-  userId: string;
-  accessToken: string;
-  accountId?: string | null;
-  env?: NodeJS.ProcessEnv;
-}): MatrixStoragePaths {
-  const env = params.env ?? process.env;
-  const stateDir = getMatrixRuntime().state.resolveStateDir(env, os.homedir);
-  const accountKey = sanitizePathSegment(params.accountId ?? DEFAULT_ACCOUNT_KEY);
-  const userKey = sanitizePathSegment(params.userId);
-  const serverKey = resolveHomeserverKey(params.homeserver);
-  const tokenHash = hashAccessToken(params.accessToken);
-  const rootDir = path.join(
-    stateDir,
-    "matrix",
-    "accounts",
-    accountKey,
-    `${serverKey}__${userKey}`,
-    tokenHash,
-  );
-  return {
-    rootDir,
-    storagePath: path.join(rootDir, "bot-storage.json"),
-    cryptoPath: path.join(rootDir, "crypto"),
-    metaPath: path.join(rootDir, STORAGE_META_FILENAME),
-    accountKey,
-    tokenHash,
-  };
-}
-
-export function maybeMigrateLegacyStorage(params: {
-  storagePaths: MatrixStoragePaths;
-  env?: NodeJS.ProcessEnv;
-}): void {
-  const legacy = resolveLegacyStoragePaths(params.env);
-  const hasLegacyStorage = fs.existsSync(legacy.storagePath);
-  const hasLegacyCrypto = fs.existsSync(legacy.cryptoPath);
-  const hasNewStorage =
-    fs.existsSync(params.storagePaths.storagePath) ||
-    fs.existsSync(params.storagePaths.cryptoPath);
-
-  if (!hasLegacyStorage && !hasLegacyCrypto) return;
-  if (hasNewStorage) return;
-
-  fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
-  if (hasLegacyStorage) {
-    try {
-      fs.renameSync(legacy.storagePath, params.storagePaths.storagePath);
-    } catch {
-      // Ignore migration failures; new store will be created.
-    }
-  }
-  if (hasLegacyCrypto) {
-    try {
-      fs.renameSync(legacy.cryptoPath, params.storagePaths.cryptoPath);
-    } catch {
-      // Ignore migration failures; new store will be created.
-    }
-  }
-}
-
-export function writeStorageMeta(params: {
-  storagePaths: MatrixStoragePaths;
-  homeserver: string;
-  userId: string;
-  accountId?: string | null;
-}): void {
-  try {
-    const payload = {
-      homeserver: params.homeserver,
-      userId: params.userId,
-      accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
-      accessTokenHash: params.storagePaths.tokenHash,
-      createdAt: new Date().toISOString(),
-    };
-    fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
-    fs.writeFileSync(
-      params.storagePaths.metaPath,
-      JSON.stringify(payload, null, 2),
-      "utf-8",
-    );
-  } catch {
-    // ignore meta write failures
-  }
-}

package/extensions/matrix/src/matrix/client/types.ts

@@ -1,34 +0,0 @@
-export type MatrixResolvedConfig = {
-  homeserver: string;
-  userId: string;
-  accessToken?: string;
-  password?: string;
-  deviceName?: string;
-  initialSyncLimit?: number;
-  encryption?: boolean;
-};
-
-/**
- * Authenticated Matrix configuration.
- * Note: deviceId is NOT included here because it's implicit in the accessToken.
- * The crypto storage assumes the device ID (and thus access token) does not change
- * between restarts. If the access token becomes invalid or crypto storage is lost,
- * both will need to be recreated together.
- */
-export type MatrixAuth = {
-  homeserver: string;
-  userId: string;
-  accessToken: string;
-  deviceName?: string;
-  initialSyncLimit?: number;
-  encryption?: boolean;
-};
-
-export type MatrixStoragePaths = {
-  rootDir: string;
-  storagePath: string;
-  cryptoPath: string;
-  metaPath: string;
-  accountKey: string;
-  tokenHash: string;
-};

package/extensions/matrix/src/matrix/client.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { CoreConfig } from "../types.js";
-import { resolveMatrixConfig } from "./client.js";
-
-describe("resolveMatrixConfig", () => {
-  it("prefers config over env", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          homeserver: "https://cfg.example.org",
-          userId: "@cfg:example.org",
-          accessToken: "cfg-token",
-          password: "cfg-pass",
-          deviceName: "CfgDevice",
-          initialSyncLimit: 5,
-        },
-      },
-    } as CoreConfig;
-    const env = {
-      MATRIX_HOMESERVER: "https://env.example.org",
-      MATRIX_USER_ID: "@env:example.org",
-      MATRIX_ACCESS_TOKEN: "env-token",
-      MATRIX_PASSWORD: "env-pass",
-      MATRIX_DEVICE_NAME: "EnvDevice",
-    } as NodeJS.ProcessEnv;
-    const resolved = resolveMatrixConfig(cfg, env);
-    expect(resolved).toEqual({
-      homeserver: "https://cfg.example.org",
-      userId: "@cfg:example.org",
-      accessToken: "cfg-token",
-      password: "cfg-pass",
-      deviceName: "CfgDevice",
-      initialSyncLimit: 5,
-      encryption: false,
-    });
-  });
-
-  it("uses env when config is missing", () => {
-    const cfg = {} as CoreConfig;
-    const env = {
-      MATRIX_HOMESERVER: "https://env.example.org",
-      MATRIX_USER_ID: "@env:example.org",
-      MATRIX_ACCESS_TOKEN: "env-token",
-      MATRIX_PASSWORD: "env-pass",
-      MATRIX_DEVICE_NAME: "EnvDevice",
-    } as NodeJS.ProcessEnv;
-    const resolved = resolveMatrixConfig(cfg, env);
-    expect(resolved.homeserver).toBe("https://env.example.org");
-    expect(resolved.userId).toBe("@env:example.org");
-    expect(resolved.accessToken).toBe("env-token");
-    expect(resolved.password).toBe("env-pass");
-    expect(resolved.deviceName).toBe("EnvDevice");
-    expect(resolved.initialSyncLimit).toBeUndefined();
-    expect(resolved.encryption).toBe(false);
-  });
-});

package/extensions/matrix/src/matrix/client.ts

@@ -1,9 +0,0 @@
-export type { MatrixAuth, MatrixResolvedConfig } from "./client/types.js";
-export { isBunRuntime } from "./client/runtime.js";
-export { resolveMatrixConfig, resolveMatrixAuth } from "./client/config.js";
-export { createMatrixClient } from "./client/create-client.js";
-export {
-  resolveSharedMatrixClient,
-  waitForMatrixSync,
-  stopSharedClient,
-} from "./client/shared.js";

package/extensions/matrix/src/matrix/credentials.ts

@@ -1,103 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { getMatrixRuntime } from "../runtime.js";
-
-export type MatrixStoredCredentials = {
-  homeserver: string;
-  userId: string;
-  accessToken: string;
-  deviceId?: string;
-  createdAt: string;
-  lastUsedAt?: string;
-};
-
-const CREDENTIALS_FILENAME = "credentials.json";
-
-export function resolveMatrixCredentialsDir(
-  env: NodeJS.ProcessEnv = process.env,
-  stateDir?: string,
-): string {
-  const resolvedStateDir =
-    stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
-  return path.join(resolvedStateDir, "credentials", "matrix");
-}
-
-export function resolveMatrixCredentialsPath(env: NodeJS.ProcessEnv = process.env): string {
-  const dir = resolveMatrixCredentialsDir(env);
-  return path.join(dir, CREDENTIALS_FILENAME);
-}
-
-export function loadMatrixCredentials(
-  env: NodeJS.ProcessEnv = process.env,
-): MatrixStoredCredentials | null {
-  const credPath = resolveMatrixCredentialsPath(env);
-  try {
-    if (!fs.existsSync(credPath)) return null;
-    const raw = fs.readFileSync(credPath, "utf-8");
-    const parsed = JSON.parse(raw) as Partial<MatrixStoredCredentials>;
-    if (
-      typeof parsed.homeserver !== "string" ||
-      typeof parsed.userId !== "string" ||
-      typeof parsed.accessToken !== "string"
-    ) {
-      return null;
-    }
-    return parsed as MatrixStoredCredentials;
-  } catch {
-    return null;
-  }
-}
-
-export function saveMatrixCredentials(
-  credentials: Omit<MatrixStoredCredentials, "createdAt" | "lastUsedAt">,
-  env: NodeJS.ProcessEnv = process.env,
-): void {
-  const dir = resolveMatrixCredentialsDir(env);
-  fs.mkdirSync(dir, { recursive: true });
-
-  const credPath = resolveMatrixCredentialsPath(env);
-
-  const existing = loadMatrixCredentials(env);
-  const now = new Date().toISOString();
-
-  const toSave: MatrixStoredCredentials = {
-    ...credentials,
-    createdAt: existing?.createdAt ?? now,
-    lastUsedAt: now,
-  };
-
-  fs.writeFileSync(credPath, JSON.stringify(toSave, null, 2), "utf-8");
-}
-
-export function touchMatrixCredentials(env: NodeJS.ProcessEnv = process.env): void {
-  const existing = loadMatrixCredentials(env);
-  if (!existing) return;
-
-  existing.lastUsedAt = new Date().toISOString();
-  const credPath = resolveMatrixCredentialsPath(env);
-  fs.writeFileSync(credPath, JSON.stringify(existing, null, 2), "utf-8");
-}
-
-export function clearMatrixCredentials(env: NodeJS.ProcessEnv = process.env): void {
-  const credPath = resolveMatrixCredentialsPath(env);
-  try {
-    if (fs.existsSync(credPath)) {
-      fs.unlinkSync(credPath);
-    }
-  } catch {
-    // ignore
-  }
-}
-
-export function credentialsMatchConfig(
-  stored: MatrixStoredCredentials,
-  config: { homeserver: string; userId: string },
-): boolean {
-  // If userId is empty (token-based auth), only match homeserver
-  if (!config.userId) {
-    return stored.homeserver === config.homeserver;
-  }
-  return stored.homeserver === config.homeserver && stored.userId === config.userId;
-}

package/extensions/matrix/src/matrix/deps.ts

@@ -1,57 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
-import type { RuntimeEnv } from "clawdbot/plugin-sdk";
-import { getMatrixRuntime } from "../runtime.js";
-
-const MATRIX_SDK_PACKAGE = "matrix-bot-sdk";
-
-export function isMatrixSdkAvailable(): boolean {
-  try {
-    const req = createRequire(import.meta.url);
-    req.resolve(MATRIX_SDK_PACKAGE);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolvePluginRoot(): string {
-  const currentDir = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(currentDir, "..", "..");
-}
-
-export async function ensureMatrixSdkInstalled(params: {
-  runtime: RuntimeEnv;
-  confirm?: (message: string) => Promise<boolean>;
-}): Promise<void> {
-  if (isMatrixSdkAvailable()) return;
-  const confirm = params.confirm;
-  if (confirm) {
-    const ok = await confirm("Matrix requires matrix-bot-sdk. Install now?");
-    if (!ok) {
-      throw new Error("Matrix requires matrix-bot-sdk (install dependencies first).");
-    }
-  }
-
-  const root = resolvePluginRoot();
-  const command = fs.existsSync(path.join(root, "pnpm-lock.yaml"))
-    ? ["pnpm", "install"]
-    : ["npm", "install", "--omit=dev", "--silent"];
-  params.runtime.log?.(`matrix: installing dependencies via ${command[0]} (${root})…`);
-  const result = await getMatrixRuntime().system.runCommandWithTimeout(command, {
-    cwd: root,
-    timeoutMs: 300_000,
-    env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
-  });
-  if (result.code !== 0) {
-    throw new Error(
-      result.stderr.trim() || result.stdout.trim() || "Matrix dependency install failed.",
-    );
-  }
-  if (!isMatrixSdkAvailable()) {
-    throw new Error("Matrix dependency install completed but matrix-bot-sdk is still missing.");
-  }
-}

package/extensions/matrix/src/matrix/format.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { markdownToMatrixHtml } from "./format.js";
-
-describe("markdownToMatrixHtml", () => {
-  it("renders basic inline formatting", () => {
-    const html = markdownToMatrixHtml("hi _there_ **boss** `code`");
-    expect(html).toContain("<em>there</em>");
-    expect(html).toContain("<strong>boss</strong>");
-    expect(html).toContain("<code>code</code>");
-  });
-
-  it("renders links as HTML", () => {
-    const html = markdownToMatrixHtml("see [docs](https://example.com)");
-    expect(html).toContain('<a href="https://example.com">docs</a>');
-  });
-
-  it("escapes raw HTML", () => {
-    const html = markdownToMatrixHtml("<b>nope</b>");
-    expect(html).toContain("&lt;b&gt;nope&lt;/b&gt;");
-    expect(html).not.toContain("<b>nope</b>");
-  });
-
-  it("flattens images into alt text", () => {
-    const html = markdownToMatrixHtml("![alt](https://example.com/img.png)");
-    expect(html).toContain("alt");
-    expect(html).not.toContain("<img");
-  });
-
-  it("preserves line breaks", () => {
-    const html = markdownToMatrixHtml("line1\nline2");
-    expect(html).toContain("<br");
-  });
-});

package/extensions/matrix/src/matrix/format.ts

@@ -1,22 +0,0 @@
-import MarkdownIt from "markdown-it";
-
-const md = new MarkdownIt({
-  html: false,
-  linkify: true,
-  breaks: true,
-  typographer: false,
-});
-
-md.enable("strikethrough");
-
-const { escapeHtml } = md.utils;
-
-md.renderer.rules.image = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
-
-md.renderer.rules.html_block = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
-md.renderer.rules.html_inline = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
-
-export function markdownToMatrixHtml(markdown: string): string {
-  const rendered = md.render(markdown ?? "");
-  return rendered.trimEnd();
-}

package/extensions/matrix/src/matrix/index.ts

@@ -1,11 +0,0 @@
-export { monitorMatrixProvider } from "./monitor/index.js";
-export { probeMatrix } from "./probe.js";
-export {
-  reactMatrixMessage,
-  resolveMatrixRoomId,
-  sendReadReceiptMatrix,
-  sendMessageMatrix,
-  sendPollMatrix,
-  sendTypingMatrix,
-} from "./send.js";
-export { resolveMatrixAuth, resolveSharedMatrixClient } from "./client.js";

package/extensions/matrix/src/matrix/monitor/allowlist.ts

@@ -1,58 +0,0 @@
-import type { AllowlistMatch } from "clawdbot/plugin-sdk";
-
-function normalizeAllowList(list?: Array<string | number>) {
-  return (list ?? []).map((entry) => String(entry).trim()).filter(Boolean);
-}
-
-export function normalizeAllowListLower(list?: Array<string | number>) {
-  return normalizeAllowList(list).map((entry) => entry.toLowerCase());
-}
-
-function normalizeMatrixUser(raw?: string | null): string {
-  return (raw ?? "").trim().toLowerCase();
-}
-
-export type MatrixAllowListMatch = AllowlistMatch<
-  "wildcard" | "id" | "prefixed-id" | "prefixed-user" | "name" | "localpart"
->;
-
-export function resolveMatrixAllowListMatch(params: {
-  allowList: string[];
-  userId?: string;
-  userName?: string;
-}): MatrixAllowListMatch {
-  const allowList = params.allowList;
-  if (allowList.length === 0) return { allowed: false };
-  if (allowList.includes("*")) {
-    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
-  }
-  const userId = normalizeMatrixUser(params.userId);
-  const userName = normalizeMatrixUser(params.userName);
-  const localPart = userId.startsWith("@") ? (userId.slice(1).split(":")[0] ?? "") : "";
-  const candidates: Array<{ value?: string; source: MatrixAllowListMatch["matchSource"] }> = [
-    { value: userId, source: "id" },
-    { value: userId ? `matrix:${userId}` : "", source: "prefixed-id" },
-    { value: userId ? `user:${userId}` : "", source: "prefixed-user" },
-    { value: userName, source: "name" },
-    { value: localPart, source: "localpart" },
-  ];
-  for (const candidate of candidates) {
-    if (!candidate.value) continue;
-    if (allowList.includes(candidate.value)) {
-      return {
-        allowed: true,
-        matchKey: candidate.value,
-        matchSource: candidate.source,
-      };
-    }
-  }
-  return { allowed: false };
-}
-
-export function resolveMatrixAllowListMatches(params: {
-  allowList: string[];
-  userId?: string;
-  userName?: string;
-}) {
-  return resolveMatrixAllowListMatch(params).allowed;
-}

package/extensions/matrix/src/matrix/monitor/auto-join.ts

@@ -1,68 +0,0 @@
-import type { MatrixClient } from "matrix-bot-sdk";
-import { AutojoinRoomsMixin } from "matrix-bot-sdk";
-
-import type { RuntimeEnv } from "clawdbot/plugin-sdk";
-import type { CoreConfig } from "../../types.js";
-import { getMatrixRuntime } from "../../runtime.js";
-
-export function registerMatrixAutoJoin(params: {
-  client: MatrixClient;
-  cfg: CoreConfig;
-  runtime: RuntimeEnv;
-}) {
-  const { client, cfg, runtime } = params;
-  const core = getMatrixRuntime();
-  const logVerbose = (message: string) => {
-    if (!core.logging.shouldLogVerbose()) return;
-    runtime.log?.(message);
-  };
-  const autoJoin = cfg.channels?.matrix?.autoJoin ?? "always";
-  const autoJoinAllowlist = cfg.channels?.matrix?.autoJoinAllowlist ?? [];
-
-  if (autoJoin === "off") {
-    return;
-  }
-
-  if (autoJoin === "always") {
-    // Use the built-in autojoin mixin for "always" mode
-    AutojoinRoomsMixin.setupOnClient(client);
-    logVerbose("matrix: auto-join enabled for all invites");
-    return;
-  }
-
-  // For "allowlist" mode, handle invites manually
-  client.on("room.invite", async (roomId: string, _inviteEvent: unknown) => {
-    if (autoJoin !== "allowlist") return;
-
-    // Get room alias if available
-    let alias: string | undefined;
-    let altAliases: string[] = [];
-    try {
-      const aliasState = await client
-        .getRoomStateEvent(roomId, "m.room.canonical_alias", "")
-        .catch(() => null);
-      alias = aliasState?.alias;
-      altAliases = Array.isArray(aliasState?.alt_aliases) ? aliasState.alt_aliases : [];
-    } catch {
-      // Ignore errors
-    }
-
-    const allowed =
-      autoJoinAllowlist.includes("*") ||
-      autoJoinAllowlist.includes(roomId) ||
-      (alias ? autoJoinAllowlist.includes(alias) : false) ||
-      altAliases.some((value) => autoJoinAllowlist.includes(value));
-
-    if (!allowed) {
-      logVerbose(`matrix: invite ignored (not in allowlist) room=${roomId}`);
-      return;
-    }
-
-    try {
-      await client.joinRoom(roomId);
-      logVerbose(`matrix: joined room ${roomId}`);
-    } catch (err) {
-      runtime.error?.(`matrix: failed to join room ${roomId}: ${String(err)}`);
-    }
-  });
-}