@formstr/mcp 0.6.0 → 0.7.0

package/README.md

@@ -236,17 +236,26 @@ Email through mailstr, using the same identity you logged in with (the account t
 
 - `list_mail` — your inbox: sender, subject, date per message (kind-1059 gift-wrapped mail).
 - `read_mail` — the full body of one message by its id.
-- `who_is_my_mail_address` — the account's mail address (NIP-05) and pubkey.
+- `list_mail_aliases` — every address (NIP-05 alias) this account can send as, and the default.
+- `who_is_my_mail_address` — the signed-in identity, its default `From:`, and its aliases.
 
 **Gated (require `--allow-writes` + `confirm: true`)**
 
 - `send_mail` — send email to an npub/hex key, or an external address via the domain's SMTP bridge.
+  Pass `from` to choose which alias to send as (one of your own addresses); omit it to send from
+  an owned alias, or the npub mailbox when you have none. A `from` you do not own is rejected with
+  the list of valid senders.
 - `claim_mailbox` — start claiming `you@mailstr.app`. Returns a **Lightning invoice to pay in
   your own wallet** — the server holds no wallet, so it cannot pay it. Mail works once NIP-05
   propagates.
 - `publish_mail_setup` — publish your profile (with the NIP-05 address) and the kind-10050
   delivery-relay list senders read.
 
+**Aliases.** A mail identity is one Nostr key; an *alias* is a NIP-05 name bound to that key.
+All of an account's aliases share one key and one inbox — mail is encrypted to the key, so which
+alias a message was addressed to is only a header. `send_mail`'s `from` picks which alias appears
+in the `From:`; `list_mail_aliases` shows the choices.
+
 ## Safety model
 
 Destructive / outward tools are **not registered** unless `--allow-writes` (or

package/dist/index.js

@@ -33354,6 +33354,64 @@ var defaultFetchJson = async (url, init) => {
     clearTimeout(timer);
   }
 };
+var OWNED_ADDRESSES_PATH = "/api/nip-05/get-nip05";
+function normalizeOwnedAddresses(body, domain = DEFAULT_MAIL_DOMAIN) {
+  const qualify = (addr, entryDomain) => {
+    if (addr.includes("@")) return addr;
+    if (typeof entryDomain === "string" && entryDomain.trim()) return `${addr}@${entryDomain}`;
+    return `${addr}@${domain}`;
+  };
+  if (typeof body === "string") return [qualify(body)];
+  let raw = [];
+  if (Array.isArray(body)) {
+    raw = body.flatMap((entry) => {
+      if (typeof entry === "string") return [{ value: entry }];
+      if (entry && typeof entry === "object") {
+        const obj = entry;
+        if (typeof obj.nip05 === "string") return [{ value: obj.nip05, domain: obj.domain }];
+        if (typeof obj.name === "string") return [{ value: obj.name, domain: obj.domain }];
+      }
+      return [];
+    });
+  } else if (body && typeof body === "object") {
+    const obj = body;
+    if (typeof obj.nip05 === "string") {
+      raw = [{ value: obj.nip05, domain: obj.domain }];
+    } else if (Array.isArray(obj.nip05Addresses)) {
+      raw = obj.nip05Addresses.filter((v) => typeof v === "string").map((value) => ({ value }));
+    }
+  }
+  return raw.map(({ value, domain: d }) => qualify(value, d));
+}
+async function defaultFetch(url, init) {
+  const res = await fetch(url, init);
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { ok: res.ok, status: res.status, body };
+}
+async function fetchAddresses(url, header, opts) {
+  const fetchJson = opts.fetchJson ?? defaultFetch;
+  const res = await fetchJson(url, { method: "GET", headers: { Authorization: header } });
+  if (res.status === 404 || res.status === 401) return [];
+  if (!res.ok) throw new Error(`Address lookup failed (${res.status})`);
+  return normalizeOwnedAddresses(res.body, opts.domain ?? DEFAULT_MAIL_DOMAIN);
+}
+async function fetchOwnedAddressesWith(signer, opts = {}) {
+  const api = (opts.api ?? DEFAULT_CLAIM_API).replace(/\/+$/, "");
+  const url = `${api}${OWNED_ADDRESSES_PATH}`;
+  return fetchAddresses(url, await signNip98With(signer, url, "GET"), opts);
+}
+function defaultFromAddress(pubkey, ownedAddresses) {
+  const isNpubAlias = (a) => {
+    const at = a.indexOf("@");
+    return at > 0 && a.slice(0, at).toLowerCase().startsWith("npub1");
+  };
+  const alias = ownedAddresses.find((a) => !isNpubAlias(a));
+  return alias ?? ownedAddresses[0] ?? `${nip19_exports.npubEncode(pubkey)}@${DEFAULT_MAIL_DOMAIN}`;
+}
 function verifySealAndRumor(wrap, seal, rumor, opts = {}) {
   const maxAge = opts.maxAgeSeconds ?? MAX_RUMOR_AGE_SECONDS;
   const now3 = opts.now ?? Math.floor(Date.now() / 1e3);
@@ -33719,9 +33777,11 @@ async function publishEverywhere(pool, relays, event) {
   };
 }
 
-// ../agent/dist/chunk-ZPXEAOMQ.js
+// ../agent/dist/chunk-5L26ARX5.js
 var service_exports2 = {};
 __export3(service_exports2, {
+  defaultSenderAddress: () => defaultSenderAddress,
+  listAliases: () => listAliases,
   mailIdentity: () => mailIdentity,
   publishMailSetup: () => publishMailSetup,
   readMail: () => readMail,
@@ -33740,6 +33800,15 @@ async function mailIdentity() {
   const profile = await fetchProfile(pubkey).catch(() => null);
   return { pubkey, npub: nip19_exports.npubEncode(pubkey), nip05: profile?.nip05 ?? null };
 }
+async function listAliases() {
+  const signer = await mailSigner();
+  return fetchOwnedAddressesWith(signer).catch(() => []);
+}
+async function defaultSenderAddress() {
+  const signer = await signerManager.getSigner();
+  const pubkey = await signer.getPublicKey();
+  return defaultFromAddress(pubkey, await listAliases());
+}
 async function readMail(opts = {}) {
   const signer = await mailSigner();
   const { mail, failures } = await readInboxWith(signer, {
@@ -33750,12 +33819,13 @@ async function readMail(opts = {}) {
 }
 async function sendMail(params) {
   const signer = await mailSigner();
+  const from = params.from ?? await defaultSenderAddress();
   return sendMailWith(signer, {
     to: params.to,
     ...params.subject !== void 0 ? { subject: params.subject } : {},
     ...params.text !== void 0 ? { text: params.text } : {},
     ...params.raw !== void 0 ? { raw: params.raw } : {},
-    ...params.from !== void 0 ? { from: params.from } : {},
+    from,
     relays: relayManager.getRelaysForModule("mail")
   });
 }
@@ -44700,7 +44770,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../agent/dist/chunk-QX4DSGPL.js
+// ../agent/dist/chunk-JORUNTXB.js
 function ok(text, data) {
   return data !== void 0 ? { ok: true, text, data } : { ok: true, text };
 }
@@ -45956,14 +46026,31 @@ function buildMailTools() {
   server.registerTool(
     "who_is_my_mail_address",
     {
-      description: "Show the mail address (NIP-05) and pubkey of the account currently signed in to this server.",
+      description: "Show the account signed in to this server, its default mail address, and every alias it can send as.",
       inputSchema: {}
     },
     async () => {
       const who = await service_exports2.mailIdentity();
+      const aliases = await service_exports2.listAliases();
+      const defaultFrom = await service_exports2.defaultSenderAddress();
       return ok(
-        who.nip05 ? `Your mail address is ${who.nip05}.` : `Signed in as ${who.npub}. No mailstr address is bound to this key yet \u2014 claim one with claim_mailbox.`,
-        who
+        `Signed in as ${who.npub}. Sending as ${defaultFrom}.` + (aliases.length ? ` Aliases: ${aliases.join(", ")}.` : " No registered alias yet \u2014 claim one with claim_mailbox."),
+        { ...who, aliases, defaultFrom }
+      );
+    }
+  );
+  server.registerTool(
+    "list_mail_aliases",
+    {
+      description: "List every mail address (NIP-05 alias) this account can send as, and which is the default. All aliases share one inbox.",
+      inputSchema: {}
+    },
+    async () => {
+      const aliases = await service_exports2.listAliases();
+      const defaultFrom = await service_exports2.defaultSenderAddress();
+      return ok(
+        aliases.length ? `You can send as ${aliases.length} address(es); default is ${defaultFrom}.` : `No aliases yet \u2014 sending uses ${defaultFrom}. Claim an address with claim_mailbox.`,
+        { aliases, defaultFrom }
       );
     }
   );
@@ -45987,6 +46074,18 @@ function buildMailTools() {
       if (args.text === void 0 && args.raw === void 0) {
         return fail("send_mail needs either `text` or `raw`.", "BAD_INPUT");
       }
+      if (args.from !== void 0) {
+        const identity = await service_exports2.mailIdentity();
+        const aliases = await service_exports2.listAliases();
+        const npubAddress = `${identity.npub}@${DEFAULT_MAIL_DOMAIN}`;
+        const validSenders = [npubAddress, ...aliases];
+        if (!validSenders.map((a) => a.toLowerCase()).includes(args.from.toLowerCase())) {
+          return fail(
+            `You cannot send as "${args.from}". Use one of: ${validSenders.join(", ")}.`,
+            "BAD_SENDER"
+          );
+        }
+      }
       try {
         const result = await service_exports2.sendMail({
           to: args.to,