runline 0.7.2 → 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/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

@@ -4,7 +4,6 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 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));
 export async function loadPluginFromPath(path) {
@@ -163,11 +162,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);
         },
     });

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

@@ -4,7 +4,6 @@ import { DEFAULT_CONFIG } from "./config/types.js";
 import { ExecutionEngine } from "./core/engine.js";
 import { resolvePluginExport } from "./plugin/api.js";
 import { discoverPlugins } from "./plugin/loader.js";
-import { registerNodePlugin } from "./plugin/node-plugin.js";
 import { PluginRegistry } from "./plugin/registry.js";
 export class Runline {
     _registry;
@@ -15,7 +14,6 @@ export class Runline {
             const plugin = resolvePluginExport(pluginOrFn, "unknown");
             this._registry.register(plugin);
         }
-        registerNodePlugin(this._registry);
         this._config = {
             connections: options.connections ?? [],
             timeoutMs: options.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
@@ -34,7 +32,6 @@ export class Runline {
     addPlugin(pluginOrFn, connections) {
         const plugin = resolvePluginExport(pluginOrFn, "unknown");
         this._registry.register(plugin);
-        registerNodePlugin(this._registry);
         if (connections) {
             this._config = {
                 ...this._config,
@@ -104,7 +101,6 @@ export class Runline {
         for (const plugin of plugins) {
             rl._registry.register(plugin);
         }
-        registerNodePlugin(rl._registry);
         return rl;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",

package/dist/plugin/node-plugin.d.ts

@@ -1,4 +0,0 @@
-import type { PluginRegistry } from "./registry.js";
-import type { PluginDef } from "./types.js";
-export declare function registerNodePlugin(registry: PluginRegistry): void;
-export declare const nodePlugin: PluginDef;

package/dist/plugin/node-plugin.js

@@ -1,546 +0,0 @@
-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 function registerNodePlugin(registry) {
-    registry.register(nodePlugin);
-}
-export const nodePlugin = {
-    name: "node",
-    version: "0.1.0",
-    actions: [
-        // 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(),
-    };
-}