runline 0.7.2 → 0.7.5

package/dist/commands/exec.js

@@ -5,8 +5,10 @@ import { loadAllPlugins } from "../plugin/loader.js";
 import { registry } from "../plugin/registry.js";
 import { printError, printJson } from "../utils/output.js";
 export async function exec(code, options) {
-    await loadAllPlugins();
     const config = loadConfig();
+    await loadAllPlugins({
+        builtinAllowlist: new Set(config.connections.map((c) => c.plugin)),
+    });
     const engine = new ExecutionEngine(registry, config);
     if (options.file) {
         if (!existsSync(code)) {

package/dist/core/engine.js

@@ -1,14 +1,12 @@
 import { readFileSync } from "node:fs";
 import { getQuickJS, shouldInterruptAfterDeadline, } from "quickjs-emscripten";
 import { applyEnvOverrides, updateConnectionConfig } from "../config/loader.js";
-import { registerNodePlugin } from "../plugin/node-plugin.js";
 export class ExecutionEngine {
     registry;
     config;
     constructor(registry, config) {
         this.registry = registry;
         this.config = config;
-        registerNodePlugin(this.registry);
     }
     async execute(code, options) {
         const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;

package/dist/main.js

@@ -39,7 +39,7 @@ program
     .addHelpText("after", `
 The code runs in a QuickJS runtime with an \`actions\` proxy.
 Each installed plugin is a top-level global. Dot-chain into resource and action.
-The built-in \`node\` global exposes host-backed fs/path/os/process/crypto/fetch actions.
+Configure the built-in \`node\` plugin to expose host-backed fs/path/os/process/crypto/fetch actions.
 
 Examples:
   $ runline exec 'return await docker.containers.list()'

package/dist/plugin/loader.d.ts

@@ -32,4 +32,4 @@ export declare function discoverPlugins(configDir?: string | null, options?: Dis
  * Load all plugins and register them into the global registry.
  * Used by the CLI.
  */
-export declare function loadAllPlugins(): Promise<void>;
+export declare function loadAllPlugins(options?: DiscoverOptions): Promise<void>;

package/dist/plugin/loader.js

@@ -1,12 +1,21 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
 import { findConfigDir } from "../config/loader.js";
 import { resolvePluginExport } from "./api.js";
-import { registerNodePlugin } from "./node-plugin.js";
 import { registry } from "./registry.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const jiti = createJiti(import.meta.url, {
+    moduleCache: false,
+    interopDefault: true,
+    tryNative: false,
+    alias: {
+        runline: new URL("../index.js", import.meta.url).pathname,
+        "runline/utils/cli": new URL("../utils/cli.js", import.meta.url).pathname,
+    },
+});
 export async function loadPluginFromPath(path) {
     let absPath = resolve(path);
     if (existsSync(absPath) && statSync(absPath).isDirectory()) {
@@ -35,9 +44,16 @@ export async function loadPluginFromPath(path) {
             throw new Error(`No entry point found in ${absPath}`);
         }
     }
-    const mod = await import(pathToFileURL(absPath).href);
+    // Plugins may live outside the project/package tree. Load them
+    // through Runline's module context so documented imports like
+    // `from "runline"` work without requiring a node_modules folder next
+    // to the plugin file.
+    const mod = (await jiti.import(absPath));
     const pluginId = absPath.replace(/.*\//, "").replace(/\.(ts|js)$/, "");
-    return resolvePluginExport(mod.default, pluginId);
+    const pluginExport = typeof mod === "object" && mod !== null && "default" in mod
+        ? mod.default
+        : mod;
+    return resolvePluginExport(pluginExport, pluginId);
 }
 async function loadFromDirectory(dir) {
     const plugins = [];
@@ -163,11 +179,10 @@ export async function discoverPlugins(configDir, options = {}) {
  * Load all plugins and register them into the global registry.
  * Used by the CLI.
  */
-export async function loadAllPlugins() {
+export async function loadAllPlugins(options = {}) {
     const configDir = findConfigDir();
-    const plugins = await discoverPlugins(configDir);
+    const plugins = await discoverPlugins(configDir, options);
     for (const p of plugins) {
         registry.register(p);
     }
-    registerNodePlugin(registry);
 }

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

@@ -77,6 +77,7 @@ async function paginateAll(ctx, path, key, qs) {
 }
 // ─── MIME encoding ───────────────────────────────────────────────
 const CRLF = "\r\n";
+const GMAIL_MAX_RAW_BYTES = 35 * 1024 * 1024;
 function base64url(bytes) {
     const buf = typeof bytes === "string" ? Buffer.from(bytes, "utf-8") : Buffer.from(bytes);
     return buf
@@ -104,21 +105,57 @@ function header(name, value) {
         return "";
     return `${name}: ${value}${CRLF}`;
 }
+function foldedBase64ByteLength(length) {
+    return length === 0 ? 0 : length + Math.floor((length - 1) / 76) * CRLF.length;
+}
+function foldBase64(encoded) {
+    let folded = "";
+    for (let i = 0; i < encoded.length; i += 76) {
+        if (i > 0)
+            folded += CRLF;
+        folded += encoded.slice(i, i + 76);
+    }
+    return folded;
+}
+function assertAttachmentPayloadFits(atts) {
+    const attachmentBodyBytes = atts.reduce((sum, att) => sum + foldedBase64ByteLength(att.contentBase64.length), 0);
+    if (attachmentBodyBytes > GMAIL_MAX_RAW_BYTES) {
+        throw new Error(`gmail: attachment payload is ${attachmentBodyBytes} bytes after MIME folding; Gmail API raw messages must be <= ${GMAIL_MAX_RAW_BYTES} bytes`);
+    }
+}
 function textPart(body, mimeType) {
     const encoded = Buffer.from(body, "utf-8").toString("base64");
-    // Fold base64 to 76 chars per RFC 2045.
-    const folded = encoded.match(/.{1,76}/g)?.join(CRLF) ?? encoded;
     return (`Content-Type: ${mimeType}; charset="UTF-8"${CRLF}` +
         `Content-Transfer-Encoding: base64${CRLF}${CRLF}` +
-        `${folded}${CRLF}`);
+        `${foldBase64(encoded)}${CRLF}`);
+}
+function normalizeAttachment(input, index) {
+    if (!input || typeof input !== "object") {
+        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") {
+        throw new Error(`gmail: attachment ${index} contentBase64 must be a base64 string`);
+    }
+    return {
+        name: input.name ?? input.filename ?? `attachment-${index + 1}`,
+        mimeType: input.mimeType ?? "application/octet-stream",
+        contentBase64,
+    };
 }
 function attachmentPart(att) {
     const encodedName = encodeHeaderWord(att.name);
-    const folded = att.contentBase64.match(/.{1,76}/g)?.join(CRLF) ?? att.contentBase64;
     return (`Content-Type: ${att.mimeType}; name="${encodedName}"${CRLF}` +
         `Content-Disposition: attachment; filename="${encodedName}"${CRLF}` +
         `Content-Transfer-Encoding: base64${CRLF}${CRLF}` +
-        `${folded}${CRLF}`);
+        `${foldBase64(att.contentBase64)}${CRLF}`);
 }
 /**
  * Build a MIME message and return its base64url-encoded form,
@@ -143,7 +180,8 @@ export function encodeEmail(email) {
     headers.push(header("MIME-Version", "1.0"));
     const text = email.text ?? "";
     const html = email.html ?? "";
-    const atts = email.attachments ?? [];
+    const atts = (email.attachments ?? []).map((att, index) => normalizeAttachment(att, index));
+    assertAttachmentPayloadFits(atts);
     const hasAtt = atts.length > 0;
     const hasBoth = text && html;
     let bodyBlock;
@@ -189,6 +227,10 @@ export function encodeEmail(email) {
                 `--${mixedBoundary}--${CRLF}`;
     }
     const raw = `${headers.join("")}${rootType}${bodyBlock}`;
+    const rawBytes = Buffer.byteLength(raw, "utf-8");
+    if (rawBytes > GMAIL_MAX_RAW_BYTES) {
+        throw new Error(`gmail: encoded message is ${rawBytes} bytes; Gmail API raw messages must be <= ${GMAIL_MAX_RAW_BYTES} bytes`);
+    }
     return base64url(raw);
 }
 // ─── Email address helpers ───────────────────────────────────────
@@ -351,7 +393,11 @@ function simplifyMessage(raw, labels) {
         }
     }
     // Body + attachments only meaningful when format=full was used.
-    const acc = { text: [], html: [], attachments: [] };
+    const acc = {
+        text: [],
+        html: [],
+        attachments: [],
+    };
     walkPayload(payload, acc);
     if (acc.text.length > 0)
         out.text = acc.text.join("\n");
@@ -412,7 +458,9 @@ async function replyToMessage(ctx, messageId, p) {
         to,
         cc: normalizeAddressList(p.cc),
         bcc: normalizeAddressList(p.bcc),
-        subject: subject.toLowerCase().startsWith("re:") ? subject : `Re: ${subject}`,
+        subject: subject.toLowerCase().startsWith("re:")
+            ? subject
+            : `Re: ${subject}`,
         text: p.text,
         html: p.html,
         inReplyTo: messageIdHeader,
@@ -756,7 +804,11 @@ export default function gmail(rl) {
         description: "Get a thread by ID",
         inputSchema: {
             id: { type: "string", required: true },
-            format: { type: "string", required: false, description: "minimal | full | metadata" },
+            format: {
+                type: "string",
+                required: false,
+                description: "minimal | full | metadata",
+            },
             metadataHeaders: { type: "array", required: false },
             simple: {
                 type: "boolean",
@@ -996,10 +1048,12 @@ export default function gmail(rl) {
         async execute(input, ctx) {
             const p = (input ?? {});
             const body = { name: p.name };
-            if (p.labelListVisibility)
+            if (p.labelListVisibility) {
                 body.labelListVisibility = p.labelListVisibility;
-            if (p.messageListVisibility)
+            }
+            if (p.messageListVisibility) {
                 body.messageListVisibility = p.messageListVisibility;
+            }
             return gmailRequest(ctx, "POST", "/labels", body);
         },
     });
@@ -1039,10 +1093,12 @@ export default function gmail(rl) {
             const body = {};
             if (p.name)
                 body.name = p.name;
-            if (p.labelListVisibility)
+            if (p.labelListVisibility) {
                 body.labelListVisibility = p.labelListVisibility;
-            if (p.messageListVisibility)
+            }
+            if (p.messageListVisibility) {
                 body.messageListVisibility = p.messageListVisibility;
+            }
             return gmailRequest(ctx, "PATCH", `/labels/${p.id}`, body);
         },
     });