@atomicmail/mcp 0.1.0 → 0.2.1

package/esm/mcp/src/tools/jmap.js

@@ -1,202 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-import { z } from "zod";
-const DEFAULT_USING = [
-    "urn:ietf:params:jmap:core",
-    "urn:ietf:params:jmap:mail",
-];
-function parseEnvelope(raw, defaultUsing, source) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`${source} is not valid JSON: ${err.message}`);
-    }
-    if (Array.isArray(value)) {
-        return { using: defaultUsing, methodCalls: value };
-    }
-    if (value !== null &&
-        typeof value === "object" &&
-        Array.isArray(value.methodCalls)) {
-        const obj = value;
-        const using = Array.isArray(obj.using)
-            ? obj.using.filter((u) => typeof u === "string")
-            : defaultUsing;
-        return { using, methodCalls: obj.methodCalls };
-    }
-    throw new Error(`${source} must be a methodCalls array, e.g. ` +
-        '[["Mailbox/get",{...},"m0"]], or an object with a methodCalls array.');
-}
-export function registerJmapTool(server, session) {
-    const apiUrl = session.apiUrl;
-    server.registerTool("jmap_request", {
-        title: "Send a JMAP request",
-        description: "Send a JMAP request to your AtomicMail inbox. Auth (session and " +
-            "capability JWT rotation) is handled automatically — just provide " +
-            "the JMAP method calls.\n\n" +
-            "Provide exactly one request body:\n" +
-            "  • methodCalls — inline JMAP batch, an array of " +
-            "[methodName, args, callId] entries.\n" +
-            "  • opsFile     — path to a saved JSON preset. Relative paths " +
-            "resolve against the credential directory (the same directory " +
-            "the skill's --ops-file flag uses), so common requests can be " +
-            "saved once and reused.\n\n" +
-            "Tip: call jmap_session first to discover your accountId.\n\n" +
-            "Examples:\n" +
-            '  methodCalls: [["Mailbox/get", {"accountId": "..."}, "m0"]]\n' +
-            '  methodCalls: [["Email/query", {"accountId": "...", "filter": {"inMailbox": "..."}}, "q0"]]\n' +
-            "  opsFile:     fetch_last_100.json",
-        inputSchema: z.object({
-            using: z
-                .array(z.string())
-                .default(DEFAULT_USING)
-                .describe("JMAP capability URNs. Defaults to core + mail. Add " +
-                '"urn:ietf:params:jmap:submission" when sending email. ' +
-                "Ignored if the file/inline body already sets a 'using' field."),
-            methodCalls: z
-                .array(z.json())
-                .optional()
-                .describe("Inline JMAP method calls array. Each entry is " +
-                '[methodName, args, callId], e.g. ["Mailbox/get", {"accountId": "abc"}, "m0"]. ' +
-                "Mutually exclusive with opsFile."),
-            opsFile: z
-                .string()
-                .optional()
-                .describe("Path to a saved JMAP preset file. Relative paths resolve " +
-                "against the credential directory. The file may contain " +
-                "either a methodCalls array or a full {using, methodCalls} " +
-                "envelope. Mutually exclusive with methodCalls."),
-        }),
-    }, async ({ using, methodCalls, opsFile }) => {
-        try {
-            if (methodCalls && opsFile) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "methodCalls and opsFile are mutually exclusive — provide one.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            let envelope;
-            if (opsFile) {
-                const filePath = isAbsolute(opsFile)
-                    ? opsFile
-                    : resolvePath(session.credentialDir, opsFile);
-                let raw;
-                try {
-                    raw = await readFile(filePath, "utf-8");
-                }
-                catch (err) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Could not read opsFile '${filePath}': ${err.message}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                envelope = parseEnvelope(raw, using, `opsFile '${filePath}'`);
-            }
-            else if (methodCalls) {
-                envelope = { using, methodCalls };
-            }
-            else {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Provide either methodCalls or opsFile.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const capabilityJWT = await session.getCapabilityToken();
-            const res = await fetch(`${apiUrl}/jmap/`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${capabilityJWT}`,
-                },
-                body: JSON.stringify(envelope),
-            });
-            const text = await res.text();
-            if (!res.ok) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `JMAP request failed (HTTP ${res.status}): ${text}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: "text", text }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `JMAP request error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    server.registerTool("jmap_session", {
-        title: "Get JMAP session",
-        description: "Fetch the JMAP session object via GET /.well-known/jmap. Returns " +
-            "your accountId, capabilities, and mailbox discovery URLs. Call " +
-            "this first to learn your accountId before issuing jmap_request " +
-            "method calls.",
-        inputSchema: {},
-        annotations: {
-            readOnlyHint: true,
-            idempotentHint: true,
-        },
-    }, async () => {
-        try {
-            const capabilityJWT = await session.getCapabilityToken();
-            const res = await fetch(`${apiUrl}/.well-known/jmap`, {
-                headers: { Authorization: `Bearer ${capabilityJWT}` },
-            });
-            const text = await res.text();
-            if (!res.ok) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Session fetch failed (HTTP ${res.status}): ${text}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: "text", text }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Session fetch error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-}

package/esm/mcp/src/tools/register.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/mcp/src/tools/register.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,WAAW,GACnB,IAAI,CAuFN"}

package/esm/mcp/src/tools/register.js

@@ -1,79 +0,0 @@
-import { z } from "zod";
-export function registerRegisterTool(server, session) {
-    server.registerTool("register", {
-        title: "Register a new AtomicMail inbox",
-        description: "Create a new AtomicMail account. Performs a Proof-of-Work signup, " +
-            "fetches the first session and capability JWTs, and writes " +
-            "credentials.json + session.jwt + capability.jwt into the " +
-            "configured credential directory. After this returns, the agent " +
-            "can immediately call jmap_session and jmap_request without any " +
-            "further setup. Idempotent guard: if an API key is already " +
-            "configured, this tool will refuse to register a second account.",
-        inputSchema: z.object({
-            username: z
-                .string()
-                .min(1)
-                .describe("Desired username for the new inbox. Becomes the local-part of your email address."),
-        }),
-        annotations: {
-            idempotentHint: false,
-            destructiveHint: false,
-        },
-    }, async ({ username }) => {
-        try {
-            if (session.hasApiKey) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "An API key is already configured for this MCP server. " +
-                                "Refusing to register a second account. Use jmap_request " +
-                                "to interact with your existing inbox, or remove " +
-                                "credentials.json (and unset ATOMIC_MAIL_API_KEY) before " +
-                                "registering a new one.",
-                        },
-                    ],
-                };
-            }
-            const { apiKey, inboxId } = await session.signup(username);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `Account created successfully for "${username}".`,
-                            "",
-                            `Inbox ID:  ${inboxId}`,
-                            `API Key:   ${apiKey}`,
-                            "",
-                            "Credentials persisted to:",
-                            `  ${session.files.credentialsFile}`,
-                            `  ${session.files.sessionFile}`,
-                            `  ${session.files.capabilityFile}`,
-                            "",
-                            "IMPORTANT: The API key is stored in credentials.json above. " +
-                                "Treat that file as a secret (mode 0600). To re-use this " +
-                                "account from another machine or a fresh MCP host, copy " +
-                                "credentials.json over, or set ATOMIC_MAIL_API_KEY in the " +
-                                "new environment.",
-                            "",
-                            "You are now logged in. Call jmap_session next to discover " +
-                                "your accountId, then use jmap_request for all email operations.",
-                        ].join("\n"),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Registration failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-}