runline 0.37.0 → 0.39.0

package/dist/plugins/agentMail/src/schemas.js

@@ -1,16 +1,8 @@
 import * as t from "typebox";
-import { DownloadedFile } from "../../_shared/base64.js";
+import { attachmentMetadata, attachmentSources, } from "../../_shared/attachments.js";
 export const STRICT = { additionalProperties: false };
 export const MAX_REQUEST_BYTES = 6_000_000;
 export const id = t.String({ minLength: 1, pattern: "\\S" });
-/**
- * At least one of `fields` must be given: "provide a change", "name a
- * recipient". Keyed off the field record itself, so the rule cannot drift
- * from the fields it governs.
- */
-export function atLeastOne(fields) {
-    return { anyOf: Object.keys(fields).map((key) => ({ required: [key] })) };
-}
 export const inboxFields = {
     inboxId: t.String({
         ...id,
@@ -82,40 +74,11 @@ export const sendFields = {
     })),
 };
 /**
- * Attachment bytes come one way each, named as gmail and googleDrive name
- * them: `contentBase64`, `contentPath`, `content` (UTF-8 text), plus
- * AgentMail's own `url`. A googleDrive download result passes straight
- * through as `contentBase64`.
+ * Attachment bytes come one way each, as every mail plugin takes them,
+ * plus AgentMail's own `url`, which AgentMail fetches itself.
  */
-const attachmentMetadata = {
-    name: t.Optional(t.String({ ...id, description: "File name; defaults to the path's name." })),
-    mimeType: t.Optional(t.String({ ...id, description: "MIME type, e.g. application/pdf." })),
-    inline: t.Optional(t.Boolean({
-        description: "Embed in the HTML body, referenced as cid:<contentId>, instead of attaching.",
-    })),
-    contentId: t.Optional(t.String({ ...id, description: "Content-ID for inline images." })),
-};
-const SIZE_NOTE = "The entire serialized request is limited to 6 MB; use url for larger files.";
 export const attachment = t.Union([
-    t.Object({
-        ...attachmentMetadata,
-        contentBase64: t.Union([t.String(), DownloadedFile], {
-            description: `Base64 bytes (standard or base64url; padding and whitespace normalized), or a googleDrive.file.download result, whose name and mimeType are used when not given here. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
-    t.Object({
-        ...attachmentMetadata,
-        contentPath: t.String({
-            ...id,
-            description: `A regular file on the runline host, read at call time. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
-    t.Object({
-        ...attachmentMetadata,
-        content: t.String({
-            description: `UTF-8 text content, e.g. a generated CSV. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
+    ...attachmentSources("The entire serialized request is limited to 6 MB; use url for larger files."),
     t.Object({
         ...attachmentMetadata,
         url: t.String({

package/dist/plugins/agentMail/src/shared.js

@@ -1,9 +1,7 @@
-import { basename } from "node:path";
 import { AuthError, credentialRequest, jsonAnswer, pathSegment, responseFailed, } from "runline";
 import * as t from "typebox";
 import { Check } from "typebox/value";
-import { standardBase64 } from "../../_shared/base64.js";
-import { readLocalFile } from "../../_shared/localFile.js";
+import { attachmentFile } from "../../_shared/attachments.js";
 import { obj } from "../../_shared/provider.js";
 import { agentMailCredential } from "./credentials.js";
 import { id, MAX_REQUEST_BYTES } from "./schemas.js";
@@ -32,59 +30,39 @@ function wireFields(fields) {
 }
 /** The bytes a request body can still hold once base64 inflates them by 4/3. */
 const MAX_FILE_BYTES = Math.floor((MAX_REQUEST_BYTES * 3) / 4);
-function base64Content(value, index) {
-    const content = standardBase64(value);
-    if (content === undefined)
-        throw new Error(`agentMail: attachment ${index} contentBase64 is not valid base64`);
-    return content;
-}
-/** One attachment's base64 bytes, or its URL for AgentMail to fetch. */
-async function attachmentSource(input, index) {
-    if ("contentBase64" in input) {
-        const value = input.contentBase64;
-        return {
-            content: base64Content(typeof value === "string" ? value : value.contentBase64, index),
-        };
+/**
+ * One attachment as AgentMail's SendAttachment: its bytes as base64, or
+ * its URL for AgentMail to fetch.
+ */
+async function wireAttachment(input, index) {
+    let source;
+    let file;
+    if ("url" in input) {
+        try {
+            const url = new URL(input.url);
+            if (url.protocol !== "https:" || url.username || url.password)
+                throw new Error();
+        }
+        catch {
+            throw new Error(`agentMail: attachment ${index} url requires HTTPS without embedded credentials`);
+        }
+        source = { url: input.url };
+        file = { name: input.name, mimeType: input.mimeType };
     }
-    if ("contentPath" in input) {
-        const bytes = await readLocalFile(input.contentPath, {
-            subject: `agentMail: attachment ${index} contentPath`,
+    else {
+        const resolved = await attachmentFile(input, index, {
+            plugin: "agentMail",
             maxBytes: MAX_FILE_BYTES,
             oversize: `agentMail: attachment ${index} exceeds the 6 MB request limit once encoded; use url`,
         });
-        return { content: bytes.toString("base64") };
-    }
-    if ("content" in input)
-        return { content: Buffer.from(input.content, "utf8").toString("base64") };
-    try {
-        const url = new URL(input.url);
-        if (url.protocol !== "https:" || url.username || url.password)
-            throw new Error();
+        if (!resolved.bytes.length)
+            throw new Error(`agentMail: attachment ${index} is empty`);
+        source = { content: resolved.bytes.toString("base64") };
+        file = resolved;
     }
-    catch {
-        throw new Error(`agentMail: attachment ${index} url requires HTTPS without embedded credentials`);
-    }
-    return { url: input.url };
-}
-/**
- * One attachment as AgentMail's SendAttachment. A download result passed
- * as contentBase64 supplies the name and type the input leaves out; a
- * local file is named for its path; text defaults to text/plain.
- */
-async function wireAttachment(input, index) {
-    const source = await attachmentSource(input, index);
-    if ("content" in source && !source.content)
-        throw new Error(`agentMail: attachment ${index} is empty`);
-    const result = "contentBase64" in input && typeof input.contentBase64 !== "string"
-        ? input.contentBase64
-        : undefined;
     return Object.fromEntries(Object.entries({
-        filename: input.name ??
-            (result?.name || undefined) ??
-            ("contentPath" in input ? basename(input.contentPath) : undefined),
-        content_type: input.mimeType ??
-            (result?.mimeType || undefined) ??
-            ("content" in input ? "text/plain" : undefined),
+        filename: file.name,
+        content_type: file.mimeType,
         content_disposition: input.inline === undefined
             ? undefined
             : input.inline

package/dist/plugins/agentMail/src/threads.js

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, id, inboxFields, labelFields, mailListFields, pageFields, STRICT, searchFields, strings, threadFields, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { id, inboxFields, labelFields, mailListFields, pageFields, STRICT, searchFields, strings, threadFields, } from "./schemas.js";
 import { attachmentPath, inboxPath, request, threadPath } from "./shared.js";
 const list = t.Object({
     ...inboxFields,

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

@@ -19,7 +19,8 @@
  */
 import { pathSegment, } from "runline";
 import * as t from "typebox";
-import { DownloadedFile, standardBase64 } from "../../_shared/base64.js";
+import { base64File } from "../../_shared/attachments.js";
+import { DownloadedFile } from "../../_shared/base64.js";
 import { renderEmailJsx } from "../../_shared/emailJsx.js";
 import { googleCredential, googleJsonRequest, googleOAuth, } from "../../_shared/googleAuth.js";
 import { GoogleTimestamp, Id, NonEmptyString, stringEnum, } from "../../_shared/googleSchemas.js";
@@ -111,30 +112,17 @@ function normalizeAttachment(input, index) {
         throw new Error(`gmail: attachment ${index} must be an object`);
     }
     const content = input.contentBase64;
-    const contentBase64 = typeof content === "string"
-        ? content
-        : content &&
-            typeof content === "object" &&
-            typeof content.contentBase64 === "string"
-            ? content.contentBase64
-            : undefined;
-    if (typeof contentBase64 !== "string") {
+    if (typeof content !== "string" &&
+        (typeof content !== "object" ||
+            !content ||
+            typeof content.contentBase64 !== "string")) {
         throw new Error(`gmail: attachment ${index} contentBase64 must be a base64 string`);
     }
-    const normalized = standardBase64(contentBase64);
-    if (normalized === undefined) {
-        throw new Error(`gmail: attachment ${index} contentBase64 is not valid base64`);
-    }
-    // A download result passed as contentBase64 names its own file and type.
-    const result = typeof content === "object" && content ? content : {};
-    const named = (value) => typeof value === "string" && value ? value : undefined;
+    const file = base64File(content, `gmail: attachment ${index}`);
     return {
-        name: input.name ??
-            input.filename ??
-            named(result.name) ??
-            `attachment-${index + 1}`,
-        mimeType: input.mimeType ?? named(result.mimeType) ?? "application/octet-stream",
-        contentBase64: normalized,
+        name: input.name ?? input.filename ?? file.name ?? `attachment-${index + 1}`,
+        mimeType: input.mimeType ?? file.mimeType ?? "application/octet-stream",
+        contentBase64: file.bytes.toString("base64"),
     };
 }
 function attachmentPart(att) {