runline 0.37.0 → 0.38.0

package/dist/plugins/microsoftMail/src/index.js

@@ -1,27 +1,210 @@
-import { graphRequest, microsoftCredential, microsoftOAuth, userBase, } from "../../_shared/microsoftAuth.js";
+/**
+ * Microsoft Outlook mail plugin for runline (Microsoft Graph).
+ *
+ * Auth: Microsoft identity platform OAuth2 (delegated, acts as the signed-in
+ * user → /me) seeded by the OAuth flow; or app-only client credentials
+ * (set tenantId/clientId/clientSecret + userUpn) for an unattended service
+ * mailbox. Delegated consent belongs to the "microsoft" grant, so one Entra
+ * app and one cached token serve every Microsoft plugin. See
+ * _shared/microsoftAuth.ts.
+ *
+ * Graph delegated scopes: Mail.Send, Mail.ReadWrite, Mail.Read.
+ *
+ * Attachments follow Graph's two documented paths: a file under 3 MB goes
+ * in one request with its message (or one POST to a draft); a file of 3 to
+ * 150 MB is attached to a draft through an upload session, its bytes PUT
+ * in ranges under 4 MB to the session's pre-authenticated Outlook URL. A
+ * message built as a draft is sent once every file is attached, and the
+ * draft is deleted if any step fails.
+ */
+import { jsonAnswer, pathSegment, } from "runline";
+import * as t from "typebox";
+import { attachmentFile, attachmentSources, } from "../../_shared/attachments.js";
+import { graphFailed, graphRequest, graphResponse, microsoftCredential, microsoftOAuth, outlookUpload, userBase, } from "../../_shared/microsoftAuth.js";
 const NAME = "microsoftMail";
 const SCOPES = [
     "https://graph.microsoft.com/Mail.Send",
     "https://graph.microsoft.com/Mail.ReadWrite",
     "https://graph.microsoft.com/Mail.Read",
 ];
-const recipients = (addrs) => (Array.isArray(addrs) ? addrs : addrs ? [addrs] : []).map((a) => ({
-    emailAddress: { address: a },
+/** Graph attaches a file in one request only under 3 MB. */
+const ONE_REQUEST_BYTES = 3 * 1024 * 1024;
+/** Graph's ceiling for one file attachment, through an upload session. */
+const MAX_ATTACHMENT_BYTES = 150 * 1024 * 1024;
+/** Upload session ranges stay under Graph's 4 MB guidance. */
+const UPLOAD_RANGE_BYTES = 3 * 1024 * 1024;
+const STRICT = { additionalProperties: false };
+const Id = (description) => t.String({ minLength: 1, ...(description ? { description } : {}) });
+const Addresses = (description, minItems = 0) => t.Array(t.String({ minLength: 1 }), {
+    description,
+    ...(minItems ? { minItems } : {}),
+});
+const Attachments = t.Array(t.Union([
+    ...attachmentSources("Up to 150 MB a file; Exchange limits a whole message to 35 MB unless the tenant raises it."),
+]), { minItems: 1 });
+/** What mail.send and mail.draft compose a message from. */
+const compose = {
+    to: t.Optional(Addresses("Recipient addresses")),
+    cc: t.Optional(Addresses("Cc addresses")),
+    bcc: t.Optional(Addresses("Bcc addresses")),
+    replyTo: t.Optional(Addresses("Reply-To addresses")),
+    subject: t.String(),
+    body: t.String(),
+    html: t.Optional(t.Boolean({ description: "body is HTML (default plain text)" })),
+    importance: t.Optional(t.Union([t.Literal("low"), t.Literal("normal"), t.Literal("high")])),
+    attachments: t.Optional(Attachments),
+};
+const send = t.Object({ ...compose, to: Addresses("Recipient addresses", 1) }, STRICT);
+const draft = t.Object(compose, STRICT);
+const byId = t.Object({ id: Id("Message id") }, STRICT);
+const SendNow = t.Optional(t.Boolean({
+    description: "Send at once (default); false keeps the draft and returns it",
 }));
-function toMessage(input) {
+const reply = t.Object({
+    id: Id("The message to reply to"),
+    comment: t.Optional(t.String({ description: "Text of the reply" })),
+    replyAll: t.Optional(t.Boolean({ description: "Reply to the sender and every recipient" })),
+    attachments: t.Optional(Attachments),
+    send: SendNow,
+}, STRICT);
+const forward = t.Object({
+    id: Id("The message to forward"),
+    to: Addresses("Recipient addresses", 1),
+    comment: t.Optional(t.String({ description: "Text above the message" })),
+    attachments: t.Optional(Attachments),
+    send: SendNow,
+}, STRICT);
+const list = t.Object({
+    search: t.Optional(Id("KQL search across the mailbox")),
+    top: t.Optional(t.Integer({ minimum: 1, description: "Default 20" })),
+}, STRICT);
+const attachmentAdd = t.Object({
+    messageId: Id("A draft message"),
+    attachment: t.Union([
+        ...attachmentSources("Up to 150 MB; Exchange limits a whole message to 35 MB unless the tenant raises it."),
+    ]),
+}, STRICT);
+const attachmentList = t.Object({ messageId: Id() }, STRICT);
+const attachmentRef = t.Object({ messageId: Id(), attachmentId: Id("From attachment.list") }, STRICT);
+const recipients = (addresses) => (addresses ?? []).map((address) => ({ emailAddress: { address } }));
+function graph(ctx, method, path, body) {
+    return graphRequest(ctx, NAME, SCOPES, method, path, body);
+}
+const messagePath = (ctx, id) => `${userBase(ctx)}/messages/${pathSegment(id)}`;
+/** Every attachment's bytes, named, before any request. */
+function files(inputs = []) {
+    return Promise.all(inputs.map(async (input, index) => {
+        const file = await attachmentFile(input, index, {
+            plugin: NAME,
+            maxBytes: MAX_ATTACHMENT_BYTES,
+            oversize: `${NAME}: attachment ${index} exceeds Graph's 150 MB attachment limit`,
+        });
+        return { ...file, name: file.name ?? `attachment-${index + 1}`, input };
+    }));
+}
+/** Whether the files ride in the same request as their message. */
+const oneRequest = (all) => all.reduce((sum, file) => sum + file.bytes.length, 0) < ONE_REQUEST_BYTES;
+/** Graph's fileAttachment, for a file sent in one request. */
+function fileAttachment(file) {
     return {
-        subject: input.subject,
-        body: {
-            contentType: input.html ? "HTML" : "Text",
-            content: input.body ?? "",
+        "@odata.type": "#microsoft.graph.fileAttachment",
+        name: file.name,
+        contentBytes: file.bytes.toString("base64"),
+        ...(file.mimeType ? { contentType: file.mimeType } : {}),
+        ...(file.input.inline !== undefined ? { isInline: file.input.inline } : {}),
+        ...(file.input.contentId ? { contentId: file.input.contentId } : {}),
+    };
+}
+/** The attachment id in an upload session's final Location header. */
+const LOCATION_ID = /Attachments\('([^']+)'\)/;
+/**
+ * Attach one file of 3 to 150 MB through an upload session: its ranges
+ * PUT in order, each checked against the range the session expects next.
+ * A failed upload deletes the session.
+ */
+async function uploadSession(ctx, messageId, file) {
+    const session = await graph(ctx, "POST", `${messagePath(ctx, messageId)}/attachments/createUploadSession`, {
+        AttachmentItem: {
+            attachmentType: "file",
+            name: file.name,
+            size: file.bytes.length,
+            ...(file.mimeType ? { contentType: file.mimeType } : {}),
+            ...(file.input.inline !== undefined
+                ? { isInline: file.input.inline }
+                : {}),
+            ...(file.input.contentId ? { contentId: file.input.contentId } : {}),
         },
-        toRecipients: recipients(input.to),
-        ccRecipients: recipients(input.cc),
+    });
+    const total = file.bytes.length;
+    try {
+        for (let start = 0; start < total; start += UPLOAD_RANGE_BYTES) {
+            const end = Math.min(start + UPLOAD_RANGE_BYTES, total);
+            const res = await outlookUpload(session.uploadUrl, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                    "Content-Range": `bytes ${start}-${end - 1}/${total}`,
+                },
+                body: file.bytes.subarray(start, end),
+            });
+            if (!res.ok)
+                throw await graphFailed(NAME, res);
+            if (end === total)
+                return LOCATION_ID.exec(res.headers.get("location") ?? "")?.[1];
+            const { nextExpectedRanges } = await jsonAnswer(res);
+            const next = nextExpectedRanges?.[0]?.split("-")[0];
+            if (next !== undefined && Number(next) !== end)
+                throw new Error(`${NAME}: the upload session expects byte ${next}, not ${end}`);
+        }
+    }
+    catch (error) {
+        await outlookUpload(session.uploadUrl, { method: "DELETE" }).catch(() => undefined);
+        throw error;
+    }
+    return undefined;
+}
+/** Attach one file to a draft, by the path its size takes. */
+async function attach(ctx, messageId, file) {
+    const id = file.bytes.length < ONE_REQUEST_BYTES
+        ? (await graph(ctx, "POST", `${messagePath(ctx, messageId)}/attachments`, fileAttachment(file))).id
+        : await uploadSession(ctx, messageId, file);
+    return { ...(id ? { id } : {}), name: file.name, size: file.bytes.length };
+}
+/**
+ * Finish a draft this call created: attach its files, then send it or
+ * hand it back. Any failure deletes the draft, so no half-built message
+ * is left in Drafts.
+ */
+async function finishDraft(ctx, created, pending, sendIt) {
+    try {
+        for (const file of pending)
+            await attach(ctx, created.id, file);
+        if (!sendIt)
+            return { id: created.id, webLink: created.webLink };
+        await graph(ctx, "POST", `${messagePath(ctx, created.id)}/send`);
+        return { success: true };
+    }
+    catch (error) {
+        await graph(ctx, "DELETE", messagePath(ctx, created.id)).catch(() => undefined);
+        throw error;
+    }
+}
+/** A Graph message from compose fields, with the files that ride along. */
+function message(p, attached) {
+    return {
+        subject: p.subject,
+        body: { contentType: p.html ? "HTML" : "Text", content: p.body },
+        toRecipients: recipients(p.to),
+        ccRecipients: recipients(p.cc),
+        ...(p.bcc ? { bccRecipients: recipients(p.bcc) } : {}),
+        ...(p.replyTo ? { replyTo: recipients(p.replyTo) } : {}),
+        ...(p.importance ? { importance: p.importance } : {}),
+        ...(attached.length ? { attachments: attached.map(fileAttachment) } : {}),
     };
 }
 export default function microsoftMail(rl) {
     rl.setName(NAME);
-    rl.setVersion("1.0.0");
+    rl.setVersion("1.1.0");
     rl.setCredential(microsoftCredential(NAME, SCOPES));
     rl.setConnectionSchema({
         authMethod: {
@@ -63,76 +246,144 @@ export default function microsoftMail(rl) {
     rl.setOAuth(microsoftOAuth(SCOPES, "Mail.Send, Mail.ReadWrite, Mail.Read"));
     rl.registerAction("mail.send", {
         access: "write",
-        description: "Send an email as the connected mailbox. Returns {success}. Get user approval before sending external mail.",
-        inputSchema: {
-            to: {
-                type: "array",
-                required: true,
-                description: "Recipient address(es)",
-            },
-            subject: { type: "string", required: true },
-            body: { type: "string", required: true },
-            cc: { type: "array", required: false },
-            html: {
-                type: "boolean",
-                required: false,
-                description: "Body is HTML (default plain text)",
-            },
+        description: "Send an email as the connected mailbox, with attachments. Returns {success}. Get user approval before sending external mail.",
+        inputSchema: send,
+        async execute(input, ctx) {
+            const p = input;
+            const all = await files(p.attachments);
+            if (oneRequest(all)) {
+                await graph(ctx, "POST", `${userBase(ctx)}/sendMail`, {
+                    message: message(p, all),
+                    saveToSentItems: true,
+                });
+                return { success: true };
+            }
+            const created = await graph(ctx, "POST", `${userBase(ctx)}/messages`, message(p, []));
+            return finishDraft(ctx, created, all, true);
         },
+    });
+    rl.registerAction("mail.draft", {
+        access: "write",
+        description: "Create a draft email, with attachments (not sent). Returns {id, webLink}; draft.send sends it.",
+        inputSchema: draft,
         async execute(input, ctx) {
-            await graphRequest(ctx, NAME, SCOPES, "POST", `${userBase(ctx)}/sendMail`, {
-                message: toMessage(input),
-                saveToSentItems: true,
-            });
+            const p = input;
+            const all = await files(p.attachments);
+            const together = oneRequest(all);
+            const created = await graph(ctx, "POST", `${userBase(ctx)}/messages`, message(p, together ? all : []));
+            return finishDraft(ctx, created, together ? [] : all, false);
+        },
+    });
+    rl.registerAction("draft.send", {
+        access: "write",
+        description: "Send a draft message. Returns {success}.",
+        inputSchema: byId,
+        async execute(input, ctx) {
+            const { id } = input;
+            await graph(ctx, "POST", `${messagePath(ctx, id)}/send`);
             return { success: true };
         },
     });
-    rl.registerAction("mail.draft", {
+    rl.registerAction("mail.reply", {
         access: "write",
-        description: "Create a draft email (not sent). Returns {id, webLink}.",
-        inputSchema: {
-            to: { type: "array", required: false },
-            subject: { type: "string", required: true },
-            body: { type: "string", required: true },
-            cc: { type: "array", required: false },
-            html: { type: "boolean", required: false },
+        description: "Reply to a message, or with replyAll to everyone on it, with attachments. Returns {success}, or {id, webLink} of the draft when send is false.",
+        inputSchema: reply,
+        async execute(input, ctx) {
+            const p = input;
+            const all = await files(p.attachments);
+            const created = await graph(ctx, "POST", `${messagePath(ctx, p.id)}/${p.replyAll ? "createReplyAll" : "createReply"}`, p.comment === undefined ? {} : { comment: p.comment });
+            return finishDraft(ctx, created, all, p.send ?? true);
         },
+    });
+    rl.registerAction("mail.forward", {
+        access: "write",
+        description: "Forward a message to more people, with attachments. Returns {success}, or {id, webLink} of the draft when send is false.",
+        inputSchema: forward,
         async execute(input, ctx) {
-            const r = await graphRequest(ctx, NAME, SCOPES, "POST", `${userBase(ctx)}/messages`, toMessage(input));
-            return { id: r.id, webLink: r.webLink };
+            const p = input;
+            const all = await files(p.attachments);
+            const created = await graph(ctx, "POST", `${messagePath(ctx, p.id)}/createForward`, {
+                toRecipients: recipients(p.to),
+                ...(p.comment === undefined ? {} : { comment: p.comment }),
+            });
+            return finishDraft(ctx, created, all, p.send ?? true);
         },
     });
     rl.registerAction("mail.list", {
         access: "read",
-        description: "List recent messages. Optional KQL search. Returns [{id,subject,from,receivedDateTime,bodyPreview,hasAttachments}].",
-        inputSchema: {
-            search: {
-                type: "string",
-                required: false,
-                description: "KQL search across the mailbox",
-            },
-            top: { type: "number", required: false, default: 20 },
-        },
+        description: "List recent messages, or search with KQL (results come newest first). Returns [{id,subject,from,receivedDateTime,bodyPreview,hasAttachments}].",
+        inputSchema: list,
         async execute(input, ctx) {
             const p = input;
             const qs = new URLSearchParams({
                 $top: String(p.top ?? 20),
                 $select: "id,subject,from,receivedDateTime,bodyPreview,hasAttachments",
-                $orderby: "receivedDateTime desc",
             });
             if (p.search)
                 qs.set("$search", `"${p.search}"`);
-            const r = await graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/messages?${qs}`);
+            else
+                qs.set("$orderby", "receivedDateTime desc");
+            const r = await graph(ctx, "GET", `${userBase(ctx)}/messages?${qs}`);
             return r.value;
         },
     });
     rl.registerAction("mail.get", {
         access: "read",
-        description: "Get one message with full body by id.",
-        inputSchema: { id: { type: "string", required: true } },
+        description: "Get one message with full body by id. Its files are listed by attachment.list.",
+        inputSchema: byId,
+        async execute(input, ctx) {
+            const { id } = input;
+            return graph(ctx, "GET", messagePath(ctx, id));
+        },
+    });
+    rl.registerAction("attachment.add", {
+        access: "write",
+        description: "Attach a file to a draft message. Returns {id, name, size}.",
+        inputSchema: attachmentAdd,
+        async execute(input, ctx) {
+            const p = input;
+            const [file] = await files([p.attachment]);
+            return attach(ctx, p.messageId, file);
+        },
+    });
+    rl.registerAction("attachment.list", {
+        access: "read",
+        description: "List a message's attachments. Returns [{id,name,contentType,size,isInline}].",
+        inputSchema: attachmentList,
+        async execute(input, ctx) {
+            const { messageId } = input;
+            const r = await graph(ctx, "GET", `${messagePath(ctx, messageId)}/attachments?$select=id,name,contentType,size,isInline`);
+            return r.value;
+        },
+    });
+    rl.registerAction("attachment.get", {
+        access: "read",
+        description: "Download one file attachment. Returns {name, mimeType, size, contentBase64}, accepted as-is as an attachment by mail plugins. A link (reference) attachment has no bytes and fails with HTTP 405.",
+        inputSchema: attachmentRef,
         async execute(input, ctx) {
             const p = input;
-            return graphRequest(ctx, NAME, SCOPES, "GET", `${userBase(ctx)}/messages/${encodeURIComponent(p.id)}`);
+            const path = `${messagePath(ctx, p.messageId)}/attachments/${pathSegment(p.attachmentId)}`;
+            const meta = await graph(ctx, "GET", `${path}?$select=name,contentType`);
+            const res = await graphResponse(ctx, NAME, SCOPES, "GET", `${path}/$value`, undefined, undefined, "*/*");
+            if (!res.ok)
+                throw await graphFailed(NAME, res);
+            const bytes = Buffer.from(await res.arrayBuffer());
+            return {
+                ...(meta.name ? { name: meta.name } : {}),
+                ...(meta.contentType ? { mimeType: meta.contentType } : {}),
+                size: bytes.length,
+                contentBase64: bytes.toString("base64"),
+            };
+        },
+    });
+    rl.registerAction("attachment.delete", {
+        access: "write",
+        description: "Remove an attachment from a draft message. Returns {success}.",
+        inputSchema: attachmentRef,
+        async execute(input, ctx) {
+            const p = input;
+            await graph(ctx, "DELETE", `${messagePath(ctx, p.messageId)}/attachments/${pathSegment(p.attachmentId)}`);
+            return { success: true };
         },
     });
 }

package/dist/plugins/todoist/src/credentials.js

@@ -1,24 +1,17 @@
 import { staticCredential } from "runline";
-/**
- * An API token, sent as a bearer to Todoist's REST v2 and Sync v9
- * surfaces on the one API origin.
- */
+/** An API token, sent as a bearer to Todoist's unified API v1. */
 export const todoistCredential = staticCredential({
     id: "todoist",
     auth: { kind: "bearer" },
     local: { secret: "apiToken" },
     targets: {
-        rest: {
-            baseUrl: "https://api.todoist.com/rest/v2/",
+        api: {
+            baseUrl: "https://api.todoist.com/api/v1/",
             methods: ["GET", "POST", "DELETE"],
         },
-        sync: {
-            baseUrl: "https://api.todoist.com/sync/v9/",
-            methods: ["POST"],
-        },
     },
     probe: {
-        target: "rest",
+        target: "api",
         path: "projects",
         method: "GET",
         acceptedStatuses: [200],