runline 0.36.0 → 0.38.0

package/dist/credentials/aws-plugin.d.ts

@@ -35,6 +35,9 @@ export interface AwsCredentialSpec {
  *   `roleDurationSeconds` shape each session request.
  * - `stsRegion`, else `region`, else `us-east-1`, is where sessions are
  *   requested.
+ * - `awsProfile` names an AWS CLI profile (an SSO login) whose key this
+ *   process signs with in place of a stored one; a host that stores the
+ *   key ignores it.
  */
 export declare function awsCredential(spec: AwsCredentialSpec): CredentialDeclaration;
 /**

package/dist/credentials/aws-plugin.js

@@ -5,7 +5,7 @@
  */
 import * as t from "typebox";
 import { AuthError } from "../auth/errors.js";
-import { awsEndpoint, awsErrorCode, awsRole, parseAwsXml } from "./aws.js";
+import { awsEndpoint, awsErrorCode, awsProfileName, awsRole, parseAwsXml, } from "./aws.js";
 import { credentialRequest, errorIdentifier, failureMessage, jsonAnswer, } from "./plugin.js";
 import { AwsAccessKeySchema, AwsSessionSchema } from "./registry.js";
 const STRICT = { additionalProperties: false };
@@ -57,6 +57,9 @@ function configString(value) {
  *   `roleDurationSeconds` shape each session request.
  * - `stsRegion`, else `region`, else `us-east-1`, is where sessions are
  *   requested.
+ * - `awsProfile` names an AWS CLI profile (an SSO login) whose key this
+ *   process signs with in place of a stored one; a host that stores the
+ *   key ignores it.
  */
 export function awsCredential(spec) {
     const key = { credential: AwsAccessKeySchema };
@@ -68,6 +71,8 @@ export function awsCredential(spec) {
     return (config) => {
         const targets = spec.targets(config);
         const probe = spec.probe ? { probe: spec.probe } : {};
+        const profile = configString(config.awsProfile);
+        const awsProfile = profile === undefined ? undefined : awsProfileName(profile);
         const roleArn = configString(config.roleArn);
         const externalId = configString(config.roleExternalId);
         const durationSeconds = configInteger(config.roleDurationSeconds);
@@ -93,7 +98,7 @@ export function awsCredential(spec) {
                     },
                 },
             },
-            localSecret,
+            ...(awsProfile === undefined ? { localSecret } : { awsProfile }),
             ...(roleArn === undefined
                 ? { method: "accessKey" }
                 : {

package/dist/credentials/aws.d.ts

@@ -14,6 +14,17 @@ export declare function awsEndpoint(service: string, region: string): string;
  * signature. Anything else is refused before any request.
  */
 export declare function awsAccessKey(value: unknown): AwsAccessKey;
+/** A profile name from config; anything else is refused before the CLI runs. */
+export declare function awsProfileName(value: unknown): string;
+/**
+ * The access key of an AWS CLI profile, as the CLI resolves it: an SSO
+ * login, an assumed role, or a key in `~/.aws/credentials`, through
+ * `aws configure export-credentials` (the `credential_process` contract).
+ * Held until five minutes before it expires; however many callers find
+ * it missing or stale, one CLI run serves them all, and a failed run is
+ * not held.
+ */
+export declare function awsProfileKey(name: string): Promise<AwsAccessKey>;
 /** A role as STS accepts it; anything else is refused before any request. */
 export declare function awsRole(role: AwsRole): AwsRole;
 /**

package/dist/credentials/aws.js

@@ -1,3 +1,4 @@
+import { execFile } from "node:child_process";
 import { XMLParser } from "fast-xml-parser";
 import { AuthError } from "../auth/errors.js";
 import { sendResource } from "./http.js";
@@ -55,6 +56,110 @@ export function awsAccessKey(value) {
             : { sessionToken: secret(key.sessionToken) }),
     };
 }
+/** An AWS CLI profile name, as `~/.aws/config` section names allow it. */
+const PROFILE = /^[\w+=,.@-]{1,64}$/;
+/** A profile name from config; anything else is refused before the CLI runs. */
+export function awsProfileName(value) {
+    if (typeof value !== "string" || !PROFILE.test(value))
+        throw new AuthError("invalid_credentials");
+    return value;
+}
+/** A profile's key is used until this long before it expires. */
+const PROFILE_KEY_MARGIN_MS = 5 * 60_000;
+/**
+ * Each profile's key as this process holds it: settled while it lasts,
+ * or still in flight, so concurrent callers share one CLI run.
+ */
+const profileKeys = new Map();
+/** A key a provider issued: one that cannot sign is a malformed answer. */
+function issuedKey(value) {
+    try {
+        return awsAccessKey(value);
+    }
+    catch {
+        throw new AuthError("invalid_response");
+    }
+}
+/**
+ * Why the CLI produced no key: it is not installed, it ran out of time,
+ * it answered more than a key, or it refused (no login, or an expired
+ * SSO session, which `aws sso login` mends).
+ */
+function cliFailure(error) {
+    if (error.code === "ENOENT")
+        return new AuthError("invalid_credentials");
+    if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+        return new AuthError("invalid_response");
+    if (error.killed)
+        return new AuthError("request_failed");
+    return new AuthError("reconnect_required");
+}
+/** One CLI run: the profile's key, as `credential_process` defines it. */
+async function exportProfileKey(profile) {
+    const stdout = await new Promise((resolve, reject) => {
+        execFile("aws", [
+            "configure",
+            "export-credentials",
+            "--profile",
+            profile,
+            "--format",
+            "process",
+        ], { timeout: 30_000, maxBuffer: 64 * 1024 }, (error, out) => (error ? reject(cliFailure(error)) : resolve(out)));
+    });
+    let exported;
+    try {
+        exported = JSON.parse(stdout);
+    }
+    catch {
+        throw new AuthError("invalid_response");
+    }
+    const expiresAt = exported.Expiration === undefined
+        ? undefined
+        : Date.parse(String(exported.Expiration));
+    if (exported.Version !== 1 ||
+        (expiresAt !== undefined && !Number.isSafeInteger(expiresAt)))
+        throw new AuthError("invalid_response");
+    return {
+        key: issuedKey({
+            accessKeyId: exported.AccessKeyId,
+            secretAccessKey: exported.SecretAccessKey,
+            ...(exported.SessionToken === undefined
+                ? {}
+                : { sessionToken: exported.SessionToken }),
+        }),
+        expiresAt,
+    };
+}
+/**
+ * The access key of an AWS CLI profile, as the CLI resolves it: an SSO
+ * login, an assumed role, or a key in `~/.aws/credentials`, through
+ * `aws configure export-credentials` (the `credential_process` contract).
+ * Held until five minutes before it expires; however many callers find
+ * it missing or stale, one CLI run serves them all, and a failed run is
+ * not held.
+ */
+export async function awsProfileKey(name) {
+    const profile = awsProfileName(name);
+    for (;;) {
+        const held = profileKeys.get(profile);
+        if (!held)
+            break;
+        const { key, expiresAt } = await held;
+        if (expiresAt === undefined ||
+            expiresAt > Date.now() + PROFILE_KEY_MARGIN_MS)
+            return key;
+        // Stale: refresh it, unless another caller already started to.
+        if (profileKeys.get(profile) === held)
+            break;
+    }
+    const exporting = exportProfileKey(profile);
+    profileKeys.set(profile, exporting);
+    exporting.catch(() => {
+        if (profileKeys.get(profile) === exporting)
+            profileKeys.delete(profile);
+    });
+    return (await exporting).key;
+}
 /** `arn:<partition>:iam::<account>:role/<path/name>`, as IAM allows it. */
 const ROLE_ARN = /^arn:aws(?:-[a-z]+)*:iam::\d{12}:role\/[\w+=,.@/-]{1,512}$/;
 const SESSION_NAME = /^[\w+=,.@-]{2,64}$/;
@@ -193,17 +298,11 @@ export async function assumeAwsRole(key, role, options) {
         !Number.isSafeInteger(expiresAt) ||
         expiresAt <= now)
         throw new AuthError("invalid_response");
-    let session;
-    try {
-        session = awsAccessKey({
-            accessKeyId: result.AccessKeyId,
-            secretAccessKey: result.SecretAccessKey,
-            sessionToken: result.SessionToken,
-        });
-    }
-    catch {
-        throw new AuthError("invalid_response");
-    }
+    const session = issuedKey({
+        accessKeyId: result.AccessKeyId,
+        secretAccessKey: result.SecretAccessKey,
+        sessionToken: result.SessionToken,
+    });
     return {
         accessKeyId: session.accessKeyId,
         secretAccessKey: session.secretAccessKey,

package/dist/credentials/broker.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { AuthError } from "../auth/errors.js";
+import { awsProfileKey } from "./aws.js";
 import { CredentialRegistry } from "./registry.js";
 import { CredentialTransport } from "./transport.js";
 /**
@@ -122,7 +123,7 @@ function localSigner(ctx, declaration) {
     const auth = definition.methods[method].authentication;
     const identity = { name: ctx.connection.name, plugin: ctx.connection.plugin };
     const expected = authorityOf(selection);
-    const project = (current) => {
+    const project = async (current) => {
         if (authorityOf(declaration(current)) !== expected)
             throw new AuthError("binding_changed");
         if (auth.kind === "none")
@@ -132,9 +133,9 @@ function localSigner(ctx, declaration) {
             return secret ? { [auth.field]: secret } : {};
         }
         if (auth.kind === "awsSigV4") {
-            const key = staticSecret(current, selection.localSecret, [
-                "sessionToken",
-            ]);
+            const key = selection.awsProfile
+                ? await awsProfileKey(selection.awsProfile)
+                : staticSecret(current, selection.localSecret, ["sessionToken"]);
             const cached = current.awsSession;
             const sessionField = auth.assumeRole?.sessionField;
             return {
@@ -178,9 +179,9 @@ function localSigner(ctx, declaration) {
             : createHash("sha256").update(JSON.stringify(tokens)).digest("hex");
         return { [auth.field]: { tokens, revision } };
     };
-    const snapshot = () => ({
+    const snapshot = async () => ({
         ...identity,
-        config: project(ctx.connection.config),
+        config: await project(ctx.connection.config),
     });
     const binding = {
         type: definition.id,
@@ -199,7 +200,7 @@ function localSigner(ctx, declaration) {
             async update(change) {
                 const flatten = writeBack(auth, expected);
                 await ctx.updateConnection(async (current) => {
-                    const projected = project(current);
+                    const projected = await project(current);
                     const patch = typeof change === "function" ? await change(projected) : change;
                     return patch ? flatten(patch, current) : undefined;
                 });

package/dist/credentials/http.d.ts

@@ -7,11 +7,25 @@ export interface ResourceOptions {
 }
 /** Internal send primitive. Callers validate destination policy before reaching it. */
 export declare function sendResource(url: string, method: HttpMethod, headers: Headers, body: Buffer | undefined, options: ResourceOptions): Promise<Response>;
+export interface PresignedRequestOptions {
+    /** Exact origins the URL may be on; anything else is refused. */
+    allowedOrigins: string[];
+    fetch: typeof globalThis.fetch;
+    method?: "GET" | "PUT" | "DELETE";
+    /** Request headers; credentials and cookies are never among them. */
+    headers?: Record<string, string>;
+    body?: Uint8Array;
+    maxResponseBytes?: number;
+}
 /**
- * Fetch a provider-issued preauthenticated URL without bearer tokens or cookies.
- * Hosts approve exact origins and enforce DNS/IP egress through their fetch hook.
- * The signed URL is itself secret: errors never include it. No redirects or retries.
+ * One request to a provider-issued preauthenticated URL — a signed
+ * download, an upload session — without bearer tokens or cookies.
+ * Hosts approve exact origins and enforce DNS/IP egress through their
+ * fetch hook. The signed URL is itself secret: errors never include it.
+ * No redirects or retries.
  */
+export declare function presignedRequest(value: string, options: PresignedRequestOptions): Promise<Response>;
+/** A GET of a provider-issued preauthenticated URL; see presignedRequest. */
 export declare function downloadResource(value: string, options: {
     allowedOrigins: string[];
     fetch: typeof globalThis.fetch;

package/dist/credentials/http.js

@@ -78,11 +78,19 @@ export async function sendResource(url, method, headers, body, options) {
     }
 }
 /**
- * Fetch a provider-issued preauthenticated URL without bearer tokens or cookies.
- * Hosts approve exact origins and enforce DNS/IP egress through their fetch hook.
- * The signed URL is itself secret: errors never include it. No redirects or retries.
+ * Headers a presigned request never sends: the URL is its only authority,
+ * so no credential or cookie rides along, and Destination belongs to the
+ * credential transport's COPY and MOVE.
  */
-export async function downloadResource(value, options) {
+const PRESIGNED_REFUSED_HEADERS = ["authorization", "cookie", "destination"];
+/**
+ * One request to a provider-issued preauthenticated URL — a signed
+ * download, an upload session — without bearer tokens or cookies.
+ * Hosts approve exact origins and enforce DNS/IP egress through their
+ * fetch hook. The signed URL is itself secret: errors never include it.
+ * No redirects or retries.
+ */
+export async function presignedRequest(value, options) {
     let url;
     try {
         url = new URL(value);
@@ -101,9 +109,23 @@ export async function downloadResource(value, options) {
         maxResponseBytes <= 0 ||
         maxResponseBytes > 64 * 1024 * 1024)
         throw new AuthError("invalid_definition");
-    return sendResource(url.toString(), "GET", new Headers(), undefined, {
-        fetch: options.fetch,
-        timeoutMs: 20_000,
-        maxResponseBytes,
-    });
+    const method = options.method ?? "GET";
+    const headers = new Headers();
+    try {
+        for (const [name, value] of Object.entries(options.headers ?? {})) {
+            if (PRESIGNED_REFUSED_HEADERS.includes(name.toLowerCase()))
+                throw new Error();
+            headers.set(name, value);
+        }
+        if (options.body !== undefined && method !== "PUT")
+            throw new Error();
+    }
+    catch {
+        throw new AuthError("request_not_allowed");
+    }
+    return sendResource(url.toString(), method, headers, options.body === undefined ? undefined : Buffer.from(options.body), { fetch: options.fetch, timeoutMs: 20_000, maxResponseBytes });
+}
+/** A GET of a provider-issued preauthenticated URL; see presignedRequest. */
+export function downloadResource(value, options) {
+    return presignedRequest(value, options);
 }

package/dist/credentials/transport.js

@@ -244,7 +244,11 @@ export class CredentialTransport {
         try {
             snapshot = await binding.connection.read();
         }
-        catch {
+        catch (error) {
+            // A store's own error can carry anything; an AuthError is already
+            // sanitized and says what is wrong with the credential itself.
+            if (error instanceof AuthError)
+                throw error;
             throw new AuthError("credential_store_failed");
         }
         return boundSnapshot(binding, method, snapshot);

package/dist/credentials/types.d.ts

@@ -225,6 +225,13 @@ export interface CredentialSelection {
     resourceOwner?: OAuthResourceOwner;
     /** The role an `assumeRole` method's sessions are issued for. */
     awsRole?: AwsRole;
+    /**
+     * The AWS CLI profile whose credentials an `awsSigV4` method's key
+     * comes from, read through the CLI when this process signs with its
+     * own connection: an SSO login, with no key stored anywhere. Hosts that
+     * store the key ignore it, as they ignore `localSecret`.
+     */
+    awsProfile?: string;
     /**
      * How a process signing with its own flat connection config (the CLI)
      * assembles a static secret: each of its parts, from a named config

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export { awsEndpoint, awsRegion, parseAwsXml } from "./credentials/aws.js";
 export type { AwsCredentialSpec } from "./credentials/aws-plugin.js";
 export { awsCredential, awsFailed, awsJson, awsList, awsQuery, awsTarget, } from "./credentials/aws-plugin.js";
 export { brokerFor } from "./credentials/broker.js";
-export { downloadResource } from "./credentials/http.js";
+export { downloadResource, type PresignedRequestOptions, presignedRequest, } from "./credentials/http.js";
 export type { CredentialCall, EmptyAnswer, ErrorEnvelope, StaticCredentialSpec, } from "./credentials/plugin.js";
 export { answerFailed, configChoice, configFlag, credentialJson, credentialOk, credentialRequest, credentialSocketUrl, errorIdentifier, failureMessage, grantSchema, graphqlFailed, hostLabel, httpsBase, jsonAnswer, jsonOrAcknowledged, multipartBody, pathSegment, pathSegments, pathWithin, refuseUnderHost, requestFailed, responseFailed, slashEncodedSegment, staticCredential, } from "./credentials/plugin.js";
 export { AwsAccessKeySchema, AwsSessionSchema, CredentialRegistry, OAuthGrantSchema, OAuthTokensSchema, staticSecretSchema, validateCredential, } from "./credentials/registry.js";

package/dist/index.js

@@ -10,7 +10,7 @@ export { buildAuthUrl, exchangeAuthCode, generatePKCE, OAUTH_CALLBACK_PORT, OAUT
 export { awsEndpoint, awsRegion, parseAwsXml } from "./credentials/aws.js";
 export { awsCredential, awsFailed, awsJson, awsList, awsQuery, awsTarget, } from "./credentials/aws-plugin.js";
 export { brokerFor } from "./credentials/broker.js";
-export { downloadResource } from "./credentials/http.js";
+export { downloadResource, presignedRequest, } from "./credentials/http.js";
 export { answerFailed, configChoice, configFlag, credentialJson, credentialOk, credentialRequest, credentialSocketUrl, errorIdentifier, failureMessage, grantSchema, graphqlFailed, hostLabel, httpsBase, jsonAnswer, jsonOrAcknowledged, multipartBody, pathSegment, pathSegments, pathWithin, refuseUnderHost, requestFailed, responseFailed, slashEncodedSegment, staticCredential, } from "./credentials/plugin.js";
 export { AwsAccessKeySchema, AwsSessionSchema, CredentialRegistry, OAuthGrantSchema, OAuthTokensSchema, staticSecretSchema, validateCredential, } from "./credentials/registry.js";
 export { CredentialTransport } from "./credentials/transport.js";

package/dist/plugins/_shared/attachments.js

@@ -0,0 +1,97 @@
+import { basename } from "node:path";
+import * as t from "typebox";
+import { DownloadedFile, standardBase64 } from "./base64.js";
+import { readLocalFile } from "./localFile.js";
+const STRICT = { additionalProperties: false };
+const id = t.String({ minLength: 1, pattern: "\\S" });
+/** What any attachment may say about itself, whatever its bytes are. */
+export 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." })),
+};
+/**
+ * An attachment's bytes, given one way each and named as gmail and
+ * googleDrive name them: `contentBase64` (base64, or a
+ * googleDrive.file.download result passed straight through),
+ * `contentPath` (a file on the runline host) or `content` (UTF-8 text).
+ * `sizeNote` states the plugin's own limit.
+ */
+export function attachmentSources(sizeNote) {
+    return [
+        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. ${sizeNote}`,
+            }),
+        }, STRICT),
+        t.Object({
+            ...attachmentMetadata,
+            contentPath: t.String({
+                ...id,
+                description: `A regular file on the runline host, read at call time. ${sizeNote}`,
+            }),
+        }, STRICT),
+        t.Object({
+            ...attachmentMetadata,
+            content: t.String({
+                description: `UTF-8 text content, e.g. a generated CSV. ${sizeNote}`,
+            }),
+        }, STRICT),
+    ];
+}
+/**
+ * Bytes given as base64, or as a googleDrive.file.download result, which
+ * also supplies a name and type. `subject` names the input in errors
+ * (`gmail: attachment 0`).
+ */
+export function base64File(value, subject) {
+    const result = typeof value === "string" ? undefined : value;
+    const content = standardBase64(typeof value === "string" ? value : value.contentBase64);
+    if (content === undefined)
+        throw new Error(`${subject} contentBase64 is not valid base64`);
+    return {
+        bytes: Buffer.from(content, "base64"),
+        name: result?.name || undefined,
+        mimeType: result?.mimeType || undefined,
+    };
+}
+/**
+ * An attachment input's bytes. A download result passed as contentBase64
+ * supplies the name and type the input leaves out; a local file is named
+ * for its path; text is text/plain. Oversized bytes, invalid base64 and
+ * unreadable files are refused here, before any request.
+ */
+export async function attachmentFile(input, index, limits) {
+    const subject = `${limits.plugin}: attachment ${index}`;
+    let file;
+    if ("contentBase64" in input) {
+        file = base64File(input.contentBase64, subject);
+    }
+    else if ("contentPath" in input) {
+        file = {
+            bytes: await readLocalFile(input.contentPath, {
+                subject: `${subject} contentPath`,
+                maxBytes: limits.maxBytes,
+                oversize: limits.oversize,
+            }),
+            name: basename(input.contentPath),
+        };
+    }
+    else {
+        file = {
+            bytes: Buffer.from(input.content, "utf8"),
+            mimeType: "text/plain",
+        };
+    }
+    if (file.bytes.length > limits.maxBytes)
+        throw new Error(limits.oversize);
+    return {
+        bytes: file.bytes,
+        name: input.name ?? file.name,
+        mimeType: input.mimeType ?? file.mimeType,
+    };
+}

package/dist/plugins/_shared/microsoftAuth.js

@@ -1,4 +1,4 @@
-import { AuthError, brokerFor, downloadResource, jsonAnswer, requestFailed, } from "runline";
+import { AuthError, brokerFor, downloadResource, jsonAnswer, presignedRequest, responseFailed, } from "runline";
 import { MICROSOFT_GRANT, microsoftCredential, microsoftEndpoint, microsoftUserBase, } from "./microsoftCredentials.js";
 export { microsoftCredential, microsoftDriveBase, } from "./microsoftCredentials.js";
 export function userBase(ctx) {
@@ -7,7 +7,11 @@ export function userBase(ctx) {
 export async function microsoftProbe(ctx, plugin, scopes) {
     return brokerFor(ctx, microsoftCredential(plugin, scopes)).probe();
 }
-export async function graphResponse(ctx, plugin, scopes, method, path, body, contentType) {
+/**
+ * One Graph request under the plugin's credential. `accept` is JSON
+ * unless the caller reads raw bytes, such as an attachment's `$value`.
+ */
+export async function graphResponse(ctx, plugin, scopes, method, path, body, contentType, accept = "application/json") {
     if (!path.startsWith("/") || path.startsWith("//"))
         throw new AuthError("request_not_allowed");
     return brokerFor(ctx, microsoftCredential(plugin, scopes)).request({
@@ -15,12 +19,21 @@ export async function graphResponse(ctx, plugin, scopes, method, path, body, con
         path: path.slice(1),
         method: method,
         headers: {
-            Accept: "application/json",
+            Accept: accept,
             ...(contentType ? { "Content-Type": contentType } : {}),
         },
         body,
     });
 }
+/**
+ * A failed Graph response, by its status and Graph's `error.code`
+ * (`ErrorItemNotFound`, `ErrorAccessDenied`); Graph's message is never read.
+ */
+export function graphFailed(plugin, response) {
+    return responseFailed(plugin, response, (body) => ({
+        code: body?.error?.code,
+    }));
+}
 /**
  * A Graph JSON request that must succeed; its answer is read by
  * `jsonAnswer`. JSON and binary requests share the same destination,
@@ -29,7 +42,7 @@ export async function graphResponse(ctx, plugin, scopes, method, path, body, con
 export async function graphRequest(ctx, plugin, scopes, method, path, body) {
     const res = await graphResponse(ctx, plugin, scopes, method, path, body === undefined ? undefined : JSON.stringify(body), body === undefined ? undefined : "application/json");
     if (!res.ok)
-        throw requestFailed(plugin, res.status);
+        throw await graphFailed(plugin, res);
     return jsonAnswer(res);
 }
 /** Graph-issued signed download URLs carry their own authority, never a bearer header. */
@@ -57,6 +70,22 @@ export async function microsoftDownload(value) {
         fetch: globalThis.fetch,
     });
 }
+/** Where Graph's Outlook attachment upload sessions live, as Microsoft documents them. */
+const OUTLOOK_UPLOAD_ORIGIN = "https://outlook.office.com";
+/**
+ * One request to an Outlook attachment upload session's `uploadUrl`. The
+ * URL carries its own authority, so the request has no bearer token; a
+ * URL on any other origin is refused.
+ */
+export function outlookUpload(uploadUrl, init) {
+    if (typeof uploadUrl !== "string")
+        throw new AuthError("invalid_response");
+    return presignedRequest(uploadUrl, {
+        allowedOrigins: [OUTLOOK_UPLOAD_ORIGIN],
+        fetch: globalThis.fetch,
+        ...init,
+    });
+}
 /**
  * A Microsoft Graph plugin's OAuth declaration: the multi-tenant endpoints,
  * `offline_access` for a refresh token, the grant every Graph plugin

package/dist/plugins/_shared/schemas.js

@@ -0,0 +1,8 @@
+/**
+ * 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] })) };
+}

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

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, attachments, clientId, contentFields, draftFields, id, idList, inboxFields, labelFields, listFields, STRICT, sendFields, strings, timestamp, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { attachments, clientId, contentFields, draftFields, id, idList, inboxFields, labelFields, listFields, STRICT, sendFields, strings, timestamp, } from "./schemas.js";
 import { attachmentPath, draftPath, inboxPath, request, sendMessage, } from "./shared.js";
 const list = t.Object({ ...inboxFields, ...listFields }, STRICT);
 const draft = t.Object(draftFields, STRICT);

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

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, clientId, id, inboxFields, pageFields, STRICT, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { clientId, id, inboxFields, pageFields, STRICT } from "./schemas.js";
 import { inboxPath, request } from "./shared.js";
 const metadataValue = t.Union([
     t.String({ maxLength: 256 }),

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

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, id, inboxFields, labelFields, mailListFields, messageContentFields, messageFields, recipientFields, replyContentFields, STRICT, searchFields, sendFields, strings, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { id, inboxFields, labelFields, mailListFields, messageContentFields, messageFields, recipientFields, replyContentFields, STRICT, searchFields, sendFields, strings, } from "./schemas.js";
 import { attachmentPath, inboxPath, messagePath, request, sendMessage, } from "./shared.js";
 const list = t.Object({
     ...inboxFields,

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({