granttap-mcp 0.1.0

package/apps/bridge/src/install.ts

@@ -0,0 +1,133 @@
+/**
+ * Auto-registration of the agent hooks — the part that used to be "copy this
+ * snippet into your config yourself".
+ *
+ *   Claude Code  ~/.claude/settings.json   hooks.PreToolUse
+ *   Codex        ~/.codex/config.toml      [features] hooks + [[hooks.PermissionRequest]]
+ *
+ * Rules: back the file up once before first touching it, never register twice
+ * (any existing "granttap" hook counts), and if a TOML merge would be ambiguous,
+ * say so instead of corrupting the file.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+
+/** The stable command agents will call. */
+export function hookCommand(agent: "claude" | "codex"): string {
+  return `node "${join(repoRoot, "bin", "granttap-mcp.mjs")}" hook ${agent}`;
+}
+
+export type InstallResult = { status: "installed" | "already" | "manual"; detail: string };
+
+function backupOnce(path: string): void {
+  const bak = path + ".bak-granttap";
+  if (existsSync(path) && !existsSync(bak)) copyFileSync(path, bak);
+}
+
+// ---------------------------------------------------------------- Claude Code
+
+export function installClaudeHook(): InstallResult {
+  const dir =
+    process.env.GRANTTAP_CLAUDE_DIR ??
+    process.env.NODVOX_CLAUDE_DIR ??
+    join(homedir(), ".claude");
+  const path = join(dir, "settings.json");
+  mkdirSync(dir, { recursive: true });
+
+  let settings: any = {};
+  if (existsSync(path)) {
+    try {
+      settings = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      return { status: "manual", detail: `${path} — не парсится как JSON, не трогаю. Добавь hook вручную.` };
+    }
+  }
+
+  const entries: any[] = (((settings.hooks ??= {}).PreToolUse ??= []) as any[]);
+  const hooks = entries.flatMap((entry) => entry?.hooks ?? []);
+  const present = hooks.some(
+    (hook: any) => typeof hook?.command === "string" && hook.command.includes("granttap"),
+  );
+  if (present) return { status: "already", detail: path };
+
+  const legacy = hooks.find(
+    (hook: any) =>
+      typeof hook?.command === "string" &&
+      (hook.command.includes("bin/nodvox.mjs") || /\bnpx\s+(?:-y\s+)?nodvox\b/.test(hook.command)),
+  );
+  if (legacy) {
+    backupOnce(path);
+    legacy.command = hookCommand("claude");
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    return { status: "installed", detail: `${path}, обновлён Nodvox → GrantTap` };
+  }
+
+  backupOnce(path);
+  entries.push({
+    matcher: "Bash|Edit|Write|MultiEdit|NotebookEdit|mcp__.*",
+    hooks: [{ type: "command", command: hookCommand("claude"), timeout: 120 }],
+  });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+  return { status: "installed", detail: path };
+}
+
+// --------------------------------------------------------------------- Codex
+
+export function installCodexHook(): InstallResult {
+  const dir =
+    process.env.GRANTTAP_CODEX_DIR ??
+    process.env.NODVOX_CODEX_DIR ??
+    join(homedir(), ".codex");
+  const path = join(dir, "config.toml");
+  mkdirSync(dir, { recursive: true });
+
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  if (existing.includes("granttap")) return { status: "already", detail: path };
+  if (existing.includes("bin/nodvox.mjs") || /\bnpx\s+(?:-y\s+)?nodvox\b/.test(existing)) {
+    const updated = existing
+      .replace(
+        /^command\s*=\s*'[^']*(?:bin\/nodvox\.mjs|\bnpx\s+(?:-y\s+)?nodvox\b)[^']*'$/gm,
+        `command = '${hookCommand("codex")}'`,
+      )
+      .replace(/^# nodvox —/gm, "# GrantTap —");
+    backupOnce(path);
+    writeFileSync(path, updated);
+    return { status: "installed", detail: `${path}, обновлён Nodvox → GrantTap` };
+  }
+
+  const hookBlock = [
+    "",
+    "# granttap — approvals from your phone/watch",
+    "[[hooks.PermissionRequest]]",
+    'matcher = ".*"',
+    "[[hooks.PermissionRequest.hooks]]",
+    'type = "command"',
+    `command = '${hookCommand("codex")}'`,
+    "timeout = 120",
+    "",
+  ].join("\n");
+
+  const hasFeatures = /^\s*\[features\]/m.test(existing);
+  const hasHooksFlag = /^\s*hooks\s*=\s*true/m.test(existing);
+
+  backupOnce(path);
+  if (!hasFeatures) {
+    writeFileSync(path, existing + "\n[features]\nhooks = true\n" + hookBlock);
+    return { status: "installed", detail: path };
+  }
+  if (hasHooksFlag) {
+    writeFileSync(path, existing + hookBlock);
+    return { status: "installed", detail: path };
+  }
+  // [features] exists without hooks=true — appending a second [features] table
+  // would be invalid TOML, so append the hook and ask for the one-line edit.
+  writeFileSync(path, existing + hookBlock);
+  return {
+    status: "manual",
+    detail: `${path}: hook добавлен, но в существующей секции [features] нужно вручную дописать «hooks = true».`,
+  };
+}

package/apps/mcp/src/server.ts

@@ -0,0 +1,147 @@
+/**
+ * GrantTap MCP server — the easy front door.
+ *
+ * Adding this to any MCP client (`claude mcp add granttap …`) gives the agent a
+ * VOLUNTARY channel to your wrist, complementing the hook's involuntary gating:
+ *
+ *   ask         — ask you a free-text question, wait for the spoken/typed answer
+ *   ask_yes_no  — ask a yes/no question, get Да/Нет from the watch
+ *   notify      — push a status/message to the phone (fire-and-forget)
+ *   setup       — register the Claude/Codex approval hooks on this machine
+ *
+ * All traffic is E2E-encrypted through the same relay; the MCP server never sees
+ * plaintext leave the machine unsealed.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { RelayClient } from "../../../packages/core/relay-client";
+import { loadConfig, machineConfigPath } from "../../bridge/src/config";
+import { installClaudeHook, installCodexHook } from "../../bridge/src/install";
+import { randomId } from "../../../packages/core/crypto";
+import type { Payload } from "../../../packages/protocol/schema";
+
+const ASK_TIMEOUT_MS = Number(
+  process.env.GRANTTAP_ASK_TIMEOUT_MS ?? process.env.NODVOX_ASK_TIMEOUT_MS ?? 180_000,
+);
+
+/** One reconnecting relay client shared by all tool calls. Failed startup is not cached. */
+let client: RelayClient | null = null;
+
+async function relay(): Promise<RelayClient | null> {
+  try {
+    if (!client) {
+      const cfg = loadConfig(machineConfigPath());
+      client = new RelayClient(cfg, { autoReconnect: true });
+    }
+    await client.connect();
+    return client;
+  } catch {
+    return null;
+  }
+}
+
+const NOT_PAIRED =
+  "GrantTap is not paired on this machine. Pair the desktop bridge with the GrantTap app first.";
+
+async function main(): Promise<void> {
+  const server = new McpServer({ name: "granttap", version: "0.1.0" });
+
+  server.tool(
+    "notify",
+    "Push a short status/message to the user's phone. Fire-and-forget — use it to keep them informed without blocking.",
+    { message: z.string().describe("Text to show on the phone") },
+    async ({ message }) => {
+      const c = await relay();
+      if (!c) return { content: [{ type: "text", text: NOT_PAIRED }] };
+        await c.send(
+          { type: "agent.event", text: message, kind: "status", createdAt: Date.now() },
+          "phone",
+          { ttlMs: 15 * 60_000 },
+        );
+      return { content: [{ type: "text", text: "sent to phone" }] };
+    },
+  );
+
+  server.tool(
+    "ask_yes_no",
+    "Ask the user a yes/no question on their phone/watch and wait for the tap. Returns 'yes' or 'no'.",
+    { question: z.string().describe("A question answerable with yes/no") },
+    async ({ question }) => {
+      const c = await relay();
+      if (!c) return { content: [{ type: "text", text: NOT_PAIRED }] };
+      const requestId = randomId(6);
+        await c.send(
+          {
+            type: "approval.request",
+            requestId,
+            agent: "granttap",
+            kind: "permission",
+            tool: "ask",
+            title: question,
+            risk: "low",
+            createdAt: Date.now(),
+          },
+          "phone",
+          { ttlMs: ASK_TIMEOUT_MS },
+        );
+      const decision = await c
+        .waitFor(
+          (p: Payload): p is Extract<Payload, { type: "approval.decision" }> =>
+            p.type === "approval.decision" && p.requestId === requestId,
+          ASK_TIMEOUT_MS,
+        )
+        .catch(() => null);
+      const answer = decision ? (decision.decision === "allow" ? "yes" : "no") : "no-answer (timeout)";
+      return { content: [{ type: "text", text: answer }] };
+    },
+  );
+
+  server.tool(
+    "ask",
+    "Ask the user an open question on their phone/watch and wait for their spoken or typed reply. Returns their answer text.",
+    { question: z.string().describe("The question to ask") },
+    async ({ question }) => {
+      const c = await relay();
+      if (!c) return { content: [{ type: "text", text: NOT_PAIRED }] };
+        const requestId = randomId(6);
+        await c.send(
+          { type: "agent.event", text: question, requestId, kind: "question", createdAt: Date.now() },
+          "phone",
+          { ttlMs: ASK_TIMEOUT_MS },
+        );
+        const reply = await c
+          .waitFor(
+            (p: Payload): p is Extract<Payload, { type: "user.message" }> =>
+              p.type === "user.message" && p.requestId === requestId,
+            ASK_TIMEOUT_MS,
+          )
+        .catch(() => null);
+      return {
+        content: [{ type: "text", text: reply ? reply.text : "no-answer (timeout)" }],
+      };
+    },
+  );
+
+  server.tool(
+    "setup",
+    "Register the GrantTap approval hooks for Claude Code and Codex on this machine.",
+    {},
+    async () => {
+      const claude = installClaudeHook();
+      const codex = installCodexHook();
+      return {
+        content: [
+          { type: "text", text: `Claude: ${claude.status} (${claude.detail})\nCodex: ${codex.status} (${codex.detail})` },
+        ],
+      };
+    },
+  );
+
+  await server.connect(new StdioServerTransport());
+}
+
+main().catch((err) => {
+  process.stderr.write(`[granttap-mcp] ${(err as Error).message}\n`);
+  process.exit(1);
+});

package/bin/granttap-mcp.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const [command = "mcp", argument] = process.argv.slice(2);
+
+let entry;
+if (command === "mcp") {
+  entry = join(root, "apps", "mcp", "src", "server.ts");
+} else if (command === "setup") {
+  entry = join(root, "apps", "bridge", "src", "bin", "setup.ts");
+} else if (command === "hook" && (argument === "claude" || argument === "codex")) {
+  entry = join(root, "apps", "bridge", "src", "bin", `${argument}-hook.ts`);
+} else {
+  process.stderr.write(
+    [
+      "Usage:",
+      "  granttap-mcp                 Start the MCP stdio server",
+      "  granttap-mcp setup           Install Claude Code and Codex approval hooks",
+      "  granttap-mcp hook <agent>    Internal hook entry point",
+      "",
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+
+const child = spawn(process.execPath, ["--import", "tsx", entry], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => child.kill(signal));
+}
+
+child.on("error", (error) => {
+  process.stderr.write(`[granttap-mcp] ${error.message}\n`);
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 1);
+});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "granttap-mcp",
+  "version": "0.1.0",
+  "description": "E2EE MCP bridge and approval hooks for GrantTap on iPhone and Apple Watch.",
+  "type": "module",
+  "bin": {
+    "granttap-mcp": "./bin/granttap-mcp.mjs"
+  },
+  "files": [
+    "apps",
+    "bin",
+    "packages",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/granttap-mcp.mjs",
+    "setup": "node bin/granttap-mcp.mjs setup",
+    "test": "node --import tsx --test tests/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm test && npm run typecheck"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "tsx": "^4.19.2",
+    "tweetnacl": "^1.0.3",
+    "ws": "^8.18.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sergii-ziborov/granttap-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sergii-ziborov/granttap-mcp/issues"
+  },
+  "homepage": "https://granttap.com",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude-code",
+    "codex",
+    "apple-watch",
+    "e2ee",
+    "approvals"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "overrides": {
+    "@hono/node-server": "2.0.11"
+  }
+}

package/packages/core/crypto.ts

@@ -0,0 +1,113 @@
+/**
+ * End-to-end encryption primitives.
+ *
+ * We use NaCl public-key authenticated encryption (Curve25519 + XSalsa20 +
+ * Poly1305) via tweetnacl — the same battle-tested stack the reference
+ * open-source client (Happy) uses. Each device holds its own secret key and
+ * knows only the peer's PUBLIC key, so the relay (which sees neither secret)
+ * can never read message contents.
+ *
+ * Pairing today = exchange public keys out of band (a generated file; later a
+ * QR code scanned by the phone). Nothing here ever leaves the device unsealed.
+ */
+import nacl from "tweetnacl";
+import { createHash } from "node:crypto";
+
+export type KeyPair = { publicKey: string; secretKey: string }; // base64
+
+const b64 = (u: Uint8Array): string => Buffer.from(u).toString("base64");
+const ub64 = (s: string): Uint8Array => new Uint8Array(Buffer.from(s, "base64"));
+
+export function generateKeyPair(): KeyPair {
+  const kp = nacl.box.keyPair();
+  return { publicKey: b64(kp.publicKey), secretKey: b64(kp.secretKey) };
+}
+
+/** Seal a JSON-serialisable payload for `theirPublicKey`. */
+export function seal(
+  payload: unknown,
+  theirPublicKey: string,
+  mySecretKey: string,
+): { nonce: string; box: string } {
+  const msg = new TextEncoder().encode(JSON.stringify(payload));
+  const nonce = nacl.randomBytes(nacl.box.nonceLength);
+  const box = nacl.box(msg, nonce, ub64(theirPublicKey), ub64(mySecretKey));
+  return { nonce: b64(nonce), box: b64(box) };
+}
+
+/** Open a sealed payload. Returns null on any auth/parse failure. */
+export function open(
+  nonce: string,
+  box: string,
+  theirPublicKey: string,
+  mySecretKey: string,
+): unknown | null {
+  let opened: Uint8Array | null = null;
+  try {
+    opened = nacl.box.open(ub64(box), ub64(nonce), ub64(theirPublicKey), ub64(mySecretKey));
+  } catch {
+    return null;
+  }
+  if (!opened) return null;
+  try {
+    return JSON.parse(new TextDecoder().decode(opened));
+  } catch {
+    return null;
+  }
+}
+
+/** Short random hex id (rooms, request ids, device ids). */
+export function randomId(bytes = 8): string {
+  return Buffer.from(nacl.randomBytes(bytes)).toString("hex");
+}
+
+// ------------------------------------------------- short pairing code (typed)
+//
+// A QR needs a camera; the simulator (and a tired thumb) needs something you can
+// type. The machine seals the pairing under a key derived from an 8-character
+// code and parks that ciphertext on the relay. The relay still learns nothing —
+// it only ever holds a blob it cannot open — and the code is single-use with a
+// short TTL, which is what keeps 8 characters from being brute-forceable.
+
+/** Unambiguous alphabet: no 0/O/1/I/L to avoid transcription mistakes. */
+const CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+
+export function generatePairingCode(length = 8): string {
+  const bytes = nacl.randomBytes(length);
+  let out = "";
+  for (let i = 0; i < length; i++) {
+    out += CODE_ALPHABET[bytes[i]! % CODE_ALPHABET.length];
+  }
+  return out;
+}
+
+export function normalizeCode(code: string): string {
+  return code.trim().toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+
+/** Key = SHA-256(normalized code). Mirrored byte-for-byte on the Swift side. */
+function codeKey(code: string): Uint8Array {
+  return new Uint8Array(createHash("sha256").update(normalizeCode(code), "utf8").digest());
+}
+
+export function sealWithCode(payload: unknown, code: string): { nonce: string; box: string } {
+  const msg = new TextEncoder().encode(JSON.stringify(payload));
+  const nonce = nacl.randomBytes(nacl.secretbox.nonceLength);
+  const box = nacl.secretbox(msg, nonce, codeKey(code));
+  return { nonce: b64(nonce), box: b64(box) };
+}
+
+export function openWithCode(nonce: string, box: string, code: string): unknown | null {
+  let opened: Uint8Array | null = null;
+  try {
+    opened = nacl.secretbox.open(ub64(box), ub64(nonce), codeKey(code));
+  } catch {
+    return null;
+  }
+  if (!opened) return null;
+  try {
+    return JSON.parse(new TextDecoder().decode(opened));
+  } catch {
+    return null;
+  }
+}