runline 0.1.0

package/dist/sdk.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+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 { PluginRegistry } from "./plugin/registry.js";
+export class Runline {
+    _registry;
+    _config;
+    constructor(options) {
+        this._registry = new PluginRegistry();
+        for (const pluginOrFn of options.plugins ?? []) {
+            const plugin = resolvePluginExport(pluginOrFn, "unknown");
+            this._registry.register(plugin);
+        }
+        this._config = {
+            connections: options.connections ?? [],
+            timeoutMs: options.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
+            memoryLimitBytes: options.memoryLimitBytes ?? DEFAULT_CONFIG.memoryLimitBytes,
+        };
+    }
+    static create(options = {}) {
+        return new Runline(options);
+    }
+    /** Execute JavaScript code in the sandbox. */
+    async execute(code) {
+        const engine = new ExecutionEngine(this._registry, this._config);
+        return engine.execute(code);
+    }
+    /** Register an additional plugin after creation. */
+    addPlugin(pluginOrFn, connections) {
+        const plugin = resolvePluginExport(pluginOrFn, "unknown");
+        this._registry.register(plugin);
+        if (connections) {
+            this._config = {
+                ...this._config,
+                connections: [...this._config.connections, ...connections],
+            };
+        }
+    }
+    /** List all available actions across all plugins. */
+    actions() {
+        return this._registry.getAllActions().map(({ plugin, action }) => ({
+            plugin,
+            action: action.name,
+            description: action.description,
+            inputSchema: action.inputSchema,
+        }));
+    }
+    /** List registered plugins. */
+    plugins() {
+        return this._registry.listPlugins().map((p) => ({
+            name: p.name,
+            version: p.version,
+            actions: p.actions.map((a) => a.name),
+        }));
+    }
+    /**
+     * Load runline from a project directory.
+     * Discovers .runline/ config and installed plugins, just like the CLI.
+     * Fully self-contained — does not mutate global state.
+     */
+    static async fromProject(cwd) {
+        const dir = cwd ?? process.cwd();
+        const configDir = findRunlineDir(dir);
+        if (!configDir)
+            return null;
+        const config = loadConfigFrom(configDir);
+        const plugins = await discoverPlugins(configDir);
+        const rl = new Runline({
+            connections: config.connections,
+            timeoutMs: config.timeoutMs,
+            memoryLimitBytes: config.memoryLimitBytes,
+        });
+        for (const plugin of plugins) {
+            rl._registry.register(plugin);
+        }
+        return rl;
+    }
+}
+function findRunlineDir(from) {
+    let dir = from;
+    while (true) {
+        if (existsSync(join(dir, ".runline")))
+            return join(dir, ".runline");
+        const parent = join(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function loadConfigFrom(configDir) {
+    const configPath = join(configDir, "config.json");
+    if (!existsSync(configPath))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        return { ...DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}

package/dist/utils/cli.d.ts

@@ -0,0 +1,13 @@
+export type OutputParser = "json" | "jsonlines" | "text";
+export interface ExecOptions {
+    parser?: OutputParser;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+}
+export interface ExecResult {
+    stdout: string;
+    rows: Record<string, unknown>[];
+}
+export declare function syncExec(command: string, args: string[], options?: ExecOptions): ExecResult;
+export declare function commandExists(name: string): boolean;

package/dist/utils/cli.js

@@ -0,0 +1,32 @@
+import { execFileSync, execSync } from "node:child_process";
+export function syncExec(command, args, options = {}) {
+    const stdout = execFileSync(command, args, {
+        encoding: "utf-8",
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : undefined,
+        timeout: options.timeout,
+        maxBuffer: 100 * 1024 * 1024,
+    }).trim();
+    const parser = options.parser ?? "text";
+    let rows = [];
+    if (parser === "json" && stdout) {
+        const parsed = JSON.parse(stdout);
+        rows = Array.isArray(parsed) ? parsed : [parsed];
+    }
+    else if (parser === "jsonlines" && stdout) {
+        rows = stdout
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    return { stdout, rows };
+}
+export function commandExists(name) {
+    try {
+        execSync(`which ${name}`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/output.d.ts

@@ -0,0 +1,4 @@
+export declare function printJson(data: unknown): void;
+export declare function printSuccess(msg: string): void;
+export declare function printError(msg: string): void;
+export declare function printWarn(msg: string): void;

package/dist/utils/output.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function printSuccess(msg) {
+    console.log(chalk.green("✓"), msg);
+}
+export function printError(msg) {
+    console.error(chalk.red("✗"), msg);
+}
+export function printWarn(msg) {
+    console.warn(chalk.yellow("⚠"), msg);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "runline",
+  "version": "0.1.0",
+  "description": "Code mode for agents — turn any API or command into a callable action",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./utils/http": "./dist/utils/http.js",
+    "./utils/cli": "./dist/utils/cli.js"
+  },
+  "bin": {
+    "runline": "./dist/main.js"
+  },
+  "files": [
+    "dist",
+    ".pi/extensions"
+  ],
+  "pi": {
+    "extensions": [
+      ".pi/extensions/runline-context"
+    ]
+  },
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.plugins.json --noCheck",
+    "prepublishOnly": "npm run build",
+    "dev": "npx tsx src/main.ts",
+    "test": "npx tsx --test src/tests/**/*.test.ts",
+    "format": "npx @biomejs/biome format --write src/",
+    "lint": "npx @biomejs/biome lint src/",
+    "check": "npx @biomejs/biome check src/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Michaelliv/runline.git"
+  },
+  "homepage": "https://github.com/Michaelliv/runline#readme",
+  "keywords": [
+    "agent",
+    "tools",
+    "mcp",
+    "sandbox",
+    "cli"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.0"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "quickjs-emscripten": "^0.32.0"
+  }
+}