matterbridge-lg-thinq-plugin 0.1.0

package/.claude/tools/discord-send-server.cjs

@@ -0,0 +1,188 @@
+'use strict';
+
+// MCP stdio server — sends a message to a Discord channel as the configured
+// bot. Reads DISCORD_BOT_TOKEN from ~/.claude/channels/discord/.env.
+// Node built-ins only; no npm deps.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const https = require('https');
+const readline = require('readline');
+
+const ENV_FILE = path.join(os.homedir(), '.claude', 'channels', 'discord', '.env');
+
+// ---------------------------------------------------------------------------
+// Transport helpers
+// ---------------------------------------------------------------------------
+
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+function sendResult(id, content) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [{ type: 'text', text: content }],
+    },
+  });
+}
+
+function sendError(id, code, message) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Token loading
+// ---------------------------------------------------------------------------
+
+function readBotToken() {
+  if (!fs.existsSync(ENV_FILE)) {
+    return null;
+  }
+  const content = fs.readFileSync(ENV_FILE, 'utf8');
+  const match = content.match(/^DISCORD_BOT_TOKEN=(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+
+// ---------------------------------------------------------------------------
+// DiscordSend tool implementation
+// ---------------------------------------------------------------------------
+
+function postMessage(channelId, content, token) {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify({ content });
+    const req = https.request(
+      {
+        hostname: 'discord.com',
+        path: `/api/v10/channels/${encodeURIComponent(channelId)}/messages`,
+        method: 'POST',
+        headers: {
+          Authorization: `Bot ${token}`,
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let body = '';
+        res.on('data', (chunk) => (body += chunk));
+        res.on('end', () => resolve({ status: res.statusCode, body }));
+      },
+    );
+    req.on('error', (err) => resolve({ status: 0, body: err.message }));
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function discordSend({ channelId, message }) {
+  if (!channelId) {
+    return 'Error: "channelId" is required.';
+  }
+  if (!message) {
+    return 'Error: "message" is required.';
+  }
+
+  const token = readBotToken();
+  if (!token) {
+    return `Error: DISCORD_BOT_TOKEN not found in ${ENV_FILE}. Run /discord:configure <token> first.`;
+  }
+
+  const { status, body } = await postMessage(channelId, message, token);
+
+  if (status >= 200 && status < 300) {
+    return `Message sent to channel ${channelId} (HTTP ${status}).`;
+  }
+  return `Error: failed to send message (HTTP ${status}): ${body}`;
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+
+const TOOL_DEFINITIONS = [
+  {
+    name: 'DiscordSend',
+    description:
+      'Send a message to a Discord channel as the configured bot, using a saved bot token (~/.claude/channels/discord/.env). The bot must already be a member of the server owning the channel, with Send Messages permission. Use for proactively pushing a message to a known channel ID — not for replying to inbound DMs (that flow uses the discord plugin\'s own reply tool).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channelId: { type: 'string', description: 'Discord channel snowflake ID to send the message to' },
+        message: { type: 'string', description: 'Message text to send' },
+      },
+      required: ['channelId', 'message'],
+    },
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Request dispatcher
+// ---------------------------------------------------------------------------
+
+function handleRequest(req) {
+  const { id, method, params } = req;
+
+  if (id === undefined || id === null) {
+    return;
+  }
+
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        serverInfo: { name: 'discord-send-server', version: '1.0.0' },
+        capabilities: { tools: {} },
+      },
+    });
+    return;
+  }
+
+  if (method === 'tools/list') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: { tools: TOOL_DEFINITIONS },
+    });
+    return;
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params || {};
+    if (name !== 'DiscordSend') {
+      sendError(id, -32601, `Unknown tool: ${name}`);
+      return;
+    }
+    discordSend(args || {})
+      .then((text) => sendResult(id, text))
+      .catch((err) => sendResult(id, `Error: ${err.message}`));
+    return;
+  }
+
+  sendError(id, -32601, `Method not found: ${method}`);
+}
+
+// ---------------------------------------------------------------------------
+// Main — read newline-delimited JSON from stdin
+// ---------------------------------------------------------------------------
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  try {
+    const req = JSON.parse(trimmed);
+    handleRequest(req);
+  } catch (_) {
+    // Malformed JSON — ignore
+  }
+});

package/.claude/tools/github-release-server.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+// MCP stdio server — creates a GitHub release via the `gh` CLI. GitHub
+// creates the git tag automatically (pointing at the target branch's HEAD)
+// if it doesn't already exist. Node built-ins only; no npm deps.
+
+const { execFileSync } = require('child_process');
+const readline = require('readline');
+
+// ---------------------------------------------------------------------------
+// Transport helpers
+// ---------------------------------------------------------------------------
+
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+function sendResult(id, content) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [{ type: 'text', text: content }],
+    },
+  });
+}
+
+function sendError(id, code, message) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// GitHubRelease tool implementation
+// ---------------------------------------------------------------------------
+
+function createRelease({ tag, targetBranch, notes, title, prerelease, repoPath }) {
+  if (!tag) {
+    return 'Error: "tag" is required.';
+  }
+  if (!targetBranch) {
+    return 'Error: "targetBranch" is required.';
+  }
+  if (!notes) {
+    return 'Error: "notes" is required.';
+  }
+
+  const isPrerelease = typeof prerelease === 'boolean' ? prerelease : /-rc\d*$/i.test(tag);
+  const releaseTitle = title || tag;
+
+  const args = [
+    'release',
+    'create',
+    tag,
+    '--target',
+    targetBranch,
+    '--title',
+    releaseTitle,
+    '--notes',
+    notes,
+  ];
+  if (isPrerelease) {
+    args.push('--prerelease');
+  }
+
+  try {
+    const stdout = execFileSync('gh', args, {
+      encoding: 'utf8',
+      cwd: repoPath || process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return `Release created (${isPrerelease ? 'prerelease' : 'release'}): ${stdout.trim()}`;
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString().trim() : '';
+    const stdout = err.stdout ? err.stdout.toString().trim() : '';
+    return `Error: gh release create failed.\n${stderr || stdout || err.message}`;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+
+const TOOL_DEFINITIONS = [
+  {
+    name: 'GitHubRelease',
+    description:
+      'Create a GitHub release using the gh CLI (must already be authenticated via `gh auth login`). GitHub creates the git tag automatically, pointing at the target branch\'s current HEAD, if the tag does not already exist. Prerelease is auto-detected from the tag (matches -rcN suffix) unless explicitly overridden.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tag: { type: 'string', description: 'Release/tag name, e.g. "1.1.7" or "1.1.7-rc07"' },
+        targetBranch: { type: 'string', description: 'Branch the tag should point at, e.g. "master" or "dev"' },
+        notes: { type: 'string', description: 'Release notes body (e.g. the changelog entry text)' },
+        title: { type: 'string', description: 'Release title (defaults to the tag if omitted)' },
+        prerelease: {
+          type: 'boolean',
+          description: 'Force prerelease flag on/off. If omitted, auto-detected from tag (-rcN suffix -> true).',
+        },
+        repoPath: {
+          type: 'string',
+          description: 'Path to the local git repository (defaults to current working directory)',
+        },
+      },
+      required: ['tag', 'targetBranch', 'notes'],
+    },
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Request dispatcher
+// ---------------------------------------------------------------------------
+
+function handleRequest(req) {
+  const { id, method, params } = req;
+
+  if (id === undefined || id === null) {
+    return;
+  }
+
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        serverInfo: { name: 'github-release-server', version: '1.0.0' },
+        capabilities: { tools: {} },
+      },
+    });
+    return;
+  }
+
+  if (method === 'tools/list') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: { tools: TOOL_DEFINITIONS },
+    });
+    return;
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params || {};
+    try {
+      let text;
+      if (name === 'GitHubRelease') {
+        text = createRelease(args || {});
+      } else {
+        sendError(id, -32601, `Unknown tool: ${name}`);
+        return;
+      }
+      sendResult(id, text);
+    } catch (err) {
+      sendResult(id, `Error: ${err.message}`);
+    }
+    return;
+  }
+
+  sendError(id, -32601, `Method not found: ${method}`);
+}
+
+// ---------------------------------------------------------------------------
+// Main — read newline-delimited JSON from stdin
+// ---------------------------------------------------------------------------
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  try {
+    const req = JSON.parse(trimmed);
+    handleRequest(req);
+  } catch (_) {
+    // Malformed JSON — ignore
+  }
+});

package/.claude/tools/glob-grep-server.cjs

@@ -0,0 +1,267 @@
+'use strict';
+
+// MCP stdio server — Glob + Grep tools
+// Node built-ins only; no npm dependencies.
+
+const { execSync } = require('child_process');
+const readline = require('readline');
+
+// ---------------------------------------------------------------------------
+// Transport helpers
+// ---------------------------------------------------------------------------
+
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+function sendResult(id, content) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [{ type: 'text', text: content }],
+    },
+  });
+}
+
+function sendError(id, code, message) {
+  send({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Glob tool implementation
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a glob pattern (with optional base path override) to a `find` command
+ * and execute it. Returns newline-joined paths or '(no results)'.
+ */
+function detectRg() {
+  try {
+    execSync('which rg', { stdio: 'ignore' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function runGlob({ pattern, path: basePath }) {
+  const searchPath = basePath || '.';
+
+  const segments = pattern.split('/');
+
+  let staticSegments = [];
+  let wildcardStart = -1;
+  for (let i = 0; i < segments.length; i++) {
+    if (segments[i].includes('*') || segments[i].includes('?')) {
+      wildcardStart = i;
+      break;
+    }
+    staticSegments.push(segments[i]);
+  }
+
+  const dynamicSegments = wildcardStart >= 0 ? segments.slice(wildcardStart) : segments;
+  const filePattern = dynamicSegments[dynamicSegments.length - 1];
+  const dirSegments = dynamicSegments.slice(0, dynamicSegments.length - 1);
+
+  let findBase = searchPath;
+  if (staticSegments.length > 0) {
+    findBase = searchPath.replace(/\/+$/, '') + '/' + staticSegments.join('/');
+  }
+
+  const hasRecursiveGlob = dirSegments.some((s) => s === '**');
+  const maxDepth = hasRecursiveGlob ? null : dirSegments.length + 1;
+
+  const safeFilePattern = filePattern.replace(/'/g, "'\\''");
+  const safeFindBase = findBase.replace(/'/g, "'\\''");
+
+  let cmd;
+  if (detectRg()) {
+    // rg --files respects .gitignore by default
+    const depthFlag = maxDepth != null ? `--max-depth ${maxDepth}` : '';
+    cmd = `rg --files ${depthFlag} --glob '${safeFilePattern}' -- '${safeFindBase}' 2>/dev/null | sort`;
+  } else {
+    // find fallback: excludes .git/node_modules but does not parse .gitignore
+    const depthFlag = maxDepth != null ? `-maxdepth ${maxDepth}` : '';
+    cmd = `find '${safeFindBase}' ${depthFlag} -name '${safeFilePattern}' -not -path '*/.git/*' -not -path '*/node_modules/*' 2>/dev/null | sort`;
+  }
+
+  try {
+    const output = execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const trimmed = output.trim();
+    return trimmed.length > 0 ? trimmed : '(no results)';
+  } catch (err) {
+    const output = (err.stdout || '').trim();
+    return output.length > 0 ? output : '(no results)';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Grep tool implementation
+// ---------------------------------------------------------------------------
+
+function runGrep({ pattern, path: searchPath, glob, type, '-i': caseInsensitive, output_mode, context, head_limit }) {
+  const base = searchPath || '.';
+  const mode = output_mode || 'files_with_matches';
+
+  let cmd;
+
+  if (detectRg()) {
+    const flags = ['--no-heading'];
+    if (caseInsensitive) flags.push('-i');
+    if (glob) flags.push(`--glob '${glob.replace(/'/g, "'\\''")}'`);
+    if (type) flags.push(`--type '${type.replace(/'/g, "'\\''")}'`);
+    if (mode === 'files_with_matches') flags.push('-l');
+    else if (mode === 'count') flags.push('-c');
+    if (context != null && mode === 'content') flags.push(`-C ${Number(context)}`);
+    flags.push(`-- '${pattern.replace(/'/g, "'\\''")}'`);
+    flags.push(`'${base.replace(/'/g, "'\\''")}'`);
+    cmd = `rg ${flags.join(' ')} 2>/dev/null`;
+  } else {
+    // grep fallback: excludes .git/node_modules but does not parse .gitignore
+    const flags = ['-r', '-E', '--exclude-dir=.git', '--exclude-dir=node_modules'];
+    if (caseInsensitive) flags.push('-i');
+    if (glob) flags.push(`--include='${glob.replace(/'/g, "'\\''")}'`);
+    if (mode === 'files_with_matches') flags.push('-l');
+    else if (mode === 'count') flags.push('-c');
+    if (context != null && mode === 'content') flags.push(`-C ${Number(context)}`);
+    flags.push(`-- '${pattern.replace(/'/g, "'\\''")}'`);
+    flags.push(`'${base.replace(/'/g, "'\\''")}'`);
+    cmd = `grep ${flags.join(' ')} 2>/dev/null`;
+  }
+
+  let output = '';
+  try {
+    output = execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  } catch (err) {
+    // grep/rg exit 1 means no matches (not an error per se)
+    output = err.stdout || '';
+  }
+
+  output = output.trim();
+
+  if (head_limit != null && output.length > 0) {
+    const lines = output.split('\n');
+    output = lines.slice(0, Number(head_limit)).join('\n');
+  }
+
+  return output.length > 0 ? output : '(no results)';
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+
+const TOOL_DEFINITIONS = [
+  {
+    name: 'Glob',
+    description: 'Fast file pattern matching tool. Returns matching file paths sorted by modification time.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob pattern to match files against' },
+        path: { type: 'string', description: 'Directory to search in (optional)' },
+      },
+      required: ['pattern'],
+    },
+  },
+  {
+    name: 'Grep',
+    description: 'Search file contents with regex. Supports glob filter, type filter, context lines, and output modes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Regex pattern to search for' },
+        path: { type: 'string', description: 'File or directory to search in (optional)' },
+        glob: { type: 'string', description: 'Glob pattern to filter files (e.g. "*.ts")' },
+        type: { type: 'string', description: 'File type to search (e.g. "js", "py")' },
+        '-i': { type: 'boolean', description: 'Case insensitive search' },
+        output_mode: {
+          type: 'string',
+          enum: ['content', 'files_with_matches', 'count'],
+          description: 'Output mode (default: files_with_matches)',
+        },
+        context: { type: 'number', description: 'Lines of context around matches (content mode only)' },
+        head_limit: { type: 'number', description: 'Limit output to first N lines' },
+      },
+      required: ['pattern'],
+    },
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Request dispatcher
+// ---------------------------------------------------------------------------
+
+function handleRequest(req) {
+  const { jsonrpc, id, method, params } = req;
+
+  // Notifications (no id) — no response
+  if (id === undefined || id === null) {
+    return;
+  }
+
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        serverInfo: { name: 'glob-grep-server', version: '1.0.0' },
+        capabilities: { tools: {} },
+      },
+    });
+    return;
+  }
+
+  if (method === 'tools/list') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: { tools: TOOL_DEFINITIONS },
+    });
+    return;
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params || {};
+    try {
+      let text;
+      if (name === 'Glob') {
+        text = runGlob(args || {});
+      } else if (name === 'Grep') {
+        text = runGrep(args || {});
+      } else {
+        sendError(id, -32601, `Unknown tool: ${name}`);
+        return;
+      }
+      sendResult(id, text);
+    } catch (err) {
+      sendResult(id, `Error: ${err.message}`);
+    }
+    return;
+  }
+
+  sendError(id, -32601, `Method not found: ${method}`);
+}
+
+// ---------------------------------------------------------------------------
+// Main — read newline-delimited JSON from stdin
+// ---------------------------------------------------------------------------
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  try {
+    const req = JSON.parse(trimmed);
+    handleRequest(req);
+  } catch (_) {
+    // Malformed JSON — ignore
+  }
+});