runline 0.1.0

package/dist/commands/plugin.js

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import { installPlugin, listInstalled, removePlugin, } from "../plugin/installer.js";
+import { loadAllPlugins } from "../plugin/loader.js";
+import { registry } from "../plugin/registry.js";
+import { printError, printJson, printSuccess } from "../utils/output.js";
+export async function pluginInstall(source, options) {
+    try {
+        const result = await installPlugin(source, { global: options.global });
+        if (options.json) {
+            printJson({ ok: true, ...result });
+        }
+        else {
+            printSuccess(`Installed ${chalk.bold(result.name)} from ${source}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        printError(msg);
+        process.exit(1);
+    }
+}
+export async function pluginRemove(name, options) {
+    const removed = removePlugin(name);
+    if (!removed) {
+        printError(`Plugin "${name}" not found`);
+        process.exit(1);
+    }
+    if (options.json) {
+        printJson({ ok: true, removed: name });
+    }
+    else {
+        printSuccess(`Removed ${chalk.bold(name)}`);
+    }
+}
+export async function pluginList(options) {
+    await loadAllPlugins();
+    const installed = listInstalled();
+    const loaded = registry.listPlugins();
+    if (options.json) {
+        printJson(loaded.map((p) => ({
+            name: p.name,
+            version: p.version,
+            actions: p.actions.map((a) => a.name),
+            source: installed.find((i) => i.name === p.name)?.source,
+        })));
+        return;
+    }
+    if (loaded.length === 0) {
+        console.log("No plugins loaded.");
+        return;
+    }
+    for (const p of loaded) {
+        const src = installed.find((i) => i.name === p.name);
+        const srcLabel = src ? chalk.dim(` (${src.source})`) : "";
+        console.log(`  ${chalk.bold(p.name)} v${p.version}${srcLabel} — ${p.actions.length} action(s)`);
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export { addConnection, applyEnvOverrides, findConfigDir, getConnection, loadConfig, removeConnection, saveConfig, } from "./loader.js";
+export type { RunlineConfig } from "./types.js";
+export { DEFAULT_CONFIG } from "./types.js";

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export { addConnection, applyEnvOverrides, findConfigDir, getConnection, loadConfig, removeConnection, saveConfig, } from "./loader.js";
+export { DEFAULT_CONFIG } from "./types.js";

package/dist/config/loader.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectionConfig } from "../plugin/types.js";
+import { type RunlineConfig } from "./types.js";
+export declare function findConfigDir(): string | null;
+export declare function loadConfig(): RunlineConfig;
+export declare function saveConfig(config: RunlineConfig): void;
+export declare function addConnection(name: string, plugin: string, configValues: Record<string, unknown>): void;
+export declare function removeConnection(name: string): boolean;
+export declare function getConnection(plugin: string, name?: string): ConnectionConfig | undefined;
+export declare function applyEnvOverrides(conn: ConnectionConfig, schema?: Record<string, {
+    env?: string;
+}>): ConnectionConfig;

package/dist/config/loader.js

@@ -0,0 +1,82 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_CONFIG } from "./types.js";
+const CONFIG_DIR_NAME = ".runline";
+const CONFIG_FILE = "config.json";
+export function findConfigDir() {
+    let dir = process.cwd();
+    while (true) {
+        const candidate = join(dir, CONFIG_DIR_NAME);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = join(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function loadConfig() {
+    const configDir = findConfigDir();
+    if (!configDir)
+        return { ...DEFAULT_CONFIG };
+    const configPath = join(configDir, CONFIG_FILE);
+    if (!existsSync(configPath))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        return {
+            ...DEFAULT_CONFIG,
+            ...raw,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(config) {
+    const configDir = findConfigDir() ?? join(process.cwd(), CONFIG_DIR_NAME);
+    mkdirSync(configDir, { recursive: true });
+    const configPath = join(configDir, CONFIG_FILE);
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+export function addConnection(name, plugin, configValues) {
+    const config = loadConfig();
+    const existing = config.connections.findIndex((c) => c.name === name);
+    const conn = { name, plugin, config: configValues };
+    if (existing >= 0) {
+        config.connections[existing] = conn;
+    }
+    else {
+        config.connections.push(conn);
+    }
+    saveConfig(config);
+}
+export function removeConnection(name) {
+    const config = loadConfig();
+    const idx = config.connections.findIndex((c) => c.name === name);
+    if (idx < 0)
+        return false;
+    config.connections.splice(idx, 1);
+    saveConfig(config);
+    return true;
+}
+export function getConnection(plugin, name) {
+    const config = loadConfig();
+    if (name)
+        return config.connections.find((c) => c.name === name);
+    return config.connections.find((c) => c.plugin === plugin);
+}
+export function applyEnvOverrides(conn, schema) {
+    if (!schema)
+        return conn;
+    const config = { ...conn.config };
+    for (const [key, field] of Object.entries(schema)) {
+        if (field.env && !config[key]) {
+            const envVal = process.env[field.env];
+            if (envVal)
+                config[key] = envVal;
+        }
+    }
+    return { ...conn, config };
+}

package/dist/config/types.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionConfig } from "../plugin/types.js";
+export interface RunlineConfig {
+    connections: ConnectionConfig[];
+    /** Execution timeout in ms. Default 30_000. */
+    timeoutMs: number;
+    /** Memory limit for QuickJS in bytes. Default 64MB. */
+    memoryLimitBytes: number;
+}
+export declare const DEFAULT_CONFIG: RunlineConfig;

package/dist/config/types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_CONFIG = {
+    connections: [],
+    timeoutMs: 30_000,
+    memoryLimitBytes: 64 * 1024 * 1024,
+};

package/dist/core/engine.d.ts

@@ -0,0 +1,21 @@
+import type { RunlineConfig } from "../config/types.js";
+import type { PluginRegistry } from "../plugin/registry.js";
+export interface ExecuteResult {
+    result: unknown;
+    error?: string;
+    logs: string[];
+}
+export interface EngineOptions {
+    timeoutMs?: number;
+    memoryLimitBytes?: number;
+}
+export declare class ExecutionEngine {
+    private registry;
+    private config;
+    constructor(registry: PluginRegistry, config: RunlineConfig);
+    execute(code: string, options?: EngineOptions): Promise<ExecuteResult>;
+    private invokeAction;
+    private resolveConnection;
+    private drainAsync;
+    private drainJobs;
+}

package/dist/core/engine.js

@@ -0,0 +1,280 @@
+import { getQuickJS, shouldInterruptAfterDeadline, } from "quickjs-emscripten";
+import { applyEnvOverrides } from "../config/loader.js";
+export class ExecutionEngine {
+    registry;
+    config;
+    constructor(registry, config) {
+        this.registry = registry;
+        this.config = config;
+    }
+    async execute(code, options) {
+        const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
+        const memoryLimitBytes = options?.memoryLimitBytes ?? this.config.memoryLimitBytes;
+        const deadlineMs = Date.now() + timeoutMs;
+        const logs = [];
+        const pendingDeferreds = new Set();
+        const QuickJS = await getQuickJS();
+        const runtime = QuickJS.newRuntime();
+        try {
+            runtime.setMemoryLimit(memoryLimitBytes);
+            runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadlineMs));
+            const context = runtime.newContext();
+            try {
+                // Inject log bridge
+                const logBridge = context.newFunction("__runline_log", (levelHandle, lineHandle) => {
+                    const level = context.getString(levelHandle);
+                    const line = context.getString(lineHandle);
+                    logs.push(`[${level}] ${line}`);
+                    return context.undefined;
+                });
+                context.setProp(context.global, "__runline_log", logBridge);
+                logBridge.dispose();
+                // Inject action bridge
+                const actionBridge = context.newFunction("__runline_invoke", (pathHandle, argsHandle) => {
+                    const path = context.getString(pathHandle);
+                    const args = argsHandle === undefined ||
+                        context.typeof(argsHandle) === "undefined"
+                        ? undefined
+                        : context.dump(argsHandle);
+                    const deferred = context.newPromise();
+                    pendingDeferreds.add(deferred);
+                    deferred.settled.finally(() => pendingDeferreds.delete(deferred));
+                    this.invokeAction(path, args).then((value) => {
+                        if (!deferred.alive)
+                            return;
+                        if (value === undefined) {
+                            deferred.resolve();
+                            return;
+                        }
+                        const serialized = JSON.stringify(value);
+                        const handle = context.newString(serialized);
+                        deferred.resolve(handle);
+                        handle.dispose();
+                    }, (err) => {
+                        if (!deferred.alive)
+                            return;
+                        const msg = err instanceof Error ? err.message : String(err);
+                        const handle = context.newError(msg);
+                        deferred.reject(handle);
+                        handle.dispose();
+                    });
+                    return deferred.handle;
+                });
+                context.setProp(context.global, "__runline_invoke", actionBridge);
+                actionBridge.dispose();
+                const plugins = this.registry.listPlugins();
+                const pluginNames = plugins.map((p) => p.name);
+                const helpData = buildHelpData(plugins);
+                const source = buildExecutionSource(code, pluginNames, helpData);
+                const evaluated = context.evalCode(source, "runline-sandbox.js");
+                if (evaluated.error) {
+                    const error = context.dump(evaluated.error);
+                    evaluated.error.dispose();
+                    return { result: null, error: formatError(error), logs };
+                }
+                // Set up promise tracking
+                context.setProp(context.global, "__runline_result", evaluated.value);
+                evaluated.value.dispose();
+                const stateResult = context.evalCode(`(function(p){ var s = { v: void 0, e: void 0, settled: false };
+           var fmtErr = function(e){ if (e && typeof e === 'object') { var m = typeof e.message === 'string' ? e.message : ''; var st = typeof e.stack === 'string' ? e.stack : ''; if (m && st) return st.indexOf(m) === -1 ? m + '\\n' + st : st; if (m) return m; if (st) return st; } return String(e); };
+           p.then(function(v){ s.v = v; s.settled = true; }, function(e){ s.e = fmtErr(e); s.settled = true; }); return s; })(__runline_result)`);
+                if (stateResult.error) {
+                    const error = context.dump(stateResult.error);
+                    stateResult.error.dispose();
+                    return { result: null, error: formatError(error), logs };
+                }
+                const stateHandle = stateResult.value;
+                try {
+                    await this.drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs);
+                    const settled = readProp(context, stateHandle, "settled") === true;
+                    if (!settled) {
+                        return {
+                            result: null,
+                            error: `Execution timed out after ${timeoutMs}ms`,
+                            logs,
+                        };
+                    }
+                    const error = readProp(context, stateHandle, "e");
+                    if (error !== undefined) {
+                        return { result: null, error: formatError(error), logs };
+                    }
+                    return { result: readProp(context, stateHandle, "v"), logs };
+                }
+                finally {
+                    stateHandle.dispose();
+                }
+            }
+            finally {
+                for (const d of pendingDeferreds) {
+                    if (d.alive)
+                        d.dispose();
+                }
+                pendingDeferreds.clear();
+                context.dispose();
+            }
+        }
+        catch (err) {
+            return {
+                result: null,
+                error: formatError(err),
+                logs,
+            };
+        }
+        finally {
+            runtime.dispose();
+        }
+    }
+    async invokeAction(path, args) {
+        const resolved = this.registry.resolveAction(path);
+        if (!resolved) {
+            throw new Error(`Unknown action: ${path}`);
+        }
+        const { plugin, action } = resolved;
+        const connection = this.resolveConnection(plugin);
+        const ctx = {
+            connection,
+            log: {
+                info: (msg) => console.log(`[${plugin.name}] ${msg}`),
+                warn: (msg) => console.warn(`[${plugin.name}] ${msg}`),
+                error: (msg) => console.error(`[${plugin.name}] ${msg}`),
+            },
+        };
+        return action.execute(args, ctx);
+    }
+    resolveConnection(plugin) {
+        const conn = this.config.connections.find((c) => c.plugin === plugin.name);
+        const base = conn ?? {
+            name: "default",
+            plugin: plugin.name,
+            config: {},
+        };
+        return applyEnvOverrides(base, plugin.connectionConfigSchema);
+    }
+    async drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs) {
+        this.drainJobs(context, runtime, deadlineMs, timeoutMs);
+        while (pendingDeferreds.size > 0) {
+            const remainingMs = deadlineMs - Date.now();
+            if (remainingMs <= 0) {
+                throw new Error(`Execution timed out after ${timeoutMs}ms`);
+            }
+            let timer;
+            try {
+                await Promise.race([
+                    Promise.race([...pendingDeferreds].map((d) => d.settled)),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error(`Execution timed out after ${timeoutMs}ms`)), remainingMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            this.drainJobs(context, runtime, deadlineMs, timeoutMs);
+        }
+        this.drainJobs(context, runtime, deadlineMs, timeoutMs);
+    }
+    drainJobs(context, runtime, deadlineMs, timeoutMs) {
+        while (runtime.hasPendingJob()) {
+            if (Date.now() >= deadlineMs) {
+                throw new Error(`Execution timed out after ${timeoutMs}ms`);
+            }
+            const pending = runtime.executePendingJobs();
+            if (pending.error) {
+                const error = context.dump(pending.error);
+                pending.error.dispose();
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+    }
+}
+// ── Helpers ──────────────────────────────────────────────
+function readProp(context, handle, key) {
+    const prop = context.getProp(handle, key);
+    try {
+        return context.dump(prop);
+    }
+    finally {
+        prop.dispose();
+    }
+}
+function formatError(cause) {
+    if (cause instanceof Error)
+        return cause.stack ?? cause.message;
+    if (typeof cause === "object" &&
+        cause !== null &&
+        "message" in cause &&
+        typeof cause.message === "string") {
+        return cause.message;
+    }
+    return String(cause);
+}
+function buildHelpData(plugins) {
+    const data = {};
+    for (const p of plugins) {
+        data[p.name] = p.actions.map((a) => ({
+            action: a.name,
+            description: a.description,
+            inputs: Object.fromEntries(Object.entries(a.inputSchema ?? {}).map(([k, v]) => [
+                k,
+                `${v.type}${v.required ? " (required)" : ""}${v.description ? " — " + v.description : ""}`,
+            ])),
+        }));
+    }
+    return data;
+}
+function buildExecutionSource(code, pluginNames = [], helpData = {}) {
+    const trimmed = code.trim();
+    const looksLikeArrow = (trimmed.startsWith("async") || trimmed.startsWith("(")) &&
+        trimmed.includes("=>");
+    const body = looksLikeArrow
+        ? `const __fn = (${trimmed});\nif (typeof __fn !== 'function') throw new Error('Code must evaluate to a function');\nreturn await __fn();`
+        : code;
+    const wrapped = `"use strict";
+const __invoke = __runline_invoke;
+const __log = __runline_log;
+try { delete globalThis.__runline_invoke; } catch {}
+try { delete globalThis.__runline_log; } catch {}
+
+const __fmt = (v) => {
+  if (typeof v === 'string') return v;
+  try { return JSON.stringify(v); } catch { return String(v); }
+};
+
+const __help = ${JSON.stringify(helpData)};
+
+const __makeProxy = (path = []) => new Proxy(() => undefined, {
+  get(_t, prop) {
+    if (prop === 'then' || typeof prop === 'symbol') return undefined;
+    if (prop === 'help') {
+      const pluginName = path[0];
+      return () => pluginName && __help[pluginName] ? __help[pluginName] : __help;
+    }
+    return __makeProxy([...path, String(prop)]);
+  },
+  apply(_t, _this, args) {
+    const p = path.join('.');
+    if (!p) throw new Error('Action path missing');
+    return Promise.resolve(__invoke(p, args[0]))
+      .then((raw) => raw === undefined ? undefined : JSON.parse(raw));
+  },
+});
+const actions = __makeProxy();
+const help = () => __help;
+${pluginNames.map((n) => `const ${n} = __makeProxy(['${n}']);`).join("\n")}
+
+const console = {
+  log: (...a) => __log('log', a.map(__fmt).join(' ')),
+  warn: (...a) => __log('warn', a.map(__fmt).join(' ')),
+  error: (...a) => __log('error', a.map(__fmt).join(' ')),
+  info: (...a) => __log('info', a.map(__fmt).join(' ')),
+  debug: (...a) => __log('debug', a.map(__fmt).join(' ')),
+};
+
+const fetch = () => { throw new Error('fetch is disabled in runline sandbox'); };
+
+(async () => {
+${body}
+})()`;
+    return wrapped;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { addConnection, findConfigDir, getConnection, loadConfig, removeConnection, saveConfig, } from "./config/loader.js";
+export type { RunlineConfig } from "./config/types.js";
+export { DEFAULT_CONFIG } from "./config/types.js";
+export type { EngineOptions, ExecuteResult } from "./core/engine.js";
+export { ExecutionEngine } from "./core/engine.js";
+export type { ActionDefinition, PluginFunction, RunlinePluginAPI, SchemaField, } from "./plugin/api.js";
+export { createPluginAPI, isPluginFunction, resolvePluginExport, } from "./plugin/api.js";
+export type { InstalledPlugin, PluginSource } from "./plugin/installer.js";
+export { installPlugin, listInstalled, parsePluginSource, removePlugin, } from "./plugin/installer.js";
+export { discoverPlugins, loadAllPlugins, loadPluginFromPath, loadPluginsFromConfig, } from "./plugin/loader.js";
+export { PluginRegistry, registry } from "./plugin/registry.js";
+export type { ActionContext, ActionDef, ConnectionConfig, InputField, InputSchema, PluginDef, } from "./plugin/types.js";
+export type { RunlineOptions } from "./sdk.js";
+export { Runline } from "./sdk.js";
+export type { ExecOptions, ExecResult, OutputParser } from "./utils/cli.js";
+export { commandExists, syncExec } from "./utils/cli.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { addConnection, findConfigDir, getConnection, loadConfig, removeConnection, saveConfig, } from "./config/loader.js";
+export { DEFAULT_CONFIG } from "./config/types.js";
+export { ExecutionEngine } from "./core/engine.js";
+export { createPluginAPI, isPluginFunction, resolvePluginExport, } from "./plugin/api.js";
+export { installPlugin, listInstalled, parsePluginSource, removePlugin, } from "./plugin/installer.js";
+export { discoverPlugins, loadAllPlugins, loadPluginFromPath, loadPluginsFromConfig, } from "./plugin/loader.js";
+export { PluginRegistry, registry } from "./plugin/registry.js";
+export { Runline } from "./sdk.js";
+export { commandExists, syncExec } from "./utils/cli.js";

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { actions } from "./commands/actions.js";
+import { connectionAdd, connectionList, connectionRemove, } from "./commands/connection.js";
+import { exec } from "./commands/exec.js";
+import { init } from "./commands/init.js";
+import { pluginInstall, pluginList, pluginRemove } from "./commands/plugin.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+const program = new Command();
+program
+    .name("runline")
+    .description("Code mode for agents — turn any API or command into a callable action")
+    .version(`runline ${version}`, "-v, --version")
+    .option("--json", "Output as JSON")
+    .option("-q, --quiet", "Suppress output")
+    .option("--no-color", "Disable color output")
+    .hook("preAction", (thisCommand) => {
+    if (thisCommand.opts().color === false) {
+        process.env.NO_COLOR = "1";
+    }
+})
+    .addHelpText("after", `
+Examples:
+  $ runline exec 'return await docker.containers.list()'
+  $ runline exec -f ./scripts/deploy.js
+  $ runline actions
+  $ runline connection add gh --plugin github --set token=ghp_xxx
+
+https://github.com/Michaelliv/runline`);
+program
+    .command("exec <code>")
+    .alias("e")
+    .description("Execute JavaScript code in the sandbox")
+    .option("-f, --file", "Treat <code> as a file path")
+    .addHelpText("after", `
+The code runs in a QuickJS sandbox with an \`actions\` proxy.
+Each installed plugin is a top-level global. Dot-chain into resource and action.
+
+Examples:
+  $ runline exec 'return await docker.containers.list()'
+  $ runline exec -f ./scripts/deploy.js
+  $ runline exec 'return await github.repo.list({ owner: "torvalds" })'`)
+    .action(async (code, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await exec(code, {
+        file: opts.file,
+        json: globals.json,
+        quiet: globals.quiet,
+    });
+});
+program
+    .command("actions")
+    .description("List all available actions and their schemas")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await actions({ json: globals.json });
+});
+// ── connection ──────────────────────────────────────────
+const connCmd = program
+    .command("connection")
+    .alias("conn")
+    .description("Manage connections");
+connCmd
+    .command("add <name>")
+    .description("Add a connection")
+    .requiredOption("-p, --plugin <plugin>", "Plugin name")
+    .option("-s, --set <key=value...>", "Config values", (v, prev) => [...prev, v], [])
+    .action(async (name, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await connectionAdd(name, {
+        plugin: opts.plugin,
+        set: opts.set,
+        json: globals.json,
+    });
+});
+connCmd
+    .command("remove <name>")
+    .description("Remove a connection")
+    .action(async (name, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await connectionRemove(name, { json: globals.json });
+});
+connCmd
+    .command("list")
+    .description("List connections")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await connectionList({ json: globals.json });
+});
+// ── plugin ──────────────────────────────────────────────
+const pluginCmd = program.command("plugin").description("Manage plugins");
+pluginCmd
+    .command("install <source>")
+    .description("Install a plugin (npm:pkg, git:repo, or local path)")
+    .option("-g, --global", "Install globally")
+    .action(async (source, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginInstall(source, { global: opts.global, json: globals.json });
+});
+pluginCmd
+    .command("remove <name>")
+    .description("Remove an installed plugin")
+    .action(async (name, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginRemove(name, { json: globals.json });
+});
+pluginCmd
+    .command("list")
+    .description("List all plugins")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await pluginList({ json: globals.json });
+});
+// ── init ────────────────────────────────────────────────
+program
+    .command("init")
+    .description("Create .runline/ in current directory")
+    .action(async (_opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    await init({ json: globals.json, quiet: globals.quiet });
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error("Fatal error:", err.message);
+    process.exit(1);
+});

package/dist/plugin/api.d.ts

@@ -0,0 +1,32 @@
+import type { ActionDef, InputSchema, PluginDef } from "./types.js";
+export interface SchemaField {
+    type: "string" | "number" | "boolean";
+    required?: boolean;
+    description?: string;
+    default?: unknown;
+    env?: string;
+}
+export interface ActionDefinition {
+    description?: string;
+    inputSchema?: InputSchema;
+    execute: ActionDef["execute"];
+}
+export interface RunlinePluginAPI {
+    registerAction(name: string, def: ActionDefinition): void;
+    setConnectionSchema(schema: Record<string, SchemaField>): void;
+    setName(name: string): void;
+    setVersion(version: string): void;
+    onInit(fn: (config: Record<string, unknown>) => void): void;
+    log: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+}
+export type PluginFunction = (api: RunlinePluginAPI) => void;
+export declare function createPluginAPI(pluginId: string): {
+    api: RunlinePluginAPI;
+    resolve: () => PluginDef;
+};
+export declare function isPluginFunction(val: unknown): val is PluginFunction;
+export declare function resolvePluginExport(exported: PluginFunction | PluginDef, pluginId: string): PluginDef;