@ketecode/loom 0.0.0-stage → 0.2.0

package/hooks/read-before-edit/hook.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Refuses the first edit of each existing file per session, telling the agent to read it and search for
+// its callers, then allows the retry. check({ files: [{ path }], cwd, session }) -> verdict.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const KEEP_MS = 2 * 24 * 60 * 60 * 1000;
+
+const stateFile = () => path.join(process.env.KETE_LOOM_STATE_DIR || path.join(os.homedir(), '.kete-loom', 'state'), 'read-before-edit.json');
+
+function load(file, now) {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    for (const k of Object.keys(data)) if (!(now - data[k] < KEEP_MS)) delete data[k];
+    return data;
+  } catch {
+    return {};
+  }
+}
+
+function check(event, now = Date.now()) {
+  const cwd = path.resolve(event.cwd || process.cwd());
+  const scope = event.session || `${cwd}@${new Date(now).toISOString().slice(0, 10)}`;
+  const file = stateFile();
+  const seen = load(file, now);
+  const fresh = [];
+  for (const f of event.files || []) {
+    if (!f || typeof f.path !== 'string') continue;
+    const abs = path.resolve(cwd, f.path);
+    const key = `${scope}\n${abs}`;
+    if (!seen[key] && fs.existsSync(abs)) fresh.push(path.relative(cwd, abs) || abs);
+    seen[key] = now;
+  }
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(seen));
+  } catch {
+    return { block: false }; // can't remember the refusal, so refusing would block forever
+  }
+  if (!fresh.length) return { block: false };
+  return {
+    block: true,
+    reason: `kete-loom (read-before-edit): before changing ${fresh.map((p) => `\`${p}\``).join(', ')}, read the whole file and search the codebase for what imports, calls or configures it. Then make the same edit again; it will go through.`,
+  };
+}
+
+module.exports = { check };

package/hooks/run.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+'use strict';
+
+// kete-loom hook runner. The installer copies it with each hook's hook.js to ~/.kete-loom/hooks/ and
+// registers `node run.js <host> <hook> <event>` with each host. It turns that host's stdin payload into
+// one normalized event, calls the hook's check(), and answers in the host's own dialect. Zero
+// dependencies.
+//
+// Events: pre-shell { command, cwd }, pre-edit { files: [{ path, content }], cwd },
+// post-edit { files: [{ path }], cwd }, session-start { cwd }, stop and stop-gate { cwd, again } when
+// the agent finishes its turn. Every event also carries `session` when the host sends a session id.
+//
+// Blocking (pre-*): exit 2 with the reason on stderr works on every host; Cursor and Copilot also get
+// their JSON verdict. stop-gate blocks by making the agent continue with the reason as its next
+// prompt (exit 2 on Claude Code, Codex and Gemini CLI; JSON on Cursor and Copilot); `again` is true
+// when this turn was itself continued by a stop hook, so a gate can let it end instead of looping. Internal errors fail OPEN (exit 0): Copilot and Kete Code deny on a crashed hook,
+// so a runner bug must never block every tool call. post-edit and session-start never block.
+
+const fs = require('fs');
+const path = require('path');
+
+const pick = (o, ...keys) => {
+  for (const k of keys) if (o && typeof o[k] === 'string') return o[k];
+  return undefined;
+};
+const parseMaybe = (v) => (typeof v === 'string' ? JSON.parse(v) : v || {});
+
+// `*** Add File: p` / `*** Update File: p` (apply_patch) and `+++ b/p` (unified diff); added lines are
+// the new content.
+function parsePatch(text) {
+  const files = [];
+  let current = null;
+  for (const line of String(text || '').split('\n')) {
+    const header = /^\*\*\* (?:Add|Update) File: (.+)$/.exec(line) || /^\*\*\* Move to: (.+)$/.exec(line) || /^\+\+\+ (?:b\/)?(.+)$/.exec(line);
+    if (header && header[1] !== '/dev/null') {
+      current = { path: header[1].trim(), content: '' };
+      files.push(current);
+    } else if (current && line.startsWith('+') && !line.startsWith('+++')) current.content += `${line.slice(1)}\n`;
+  }
+  return files;
+}
+
+// A Claude-style tool_input -> [{ path, content }].
+const claudeFiles = (input) => {
+  const p = pick(input, 'file_path', 'notebook_path', 'path', 'filePath');
+  return p ? [{ path: p, content: pick(input, 'content', 'new_string', 'new_source') || '' }] : [];
+};
+
+// Tolerant reader for hosts whose edit arguments aren't fully documented (Copilot, OpenCode).
+const looseFiles = (args) => {
+  if (pick(args, 'patchText', 'patch', 'input')) return parsePatch(pick(args, 'patchText', 'patch', 'input'));
+  const p = pick(args, 'path', 'filePath', 'file_path');
+  return p ? [{ path: p, content: pick(args, 'file_text', 'content', 'new_str', 'newString', 'new_string') || '' }] : [];
+};
+
+const SHELL_TOOLS = { kete: ['shell'], copilot: ['bash', 'powershell', 'shell'], opencode: ['bash'] };
+const EDIT_TOOLS = { kete: ['edit', 'write', 'patch'], copilot: ['edit', 'create', 'str_replace_editor', 'apply_patch'], opencode: ['edit', 'write', 'apply_patch'] };
+
+// Each host's payload -> the normalized event, or null when the call isn't one this event handles.
+// Claude, Codex and Gemini filter tools with matchers at registration; the rest are filtered here.
+function normalize(host, event, j) {
+  const cwd = pick(j, 'cwd') || (Array.isArray(j.workspace_roots) && j.workspace_roots[0]) || process.env.CURSOR_PROJECT_DIR || process.cwd();
+  const tool = j.tool || j.toolName || j.tool_name;
+  const toolArgs = () => (host === 'copilot' ? parseMaybe(j.toolArgs) : j.tool_input || j.args || {});
+  const session = pick(j, 'session_id', 'sessionId', 'conversation_id');
+  if (event === 'session-start') return { cwd, session };
+  if (event === 'stop' || event === 'stop-gate') return { cwd, session, again: j.stop_hook_active === true || j.loop_count > 0 };
+  if (SHELL_TOOLS[host] && event === 'pre-shell' && tool && !SHELL_TOOLS[host].includes(tool)) return null;
+  if (EDIT_TOOLS[host] && event !== 'pre-shell' && tool && !EDIT_TOOLS[host].includes(tool)) return null;
+
+  if (event === 'pre-shell') {
+    const command = host === 'cursor' ? j.command : pick(toolArgs(), 'command');
+    return typeof command === 'string' ? { command, cwd, session, background: toolArgs().run_in_background === true } : null;
+  }
+  let files;
+  if (host === 'codex') files = parsePatch(pick(j.tool_input, 'command', 'input', 'patch'));
+  else if (host === 'cursor') files = j.file_path ? [{ path: j.file_path, content: '' }] : [];
+  else if (host === 'claude' || host === 'gemini') files = claudeFiles(j.tool_input);
+  else files = looseFiles(toolArgs());
+  return files.length ? { files, cwd, session } : null;
+}
+
+const SESSION_JSON = {
+  claude: (c) => ({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: c } }),
+  codex: (c) => ({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: c } }),
+  gemini: (c) => ({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: c } }),
+  kete: (c) => ({ context: c }),
+  cursor: (c) => ({ additional_context: c }),
+  copilot: (c) => ({ additionalContext: c }),
+};
+const ALLOW_JSON = { cursor: { permission: 'allow' } };
+const DENY_JSON = {
+  cursor: (reason) => ({ permission: 'deny', user_message: reason, agent_message: reason }),
+  copilot: (reason) => ({ permissionDecision: 'deny', permissionDecisionReason: reason }),
+};
+
+// How each host is told to keep going instead of ending the turn.
+const CONTINUE_JSON = {
+  cursor: (reason) => ({ followup_message: reason }),
+  copilot: (reason) => ({ decision: 'block', reason }),
+};
+
+const EVENTS = ['pre-shell', 'pre-edit', 'post-edit', 'session-start', 'stop', 'stop-gate'];
+const allow = (host, event) => ({ code: 0, stdout: event.startsWith('pre-') && ALLOW_JSON[host] ? JSON.stringify(ALLOW_JSON[host]) : '', stderr: '' });
+
+// Returns { code, stdout, stderr } so tests can drive it without a process.
+function respond(host, hookName, input, hooksDir = __dirname, event = 'pre-shell') {
+  let verdict;
+  try {
+    if (!Object.prototype.hasOwnProperty.call(SESSION_JSON, host) && host !== 'opencode') throw new Error(`unknown host "${host}"`);
+    if (!EVENTS.includes(event)) throw new Error(`unknown event "${event}"`);
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(hookName || '')) throw new Error(`bad hook name "${hookName}"`);
+    const normalized = normalize(host, event, input ? JSON.parse(input) : {});
+    if (!normalized) return allow(host, event);
+    const { check } = require(path.join(hooksDir, hookName, 'hook.js'));
+    verdict = check(normalized) || {};
+  } catch (e) {
+    const r = allow(host, event);
+    return { ...r, stderr: `kete-loom hook ${hookName}: ${e.message} (allowed)\n` };
+  }
+  if (event === 'session-start') {
+    return verdict.context && SESSION_JSON[host] ? { code: 0, stdout: JSON.stringify(SESSION_JSON[host](String(verdict.context))), stderr: '' } : allow(host, event);
+  }
+  if (event === 'stop-gate' && verdict.block) {
+    const reason = String(verdict.reason || `Continue: kete-loom hook ${hookName} asked for more work`);
+    if (CONTINUE_JSON[host]) return { code: 0, stdout: JSON.stringify(CONTINUE_JSON[host](reason)), stderr: '' };
+    return { code: 2, stdout: '', stderr: `${reason}\n` };
+  }
+  if (!event.startsWith('pre-') || !verdict.block) return allow(host, event);
+  const reason = String(verdict.reason || `Blocked by kete-loom hook ${hookName}`);
+  return { code: 2, stdout: DENY_JSON[host] ? JSON.stringify(DENY_JSON[host](reason)) : '', stderr: `${reason}\n` };
+}
+
+if (require.main === module) {
+  const [host, hookName, event = 'pre-shell'] = process.argv.slice(2);
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8');
+  } catch {
+    // no stdin: treated as an empty event
+  }
+  const r = respond(host, hookName, input, __dirname, event);
+  if (r.stdout) process.stdout.write(r.stdout);
+  if (r.stderr) process.stderr.write(r.stderr);
+  process.exitCode = r.code;
+}
+
+module.exports = { respond, normalize, parsePatch, EVENTS };

package/hooks/verify-before-stop/HOOK.md

@@ -0,0 +1,32 @@
+---
+name: verify-before-stop
+description: When the agent says it is done, runs the project's own lint and type-check commands if files changed, and sends it back to fix any failure instead of letting it finish with broken code.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: testing
+  kete-loom/risk: runs-commands
+  kete-loom/event: "stop-gate"
+  kete-loom/opt-in: "true"
+  kete-loom/owner: "Kete-org"
+---
+
+# Verify before stop
+
+Runs when the agent ends its turn, in a git repository only.
+
+If the working tree has changed code files, it runs the checks the project already defines:
+
+| Project | Checks |
+|---|---|
+| `package.json` | the `typecheck` / `type-check` / `check-types` script and the `lint` script, run with the package manager the lockfile belongs to |
+| Python | `ruff check` on the changed `.py` files, when Ruff is configured and installed |
+| Go | `go vet ./...` |
+
+If a check fails, the turn does not end. The agent gets the failing command and the end of its output, and is told to fix the cause, not the check. It is sent back only once in a row, so a check it can't fix never traps it in a loop.
+
+Tests are not run, because they can take far longer than a hook should. Use the `/verify` command or the `verification-loop` skill for that. Each check is limited to 75 seconds. Nothing is installed and nothing is changed.
+
+Available in Claude Code, Codex, Gemini CLI, Cursor and GitHub Copilot. Kete Code's and OpenCode's stop hooks can't send the agent back to work.
+
+Opt-in: `--hooks` leaves it out; install it by name with `--hook` or with `--profile strict`.

package/hooks/verify-before-stop/hook.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// When the agent ends its turn with changed code, runs the project's own lint and type-check commands
+// and sends it back to fix failures. check({ cwd, again }) -> verdict.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync, spawnSync } = require('child_process');
+
+const TIMEOUT_MS = 75000;
+const CODE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|py|go|json)$/;
+
+const git = (cwd, args) => {
+  try {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 });
+  } catch {
+    return null;
+  }
+};
+
+function onPath(bin) {
+  const exts = process.platform === 'win32' ? (process.env.PATHEXT || '.EXE;.CMD').split(';') : [''];
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) for (const ext of exts) if (dir && fs.existsSync(path.join(dir, bin + ext))) return true;
+  return false;
+}
+
+// [label, program, args] for each check the project defines.
+function checksFor(root, changed) {
+  const checks = [];
+  const has = (f) => fs.existsSync(path.join(root, f));
+  let pkg = null;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  } catch {
+    // no package.json
+  }
+  const scripts = (pkg && pkg.scripts) || {};
+  const pm = has('pnpm-lock.yaml') ? 'pnpm' : has('yarn.lock') ? 'yarn' : has('bun.lock') || has('bun.lockb') ? 'bun' : 'npm';
+  for (const name of [['typecheck', 'type-check', 'check-types'].find((s) => scripts[s]), scripts.lint && 'lint'].filter(Boolean)) {
+    checks.push([`${pm} run ${name}`, pm, ['run', name]]);
+  }
+  const py = changed.filter((f) => f.endsWith('.py'));
+  const ruffConfigured = has('ruff.toml') || has('.ruff.toml') || /\[tool\.ruff/.test(has('pyproject.toml') ? fs.readFileSync(path.join(root, 'pyproject.toml'), 'utf8') : '');
+  if (py.length && ruffConfigured && onPath('ruff')) checks.push([`ruff check ${py.join(' ')}`, 'ruff', ['check', ...py]]);
+  if (changed.some((f) => f.endsWith('.go')) && has('go.mod') && onPath('go')) checks.push(['go vet ./...', 'go', ['vet', './...']]);
+  return checks;
+}
+
+function check(event) {
+  if (event.again) return { block: false };
+  const cwd = event.cwd || process.cwd();
+  const root = (git(cwd, ['rev-parse', '--show-toplevel']) || '').trim();
+  if (!root) return { block: false };
+  const changed = (git(root, ['status', '--porcelain', '--untracked-files=all']) || '')
+    .split('\n').filter(Boolean).map((l) => l.slice(3).replace(/^.* -> /, '').replace(/^"|"$/g, ''))
+    .filter((f) => CODE.test(f) && fs.existsSync(path.join(root, f)));
+  if (!changed.length) return { block: false };
+  for (const [label, program, args] of checksFor(root, changed)) {
+    const r = spawnSync(program, args, { cwd: root, encoding: 'utf8', timeout: TIMEOUT_MS, shell: process.platform === 'win32' });
+    if (r.error || r.status === 0) continue; // a check that can't start or times out says nothing about the code
+    const tail = `${r.stdout || ''}${r.stderr || ''}`.trim().split('\n').slice(-30).join('\n').slice(-2500);
+    return {
+      block: true,
+      reason: `kete-loom (verify-before-stop): \`${label}\` fails with your changes. Fix the cause in the code (don't weaken the check), run it again, and only then finish.\n\n${tail}`,
+    };
+  }
+  return { block: false };
+}
+
+module.exports = { check, checksFor };

package/mcp/atlassian.json

@@ -0,0 +1,11 @@
+{
+  "name": "atlassian",
+  "description": "Atlassian's remote MCP server for Jira and Confluence: issues, pages and search, signed in with Atlassian OAuth.",
+  "version": "0.1.0",
+  "category": "integrations",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.atlassian.com/v2/mcp",
+  "auth": "oauth",
+  "homepage": "https://support.atlassian.com/atlassian-rovo-mcp-server/docs/getting-started-with-the-atlassian-remote-mcp-server/"
+}

package/mcp/chrome-devtools.json

@@ -0,0 +1,18 @@
+{
+  "name": "chrome-devtools",
+  "description": "The Chrome DevTools MCP server: control and inspect a live Chrome, including console, network, performance traces and screenshots.",
+  "version": "0.1.0",
+  "category": "testing",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "npx",
+  "args": [
+    "-y",
+    "chrome-devtools-mcp@latest"
+  ],
+  "auth": "none",
+  "requires": [
+    "node"
+  ],
+  "homepage": "https://github.com/ChromeDevTools/chrome-devtools-mcp"
+}

package/mcp/clickhouse.json

@@ -0,0 +1,11 @@
+{
+  "name": "clickhouse",
+  "description": "ClickHouse Cloud's remote MCP server: list databases and tables and run read-only SQL on services you enable it for, signed in with ClickHouse Cloud OAuth.",
+  "version": "0.1.0",
+  "category": "data",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.clickhouse.cloud/mcp",
+  "auth": "oauth",
+  "homepage": "https://clickhouse.com/docs/cloud/features/ai-ml/remote-mcp"
+}

package/mcp/cloudflare.json

@@ -0,0 +1,11 @@
+{
+  "name": "cloudflare",
+  "description": "Cloudflare's remote MCP server for the Cloudflare API and docs, signed in with Cloudflare OAuth.",
+  "version": "0.1.0",
+  "category": "devops",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.cloudflare.com/mcp",
+  "auth": "oauth",
+  "homepage": "https://developers.cloudflare.com/agents/model-context-protocol/mcp-servers-for-cloudflare/"
+}

package/mcp/context7.json

@@ -0,0 +1,11 @@
+{
+  "name": "context7",
+  "description": "Context7 by Upstash: up-to-date, version-specific library documentation and code examples for the model. Works without a key at lower rate limits.",
+  "version": "0.1.0",
+  "category": "docs",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.context7.com/mcp",
+  "auth": "oauth",
+  "homepage": "https://github.com/upstash/context7"
+}

package/mcp/exa.json

@@ -0,0 +1,11 @@
+{
+  "name": "exa",
+  "description": "Exa's remote MCP server: web search, page contents and code search for the model. Free and rate-limited without a key; no sign-in needed.",
+  "version": "0.1.0",
+  "category": "docs",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.exa.ai/mcp",
+  "auth": "none",
+  "homepage": "https://exa.ai/docs/reference/exa-mcp"
+}

package/mcp/fetch.json

@@ -0,0 +1,17 @@
+{
+  "name": "fetch",
+  "description": "The reference Fetch MCP server: fetch a web page and return it as Markdown for the model to read.",
+  "version": "0.1.0",
+  "category": "docs",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "uvx",
+  "args": [
+    "mcp-server-fetch"
+  ],
+  "auth": "none",
+  "requires": [
+    "uvx"
+  ],
+  "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch"
+}

package/mcp/figma.json

@@ -0,0 +1,11 @@
+{
+  "name": "figma",
+  "description": "Figma's remote MCP server: bring design context (frames, components, variables) into code, signed in with Figma.",
+  "version": "0.1.0",
+  "category": "coding",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.figma.com/mcp",
+  "auth": "oauth",
+  "homepage": "https://developers.figma.com/docs/figma-mcp-server/"
+}

package/mcp/firecrawl.json

@@ -0,0 +1,11 @@
+{
+  "name": "firecrawl",
+  "description": "Firecrawl's remote MCP server: scrape, crawl, map and search websites into clean Markdown or structured data, signed in with Firecrawl OAuth.",
+  "version": "0.1.0",
+  "category": "data",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.firecrawl.dev/v2/mcp-oauth",
+  "auth": "oauth",
+  "homepage": "https://docs.firecrawl.dev/mcp-server"
+}

package/mcp/git.json

@@ -0,0 +1,17 @@
+{
+  "name": "git",
+  "description": "The reference Git MCP server: read history, diffs and status and make commits in a local repository.",
+  "version": "0.1.0",
+  "category": "devops",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "uvx",
+  "args": [
+    "mcp-server-git"
+  ],
+  "auth": "none",
+  "requires": [
+    "uvx"
+  ],
+  "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/git"
+}

package/mcp/github.json

@@ -0,0 +1,11 @@
+{
+  "name": "github",
+  "description": "GitHub's official remote MCP server: repositories, issues, pull requests and Actions, signed in with GitHub OAuth.",
+  "version": "0.1.0",
+  "category": "integrations",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://api.githubcopilot.com/mcp/",
+  "auth": "oauth",
+  "homepage": "https://github.com/github/github-mcp-server"
+}

package/mcp/linear.json

@@ -0,0 +1,11 @@
+{
+  "name": "linear",
+  "description": "Linear's remote MCP server: read and update issues, projects and comments, signed in with Linear OAuth.",
+  "version": "0.1.0",
+  "category": "integrations",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.linear.app/mcp",
+  "auth": "oauth",
+  "homepage": "https://linear.app/docs/mcp"
+}

package/mcp/memory.json

@@ -0,0 +1,18 @@
+{
+  "name": "memory",
+  "description": "The reference Memory MCP server: a local knowledge graph the agent can store and recall facts in across sessions.",
+  "version": "0.1.0",
+  "category": "ai",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "npx",
+  "args": [
+    "-y",
+    "@modelcontextprotocol/server-memory"
+  ],
+  "auth": "none",
+  "requires": [
+    "node"
+  ],
+  "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory"
+}

package/mcp/notion.json

@@ -0,0 +1,11 @@
+{
+  "name": "notion",
+  "description": "Notion's remote MCP server: search, read and edit pages and databases, signed in with Notion OAuth.",
+  "version": "0.1.0",
+  "category": "integrations",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.notion.com/mcp",
+  "auth": "oauth",
+  "homepage": "https://developers.notion.com/docs/get-started-with-mcp"
+}

package/mcp/playwright.json

@@ -0,0 +1,18 @@
+{
+  "name": "playwright",
+  "description": "Microsoft's Playwright MCP server: drive a real browser through the accessibility tree to navigate, click, fill forms and check pages.",
+  "version": "0.1.0",
+  "category": "testing",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "npx",
+  "args": [
+    "-y",
+    "@playwright/mcp@latest"
+  ],
+  "auth": "none",
+  "requires": [
+    "node"
+  ],
+  "homepage": "https://github.com/microsoft/playwright-mcp"
+}

package/mcp/sentry.json

@@ -0,0 +1,11 @@
+{
+  "name": "sentry",
+  "description": "Sentry's remote MCP server: search errors and issues, inspect events and triage, signed in with Sentry OAuth.",
+  "version": "0.1.0",
+  "category": "devops",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.sentry.dev/mcp",
+  "auth": "oauth",
+  "homepage": "https://github.com/getsentry/sentry-mcp"
+}

package/mcp/stripe.json

@@ -0,0 +1,11 @@
+{
+  "name": "stripe",
+  "description": "Stripe's remote MCP server: work with the Stripe API and search Stripe docs, signed in with Stripe OAuth.",
+  "version": "0.1.0",
+  "category": "integrations",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.stripe.com",
+  "auth": "oauth",
+  "homepage": "https://docs.stripe.com/mcp"
+}

package/mcp/supabase.json

@@ -0,0 +1,11 @@
+{
+  "name": "supabase",
+  "description": "Supabase's remote MCP server in read-only mode: inspect projects, schemas and data, and search the docs, signed in with Supabase OAuth.",
+  "version": "0.1.0",
+  "category": "data",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.supabase.com/mcp?read_only=true",
+  "auth": "oauth",
+  "homepage": "https://supabase.com/docs/guides/getting-started/mcp"
+}

package/mcp/time.json

@@ -0,0 +1,17 @@
+{
+  "name": "time",
+  "description": "The reference Time MCP server: current time and timezone conversion.",
+  "version": "0.1.0",
+  "category": "meta",
+  "risk": "runs-commands",
+  "transport": "stdio",
+  "command": "uvx",
+  "args": [
+    "mcp-server-time"
+  ],
+  "auth": "none",
+  "requires": [
+    "uvx"
+  ],
+  "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/time"
+}

package/mcp/vercel.json

@@ -0,0 +1,11 @@
+{
+  "name": "vercel",
+  "description": "Vercel's remote MCP server: search the docs, manage projects and deployments, read deployment logs and query Web Analytics, signed in with Vercel OAuth.",
+  "version": "0.1.0",
+  "category": "devops",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.vercel.com",
+  "auth": "oauth",
+  "homepage": "https://vercel.com/docs/agent-resources/vercel-mcp"
+}