runline 0.1.0

package/dist/plugin/api.js

@@ -0,0 +1,68 @@
+export function createPluginAPI(pluginId) {
+    let name = pluginId;
+    let version = "0.0.0";
+    const actions = [];
+    let connectionConfigSchema;
+    const initHooks = [];
+    const api = {
+        setName(n) {
+            if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(n)) {
+                throw new Error(`Invalid plugin name "${n}": must be a valid JS identifier (no hyphens, no dots). Use camelCase.`);
+            }
+            name = n;
+        },
+        setVersion(v) {
+            version = v;
+        },
+        registerAction(actionName, def) {
+            actions.push({ name: actionName, ...def });
+        },
+        setConnectionSchema(schema) {
+            connectionConfigSchema = {};
+            for (const [key, field] of Object.entries(schema)) {
+                connectionConfigSchema[key] = { ...field };
+            }
+        },
+        onInit(fn) {
+            initHooks.push(fn);
+        },
+        log: {
+            info(msg) {
+                console.log(`[${name}] ${msg}`);
+            },
+            warn(msg) {
+                console.warn(`[${name}] ${msg}`);
+            },
+            error(msg) {
+                console.error(`[${name}] ${msg}`);
+            },
+        },
+    };
+    function resolve() {
+        const plugin = {
+            name,
+            version,
+            actions,
+            connectionConfigSchema,
+        };
+        if (initHooks.length > 0) {
+            plugin.initHooks = initHooks;
+        }
+        return plugin;
+    }
+    return { api, resolve };
+}
+export function isPluginFunction(val) {
+    return typeof val === "function";
+}
+export function resolvePluginExport(exported, pluginId) {
+    if (isPluginFunction(exported)) {
+        const { api, resolve } = createPluginAPI(pluginId);
+        exported(api);
+        return resolve();
+    }
+    if (exported && typeof exported === "object" && "actions" in exported) {
+        return exported;
+    }
+    throw new Error(`Invalid plugin export from "${pluginId}": expected a function or { name, actions } object`);
+}

package/dist/plugin/installer.d.ts

@@ -0,0 +1,27 @@
+export interface PluginSource {
+    type: "npm" | "git" | "local";
+    name: string;
+    ref?: string;
+    url?: string;
+    path?: string;
+    subpath?: string;
+}
+export interface InstalledPlugin {
+    source: string;
+    path: string;
+    name?: string;
+}
+export declare function parsePluginSource(source: string): PluginSource;
+export declare function installPlugin(source: string, options?: {
+    global?: boolean;
+}): Promise<{
+    path: string;
+    name: string;
+}>;
+export declare function removePlugin(name: string): boolean;
+export declare function listInstalled(): Array<{
+    name: string;
+    type: string;
+    source: string;
+    path: string;
+}>;

package/dist/plugin/installer.js

@@ -0,0 +1,181 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { findConfigDir } from "../config/loader.js";
+const PLUGINS_FILE = "plugins.json";
+export function parsePluginSource(source) {
+    if (source.startsWith("npm:")) {
+        const rest = source.slice(4);
+        let name;
+        let ref;
+        if (rest.startsWith("@")) {
+            const lastAt = rest.lastIndexOf("@");
+            if (lastAt > 0 && lastAt !== rest.indexOf("@")) {
+                name = rest.slice(0, lastAt);
+                ref = rest.slice(lastAt + 1);
+            }
+            else {
+                name = rest;
+            }
+        }
+        else {
+            const atIdx = rest.indexOf("@");
+            if (atIdx > 0) {
+                name = rest.slice(0, atIdx);
+                ref = rest.slice(atIdx + 1);
+            }
+            else {
+                name = rest;
+            }
+        }
+        return { type: "npm", name, ref };
+    }
+    if (source.startsWith("git:") ||
+        source.startsWith("https://") ||
+        source.startsWith("http://") ||
+        source.startsWith("ssh://")) {
+        let raw = source;
+        if (raw.startsWith("git:"))
+            raw = raw.slice(4);
+        let subpath;
+        const hashIdx = raw.indexOf("#");
+        if (hashIdx > 0) {
+            subpath = raw.slice(hashIdx + 1);
+            raw = raw.slice(0, hashIdx);
+        }
+        let ref;
+        const atIdx = raw.lastIndexOf("@");
+        if (atIdx > 0 && !raw.slice(atIdx).includes("/")) {
+            ref = raw.slice(atIdx + 1);
+            raw = raw.slice(0, atIdx);
+        }
+        let url = raw;
+        if (!url.startsWith("http://") &&
+            !url.startsWith("https://") &&
+            !url.startsWith("ssh://")) {
+            url = `https://${url}`;
+        }
+        if (!url.endsWith(".git"))
+            url += ".git";
+        const name = subpath ? basename(subpath) : basename(url, ".git");
+        return { type: "git", name, url, ref, subpath };
+    }
+    const absPath = resolve(source);
+    const name = basename(absPath).replace(/\.(ts|js)$/, "");
+    return { type: "local", name, path: absPath };
+}
+function getPluginsDir(global) {
+    if (global) {
+        const dir = join(homedir(), ".runline", "plugins");
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    const configDir = findConfigDir();
+    const dir = configDir
+        ? join(configDir, "..", ".runline", "plugins")
+        : join(process.cwd(), ".runline", "plugins");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function getPluginsJsonPath() {
+    const configDir = findConfigDir();
+    return configDir
+        ? join(configDir, PLUGINS_FILE)
+        : join(process.cwd(), ".runline", PLUGINS_FILE);
+}
+function readPluginsJson() {
+    const path = getPluginsJsonPath();
+    if (!existsSync(path))
+        return { plugins: [] };
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+function writePluginsJson(data) {
+    const path = getPluginsJsonPath();
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+}
+export async function installPlugin(source, options) {
+    const parsed = parsePluginSource(source);
+    const pluginsDir = getPluginsDir(options?.global ?? false);
+    let installPath;
+    switch (parsed.type) {
+        case "npm": {
+            const npmDir = join(pluginsDir, "npm");
+            mkdirSync(npmDir, { recursive: true });
+            const spec = parsed.ref ? `${parsed.name}@${parsed.ref}` : parsed.name;
+            execSync(`npm install ${spec}`, { cwd: npmDir, stdio: "pipe" });
+            installPath = join(npmDir, "node_modules", parsed.name);
+            break;
+        }
+        case "git": {
+            const gitUrl = parsed.url;
+            const urlObj = new URL(gitUrl);
+            const gitDir = join(pluginsDir, "git", urlObj.hostname, urlObj.pathname.replace(/\.git$/, ""));
+            if (existsSync(gitDir)) {
+                execSync("git pull", { cwd: gitDir, stdio: "pipe" });
+            }
+            else {
+                mkdirSync(join(gitDir, ".."), { recursive: true });
+                const refArg = parsed.ref ? `--branch ${parsed.ref}` : "";
+                execSync(`git clone ${refArg} ${parsed.url} ${gitDir}`, {
+                    stdio: "pipe",
+                });
+            }
+            if (existsSync(join(gitDir, "package.json"))) {
+                execSync("npm install", { cwd: gitDir, stdio: "pipe" });
+            }
+            installPath = parsed.subpath ? join(gitDir, parsed.subpath) : gitDir;
+            break;
+        }
+        case "local": {
+            const localPath = parsed.path;
+            if (!existsSync(localPath)) {
+                throw new Error(`Path does not exist: ${localPath}`);
+            }
+            installPath = localPath;
+            break;
+        }
+    }
+    const data = readPluginsJson();
+    const existing = data.plugins.findIndex((p) => p.source === source);
+    const entry = {
+        source,
+        path: installPath,
+        name: parsed.name,
+    };
+    if (existing >= 0) {
+        data.plugins[existing] = entry;
+    }
+    else {
+        data.plugins.push(entry);
+    }
+    writePluginsJson(data);
+    return { path: installPath, name: parsed.name };
+}
+export function removePlugin(name) {
+    const data = readPluginsJson();
+    const idx = data.plugins.findIndex((p) => p.name === name || p.source.includes(name));
+    if (idx < 0)
+        return false;
+    const plugin = data.plugins[idx];
+    const parsed = parsePluginSource(plugin.source);
+    if (parsed.type !== "local" && existsSync(plugin.path)) {
+        rmSync(plugin.path, { recursive: true, force: true });
+    }
+    data.plugins.splice(idx, 1);
+    writePluginsJson(data);
+    return true;
+}
+export function listInstalled() {
+    const data = readPluginsJson();
+    return data.plugins.map((p) => {
+        const parsed = parsePluginSource(p.source);
+        return {
+            name: p.name || parsed.name,
+            type: parsed.type,
+            source: p.source,
+            path: p.path,
+        };
+    });
+}

package/dist/plugin/loader.d.ts

@@ -0,0 +1,13 @@
+import type { PluginDef } from "./types.js";
+export declare function loadPluginFromPath(path: string): Promise<PluginDef>;
+export declare function loadPluginsFromConfig(configDir: string): Promise<PluginDef[]>;
+/**
+ * Discover and return all plugins from a config directory and global dir.
+ * Does NOT mutate any global state.
+ */
+export declare function discoverPlugins(configDir?: string | null): Promise<PluginDef[]>;
+/**
+ * Load all plugins and register them into the global registry.
+ * Used by the CLI.
+ */
+export declare function loadAllPlugins(): Promise<void>;

package/dist/plugin/loader.js

@@ -0,0 +1,164 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+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 { registry } from "./registry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export async function loadPluginFromPath(path) {
+    let absPath = resolve(path);
+    if (existsSync(absPath) && statSync(absPath).isDirectory()) {
+        const candidates = [
+            join(absPath, "src", "index.ts"),
+            join(absPath, "src", "index.js"),
+            join(absPath, "index.ts"),
+            join(absPath, "index.js"),
+        ];
+        const pkgPath = join(absPath, "package.json");
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                if (pkg.main)
+                    candidates.unshift(join(absPath, pkg.main));
+            }
+            catch (err) {
+                console.error(`[runline] Failed to parse ${pkgPath}:`, err.message);
+            }
+        }
+        const found = candidates.find((c) => existsSync(c));
+        if (found) {
+            absPath = found;
+        }
+        else {
+            throw new Error(`No entry point found in ${absPath}`);
+        }
+    }
+    const mod = await import(pathToFileURL(absPath).href);
+    const pluginId = absPath.replace(/.*\//, "").replace(/\.(ts|js)$/, "");
+    return resolvePluginExport(mod.default, pluginId);
+}
+async function loadFromDirectory(dir) {
+    const plugins = [];
+    if (!existsSync(dir))
+        return plugins;
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isFile() &&
+            (entry.endsWith(".ts") || entry.endsWith(".js")) &&
+            !entry.endsWith(".d.ts") &&
+            !entry.endsWith(".test.ts")) {
+            try {
+                plugins.push(await loadPluginFromPath(fullPath));
+            }
+            catch (err) {
+                console.error(`[runline] Failed to load plugin from ${fullPath}:`, err.message);
+            }
+        }
+        else if (stat.isDirectory()) {
+            const candidates = [
+                join(fullPath, "index.ts"),
+                join(fullPath, "index.js"),
+                join(fullPath, "src", "index.ts"),
+                join(fullPath, "src", "index.js"),
+            ];
+            const found = candidates.find((c) => existsSync(c));
+            if (found) {
+                try {
+                    plugins.push(await loadPluginFromPath(found));
+                }
+                catch (err) {
+                    console.error(`[runline] Failed to load plugin from ${found}:`, err.message);
+                }
+            }
+            const pkgJson = join(fullPath, "package.json");
+            if (existsSync(pkgJson)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+                    const pluginPaths = pkg.runline?.plugins ?? [];
+                    for (const p of pluginPaths) {
+                        try {
+                            plugins.push(await loadPluginFromPath(join(fullPath, p)));
+                        }
+                        catch (err) {
+                            console.error(`[runline] Failed to load plugin from ${join(fullPath, p)}:`, err.message);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(`[runline] Failed to parse ${pkgJson}:`, err.message);
+                }
+            }
+        }
+    }
+    return plugins;
+}
+export async function loadPluginsFromConfig(configDir) {
+    const plugins = [];
+    const pluginsFile = join(configDir, "plugins.json");
+    if (!existsSync(pluginsFile))
+        return plugins;
+    try {
+        const data = JSON.parse(readFileSync(pluginsFile, "utf-8"));
+        const entries = data.plugins ?? data;
+        for (const entry of entries) {
+            const p = typeof entry === "string" ? entry : entry.path;
+            try {
+                plugins.push(await loadPluginFromPath(p));
+            }
+            catch (err) {
+                console.error(`[runline] Failed to load plugin from ${p}:`, err.message);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[runline] Failed to parse ${pluginsFile}:`, err.message);
+    }
+    return plugins;
+}
+/**
+ * Discover and return all plugins from a config directory and global dir.
+ * Does NOT mutate any global state.
+ */
+export async function discoverPlugins(configDir) {
+    const loaded = new Set();
+    const result = [];
+    function addIfNew(plugin) {
+        if (!loaded.has(plugin.name)) {
+            result.push(plugin);
+            loaded.add(plugin.name);
+        }
+    }
+    if (configDir) {
+        const projectPluginsDir = join(configDir, "plugins");
+        const projectPlugins = await loadFromDirectory(projectPluginsDir);
+        for (const p of projectPlugins)
+            addIfNew(p);
+        const configPlugins = await loadPluginsFromConfig(configDir);
+        for (const p of configPlugins)
+            addIfNew(p);
+    }
+    const globalDir = join(homedir(), ".runline", "plugins");
+    const globalPlugins = await loadFromDirectory(globalDir);
+    for (const p of globalPlugins)
+        addIfNew(p);
+    // Built-in plugins shipped with the package
+    const builtinDir = join(__dirname, "..", "plugins");
+    const builtinPlugins = await loadFromDirectory(builtinDir);
+    for (const p of builtinPlugins)
+        addIfNew(p);
+    return result;
+}
+/**
+ * Load all plugins and register them into the global registry.
+ * Used by the CLI.
+ */
+export async function loadAllPlugins() {
+    const configDir = findConfigDir();
+    const plugins = await discoverPlugins(configDir);
+    for (const p of plugins) {
+        registry.register(p);
+    }
+}

package/dist/plugin/registry.d.ts

@@ -0,0 +1,18 @@
+import type { ActionDef, PluginDef } from "./types.js";
+export declare class PluginRegistry {
+    private plugins;
+    register(plugin: PluginDef): void;
+    getPlugin(name: string): PluginDef | undefined;
+    getAction(pluginName: string, actionName: string): ActionDef | undefined;
+    getAllActions(): Array<{
+        plugin: string;
+        action: ActionDef;
+    }>;
+    /** Resolve a dotted path like "docker.containers.list" to a plugin + action. */
+    resolveAction(path: string): {
+        plugin: PluginDef;
+        action: ActionDef;
+    } | undefined;
+    listPlugins(): PluginDef[];
+}
+export declare const registry: PluginRegistry;

package/dist/plugin/registry.js

@@ -0,0 +1,43 @@
+export class PluginRegistry {
+    plugins = new Map();
+    register(plugin) {
+        this.plugins.set(plugin.name, plugin);
+    }
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    getAction(pluginName, actionName) {
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin)
+            return undefined;
+        return plugin.actions.find((a) => a.name === actionName);
+    }
+    getAllActions() {
+        const result = [];
+        for (const [pluginName, plugin] of this.plugins) {
+            for (const action of plugin.actions) {
+                result.push({ plugin: pluginName, action });
+            }
+        }
+        return result;
+    }
+    /** Resolve a dotted path like "docker.containers.list" to a plugin + action. */
+    resolveAction(path) {
+        const dot = path.indexOf(".");
+        if (dot < 0)
+            return undefined;
+        const pluginName = path.slice(0, dot);
+        const actionName = path.slice(dot + 1);
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin)
+            return undefined;
+        const action = plugin.actions.find((a) => a.name === actionName);
+        if (!action)
+            return undefined;
+        return { plugin, action };
+    }
+    listPlugins() {
+        return Array.from(this.plugins.values());
+    }
+}
+export const registry = new PluginRegistry();

package/dist/plugin/types.d.ts

@@ -0,0 +1,40 @@
+export interface InputField {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+}
+export type InputSchema = Record<string, InputField>;
+export interface ActionDef {
+    name: string;
+    description?: string;
+    inputSchema?: InputSchema;
+    execute: (input: unknown, ctx: ActionContext) => unknown | Promise<unknown>;
+}
+export interface ConnectionConfig {
+    name: string;
+    plugin: string;
+    config: Record<string, unknown>;
+}
+export interface ActionContext {
+    connection: ConnectionConfig;
+    log: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+}
+export interface PluginDef {
+    name: string;
+    version: string;
+    actions: ActionDef[];
+    connectionConfigSchema?: Record<string, {
+        type: string;
+        required?: boolean;
+        description?: string;
+        default?: unknown;
+        env?: string;
+    }>;
+    /** @internal */
+    initHooks?: Array<(config: Record<string, unknown>) => void>;
+}

package/dist/plugin/types.js

@@ -0,0 +1 @@
+export {};