runline 0.7.2 → 0.7.5

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.5",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -65,6 +65,7 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "jiti": "^2.7.0",
     "proper-lockfile": "^4.1.2",
     "quickjs-emscripten": "^0.32.0",
     "rrule": "^2.8.1"

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;