chainlesschain 0.47.7 → 0.47.9

package/src/lib/matrix-bridge.js

@@ -8,6 +8,7 @@ import crypto from "crypto";
 /* ── In-memory stores ──────────────────────────────────────── */
 const _rooms = new Map();
 const _messages = new Map();
+const _spaceChildren = new Map(); // spaceRoomId → Map<childRoomId, { via: string[] }>
 let _loginState = {
   state: "logged_out",
   userId: null,
@@ -181,11 +182,262 @@ export function getMessages(roomId, filter = {}) {
   return messages.slice(0, limit);
 }
 
+/* ── Threads (MSC3440 / spec §11.38) ───────────────────────── */
+
+/**
+ * Send a threaded reply. Stores an m.room.message event whose content has
+ *   m.relates_to: { rel_type: "m.thread", event_id: <root>, is_falling_back, m.in_reply_to }
+ * Clients that don't understand threads fall back to rendering as a reply
+ * when is_falling_back=true (the default per spec).
+ *
+ * @param {Object} db
+ * @param {Object} params
+ *   @param {string} params.roomId
+ *   @param {string} params.rootEventId - Event id of the thread's root message
+ *   @param {string} params.body
+ *   @param {string} [params.msgtype="m.text"]
+ *   @param {string} [params.inReplyTo] - Defaults to rootEventId
+ *   @param {boolean} [params.isFallingBack=true]
+ */
+export function sendThreadReply(
+  db,
+  { roomId, rootEventId, body, msgtype, inReplyTo, isFallingBack = true },
+) {
+  if (!roomId) throw new Error("Room ID is required");
+  if (!rootEventId) throw new Error("rootEventId is required");
+  if (!body) throw new Error("Message body is required");
+
+  const id = crypto.randomUUID();
+  const eventId = `$${crypto.randomBytes(16).toString("hex")}`;
+  const now = new Date().toISOString();
+
+  const relatesTo = {
+    rel_type: "m.thread",
+    event_id: rootEventId,
+    is_falling_back: isFallingBack,
+    "m.in_reply_to": { event_id: inReplyTo || rootEventId },
+  };
+
+  const message = {
+    id,
+    eventId,
+    roomId,
+    sender: _loginState.userId || "cli-user",
+    eventType: "m.room.message",
+    content: {
+      body,
+      msgtype: msgtype || "m.text",
+      "m.relates_to": relatesTo,
+    },
+    originServerTs: now,
+    isEncrypted: _loginState.e2eeEnabled,
+    createdAt: now,
+  };
+
+  _messages.set(id, message);
+
+  db.prepare(
+    `INSERT INTO matrix_events (id, event_id, room_id, sender, event_type, content, origin_server_ts, is_encrypted, decrypted_content, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    eventId,
+    roomId,
+    message.sender,
+    "m.room.message",
+    JSON.stringify(message.content),
+    now,
+    message.isEncrypted ? 1 : 0,
+    body,
+    now,
+  );
+
+  return { success: true, event: message };
+}
+
+/**
+ * List all replies to a given thread root (in chronological order).
+ */
+export function getThreadMessages(roomId, rootEventId) {
+  if (!roomId) throw new Error("Room ID is required");
+  if (!rootEventId) throw new Error("rootEventId is required");
+
+  return [..._messages.values()]
+    .filter((m) => {
+      if (m.roomId !== roomId) return false;
+      const rel = m.content && m.content["m.relates_to"];
+      return rel && rel.rel_type === "m.thread" && rel.event_id === rootEventId;
+    })
+    .sort((a, b) =>
+      a.originServerTs < b.originServerTs
+        ? -1
+        : a.originServerTs > b.originServerTs
+          ? 1
+          : 0,
+    );
+}
+
+/**
+ * List distinct thread roots within a room (events that have at least one
+ * threaded reply). Returns { rootEventId, replyCount, lastReplyAt }.
+ */
+export function getThreadRoots(roomId) {
+  if (!roomId) throw new Error("Room ID is required");
+
+  const rollup = new Map();
+  for (const m of _messages.values()) {
+    if (m.roomId !== roomId) continue;
+    const rel = m.content && m.content["m.relates_to"];
+    if (!rel || rel.rel_type !== "m.thread") continue;
+    const rootId = rel.event_id;
+    const existing = rollup.get(rootId) || {
+      rootEventId: rootId,
+      replyCount: 0,
+      lastReplyAt: null,
+    };
+    existing.replyCount += 1;
+    if (!existing.lastReplyAt || m.originServerTs > existing.lastReplyAt) {
+      existing.lastReplyAt = m.originServerTs;
+    }
+    rollup.set(rootId, existing);
+  }
+  return [...rollup.values()];
+}
+
+/* ── Spaces (spec §11.34) ──────────────────────────────────── */
+
+/**
+ * Create a Matrix Space. A Space is a room whose creation content declares
+ *   type: "m.space"
+ * — we model this by setting room.type on the in-memory room record and
+ * persisting it into matrix_rooms (reusing the existing topic column would
+ * be wrong, so we encode type by a "#space:" prefix on the room name).
+ *
+ * @param {Object} db
+ * @param {Object} params
+ *   @param {string} params.name
+ *   @param {string} [params.topic]
+ */
+export function createSpace(db, { name, topic }) {
+  if (!name) throw new Error("Space name is required");
+
+  const id = crypto.randomUUID();
+  const roomId = `!space_${crypto.randomBytes(8).toString("hex")}`;
+  const now = new Date().toISOString();
+
+  const space = {
+    id,
+    roomId,
+    name,
+    topic: topic || null,
+    type: "m.space",
+    isEncrypted: false, // Spaces are not encrypted per spec
+    memberCount: 1,
+    lastEventAt: now,
+    joinedAt: now,
+    status: "joined",
+    createdAt: now,
+  };
+
+  _rooms.set(id, space);
+  _spaceChildren.set(roomId, new Map());
+
+  db.prepare(
+    `INSERT INTO matrix_rooms (id, room_id, name, topic, is_encrypted, member_count, last_event_at, joined_at, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(id, roomId, name, topic || null, 0, 1, now, now, "joined", now);
+
+  return { success: true, space };
+}
+
+/**
+ * Add a child room to a Space. In real Matrix this writes an m.space.child
+ * state event to the parent space with state_key = childRoomId.
+ *
+ * @param {Object} db
+ * @param {Object} params
+ *   @param {string} params.spaceId - Parent space's room id (!space_*)
+ *   @param {string} params.childRoomId - Child room id
+ *   @param {string[]} [params.via] - Homeservers via which the child is reachable
+ */
+export function addSpaceChild(db, { spaceId, childRoomId, via }) {
+  if (!spaceId) throw new Error("spaceId is required");
+  if (!childRoomId) throw new Error("childRoomId is required");
+
+  const children = _spaceChildren.get(spaceId);
+  if (!children) {
+    throw new Error(`Space not found: ${spaceId}`);
+  }
+  const viaList = Array.isArray(via) && via.length > 0 ? via : ["matrix.org"];
+  children.set(childRoomId, { via: viaList });
+
+  // Persist as an m.space.child state event in matrix_events
+  const id = crypto.randomUUID();
+  const eventId = `$${crypto.randomBytes(16).toString("hex")}`;
+  const now = new Date().toISOString();
+  const content = { via: viaList };
+
+  db.prepare(
+    `INSERT INTO matrix_events (id, event_id, room_id, sender, event_type, content, origin_server_ts, is_encrypted, decrypted_content, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    eventId,
+    spaceId,
+    _loginState.userId || "cli-user",
+    "m.space.child",
+    JSON.stringify({ state_key: childRoomId, content }),
+    now,
+    0,
+    null,
+    now,
+  );
+
+  return { success: true, spaceId, childRoomId, via: viaList };
+}
+
+/**
+ * Remove a child from a Space (equivalent to sending an empty m.space.child
+ * state event in real Matrix).
+ */
+export function removeSpaceChild(db, { spaceId, childRoomId }) {
+  if (!spaceId) throw new Error("spaceId is required");
+  if (!childRoomId) throw new Error("childRoomId is required");
+
+  const children = _spaceChildren.get(spaceId);
+  if (!children) {
+    throw new Error(`Space not found: ${spaceId}`);
+  }
+  const removed = children.delete(childRoomId);
+  return { success: true, removed };
+}
+
+/**
+ * List all children of a Space.
+ */
+export function listSpaceChildren(spaceId) {
+  if (!spaceId) throw new Error("spaceId is required");
+  const children = _spaceChildren.get(spaceId);
+  if (!children) return [];
+  return [...children.entries()].map(([childRoomId, meta]) => ({
+    childRoomId,
+    via: meta.via,
+  }));
+}
+
+/**
+ * List all Spaces (rooms with type === "m.space").
+ */
+export function listSpaces() {
+  return [..._rooms.values()].filter((r) => r.type === "m.space");
+}
+
 /* ── Reset (for testing) ───────────────────────────────────── */
 
 export function _resetState() {
   _rooms.clear();
   _messages.clear();
+  _spaceChildren.clear();
   _loginState = {
     state: "logged_out",
     userId: null,

package/src/lib/mcp-registry.js

@@ -0,0 +1,347 @@
+/**
+ * MCP community server registry — pure read-only catalog.
+ *
+ * Ships a bundled list of well-known community MCP servers so users can
+ * discover, search, and one-shot install them without maintaining a
+ * remote index. Mirrors the curated catalog from
+ * `desktop-app-vue/src/main/mcp/community-registry.js` but pared down
+ * to what the CLI actually needs: browse + search + hand the chosen
+ * entry to `mcp add`.
+ *
+ * The catalog is intentionally small (the 8 first-party
+ * `@modelcontextprotocol/server-*` packages). Users who want more can
+ * still `cc mcp add` any server by hand — the registry is a
+ * convenience, not the source of truth for which servers exist.
+ */
+
+/* ── constants ──────────────────────────────────────────────── */
+
+export const CATEGORIES = Object.freeze([
+  "database",
+  "filesystem",
+  "version-control",
+  "search",
+  "automation",
+  "communication",
+  "cloud",
+  "productivity",
+]);
+
+export const TRANSPORTS = Object.freeze(["stdio", "http"]);
+
+/**
+ * Bundled catalog. Frozen at module load — treat as read-only. Each
+ * entry carries enough for `cc mcp add` to wire it up verbatim
+ * (command + args) plus prose/examples that help the agent REPL
+ * decide when to use it.
+ */
+export const CATALOG = Object.freeze([
+  {
+    id: "mcp-server-filesystem",
+    name: "filesystem",
+    displayName: "File System",
+    description:
+      "File system access — read, write, list, and manage files and directories.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "filesystem",
+    tags: ["file", "directory", "read", "write", "filesystem"],
+    npmPackage: "@modelcontextprotocol/server-filesystem",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem"],
+    transport: "stdio",
+    tools: [
+      "read_file",
+      "write_file",
+      "list_directory",
+      "create_directory",
+      "move_file",
+      "search_files",
+      "get_file_info",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
+    rating: 5.0,
+  },
+  {
+    id: "mcp-server-postgresql",
+    name: "postgresql",
+    displayName: "PostgreSQL",
+    description:
+      "PostgreSQL database — execute queries, inspect schema, manage data.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "database",
+    tags: ["database", "sql", "postgresql", "postgres", "query"],
+    npmPackage: "@modelcontextprotocol/server-postgres",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-postgres"],
+    transport: "stdio",
+    tools: ["query", "list_tables", "describe_table"],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/postgres",
+    rating: 4.8,
+  },
+  {
+    id: "mcp-server-sqlite",
+    name: "sqlite",
+    displayName: "SQLite",
+    description:
+      "SQLite database — local, embedded query execution and schema management.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "database",
+    tags: ["database", "sql", "sqlite", "local", "embedded"],
+    npmPackage: "@modelcontextprotocol/server-sqlite",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-sqlite"],
+    transport: "stdio",
+    tools: [
+      "read_query",
+      "write_query",
+      "create_table",
+      "list_tables",
+      "describe_table",
+      "append_insight",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite",
+    rating: 4.7,
+  },
+  {
+    id: "mcp-server-git",
+    name: "git",
+    displayName: "Git",
+    description:
+      "Git version control — status, diff, log, commit, branch management.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "version-control",
+    tags: ["git", "version-control", "diff", "commit", "branch"],
+    npmPackage: "@modelcontextprotocol/server-git",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-git"],
+    transport: "stdio",
+    tools: [
+      "git_status",
+      "git_diff",
+      "git_log",
+      "git_commit",
+      "git_branch_list",
+      "git_checkout",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
+    rating: 4.9,
+  },
+  {
+    id: "mcp-server-brave-search",
+    name: "brave-search",
+    displayName: "Brave Search",
+    description:
+      "Web search via Brave Search API — general web + local business queries.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "search",
+    tags: ["search", "web", "brave", "internet", "query"],
+    npmPackage: "@modelcontextprotocol/server-brave-search",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-brave-search"],
+    transport: "stdio",
+    tools: ["brave_web_search", "brave_local_search"],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search",
+    rating: 4.6,
+  },
+  {
+    id: "mcp-server-puppeteer",
+    name: "puppeteer",
+    displayName: "Puppeteer",
+    description:
+      "Browser automation — navigate, screenshot, click, fill forms, evaluate JS.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "automation",
+    tags: ["browser", "automation", "puppeteer", "scraping", "screenshot"],
+    npmPackage: "@modelcontextprotocol/server-puppeteer",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+    transport: "stdio",
+    tools: [
+      "puppeteer_navigate",
+      "puppeteer_screenshot",
+      "puppeteer_click",
+      "puppeteer_fill",
+      "puppeteer_evaluate",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer",
+    rating: 4.5,
+  },
+  {
+    id: "mcp-server-slack",
+    name: "slack",
+    displayName: "Slack",
+    description:
+      "Slack workspace — read messages, post updates, manage channels and threads.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "communication",
+    tags: ["slack", "messaging", "chat", "communication", "team"],
+    npmPackage: "@modelcontextprotocol/server-slack",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-slack"],
+    transport: "stdio",
+    tools: [
+      "slack_list_channels",
+      "slack_post_message",
+      "slack_reply_to_thread",
+      "slack_get_channel_history",
+      "slack_search_messages",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/slack",
+    rating: 4.4,
+  },
+  {
+    id: "mcp-server-github",
+    name: "github",
+    displayName: "GitHub",
+    description:
+      "GitHub API — manage repositories, issues, pull requests, and actions.",
+    version: "1.0.0",
+    author: "Anthropic",
+    category: "version-control",
+    tags: ["github", "repository", "issues", "pull-request", "api"],
+    npmPackage: "@modelcontextprotocol/server-github",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    transport: "stdio",
+    tools: [
+      "create_or_update_file",
+      "search_repositories",
+      "create_repository",
+      "get_file_contents",
+      "push_files",
+      "create_issue",
+      "create_pull_request",
+      "list_issues",
+      "list_commits",
+    ],
+    homepage:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/github",
+    rating: 4.8,
+  },
+]);
+
+/* ── public API ─────────────────────────────────────────────── */
+
+/**
+ * Return the catalog filtered, sorted, and paginated.
+ *
+ * @param {object} [filters]
+ * @param {string} [filters.category]
+ * @param {string[]} [filters.tags]        — any-match
+ * @param {string} [filters.author]        — substring, case-insensitive
+ * @param {"name"|"rating"|"category"} [filters.sortBy="name"]
+ * @param {"asc"|"desc"} [filters.sortOrder="asc"]
+ * @param {number} [filters.limit]
+ * @param {number} [filters.offset]
+ * @returns {{ servers: object[], total: number }}
+ */
+export function listServers(filters = {}) {
+  let servers = CATALOG.slice();
+
+  if (filters.category) {
+    const cat = String(filters.category).toLowerCase();
+    servers = servers.filter((s) => s.category === cat);
+  }
+
+  if (Array.isArray(filters.tags) && filters.tags.length > 0) {
+    const wanted = new Set(filters.tags.map((t) => String(t).toLowerCase()));
+    servers = servers.filter(
+      (s) => s.tags && s.tags.some((tag) => wanted.has(tag.toLowerCase())),
+    );
+  }
+
+  if (filters.author) {
+    const a = String(filters.author).toLowerCase();
+    servers = servers.filter(
+      (s) => s.author && s.author.toLowerCase().includes(a),
+    );
+  }
+
+  const total = servers.length;
+
+  const sortBy = filters.sortBy || "name";
+  const sortDir = filters.sortOrder === "desc" ? -1 : 1;
+  servers = servers.slice().sort((a, b) => {
+    const av = a[sortBy];
+    const bv = b[sortBy];
+    if (typeof av === "number" && typeof bv === "number") {
+      return (av - bv) * sortDir;
+    }
+    return String(av ?? "").localeCompare(String(bv ?? "")) * sortDir;
+  });
+
+  const offset =
+    Number.isInteger(filters.offset) && filters.offset > 0 ? filters.offset : 0;
+  const limit =
+    Number.isInteger(filters.limit) && filters.limit > 0
+      ? filters.limit
+      : servers.length;
+  servers = servers.slice(offset, offset + limit);
+
+  return { servers, total };
+}
+
+/**
+ * Keyword search across `name`, `displayName`, `description`, and `tags`.
+ * Returns matches ranked by a simple weighted score — name/id are
+ * weighted highest, then tags, then description.
+ */
+export function searchServers(keyword) {
+  if (typeof keyword !== "string" || !keyword.trim()) return [];
+  const q = keyword.trim().toLowerCase();
+
+  const scored = [];
+  for (const entry of CATALOG) {
+    let score = 0;
+    if (entry.name && entry.name.toLowerCase() === q) score += 100;
+    else if (entry.name && entry.name.toLowerCase().includes(q)) score += 40;
+    if (entry.id.toLowerCase().includes(q)) score += 20;
+    if (entry.displayName && entry.displayName.toLowerCase().includes(q)) {
+      score += 30;
+    }
+    if (Array.isArray(entry.tags)) {
+      for (const tag of entry.tags) {
+        if (tag.toLowerCase() === q) score += 25;
+        else if (tag.toLowerCase().includes(q)) score += 10;
+      }
+    }
+    if (entry.description && entry.description.toLowerCase().includes(q)) {
+      score += 15;
+    }
+    if (entry.category && entry.category.toLowerCase().includes(q)) {
+      score += 10;
+    }
+    if (score > 0) scored.push({ entry, score });
+  }
+
+  scored.sort((a, b) => b.score - a.score);
+  return scored.map((s) => s.entry);
+}
+
+/**
+ * Look up a catalog entry by `id` or by `name`. Returns `null` if
+ * neither matches. Matching is case-insensitive.
+ */
+export function getServer(idOrName) {
+  if (typeof idOrName !== "string" || !idOrName.trim()) return null;
+  const needle = idOrName.trim().toLowerCase();
+  return (
+    CATALOG.find(
+      (s) => s.id.toLowerCase() === needle || s.name.toLowerCase() === needle,
+    ) || null
+  );
+}