@paigy/mcp 0.12.1 → 0.12.2

package/dist/chunk-DUTOEZEL.js

@@ -0,0 +1,152 @@
+import {
+  BACKEND_URL,
+  fetchRoster,
+  openSealedAnswer,
+  reach,
+  readKeyFile,
+  sealFields,
+  verifiedRecipients
+} from "./chunk-BJ2J2AOB.js";
+
+// src/client.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+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 call the `pair` tool to connect this agent (it returns an approval link to show the user), then retry. Manual fallback: `npx -y @paigy/mcp paigy-mcp-onboard`.";
+function ensureAuthed(res) {
+  if (res.status === 401) throw new Error(ONBOARD_MSG);
+  return res;
+}
+async function sealForE2ee(req, token, deps = {}) {
+  const keyFile = (deps.readKeyFile ?? readKeyFile)();
+  if (!keyFile?.e2ee) return req;
+  if (!keyFile.uikPub) {
+    throw new Error("E2EE pairing is missing its pinned identity key (key.json.uikPub) \u2014 re-pair; refusing to send plaintext.");
+  }
+  const roster = await (deps.fetchRoster ?? fetchRoster)(token);
+  if (!roster) {
+    throw new Error("E2EE pairing has no device roster to seal to \u2014 refusing to send plaintext. Approve a device on your phone, then retry.");
+  }
+  const recipients = verifiedRecipients(roster, keyFile.uikPub);
+  if (recipients.length === 0) {
+    throw new Error("No roster device verified against the pinned identity key \u2014 refusing to send plaintext (a server-injected device is dropped).");
+  }
+  const sealedContext = {
+    ...req.context,
+    ...req.repo !== void 0 ? { repo: req.repo } : {},
+    ...req.branch !== void 0 ? { branch: req.branch } : {}
+  };
+  const envelope = sealFields({ context: sealedContext, options: req.options, visuals: req.visuals }, recipients);
+  const { context: _c, options: _o, visuals: _v, repo: _r, branch: _b, ...meta } = req;
+  return { ...meta, envelope };
+}
+async function submitNotification(req) {
+  const token = loadToken();
+  const body = await sealForE2ee(req, token);
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(body)
+  }));
+  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));
+function decryptAnswer(reply, deps = {}) {
+  if (!reply.sealed) return reply.answer;
+  const keyFile = (deps.readKeyFile ?? readKeyFile)();
+  if (!keyFile?.keypair) {
+    throw new Error("received a sealed answer but this agent has no device key to open it \u2014 re-pair.");
+  }
+  return openSealedAnswer(reply.sealed, keyFile.keypair);
+}
+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 reach(`${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 decryptItem(item);
+    if (now() - start >= windowMs) return { type: "idle" };
+    await doSleep(intervalMs);
+  }
+}
+function decryptItem(item) {
+  if (item.type !== "reply" || !item.sealed) return item;
+  const answer = decryptAnswer(item);
+  const { sealed: _s, ...rest } = item;
+  return { ...rest, answer };
+}
+async function checkReplies() {
+  const token = loadToken();
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
+    headers: { authorization: `Bearer ${token}` }
+  }));
+  if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
+  const pending = await res.json();
+  return {
+    ...pending,
+    replies: pending.replies.map((r) => {
+      if (!r.sealed) return r;
+      const { sealed: _s, ...rest } = r;
+      return { ...rest, answer: decryptAnswer(r) };
+    })
+  };
+}
+async function setTaskState(notificationId, state) {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${notificationId}/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 registerDelivery(mode) {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${loadToken()}` },
+    body: JSON.stringify({ mode })
+  }));
+  if (!res.ok) throw new Error(`register_delivery failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+async function scheduleCallback(req) {
+  const token = loadToken();
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/callback`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(req)
+  }));
+  if (!res.ok) throw new Error(`schedule_callback failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+
+export {
+  submitNotification,
+  awaitReply,
+  checkReplies,
+  setTaskState,
+  registerDelivery,
+  scheduleCallback
+};

package/dist/index.js

@@ -1,25 +1,30 @@
 #!/usr/bin/env node
 import {
-  NotifyRequestSchema,
-  ScheduleCallbackSchema,
-  SetTaskStateSchema,
   awaitReply,
   checkReplies,
   scheduleCallback,
   setTaskState,
   submitNotification
-} from "./chunk-ACPCCDHI.js";
+} from "./chunk-DUTOEZEL.js";
 import {
+  NotifyRequestSchema,
+  ScheduleCallbackSchema,
+  SetTaskStateSchema,
+  deleteKeyFile,
   deleteToken,
+  fetchCredential,
+  finalizeE2ee,
   openBrowser,
-  pollToken,
+  pairStep,
+  readKeyFile,
   readToken,
   requestCode,
   revokeToken,
+  saveKeyFile,
   saveToken,
-  sleep
-} from "./chunk-AILC3H3U.js";
-import "./chunk-GU7C5H6L.js";
+  sleep,
+  startE2ee
+} from "./chunk-BJ2J2AOB.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -84,11 +89,26 @@ function detectGit() {
     branch: branch && branch !== "HEAD" ? branch : void 0
   };
 }
+function pairedResult(token, sas, note, e2ee) {
+  const base = {
+    status: "paired",
+    nickname: token.nickname,
+    agent: token.agent,
+    device: token.device
+  };
+  if (sas) {
+    base.e2ee = !!e2ee;
+    base.sas = sas;
+    base.verify_message = `This pairing is end-to-end encrypted. Ask the user to verify this code matches the one on their phone: ${sas}` + (e2ee ? "" : " (identity key not yet confirmed on the phone).");
+  }
+  if (note) base.note = note;
+  return { content: [{ type: "text", text: JSON.stringify(base) }] };
+}
 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 notificationId \u2014 it's scoped to that one notification, so it never returns replies meant for other notifications. 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. When you need a decision or input, MATCH the answer shape to the question \u2014 don't default everything to free text, and don't reflexively make everything yes/no. Pick the best tool for the job: yes/no \u2192 select:'confirm'; approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve'; pick one of several \u2192 options + select:'one'; pick several / a subset \u2192 options + select:'many'; rank or prioritize \u2192 options + select:'rank'. Reserve select:'text' (free-form reply only) for plain updates and answers that genuinely can't be structured (the user can always add free text on top of any shape). On a { kind: 'clarify' } reply, see notify_user's own description for how to respond. When urgency is 'call', remember the title + description are spoken aloud \u2014 write them short and conversational, and name things instead of using IDs (e.g. 'the pull request about the agents page', not 'PR #235'). When the user asks you to follow up later \u2014 when you're done, if you're blocked, or at a set time \u2014 record it with schedule_callback so you don't drop it if you go idle. If you're about to start a genuinely long-running or blocking piece of work \u2014 one where the user would otherwise sit and wait \u2014 mention ONCE, in passing, that you can reach them when it's done or if you hit a blocker, instead of them needing to babysit the terminal. Don't offer this for quick tasks, and don't repeat the offer if they've already said yes or no earlier in the conversation. Escalate silence, don't just wait on it: if you notified at a lower urgency (inbox/push/banner) for something that's genuinely blocking real progress, call await_reply up to twice (~5 min each, ~10 min total) \u2014 if it's still idle after that AND the item is genuinely blocking, send a fresh notify_user on the SAME threadId at urgency:'call'. Skip this for anything that isn't truly blocking; a normal question can just sit in the inbox."
+    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 notificationId \u2014 it's scoped to that one notification, so it never returns replies meant for other notifications. 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. When you need a decision or input, MATCH the answer shape to the question \u2014 don't default everything to free text, and don't reflexively make everything yes/no. Pick the best tool for the job: yes/no \u2192 select:'confirm'; approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve'; pick one of several \u2192 options + select:'one'; pick several / a subset \u2192 options + select:'many'; rank or prioritize \u2192 options + select:'rank'. Reserve select:'text' (free-form reply only) for plain updates and answers that genuinely can't be structured (the user can always add free text on top of any shape). On a { kind: 'clarify' } reply, see notify_user's own description for how to respond. When urgency is 'call', remember the title + description are spoken aloud \u2014 write them short and conversational, and name things instead of using IDs (e.g. 'the pull request about the agents page', not 'PR #235'). When the user asks you to follow up later \u2014 when you're done, if you're blocked, or at a set time \u2014 record it with schedule_callback so you don't drop it if you go idle. If you're about to start a genuinely long-running or blocking piece of work \u2014 one where the user would otherwise sit and wait \u2014 mention ONCE, in passing, that you can reach them when it's done or if you hit a blocker, instead of them needing to babysit the terminal. Don't offer this for quick tasks, and don't repeat the offer if they've already said yes or no earlier in the conversation. Escalate silence, don't just wait on it: if you notified at a lower urgency (inbox/push/banner) for something that's genuinely blocking real progress, call await_reply up to twice (~5 min each, ~10 min total) \u2014 if it's still idle after that AND the item is genuinely blocking, send a fresh notify_user on the SAME threadId at urgency:'call'. Skip this for anything that isn't truly blocking; a normal question can just sit in the inbox. NEVER go quietly idle while something might still be pending for you: whenever you end a turn with any Paigy notification unanswered (or any chance the user replied through the app while you worked), schedule your own ~2-minute wake-up (harness ScheduleWakeup or equivalent) and call check_replies when it fires; if still nothing, re-schedule and keep looping until resolved or the user says stop. For legibility, always use this exact wording \u2014 reason: 'Paigy idle check \u2014 waiting on <thing>', wake-up prompt: 'Paigy idle check: call check_replies and engage with anything unacknowledged; if idle, re-schedule (~2min).' \u2014 so the user can recognize every idle check at a glance. This self-polling in your own live session (full context intact) is the PRIMARY mechanism; the plugin's Stop hooks are only the dead-session safety net."
   }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -135,7 +155,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "pair": {
       const { device_code } = PairSchema.parse(request.params.arguments ?? {});
       if (!device_code) {
-        const code = await requestCode();
+        const { keyFile, offer } = startE2ee();
+        const code = await requestCode(void 0, offer);
+        saveKeyFile({ ...keyFile, userCode: code.user_code });
         openBrowser(code.verification_uri_complete);
         const qr = qrcode(0, "M");
         qr.addData(code.verification_uri_complete);
@@ -155,18 +177,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      let kf = readKeyFile();
       const start = Date.now();
       const capMs = 9e4;
       while (Date.now() - start < capMs) {
-        const token = await pollToken(device_code);
-        if (token) {
-          saveToken(token);
-          return {
-            content: [{
-              type: "text",
-              text: JSON.stringify({ status: "paired", nickname: token.nickname, agent: token.agent, device: token.device })
-            }]
-          };
+        const step = await pairStep(device_code, kf);
+        if (step.kind === "e2ee_aborted") {
+          deleteKeyFile();
+          kf = null;
+          await sleep(2e3);
+          continue;
+        }
+        if (step.kind === "paired") {
+          saveToken(step.token);
+          if (!step.sas || !kf) {
+            deleteKeyFile();
+            return pairedResult(step.token);
+          }
+          const finalDeadline = Math.min(Date.now() + 1e4, start + capMs);
+          let e2ee = false;
+          while (Date.now() < finalDeadline) {
+            const cred = kf.userCode ? await fetchCredential(kf.userCode) : null;
+            if (cred && step.uikPub) {
+              e2ee = finalizeE2ee(kf, cred, step.uikPub);
+              break;
+            }
+            await sleep(2e3);
+          }
+          if (!e2ee) deleteKeyFile();
+          return pairedResult(step.token, step.sas, void 0, e2ee);
         }
         await sleep(2e3);
       }
@@ -192,6 +231,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
       const removed = deleteToken();
+      deleteKeyFile();
       return {
         content: [{
           type: "text",

package/dist/listen.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import {
-  WAKE_EVENT,
   checkReplies,
-  registerDelivery,
+  registerDelivery
+} from "./chunk-DUTOEZEL.js";
+import {
+  WAKE_EVENT,
   wakeChannel
-} from "./chunk-ACPCCDHI.js";
-import "./chunk-GU7C5H6L.js";
+} from "./chunk-BJ2J2AOB.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";

package/dist/onboard.js

@@ -7,8 +7,7 @@ import {
   requestCode,
   saveToken,
   sleep
-} from "./chunk-AILC3H3U.js";
-import "./chunk-GU7C5H6L.js";
+} from "./chunk-BJ2J2AOB.js";
 
 // src/onboard.ts
 async function main() {

package/dist/statusline.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import {
+  BACKEND_URL,
   readToken
-} from "./chunk-AILC3H3U.js";
-import {
-  BACKEND_URL
-} from "./chunk-GU7C5H6L.js";
+} from "./chunk-BJ2J2AOB.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "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",
@@ -35,6 +35,7 @@
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8",
+    "@paigy/crypto": "0.0.0",
     "@paigy/schema": "0.0.0"
   },
   "scripts": {