runline 0.7.1 → 0.7.4

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/main.js

@@ -34,11 +34,12 @@ https://github.com/Michaelliv/runline`);
 program
     .command("exec <code>")
     .alias("e")
-    .description("Execute JavaScript code in the sandbox")
+    .description("Execute JavaScript code in the QuickJS runtime")
     .option("-f, --file", "Treat <code> as a file path")
     .addHelpText("after", `
-The code runs in a QuickJS sandbox with an \`actions\` proxy.
+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.
+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

@@ -162,9 +162,9 @@ 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);
     }

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);
         },
     });

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

@@ -0,0 +1,544 @@
+import { exec as execCb, execFile as execFileCb } from "node:child_process";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { access, appendFile, copyFile, lstat, mkdir, readdir, readFile, rename, rm, stat, unlink, writeFile, } from "node:fs/promises";
+import { arch, cpus, EOL, freemem, homedir, hostname, platform, release, tmpdir, totalmem, type, uptime, userInfo, } from "node:os";
+import { basename, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, relative, resolve, sep, } from "node:path";
+import { promisify } from "node:util";
+const exec = promisify(execCb);
+const execFile = promisify(execFileCb);
+const pathInput = (description = "Filesystem path") => ({
+    path: { type: "string", required: true, description },
+});
+function action(name, def) {
+    return { name, ...def };
+}
+export default function node(rl) {
+    rl.setName("node");
+    rl.setVersion("0.1.0");
+    for (const action of nodeActions) {
+        rl.registerAction(action.name, action);
+    }
+}
+const nodeActions = [
+    // fs/promises-shaped actions
+    action("fs.readFile", {
+        description: "Read a file from the host filesystem",
+        inputSchema: {
+            path: { type: "string", required: true, description: "File path" },
+            encoding: {
+                type: "string",
+                required: false,
+                description: "Text encoding. Defaults to utf8. Use base64 for binary-safe reads.",
+            },
+        },
+        async execute(input) {
+            const { path, encoding = "utf8" } = objectInput(input);
+            return readFile(path, { encoding });
+        },
+    }),
+    action("fs.writeFile", {
+        description: "Write text data to a file on the host filesystem",
+        inputSchema: {
+            path: { type: "string", required: true, description: "File path" },
+            data: { type: "string", required: true, description: "File contents" },
+            encoding: {
+                type: "string",
+                required: false,
+                description: "Text encoding. Defaults to utf8.",
+            },
+        },
+        async execute(input) {
+            const { path, data, encoding = "utf8", } = objectInput(input);
+            await writeFile(path, data, { encoding });
+            return ok({ path });
+        },
+    }),
+    action("fs.appendFile", {
+        description: "Append text data to a file on the host filesystem",
+        inputSchema: {
+            path: { type: "string", required: true, description: "File path" },
+            data: {
+                type: "string",
+                required: true,
+                description: "File contents to append",
+            },
+            encoding: {
+                type: "string",
+                required: false,
+                description: "Text encoding. Defaults to utf8.",
+            },
+        },
+        async execute(input) {
+            const { path, data, encoding = "utf8", } = objectInput(input);
+            await appendFile(path, data, { encoding });
+            return ok({ path });
+        },
+    }),
+    action("fs.readdir", {
+        description: "List a directory",
+        inputSchema: {
+            ...pathInput("Directory path"),
+            withFileTypes: {
+                type: "boolean",
+                required: false,
+                description: "Return typed entries instead of names",
+            },
+        },
+        async execute(input) {
+            const { path, withFileTypes = false } = objectInput(input);
+            if (!withFileTypes)
+                return readdir(path);
+            const entries = await readdir(path, { withFileTypes: true });
+            return entries.map((entry) => ({
+                name: entry.name,
+                isFile: entry.isFile(),
+                isDirectory: entry.isDirectory(),
+                isSymbolicLink: entry.isSymbolicLink(),
+            }));
+        },
+    }),
+    action("fs.stat", {
+        description: "Stat a filesystem path",
+        inputSchema: pathInput(),
+        async execute(input) {
+            return serializeStats(await stat(objectInput(input).path));
+        },
+    }),
+    action("fs.lstat", {
+        description: "lstat a filesystem path",
+        inputSchema: pathInput(),
+        async execute(input) {
+            return serializeStats(await lstat(objectInput(input).path));
+        },
+    }),
+    action("fs.exists", {
+        description: "Check whether a filesystem path exists",
+        inputSchema: pathInput(),
+        execute(input) {
+            return existsSync(objectInput(input).path);
+        },
+    }),
+    action("fs.access", {
+        description: "Check file access",
+        inputSchema: pathInput(),
+        async execute(input) {
+            await access(objectInput(input).path);
+            return ok();
+        },
+    }),
+    action("fs.mkdir", {
+        description: "Create a directory",
+        inputSchema: {
+            ...pathInput(),
+            recursive: {
+                type: "boolean",
+                required: false,
+                description: "Create parent directories. Defaults to true.",
+            },
+        },
+        async execute(input) {
+            const { path, recursive = true } = objectInput(input);
+            await mkdir(path, { recursive });
+            return ok({ path });
+        },
+    }),
+    action("fs.rm", {
+        description: "Remove a file or directory",
+        inputSchema: {
+            ...pathInput(),
+            recursive: {
+                type: "boolean",
+                required: false,
+                description: "Remove directories recursively",
+            },
+            force: {
+                type: "boolean",
+                required: false,
+                description: "Ignore missing paths",
+            },
+        },
+        async execute(input) {
+            const { path, recursive = false, force = false, } = objectInput(input);
+            await rm(path, { recursive, force });
+            return ok({ path });
+        },
+    }),
+    action("fs.unlink", {
+        description: "Remove a file",
+        inputSchema: pathInput(),
+        async execute(input) {
+            const { path } = objectInput(input);
+            await unlink(path);
+            return ok({ path });
+        },
+    }),
+    action("fs.rename", {
+        description: "Rename a file or directory",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Source path" },
+            to: { type: "string", required: true, description: "Destination path" },
+        },
+        async execute(input) {
+            const { from, to } = objectInput(input);
+            await rename(from, to);
+            return ok({ from, to });
+        },
+    }),
+    action("fs.copyFile", {
+        description: "Copy a file",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Source path" },
+            to: { type: "string", required: true, description: "Destination path" },
+        },
+        async execute(input) {
+            const { from, to } = objectInput(input);
+            await copyFile(from, to);
+            return ok({ from, to });
+        },
+    }),
+    // path-shaped actions. Most accept either an array or { segments: string[] }.
+    action("path.join", {
+        description: "Join path segments",
+        inputSchema: {
+            segments: {
+                type: "array",
+                required: true,
+                description: "Path segments",
+            },
+        },
+        execute(input) {
+            return join(...stringArrayInput(input));
+        },
+    }),
+    action("path.resolve", {
+        description: "Resolve path segments",
+        inputSchema: {
+            segments: {
+                type: "array",
+                required: true,
+                description: "Path segments",
+            },
+        },
+        execute(input) {
+            return resolve(...stringArrayInput(input));
+        },
+    }),
+    action("path.normalize", {
+        description: "Normalize a path",
+        inputSchema: pathInput(),
+        execute(input) {
+            return normalize(objectInput(input).path);
+        },
+    }),
+    action("path.dirname", {
+        description: "Get a path dirname",
+        inputSchema: pathInput(),
+        execute(input) {
+            return dirname(objectInput(input).path);
+        },
+    }),
+    action("path.basename", {
+        description: "Get a path basename",
+        inputSchema: {
+            ...pathInput(),
+            suffix: {
+                type: "string",
+                required: false,
+                description: "Optional suffix to remove",
+            },
+        },
+        execute(input) {
+            const { path, suffix } = objectInput(input);
+            return basename(path, suffix);
+        },
+    }),
+    action("path.extname", {
+        description: "Get a path extension",
+        inputSchema: pathInput(),
+        execute(input) {
+            return extname(objectInput(input).path);
+        },
+    }),
+    action("path.relative", {
+        description: "Get a relative path",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Source path" },
+            to: { type: "string", required: true, description: "Destination path" },
+        },
+        execute(input) {
+            const { from, to } = objectInput(input);
+            return relative(from, to);
+        },
+    }),
+    action("path.isAbsolute", {
+        description: "Check whether a path is absolute",
+        inputSchema: pathInput(),
+        execute(input) {
+            return isAbsolute(objectInput(input).path);
+        },
+    }),
+    action("path.parse", {
+        description: "Parse a path into components",
+        inputSchema: pathInput(),
+        execute(input) {
+            return parse(objectInput(input).path);
+        },
+    }),
+    action("path.format", {
+        description: "Format a path object into a path string",
+        inputSchema: {
+            pathObject: {
+                type: "object",
+                required: true,
+                description: "Node path object",
+            },
+        },
+        execute(input) {
+            return format(objectInput(input)
+                .pathObject);
+        },
+    }),
+    action("path.constants", {
+        description: "Get path separator constants",
+        execute() {
+            return { sep, delimiter };
+        },
+    }),
+    // os/process/shell actions
+    action("os.info", {
+        description: "Get useful host OS information",
+        execute() {
+            return {
+                platform: platform(),
+                arch: arch(),
+                type: type(),
+                release: release(),
+                hostname: hostname(),
+                homedir: homedir(),
+                tmpdir: tmpdir(),
+                uptime: uptime(),
+                totalmem: totalmem(),
+                freemem: freemem(),
+                eol: EOL,
+                cpus: cpus().map((cpu) => ({ model: cpu.model, speed: cpu.speed })),
+            };
+        },
+    }),
+    action("os.platform", {
+        description: "Get OS platform",
+        execute: () => platform(),
+    }),
+    action("os.arch", {
+        description: "Get OS architecture",
+        execute: () => arch(),
+    }),
+    action("os.homedir", {
+        description: "Get home directory",
+        execute: () => homedir(),
+    }),
+    action("os.tmpdir", {
+        description: "Get temp directory",
+        execute: () => tmpdir(),
+    }),
+    action("os.userInfo", {
+        description: "Get current user information",
+        execute() {
+            const info = userInfo();
+            return {
+                username: info.username,
+                uid: info.uid,
+                gid: info.gid,
+                shell: info.shell,
+                homedir: info.homedir,
+            };
+        },
+    }),
+    action("process.cwd", {
+        description: "Get the current working directory",
+        execute: () => process.cwd(),
+    }),
+    action("process.env", {
+        description: "Read environment variables from the host process",
+        inputSchema: {
+            name: {
+                type: "string",
+                required: false,
+                description: "Optional variable name. Omit to return all env vars.",
+            },
+        },
+        execute(input) {
+            const name = input?.name;
+            return name ? process.env[name] : { ...process.env };
+        },
+    }),
+    action("process.exec", {
+        description: "Run a shell command on the host",
+        inputSchema: {
+            command: {
+                type: "string",
+                required: true,
+                description: "Shell command",
+            },
+            cwd: {
+                type: "string",
+                required: false,
+                description: "Working directory",
+            },
+            timeout: {
+                type: "number",
+                required: false,
+                description: "Timeout in milliseconds",
+            },
+        },
+        async execute(input) {
+            const { command, cwd, timeout } = objectInput(input);
+            const { stdout, stderr } = await exec(command, {
+                cwd,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            return { stdout, stderr };
+        },
+    }),
+    action("process.execFile", {
+        description: "Run a host executable without a shell",
+        inputSchema: {
+            file: {
+                type: "string",
+                required: true,
+                description: "Executable path or name",
+            },
+            args: { type: "array", required: false, description: "Arguments" },
+            cwd: {
+                type: "string",
+                required: false,
+                description: "Working directory",
+            },
+            timeout: {
+                type: "number",
+                required: false,
+                description: "Timeout in milliseconds",
+            },
+        },
+        async execute(input) {
+            const { file, args = [], cwd, timeout, } = objectInput(input);
+            const { stdout, stderr } = await execFile(file, args, {
+                cwd,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            return { stdout, stderr };
+        },
+    }),
+    action("crypto.randomUUID", {
+        description: "Generate a random UUID using the host crypto runtime",
+        execute() {
+            return randomUUID();
+        },
+    }),
+    action("crypto.randomBytes", {
+        description: "Generate cryptographically strong random bytes as hex or base64",
+        inputSchema: {
+            size: {
+                type: "number",
+                required: true,
+                description: "Number of bytes",
+            },
+            encoding: {
+                type: "string",
+                required: false,
+                description: "hex or base64. Defaults to hex.",
+            },
+        },
+        execute(input) {
+            const { size, encoding = "hex" } = objectInput(input);
+            return randomBytes(size).toString(encoding);
+        },
+    }),
+    action("crypto.hash", {
+        description: "Hash text data with a Node crypto digest algorithm",
+        inputSchema: {
+            algorithm: {
+                type: "string",
+                required: false,
+                description: "Digest algorithm. Defaults to sha256.",
+            },
+            data: { type: "string", required: true, description: "Data to hash" },
+            encoding: {
+                type: "string",
+                required: false,
+                description: "Digest encoding. Defaults to hex.",
+            },
+        },
+        execute(input) {
+            const { algorithm = "sha256", data, encoding = "hex", } = objectInput(input);
+            return createHash(algorithm).update(data).digest(encoding);
+        },
+    }),
+    action("fetch", {
+        description: "Perform an HTTP fetch from the host runtime",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Request URL" },
+            method: { type: "string", required: false, description: "HTTP method" },
+            headers: {
+                type: "object",
+                required: false,
+                description: "Request headers",
+            },
+            body: { type: "string", required: false, description: "Request body" },
+        },
+        async execute(input) {
+            const { url, method, headers, body } = objectInput(input);
+            const res = await fetch(url, { method, headers, body });
+            const contentType = res.headers.get("content-type") ?? "";
+            const text = await res.text();
+            return {
+                ok: res.ok,
+                status: res.status,
+                statusText: res.statusText,
+                headers: Object.fromEntries(res.headers.entries()),
+                body: contentType.includes("application/json") ? safeJson(text) : text,
+            };
+        },
+    }),
+];
+function objectInput(input) {
+    return (input && typeof input === "object" ? input : {});
+}
+function stringArrayInput(input) {
+    if (Array.isArray(input))
+        return input.map(String);
+    const { segments } = objectInput(input);
+    return Array.isArray(segments) ? segments.map(String) : [];
+}
+function ok(extra = {}) {
+    return { ok: true, ...extra };
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function serializeStats(s) {
+    return {
+        size: s.size,
+        mode: s.mode,
+        uid: s.uid,
+        gid: s.gid,
+        atimeMs: s.atimeMs,
+        mtimeMs: s.mtimeMs,
+        ctimeMs: s.ctimeMs,
+        birthtimeMs: s.birthtimeMs,
+        isFile: s.isFile(),
+        isDirectory: s.isDirectory(),
+        isSymbolicLink: s.isSymbolicLink(),
+        isBlockDevice: s.isBlockDevice(),
+        isCharacterDevice: s.isCharacterDevice(),
+        isFIFO: s.isFIFO(),
+        isSocket: s.isSocket(),
+    };
+}

package/dist/sdk.d.ts

@@ -12,7 +12,7 @@ export declare class Runline {
     private _config;
     private constructor();
     static create(options?: RunlineOptions): Runline;
-    /** Execute JavaScript code in the sandbox. */
+    /** Execute JavaScript code in the QuickJS runtime. */
     execute(code: string): Promise<ExecuteResult>;
     /** Register an additional plugin after creation. */
     addPlugin(pluginOrFn: PluginDef | PluginFunction, connections?: ConnectionConfig[]): void;

package/dist/sdk.js

@@ -23,7 +23,7 @@ export class Runline {
     static create(options = {}) {
         return new Runline(options);
     }
-    /** Execute JavaScript code in the sandbox. */
+    /** Execute JavaScript code in the QuickJS runtime. */
     async execute(code) {
         const engine = new ExecutionEngine(this._registry, this._config);
         return engine.execute(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -55,7 +55,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@biomejs/biome": "^2.3.14",
+    "@biomejs/biome": "^2.4.12",
     "@types/bun": "^1.2.17",
     "@types/node": "^25.5.0",
     "@types/proper-lockfile": "^4.1.4",