runline 0.7.1 → 0.7.2

package/dist/core/engine.js

@@ -1,12 +1,14 @@
 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

@@ -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.
+The built-in \`node\` global exposes host-backed fs/path/os/process/crypto/fetch actions.
 
 Examples:
   $ runline exec 'return await docker.containers.list()'

package/dist/plugin/loader.js

@@ -4,6 +4,7 @@ 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) {
@@ -168,4 +169,5 @@ export async function loadAllPlugins() {
     for (const p of plugins) {
         registry.register(p);
     }
+    registerNodePlugin(registry);
 }

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,546 @@
+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(),
+    };
+}

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

@@ -4,6 +4,7 @@ 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;
@@ -14,6 +15,7 @@ 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,
@@ -23,7 +25,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);
@@ -32,6 +34,7 @@ export class Runline {
     addPlugin(pluginOrFn, connections) {
         const plugin = resolvePluginExport(pluginOrFn, "unknown");
         this._registry.register(plugin);
+        registerNodePlugin(this._registry);
         if (connections) {
             this._config = {
                 ...this._config,
@@ -101,6 +104,7 @@ 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.1",
+  "version": "0.7.2",
   "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",