@paigy/mcp 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mauricio Urdaneta Uribe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @paigy/mcp
+
+A voice inbox for your AI agents. This MCP server lets an agent **notify a user** and **await their reply** — so a long-running agent can ask a question, hand off, and resume on the answer.
+
+## Install
+
+### As a Claude Code plugin (one step)
+
+```
+/plugin marketplace add mauurda/paigy
+/plugin install paigy
+```
+
+The Paigy MCP connects automatically. The first time an agent uses it while
+unpaired, it prompts you to pair — run `/paigy-onboard` (opens your browser to
+approve).
+
+### Or add the MCP directly
+
+No clone needed. Add it to Claude Code (`-s user` = available in every project; drop it for just the current one):
+
+```bash
+claude mcp add paigy -s user -- npx -y @paigy/mcp
+```
+
+Or wire it into any MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "paigy": {
+      "command": "npx",
+      "args": ["-y", "@paigy/mcp"]
+    }
+  }
+}
+```
+
+First-time pairing (link the server to your Paigy account):
+
+```bash
+npx -p @paigy/mcp paigy-mcp-onboard
+```
+
+It talks to the hosted backend by default — no config needed. Set
+`PAIGY_BACKEND_URL=http://localhost:3000` only for local development.
+
+## Tools
+
+- **`notify_user`** — notify the user (context: title + description chunks, plus optional options — each an answerable choice that can carry a sandboxed `html` or `image` preview for visual "pick one" decisions — visuals, `urgency`, and `parentId` for a clarification). Returns a request id + thread id. If a reply comes back as `{kind:'clarify', chunks:[...]}`, respond via notify_user with the SAME threadId and an expanded description.
+- **`await_reply`** — wait for the user's reply to a specific notification (pass its id). Scoped: will not return replies meant for other notifications. Returns `reply` / `remind` / `idle`.
+- **`check_replies`** — catch-up sweep: returns replies you haven't consumed yet (now marked seen) plus still-pending notifications.
+- **`poll_answer`** — fetch the answer to a specific request by id.
+- **`set_task_state`** — report progress on a request: `in_progress` / `completed` / `needs_input`.
+
+## Configuration
+
+- `PAIGY_BACKEND_URL` — the Paigy API base (defaults to the hosted backend).
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { execSync } from "child_process";
+
+// ../../packages/schema/dist/index.js
+import { z } from "zod";
+var ContextSchema = z.object({
+  title: z.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
+  description: z.array(z.string().min(1)).min(1).describe("Semantic chunks of detail (each a standalone, non-empty piece). The user can select chunks to ask you to expand.")
+});
+var OptionSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  // .describe() flows into the MCP notify_user JSON schema (zodToJsonSchema), so
+  // the constraints below are what an agent reads when deciding to use these.
+  html: z.string().max(16384).describe(
+    "Optional sandboxed HTML/CSS preview for a visual 'pick one' (shown in the option card). Untrusted-sandboxed: NO JavaScript, NO external network or images \u2014 inline CSS and data: URIs only; <=16KB. Use for layout/CSS mockups, tables, diffs. For a hosted image use `image` instead."
+  ).optional(),
+  image: z.string().url().describe(
+    "Optional image URL rendered as the option's preview (plain image, not sandboxed). For agent-generated HTML/CSS mockups, use `html` instead."
+  ).optional()
+});
+var VisualSchema = z.object({
+  url: z.string().url(),
+  label: z.string().optional()
+});
+var AgentSchema = z.object({
+  name: z.string()
+});
+var NotifyRequestSchema = z.object({
+  context: ContextSchema,
+  options: z.array(OptionSchema).optional(),
+  visuals: z.array(VisualSchema).optional(),
+  agent: AgentSchema,
+  /** Git repo the agent is working in ("owner/name"), when applicable. */
+  repo: z.string().optional(),
+  /** Git branch the agent is on, when applicable. */
+  branch: z.string().optional(),
+  /** Continue an existing conversation; omitted = start a new thread. */
+  threadId: z.string().uuid().optional(),
+  createdAt: z.string().datetime(),
+  urgency: z.enum(["inbox", "call"]).default("inbox").describe(
+    "'inbox' (default) = sits silently in the inbox for the user to get to. 'call' = rings the user's phone now (a CallKit voice call) \u2014 use only when you genuinely need them in the moment (blocked and waiting, time-sensitive). context.title becomes what they see on the ring, so make it specific."
+  ),
+  /** The request this one was spawned from, for a clarification. */
+  parentId: z.string().optional(),
+  /** How the user answers the options: pick one (default), pick several, or pick & order. */
+  select: z.enum(["one", "many", "rank"]).default("one")
+});
+var NotifyStatusSchema = z.enum(["pending", "answered", "ignored"]);
+var AgentStateSchema = z.enum(["idle", "in_progress", "completed", "needs_input"]);
+var SetTaskStateSchema = z.object({
+  state: z.enum(["in_progress", "completed", "needs_input"])
+});
+var UserAnswerSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("option"), optionId: z.string() }),
+  z.object({ kind: z.literal("text"), text: z.string() }),
+  z.object({ kind: z.literal("ignored") }),
+  z.object({ kind: z.literal("multi"), optionIds: z.array(z.string()) }),
+  z.object({ kind: z.literal("ranked"), optionIds: z.array(z.string()) }),
+  z.object({ kind: z.literal("clarify"), chunks: z.array(z.string()).min(1) })
+]);
+var AwaitItemSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("reply"),
+    threadId: z.string(),
+    notificationId: z.string(),
+    answer: UserAnswerSchema
+  }),
+  z.object({
+    type: z.literal("remind"),
+    threadId: z.string(),
+    notificationId: z.string(),
+    remindAt: z.string().datetime({ offset: true }),
+    /** Seconds until remindAt, server-computed — pass straight to ScheduleWakeup. */
+    remindInSeconds: z.number()
+  }),
+  z.object({ type: z.literal("idle") })
+]);
+var PendingRepliesSchema = z.object({
+  replies: z.array(
+    z.object({ threadId: z.string(), notificationId: z.string(), answer: UserAnswerSchema })
+  ),
+  pending: z.array(
+    z.object({ threadId: z.string(), notificationId: z.string(), createdAt: z.string() })
+  )
+});
+var NotifyResponseSchema = z.object({
+  id: z.string(),
+  status: NotifyStatusSchema,
+  createdAt: z.string().datetime(),
+  answer: UserAnswerSchema.optional(),
+  answeredAt: z.string().datetime().optional()
+});
+var UserResponseSchema = z.object({
+  requestId: z.string(),
+  answer: UserAnswerSchema,
+  answeredAt: z.string().datetime()
+});
+var InboxItemSchema = z.object({
+  id: z.string(),
+  status: NotifyStatusSchema,
+  context: ContextSchema,
+  options: z.array(OptionSchema).optional(),
+  visuals: z.array(VisualSchema).optional(),
+  agent: z.string(),
+  nickname: z.string(),
+  repo: z.string().optional(),
+  branch: z.string().optional(),
+  createdAt: z.string().datetime(),
+  snoozedUntil: z.string().datetime().optional(),
+  agentState: AgentStateSchema.default("idle"),
+  parentId: z.string().optional(),
+  select: z.enum(["one", "many", "rank"]).default("one")
+});
+var SnoozeRequestSchema = z.object({
+  requestId: z.string(),
+  until: z.string().datetime()
+});
+var PushTokenSchema = z.object({
+  voipToken: z.string().min(1),
+  platform: z.enum(["ios"])
+});
+var UserSettingsSchema = z.object({
+  callsEnabled: z.boolean()
+});
+var DeviceAgentTokenSchema = z.object({
+  token: z.string(),
+  deviceId: z.string(),
+  agentName: z.string(),
+  /** User-chosen session label; defaults to `<agent> <device>`. */
+  nickname: z.string(),
+  createdAt: z.string().datetime()
+});
+var PairingStatusSchema = z.enum(["pending", "approved", "denied", "expired"]);
+var DeviceCodeSchema = z.object({
+  device_code: z.string(),
+  user_code: z.string(),
+  verification_uri: z.string().url(),
+  verification_uri_complete: z.string().url(),
+  interval: z.number(),
+  expires_in: z.number()
+});
+var DeviceInfoSchema = z.object({
+  code: z.string(),
+  agent: z.string(),
+  device: z.string().nullable(),
+  status: PairingStatusSchema
+});
+var DeviceTokenSchema = z.object({
+  access_token: z.string(),
+  nickname: z.string(),
+  agent: z.string(),
+  device: z.string().nullable()
+});
+
+// src/index.ts
+import { z as z2 } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/client.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var BACKEND_URL = process.env.PAIGY_BACKEND_URL ?? "https://paigy.ai";
+var TOKEN_PATH = join(homedir(), ".paigy", "token.json");
+function loadToken() {
+  if (process.env.PAIGY_TOKEN) return process.env.PAIGY_TOKEN;
+  if (existsSync(TOKEN_PATH)) {
+    try {
+      const raw = readFileSync(TOKEN_PATH, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.access_token) return parsed.access_token;
+    } catch {
+    }
+  }
+  return "";
+}
+var ONBOARD_MSG = "Not paired with Paigy yet \u2014 run /paigy-onboard (or `npx -y @paigy/mcp paigy-mcp-onboard`) to pair this agent, then retry.";
+function ensureAuthed(res) {
+  if (res.status === 401) throw new Error(ONBOARD_MSG);
+  return res;
+}
+async function submitNotification(req) {
+  const token = loadToken();
+  const res = ensureAuthed(await fetch(`${BACKEND_URL}/api/notify`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(req)
+  }));
+  if (!res.ok) throw new Error(`notify failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function awaitReply(notificationId, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 5e3;
+  const windowMs = opts.windowMs ?? 3e5;
+  const doSleep = opts.sleep ?? sleep;
+  const now = opts.now ?? Date.now;
+  const token = loadToken();
+  const start = now();
+  while (true) {
+    const res = ensureAuthed(await fetch(`${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`, {
+      headers: { authorization: `Bearer ${token}` }
+    }));
+    if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
+    const item = await res.json();
+    if (item.type !== "idle") return item;
+    if (now() - start >= windowMs) return { type: "idle" };
+    await doSleep(intervalMs);
+  }
+}
+async function checkReplies() {
+  const token = loadToken();
+  const res = ensureAuthed(await fetch(`${BACKEND_URL}/api/pending`, {
+    headers: { authorization: `Bearer ${token}` }
+  }));
+  if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+async function setTaskState(id, state) {
+  const res = ensureAuthed(await fetch(`${BACKEND_URL}/api/notify/${id}/state`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json", authorization: `Bearer ${loadToken()}` },
+    body: JSON.stringify({ state })
+  }));
+  if (!res.ok) throw new Error(`set_task_state failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+async function pollAnswer(id) {
+  const token = loadToken();
+  const res = ensureAuthed(await fetch(`${BACKEND_URL}/api/poll/${id}`, {
+    headers: { authorization: `Bearer ${token}` }
+  }));
+  if (!res.ok) throw new Error(`poll failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+
+// src/index.ts
+var PollAnswerSchema = z2.object({
+  id: z2.string().describe("Request id returned by notify_user.")
+});
+var AwaitReplySchema = z2.object({
+  notificationId: z2.string().describe("The id returned by notify_user \u2014 waits for the user's reply to THIS notification only.")
+});
+var CheckRepliesSchema = z2.object({});
+var SetTaskStateToolSchema = z2.object({
+  notificationId: z2.string(),
+  state: SetTaskStateSchema.shape.state
+});
+function detectGit() {
+  const run = (cmd) => {
+    try {
+      return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }).trim();
+    } catch {
+      return "";
+    }
+  };
+  const remote = run("git remote get-url origin");
+  const match = remote.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+  const branch = run("git rev-parse --abbrev-ref HEAD");
+  return {
+    repo: match ? match[1] : void 0,
+    branch: branch && branch !== "HEAD" ? branch : void 0
+  };
+}
+var server = new Server(
+  { name: "paigy", version: "0.0.0" },
+  {
+    capabilities: { tools: {} },
+    instructions: "On startup, call check_replies once to pick up any replies or pending work you missed while away. To wait for the answer to something you just asked, call await_reply with that notification's id \u2014 it's scoped to that one request, so it never returns replies meant for other requests. Use check_replies again only when re-booting or after waiting a long time on something else. Never end a turn that still needs the user without notify_user + await_reply. If a reply comes back as { kind: 'clarify', chunks: [...] }, the user wants more detail on those chunks \u2014 respond by calling notify_user again with the SAME threadId and an expanded description covering them."
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "notify_user",
+      description: "Notify the user via Paigy and get a request id to poll for their answer. Provide context.title (a specific, non-empty one-line headline \u2014 this is what the user sees first, and what shows on the ring for a call) and context.description (an array of standalone, non-empty detail chunks the user can selectively ask you to expand). Set `urgency`: 'inbox' (default) drops it silently in their inbox; 'call' rings their phone now as a voice call \u2014 use 'call' only when you genuinely need them in the moment (blocked/waiting, time-sensitive), not for routine FYIs. Plus optional options (answerable choices; each may carry a sandboxed `html` or an `image` preview for a visual 'pick one' \u2014 e.g. show layout/UI alternatives) and visuals. Use `select` to control how the user answers options: 'one' (default) = pick a single option; 'many' = multi-select, user checks any subset \u2192 answer arrives as {kind:'multi', optionIds:[...]}; 'rank' = select and order, user taps options in preferred order \u2192 answer arrives as {kind:'ranked', optionIds:[...]} (ordered by choice). If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail on those chunks \u2014 respond via notify_user with the SAME threadId and an expanded description. Pass `threadId` from a prior notify_user result or an await_reply reply to continue that conversation thread; omit it to start a new one.",
+      inputSchema: zodToJsonSchema(NotifyRequestSchema, { target: "openApi3" })
+    },
+    {
+      name: "poll_answer",
+      description: "Fetch the user's answer to a previous notify_user request. Returns status pending | answered | ignored, with the answer once present. Errors if the id is unknown or expired.",
+      inputSchema: zodToJsonSchema(PollAnswerSchema, { target: "openApi3" })
+    },
+    {
+      name: "await_reply",
+      description: "Wait for the user's reply to THE specific notification you sent for the current request (pass its id from notify_user). This is how you wait for your answer in-context. Polls ~5 min; returns { type:'reply', answer } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' }. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications/requests, so concurrent requests don't cross.",
+      inputSchema: zodToJsonSchema(AwaitReplySchema, { target: "openApi3" })
+    },
+    {
+      name: "check_replies",
+      description: "The catch-up router for everything NOT tied to your current request: returns replies the user sent that you haven't seen yet (now marked seen) plus still-pending notifications you sent. Use it when booting up / starting a session, or when you've been waiting a long time on something else, to discover acks or work you're unaware of. To wait on a request you just sent, use await_reply instead.",
+      inputSchema: zodToJsonSchema(CheckRepliesSchema, { target: "openApi3" })
+    },
+    {
+      name: "set_task_state",
+      description: "Report progress on a request you received: in_progress (you started working), completed (done), or needs_input (you need more from the user \u2014 usually paired with a notify_user carrying parentId = this request's id).",
+      inputSchema: zodToJsonSchema(SetTaskStateToolSchema, { target: "openApi3" })
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  switch (request.params.name) {
+    case "notify_user": {
+      const parsed = NotifyRequestSchema.parse(request.params.arguments);
+      const git = detectGit();
+      const enriched = {
+        ...parsed,
+        repo: parsed.repo ?? git.repo,
+        branch: parsed.branch ?? git.branch
+      };
+      const result = await submitNotification(enriched);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    case "poll_answer": {
+      const { id } = PollAnswerSchema.parse(request.params.arguments);
+      const result = await pollAnswer(id);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    case "await_reply": {
+      const { notificationId } = AwaitReplySchema.parse(request.params.arguments);
+      const item = await awaitReply(notificationId);
+      return { content: [{ type: "text", text: JSON.stringify(item) }] };
+    }
+    case "check_replies": {
+      CheckRepliesSchema.parse(request.params.arguments ?? {});
+      const result = await checkReplies();
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    case "set_task_state": {
+      const { notificationId, state } = SetTaskStateToolSchema.parse(request.params.arguments);
+      const result = await setTaskState(notificationId, state);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    default:
+      throw new Error(`Unknown tool: ${request.params.name}`);
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/onboard.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+// src/onboard.ts
+import { execFile } from "child_process";
+import { mkdirSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+var BACKEND_URL = process.env.PAIGY_BACKEND_URL ?? "https://paigy.ai";
+var AGENT_NAME = process.env.PAIGY_AGENT ?? "mcp-agent";
+var TOKEN_PATH = join(homedir(), ".paigy", "token.json");
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+  const args = platform() === "win32" ? ["/c", "start", url] : [url];
+  execFile(cmd, args, (err) => {
+    if (err) {
+    }
+  });
+}
+function saveToken(token) {
+  const dir = join(homedir(), ".paigy");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(TOKEN_PATH, JSON.stringify(token, null, 2) + "\n", { mode: 384 });
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function requestCode() {
+  const res = await fetch(`${BACKEND_URL}/api/device/code`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ agent: AGENT_NAME })
+  });
+  if (!res.ok) throw new Error(`/api/device/code failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+async function pollToken(deviceCode) {
+  const res = await fetch(`${BACKEND_URL}/api/device/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ device_code: deviceCode })
+  });
+  if (res.ok) return await res.json();
+  const body = await res.json().catch(() => ({ error: "unknown" }));
+  const err = body.error ?? "unknown";
+  if (err === "authorization_pending") return null;
+  if (err === "expired_token") throw new Error("Device code expired. Please re-run onboarding.");
+  if (err === "access_denied") throw new Error("Access denied by user. Onboarding cancelled.");
+  throw new Error(`Unexpected error from /api/device/token: ${err}`);
+}
+async function main() {
+  console.log(`
+Paigy MCP onboarding (agent: "${AGENT_NAME}")
+`);
+  const code = await requestCode();
+  console.log("Open this URL in your browser to approve the connection:\n");
+  console.log(`  ${code.verification_uri_complete}
+`);
+  console.log(`  (User code: ${code.user_code})
+`);
+  openBrowser(code.verification_uri_complete);
+  const intervalMs = (code.interval ?? 5) * 1e3;
+  const expiresAt = Date.now() + code.expires_in * 1e3;
+  process.stdout.write("Waiting for approval");
+  while (Date.now() < expiresAt) {
+    await sleep(intervalMs);
+    process.stdout.write(".");
+    try {
+      const token = await pollToken(code.device_code);
+      if (token !== null) {
+        saveToken(token);
+        console.log(`
+
+Paired! Token saved to ${TOKEN_PATH} (mode 0600).`);
+        console.log("Treat this token like a password \u2014 it grants account access. Never log, echo, or commit it.");
+        console.log(`  Nickname : ${token.nickname}`);
+        console.log(`  Agent    : ${token.agent}`);
+        console.log(`  Device   : ${token.device ?? "(none)"}
+`);
+        return;
+      }
+    } catch (err) {
+      console.error(`
+
+${err.message}
+`);
+      process.exit(1);
+    }
+  }
+  console.error("\n\nDevice code expired without approval. Please re-run onboarding.\n");
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+export {
+  TOKEN_PATH
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@paigy/mcp",
+  "version": "0.4.0",
+  "description": "Paigy MCP server — a voice inbox for your AI agents. Lets an agent notify a user and await their reply.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mcp": "./dist/index.js",
+    "paigy-mcp": "./dist/index.js",
+    "paigy-mcp-onboard": "./dist/onboard.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mauurda/paigy.git",
+    "directory": "apps/mcp"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "@paigy/schema": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/onboard.ts --format esm --clean",
+    "dev": "tsup src/index.ts src/onboard.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}