@paigy/mcp 0.35.0 → 0.36.0

package/dist/chunk-XIPO3U6I.js

@@ -0,0 +1,309 @@
+import {
+  CHECK_REPLIES_DESCRIPTION,
+  CONTACT_DESCRIPTION,
+  CONTACT_SCHEMA,
+  CREATE_GOAL_DESCRIPTION,
+  CreateGoalSchema,
+  HandoffSchema,
+  SCHEDULE_CALLBACK_DESCRIPTION,
+  SEARCH_THREADS_DESCRIPTION,
+  SET_WORK_STATE_DESCRIPTION,
+  ScheduleCallbackSchema,
+  SetTaskStateSchema,
+  SetWorkStateSchema,
+  mcpInputSchema,
+  serverInstructions
+} from "./chunk-WNE6STMA.js";
+import {
+  AGENT_NAME
+} from "./chunk-PRC6GKRN.js";
+
+// src/toolset.ts
+var ONBOARD_DESCRIPTION = "Get this agent talking to Paigy \u2014 call it FIRST, before contact/await_reply, and any time you're unsure who you are. One call, and it does whatever the situation needs: NOT SET UP \u2192 hatches an identity instantly if this machine holds a device credential (the user ran the Paigy desktop app or harness), otherwise starts the code ceremony; ALREADY SET UP \u2192 returns your current identity and offers the two things left to decide, renaming it or unpairing; TOKEN NO LONGER VALID \u2192 says so, then re-pairs. Pass { name, voice } to choose who you are when hatching, or to RENAME yourself when already set up (voices: rachel, george, jessica, brian, lily). Safe to call any time: idempotent, and it never writes settings \u2014 the tool-allowlist state it reports is read-only. If it returns a `user_code`, print it to the user immediately and call onboard again with the `device_code`. If it returns `enable_command`, PRINT that command for the user to run \u2014 you cannot apply it yourself (it writes your own permission allowlist, which hosts block as privilege escalation), so print it, don't wait for it, and carry on.";
+var SERVER_INSTRUCTIONS = serverInstructions({ waits: true });
+
+// src/tools.ts
+import { z } from "zod";
+var AwaitReplySchema = z.object({
+  notificationId: z.string().describe("The notificationId returned by contact \u2014 waits for the user's reply to THIS notification only.")
+});
+var OnboardSchema = z.object({
+  name: z.string().max(60).optional(),
+  voice: z.string().max(40).optional(),
+  /** Continue a code ceremony already in flight — same meaning as `pair`'s. */
+  device_code: z.string().optional(),
+  /** Which allowlist to REPORT on (never written by `start`). */
+  scope: z.enum(["user", "project"]).optional()
+});
+var PairSchema = z.object({
+  device_code: z.string().optional().describe("Omit to start pairing (returns an approval link to show the user). Pass the device_code from that first call to finish, once the user has approved."),
+  name: z.string().min(1).max(60).optional().describe("Hatch path only: the name you choose for this identity. Pick your own \u2014 ONE or TWO words, the way you'd introduce yourself on a call (it is spoken aloud and shown in lists). 'Piper', 'Blue Heron' \u2014 never a sentence or a task description."),
+  voice: z.string().optional().describe("Hatch path only: your voice on calls \u2014 one of rachel, george, jessica, brian, lily.")
+});
+var GetThreadSchema = z.object({
+  parentId: z.string().describe("The thread to read \u2014 from a reply, request, or past notification.")
+});
+var SearchThreadsSchema = z.object({
+  q: z.string().describe("What to look for \u2014 plain words or a phrase (e.g. 'the livekit timeout', 'deploy to prod').")
+});
+var SetTaskStateToolSchema = z.object({
+  notificationId: z.string(),
+  state: SetTaskStateSchema.shape.state
+});
+var AnswerCallerQuestionSchema = z.object({
+  notificationId: z.string().describe("The notification whose call carried the caller's question \u2014 from the partial turn or the settled reply."),
+  answer: z.string().min(1).max(1500).describe("The answer, as one or two short SPOKEN sentences \u2014 it may be read aloud on the live call.")
+});
+var TOOLS = [
+  {
+    // #575: THE attention verb — the one model-facing surface, every agent.
+    // The retired names (notify/notify_user) stay callable as hidden aliases
+    // for stale prompts and cached servers; see toolset.ts for the design.
+    name: "contact",
+    description: CONTACT_DESCRIPTION,
+    inputSchema: CONTACT_SCHEMA
+  },
+  {
+    // ONE rail for starting a session (#875). `pair`, the `paigy-mcp-onboard` CLI and
+    // `enable_tools` were three doors into one flow, and "onboard" was the word people
+    // reached for attached to the tool that did the least. It's the door now.
+    name: "onboard",
+    description: ONBOARD_DESCRIPTION,
+    inputSchema: mcpInputSchema(OnboardSchema)
+  },
+  {
+    name: "pair",
+    description: "Pair this agent with the user's Paigy account (one-time) \u2014 required before contact/await_reply work. FAST PATH: if this machine already holds a device credential (the user ran the Paigy desktop harness or app), calling pair hatches a fresh identity INSTANTLY \u2014 no code, no approval. Pass { name, voice } to choose who you are (pick your own; voices: rachel, george, jessica, brian, lily). Only when no device credential exists does the code ceremony below run. It does NOT open a browser; the user enters the code in the Paigy app (or scans `qr`). Step 1: call with NO args \u2014 returns { user_code, device_code, qr, user_message } AND starts polling for approval in the background. REQUIRED: You MUST immediately print the `user_message` (the bare code) as a text message to the user, AND in that same turn call step 2 (pair with the device_code). This ensures the user sees the code in chat while the tool blocks/polls in the background for approval. Step 2: call with that device_code to collect the result. Because approval is already being polled in the background, this returns the moment the user approves; on { status:'pending' } just call again to keep waiting; on { status:'awaiting_confirmation' } (E2EE) show the bare `user_message` verify code and call again to finish. The leading text block of every result states the code plainly, so it shows even if you emit no prose. On { status:'paired' } ALWAYS follow the `enable_prompt` \u2014 PRINT the returned `enable_command` so the user can allowlist Paigy's tools and notify/await stop prompting each time. Printing is the whole job: that command writes your own permission allowlist, so you must not run it and a host will block you if you try.",
+    inputSchema: mcpInputSchema(PairSchema)
+  },
+  {
+    name: "unpair",
+    description: "Log out / unpair this agent from the user's Paigy account: revokes the token server-side (it stops working everywhere) and deletes the local ~/.paigy/token.json. Takes no arguments. After this, contact/await_reply won't work until the user pairs again with the pair tool.",
+    inputSchema: mcpInputSchema(z.object({}))
+  },
+  {
+    name: "await_reply",
+    description: "Wait for the user's reply to a live call or an answer contact says already exists (pass its notificationId). A quiet inbox delivery is asynchronous: keep working and use check_replies later instead. On a live call, keep calling await_reply for your answer in-context. Polls ~45s per call \u2014 deliberately under the 60s cap most hosts put on a single tool call, so it ALWAYS returns you something. Returns { type:'reply', answer, workId?, decisionId? } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' } (this window ended, no answer yet). While your contact is being handled on a LIVE call, you may receive { type:'partial', inFlight:true, turn } results: what the user said to each turn, as they say it. Use partials to PREPARE \u2014 fetch the data, draft the thing, warm the build \u2014 never to act irreversibly: the user can still revise any of them until the final reply arrives. Partial = intelligence, settled = authorization. If a partial's acts carry a question aimed at you and you know the answer, call contact on the SAME parentId right away \u2014 the caller hears your answer on the same call instead of waiting for a callback. Keep calling await_reply until you get the final reply \u2014 THAT one is the decision. On idle, if this is genuinely still blocking you and you have nothing else useful to do meanwhile, just call await_reply again immediately \u2014 keep looping. This is how you actually deliver on the point of calling: the user steps away for a while and comes back to find you'd already continued the moment they answered, not idle waiting to be checked on. Don't give up after one window. Only stop looping to do other work (and check back later), or after an unreasonably long stretch (tens of minutes to hours) worth telling the user about instead. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications, so concurrent contact calls don't cross. A CALL answer can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a blocking question'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's parentId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry `intents` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' (\"call me after lunch\") \u2192 register it NOW with schedule_callback \u2014 when the intent carries `dueInSeconds` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' (\"you pick\") \u2192 make the call yourself and tell them what you chose; 'channel' (\"text me next time\") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped \"should I call you back?\" because the follow-up is implied. `transcript` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions (\"yes, IF tests pass\") before acting. If your ask declared `points`, the reply carries `covered` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same parentId) or proceed knowingly partial; never treat a partial answer as complete.",
+    inputSchema: mcpInputSchema(AwaitReplySchema)
+  },
+  {
+    name: "check_replies",
+    description: CHECK_REPLIES_DESCRIPTION,
+    inputSchema: mcpInputSchema(z.object({}))
+  },
+  {
+    name: "get_thread",
+    description: "The chronological transcript of one Paigy conversation thread \u2014 every past ask, answer, and user request on it. Call this to REHYDRATE when you're resuming or being seeded: a check_replies request whose parentId you don't recognize means the user is continuing an old conversation with you, and one carrying a contextParentId means they want a past conversation (possibly with a DIFFERENT agent) as your starting context \u2014 in both cases call get_thread FIRST and read the turns as prior conversation you were part of, not as new input. Turns: { role:'agent', title, description[], answer }, { role:'user', text }, and context turns { role:'handoff'|'recap', title, description[] } \u2014 a handoff is a predecessor's brief for you; a recap SUMMARIZES everything before it (the transcript starts at the latest recap, so treat it as the base and the turns after it as what happened since). Oldest first, capped at the most recent 30.",
+    inputSchema: mcpInputSchema(GetThreadSchema)
+  },
+  {
+    name: "search_threads",
+    description: SEARCH_THREADS_DESCRIPTION,
+    inputSchema: mcpInputSchema(SearchThreadsSchema)
+  },
+  {
+    name: "create_goal",
+    description: CREATE_GOAL_DESCRIPTION,
+    inputSchema: mcpInputSchema(CreateGoalSchema)
+  },
+  {
+    name: "set_work_state",
+    description: SET_WORK_STATE_DESCRIPTION,
+    inputSchema: mcpInputSchema(SetWorkStateSchema)
+  },
+  {
+    name: "answer_caller_question",
+    description: "Answer a question the user asked DURING a live call, while they're still on it. When a partial turn or a settled reply carries a `question` intent aimed at you, answer it here immediately: if their call is still live, your answer is spoken to them on that same call (returns live: true). If the call already ended (live: false), send the answer as a threaded contact instead \u2014 never drop it. Short spoken sentences only; this may be read aloud.",
+    inputSchema: mcpInputSchema(AnswerCallerQuestionSchema)
+  },
+  {
+    name: "schedule_callback",
+    description: SCHEDULE_CALLBACK_DESCRIPTION,
+    inputSchema: mcpInputSchema(ScheduleCallbackSchema)
+  },
+  {
+    name: "handoff",
+    description: "Deposit your working context for a SUCCESSOR agent \u2014 what you did, what's left, links, gotchas \u2014 as one note on a thread ({ title, notes[] }). This does NOT ring the user or enter their inbox: it's context, not a question. The successor reads it back with get_thread. Pass `target` (a sibling connection's token id or agent name, SAME account only) to hand off DIRECTLY to that agent \u2014 the note is dispatched to it as a request it picks up. Pass `workId` to move that existing outcome and its pending replies to the successor without reminting it; a target is required in that form. Omit `target` to leave the thread for the user to hand off to an agent themselves in the app. Pass `parentId` to land the handoff on an existing conversation; omit it to mint a fresh thread. Returns { parentId }. Pass recap:true when the note SUMMARIZES the thread so far (for a successor OR for your own later session): a recap resets the rehydration window \u2014 get_thread returns the latest recap + only the turns after it. Write one whenever a thread has grown long and you're pausing, handing off, or nearing your context limit.",
+    inputSchema: mcpInputSchema(HandoffSchema)
+  }
+];
+var TOOL_NAMES = TOOLS.map((t) => t.name);
+var HIDDEN_ALIASES = ["notify", "notify_user", "set_task_state"];
+
+// src/clients.ts
+import { execFile } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join, dirname } from "path";
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+  const args = platform() === "win32" ? ["/c", "start", url] : [url];
+  execFile(cmd, args, () => {
+  });
+}
+function withPaigyMcpJson(existing, agent) {
+  let config = {};
+  if (existing) {
+    try {
+      config = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  config.mcpServers = {
+    ...config.mcpServers ?? {},
+    paigy: { command: "npx", args: ["-y", "@paigy/mcp@latest"], env: { PAIGY_AGENT: agent } }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function withPaigyMcpToml(existing, agent) {
+  if (existing.includes("[mcp_servers.paigy]")) return null;
+  const entry = [
+    "",
+    "[mcp_servers.paigy]",
+    'command = "npx"',
+    'args = ["-y", "@paigy/mcp@latest"]',
+    `env = { PAIGY_AGENT = "${agent}" }`,
+    ""
+  ].join("\n");
+  return existing + entry;
+}
+function autoConfigureClients(skip = AGENT_NAME) {
+  const home = homedir();
+  const registered = [];
+  if (skip !== "antigravity") {
+    const antigravityConfigs = [
+      join(home, ".gemini", "config", "mcp_config.json"),
+      join(home, ".gemini", "antigravity-cli", "mcp_config.json")
+    ];
+    for (const path of antigravityConfigs) {
+      try {
+        if (!existsSync(dirname(path))) continue;
+        const existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+        const updated = withPaigyMcpJson(existing, "antigravity");
+        if (updated === null) continue;
+        writeFileSync(path, updated);
+        registered.push(`Google Antigravity (${path})`);
+      } catch {
+      }
+    }
+  }
+  if (skip !== "codex") {
+    const codexConfig = join(home, ".codex", "config.toml");
+    try {
+      if (existsSync(dirname(codexConfig))) {
+        const existing = existsSync(codexConfig) ? readFileSync(codexConfig, "utf8") : "";
+        const updated = withPaigyMcpToml(existing, "codex");
+        if (updated !== null) {
+          writeFileSync(codexConfig, updated);
+          registered.push(`OpenAI Codex (${codexConfig})`);
+        }
+      }
+    } catch {
+    }
+  }
+  return registered;
+}
+function claudeInstallHint(skip = AGENT_NAME) {
+  if (skip.startsWith("claude")) return null;
+  const claudeDir = join(homedir(), ".claude");
+  if (!existsSync(claudeDir)) return null;
+  try {
+    const registry = join(claudeDir, "plugins", "installed_plugins.json");
+    if (existsSync(registry) && readFileSync(registry, "utf8").includes('"paigy@')) return null;
+  } catch {
+  }
+  return "Claude Code detected \u2014 to add Paigy there, run /plugin marketplace add paigy-ai/mcp then /plugin install paigy (pairing carries over; no need to pair again). Note: If you run this inside a live session, type /reload-plugins afterward so the agent connects to the new tools.";
+}
+var ENABLE_COMMAND = "npx -y -p @paigy/mcp@latest paigy-enable-tools";
+var PROMPTS_ON_PURPOSE = /* @__PURE__ */ new Set(["pair", "unpair"]);
+var PAIGY_TOOL_IDS = [
+  ...TOOL_NAMES.filter((n) => !PROMPTS_ON_PURPOSE.has(n)),
+  ...HIDDEN_ALIASES
+].map((n) => `mcp__paigy__${n}`);
+function withPaigyAllowlist(existing, tools) {
+  let config = {};
+  if (existing) {
+    try {
+      config = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  const permissions = config.permissions && typeof config.permissions === "object" ? config.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? [...permissions.allow] : [];
+  for (const t of tools) if (!allow.includes(t)) allow.push(t);
+  config.permissions = { ...permissions, allow };
+  return JSON.stringify(config, null, 2);
+}
+function settingsPathFor(scope, cwd) {
+  return scope === "project" ? join(cwd, ".claude", "settings.json") : join(homedir(), ".claude", "settings.json");
+}
+function paigyToolsAllowlisted(scope = "user", cwd = process.cwd()) {
+  try {
+    const path = settingsPathFor(scope, cwd);
+    if (!path || !existsSync(path)) return false;
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    const allow = Array.isArray(config.permissions?.allow) ? config.permissions.allow : [];
+    return PAIGY_TOOL_IDS.every((t) => allow.includes(t));
+  } catch {
+    return false;
+  }
+}
+function enablePaigyTools(scope = "user", cwd = process.cwd()) {
+  if (scope === "user" && !existsSync(join(homedir(), ".claude"))) {
+    return {
+      ok: false,
+      reason: `No ~/.claude on this machine \u2014 the hosting tool uses its own permission allowlist. Add these ids there by hand: ${PAIGY_TOOL_IDS.join(", ")}.`
+    };
+  }
+  const path = settingsPathFor(scope, cwd);
+  let existing = null;
+  try {
+    existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+  } catch {
+    existing = null;
+  }
+  let prevAllow = [];
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing);
+      if (Array.isArray(parsed.permissions?.allow)) prevAllow = parsed.permissions.allow;
+    } catch {
+      return { ok: false, reason: `${path} didn't parse as JSON \u2014 not overwriting it. Add the ids by hand.` };
+    }
+  }
+  const updated = withPaigyAllowlist(existing, PAIGY_TOOL_IDS);
+  if (updated === null) return { ok: false, reason: `${path} didn't parse as JSON \u2014 not overwriting it. Add the ids by hand.` };
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, updated + "\n");
+  } catch (e) {
+    return { ok: false, reason: `Couldn't write ${path}: ${e.message}` };
+  }
+  return {
+    ok: true,
+    path,
+    added: PAIGY_TOOL_IDS.filter((t) => !prevAllow.includes(t)),
+    already: PAIGY_TOOL_IDS.filter((t) => prevAllow.includes(t))
+  };
+}
+
+export {
+  SERVER_INSTRUCTIONS,
+  AwaitReplySchema,
+  OnboardSchema,
+  PairSchema,
+  GetThreadSchema,
+  SearchThreadsSchema,
+  SetTaskStateToolSchema,
+  AnswerCallerQuestionSchema,
+  TOOLS,
+  openBrowser,
+  autoConfigureClients,
+  claudeInstallHint,
+  ENABLE_COMMAND,
+  PAIGY_TOOL_IDS,
+  paigyToolsAllowlisted,
+  enablePaigyTools
+};

package/dist/enable.js

@@ -2,8 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-KNMI3CJ3.js";
-import "./chunk-U6SLIORK.js";
+} from "./chunk-XIPO3U6I.js";
+import "./chunk-WNE6STMA.js";
+import "./chunk-PRC6GKRN.js";
 
 // src/enable.ts
 function main() {