@paigy/mcp 0.8.2 → 0.8.5

package/README.md

@@ -102,6 +102,27 @@ Then pair: `npx -p @paigy/mcp@latest paigy-mcp-onboard`.
 
 - `PAIGY_BACKEND_URL` — the Paigy API base (defaults to the hosted backend).
 
+## Statusline (Claude Code)
+
+`paigy-statusline` prints a one-line connection status — the account's session
+mode and whether a phone is paired — for Claude Code's status bar:
+
+```
+paigy: all calls · phone ✓
+```
+
+Enable it in `~/.claude/settings.json`:
+
+```json
+"statusLine": { "type": "command", "command": "npx -y @paigy/mcp@latest paigy-statusline" }
+```
+
+It reads `GET /api/status` with the pairing token and caches the result in
+`~/.paigy/status.json` for 60 seconds, so the bar's constant refreshes never
+hammer the API; when offline it shows the last known state. `paigy: unpaired`
+means there's no token (or the pairing was revoked) — run `/paigy-onboard` to
+pair; `paigy: …` means the status isn't known yet (first run while offline).
+
 ## Publishing (maintainers)
 
 Tool input schemas are generated from zod in `src/schema.ts` as draft-2020-12 JSON

package/dist/{chunk-BUELEUTV.js → chunk-FDJFLJHR.js}

@@ -162,7 +162,8 @@ var SnoozeRequestSchema = z.object({
 var PushTokenSchema = z.object({
   voipToken: z.string().min(1).optional(),
   alertToken: z.string().min(1).optional(),
-  platform: z.literal("ios")
+  fcmToken: z.string().min(1).optional(),
+  platform: z.enum(["ios", "android"])
 });
 var MissedCallSchema = z.enum([
   "retry_10m",
@@ -185,7 +186,14 @@ var UserSettingsSchema = z.object({
   autoCallback: z.boolean(),
   /** Opt-in (default false) to using your content to improve Paigy and train models. */
   improveConsent: z.boolean(),
-  missedCall: MissedCallSchema.default("backoff_standard")
+  missedCall: MissedCallSchema.default("backoff_standard"),
+  /** Where voice audio is processed. 'hosted' (default) = Paigy's voice services
+   *  (ElevenLabs TTS, faster-whisper STT, the call bot); 'on_device' = the phone
+   *  synthesizes and transcribes locally — no audio or spoken text leaves it.
+   *  Optional, NOT defaulted: a stale client PATCHing the full settings object
+   *  must not silently reset this privacy choice. Absent = leave unchanged on
+   *  write, 'hosted' on read (see store.ts). */
+  voiceMode: z.enum(["hosted", "on_device"]).optional()
 });
 var HistoryItemSchema = z.object({
   id: z.string(),
@@ -236,6 +244,13 @@ var DeliveryConfigSchema = z.object({
    *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
   realtime: z.object({ url: z.string(), anonKey: z.string() }).nullable()
 });
+var StatusSchema = z.object({
+  agent: z.string(),
+  nickname: z.string(),
+  sessionMode: z.enum(["default", "all_calls", "silent"]),
+  /** A phone is registered for push/ring (any push token on the account). */
+  phone: z.boolean()
+});
 var WakeNudgeSchema = z.object({
   kind: z.enum(["reply", "request", "callback"]),
   notificationId: z.string().optional(),

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   scheduleCallback,
   setTaskState,
   submitNotification
-} from "./chunk-BUELEUTV.js";
+} from "./chunk-FDJFLJHR.js";
 import {
   deleteToken,
   openBrowser,
@@ -99,7 +99,7 @@ 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. 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 open-ended free text only for answers that genuinely can't be structured (the user can always add free text on top of any shape). 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. 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."
+    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. 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 open-ended free text only for answers that genuinely can't be structured (the user can always add free text on top of any shape). 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. 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 text or call 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."
   }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({

package/dist/listen.js

@@ -4,7 +4,7 @@ import {
   checkReplies,
   registerDelivery,
   wakeChannel
-} from "./chunk-BUELEUTV.js";
+} from "./chunk-FDJFLJHR.js";
 import "./chunk-GU7C5H6L.js";
 
 // src/listen.ts

package/dist/statusline.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import {
+  readToken
+} from "./chunk-AILC3H3U.js";
+import {
+  BACKEND_URL
+} from "./chunk-GU7C5H6L.js";
+
+// src/statusline.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DIR = join(homedir(), ".paigy");
+var CACHE = join(DIR, "status.json");
+var TTL_MS = 6e4;
+var MODE_LABEL = {
+  default: "default",
+  all_calls: "all calls",
+  silent: "silent"
+};
+function render(status) {
+  if (!status) return "paigy: unpaired";
+  return `paigy: ${MODE_LABEL[status.sessionMode]} \xB7 ${status.phone ? "phone \u2713" : "no phone"}`;
+}
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(CACHE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function fetchStatus(token) {
+  const res = await fetch(`${BACKEND_URL}/api/status`, {
+    headers: { authorization: `Bearer ${token}` },
+    signal: AbortSignal.timeout(2e3)
+    // a statusline must render fast or not at all
+  });
+  if (res.status === 401) return null;
+  if (res.status === 404) {
+    if ((await res.text()).includes("not_found")) return null;
+    throw new Error("status 404");
+  }
+  if (!res.ok) throw new Error(`status ${res.status}`);
+  return await res.json();
+}
+async function main() {
+  const token = readToken();
+  if (!token) return render(null);
+  const cached = readCache();
+  if (cached && Date.now() - cached.at < TTL_MS) return render(cached.status);
+  try {
+    const status = await fetchStatus(token);
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(CACHE, JSON.stringify({ at: Date.now(), status }));
+    return render(status);
+  } catch {
+    return cached ? render(cached.status) : "paigy: \u2026";
+  }
+}
+if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/^file:\/\//, ""))) {
+  void main().then((line) => console.log(line));
+}
+export {
+  main,
+  render
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "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",
@@ -8,7 +8,8 @@
     "mcp": "./dist/index.js",
     "paigy-mcp": "./dist/index.js",
     "paigy-mcp-onboard": "./dist/onboard.js",
-    "paigy-listen": "./dist/listen.js"
+    "paigy-listen": "./dist/listen.js",
+    "paigy-statusline": "./dist/statusline.js"
   },
   "files": [
     "dist"
@@ -35,8 +36,8 @@
     "@paigy/schema": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/onboard.ts src/listen.ts --format esm --clean",
-    "dev": "tsup src/index.ts src/onboard.ts src/listen.ts --format esm --watch",
+    "build": "tsup src/index.ts src/onboard.ts src/listen.ts src/statusline.ts --format esm --clean",
+    "dev": "tsup src/index.ts src/onboard.ts src/listen.ts src/statusline.ts --format esm --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }