runline 0.3.1 → 0.3.3

package/dist/commands/actions.d.ts

@@ -1,3 +1,4 @@
 export declare function actions(options: {
     json?: boolean;
+    connected?: boolean;
 }): Promise<void>;

package/dist/commands/actions.js

@@ -1,12 +1,19 @@
 import chalk from "chalk";
+import { loadConfig } from "../config/loader.js";
 import { loadAllPlugins } from "../plugin/loader.js";
 import { registry } from "../plugin/registry.js";
 import { printJson } from "../utils/output.js";
 export async function actions(options) {
     await loadAllPlugins();
     const all = registry.getAllActions();
+    const connectedPlugins = options.connected
+        ? new Set(loadConfig().connections.map((c) => c.plugin))
+        : null;
+    const filtered = connectedPlugins
+        ? all.filter(({ plugin }) => connectedPlugins.has(plugin))
+        : all;
     if (options.json) {
-        printJson(all.map(({ plugin, action }) => ({
+        printJson(filtered.map(({ plugin, action }) => ({
             plugin,
             action: action.name,
             description: action.description,
@@ -14,12 +21,18 @@ export async function actions(options) {
         })));
         return;
     }
-    if (all.length === 0) {
-        console.log("No actions registered. Install a plugin first.");
+    if (filtered.length === 0) {
+        if (options.connected) {
+            console.log("No actions found for connected services.");
+            console.log("Add a connection first: runline connection add <name> -p <plugin>");
+        }
+        else {
+            console.log("No actions registered. Install a plugin first.");
+        }
         return;
     }
     const grouped = new Map();
-    for (const entry of all) {
+    for (const entry of filtered) {
         const list = grouped.get(entry.plugin) ?? [];
         list.push(entry);
         grouped.set(entry.plugin, list);

package/dist/main.js

@@ -55,9 +55,10 @@ Examples:
 program
     .command("actions")
     .description("List all available actions and their schemas")
-    .action(async (_opts, cmd) => {
+    .option("-c, --connected", "Only show actions for plugins with configured connections")
+    .action(async (opts, cmd) => {
     const globals = cmd.optsWithGlobals();
-    await actions({ json: globals.json });
+    await actions({ json: globals.json, connected: opts.connected });
 });
 // ── connection ──────────────────────────────────────────
 const connCmd = program

package/dist/plugin/loader.d.ts

@@ -1,11 +1,33 @@
 import type { PluginDef } from "./types.js";
 export declare function loadPluginFromPath(path: string): Promise<PluginDef>;
 export declare function loadPluginsFromConfig(configDir: string): Promise<PluginDef[]>;
+export interface DiscoverOptions {
+    /**
+     * When supplied, only built-in plugins whose name is in this set
+     * are loaded. Plugins discovered in the project dir, `plugins.json`,
+     * or `~/.runline/plugins` are always loaded — users put them there
+     * deliberately — but the 188 bundled builtins are gated so agents
+     * don't see every possible action regardless of configuration.
+     *
+     * Omit to load every builtin (CLI default: `runline actions` etc.
+     * surfaces the full catalog).
+     */
+    builtinAllowlist?: Set<string> | null;
+    /**
+     * Override the directory where bundled plugins live. Default is
+     * `<loader>/../plugins`, which resolves to `dist/plugins/` at
+     * runtime. Tests set this so they can exercise allowlist logic
+     * without depending on the real bundled catalog.
+     */
+    builtinDir?: string;
+}
+/** Default path to the bundled plugin directory. */
+export declare function defaultBuiltinDir(): string;
 /**
  * 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[]>;
+export declare function discoverPlugins(configDir?: string | null, options?: DiscoverOptions): Promise<PluginDef[]>;
 /**
  * Load all plugins and register them into the global registry.
  * Used by the CLI.

package/dist/plugin/loader.js

@@ -118,11 +118,15 @@ export async function loadPluginsFromConfig(configDir) {
     }
     return plugins;
 }
+/** Default path to the bundled plugin directory. */
+export function defaultBuiltinDir() {
+    return join(__dirname, "..", "plugins");
+}
 /**
  * Discover and return all plugins from a config directory and global dir.
  * Does NOT mutate any global state.
  */
-export async function discoverPlugins(configDir) {
+export async function discoverPlugins(configDir, options = {}) {
     const loaded = new Set();
     const result = [];
     function addIfNew(plugin) {
@@ -144,11 +148,14 @@ export async function discoverPlugins(configDir) {
     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 builtinDir = options.builtinDir ?? defaultBuiltinDir();
     const builtinPlugins = await loadFromDirectory(builtinDir);
-    for (const p of builtinPlugins)
+    for (const p of builtinPlugins) {
+        if (options.builtinAllowlist && !options.builtinAllowlist.has(p.name)) {
+            continue;
+        }
         addIfNew(p);
+    }
     return result;
 }
 /**

package/dist/sdk.d.ts

@@ -34,8 +34,26 @@ export declare class Runline {
     connections(): ConnectionConfig[];
     /**
      * Load runline from a project directory.
-     * Discovers .runline/ config and installed plugins, just like the CLI.
+     *
+     * Discovers the `.runline/` config and registers:
+     *   - every plugin dropped into `.runline/plugins/`,
+     *   - every plugin listed in `.runline/plugins.json`,
+     *   - every plugin in `~/.runline/plugins/`,
+     *   - and — from the 188 builtins shipped with the package — only
+     *     the ones named in `config.connections[].plugin`.
+     *
+     * Gating the builtins keeps `runline.actions()` scoped to what the
+     * project actually configured. Without this, a project with a
+     * single connection would still expose every bundled action to an
+     * agent, which is both noisy and a privacy problem (the agent sees
+     * surface area it has no credentials for).
+     *
+     * `options.builtinDir` is a test-only hook; production callers
+     * should rely on the default path to the bundled plugins.
+     *
      * Fully self-contained — does not mutate global state.
      */
-    static fromProject(cwd?: string): Promise<Runline | null>;
+    static fromProject(cwd?: string, options?: {
+        builtinDir?: string;
+    }): Promise<Runline | null>;
 }

package/dist/sdk.js

@@ -63,16 +63,36 @@ export class Runline {
     }
     /**
      * Load runline from a project directory.
-     * Discovers .runline/ config and installed plugins, just like the CLI.
+     *
+     * Discovers the `.runline/` config and registers:
+     *   - every plugin dropped into `.runline/plugins/`,
+     *   - every plugin listed in `.runline/plugins.json`,
+     *   - every plugin in `~/.runline/plugins/`,
+     *   - and — from the 188 builtins shipped with the package — only
+     *     the ones named in `config.connections[].plugin`.
+     *
+     * Gating the builtins keeps `runline.actions()` scoped to what the
+     * project actually configured. Without this, a project with a
+     * single connection would still expose every bundled action to an
+     * agent, which is both noisy and a privacy problem (the agent sees
+     * surface area it has no credentials for).
+     *
+     * `options.builtinDir` is a test-only hook; production callers
+     * should rely on the default path to the bundled plugins.
+     *
      * Fully self-contained — does not mutate global state.
      */
-    static async fromProject(cwd) {
+    static async fromProject(cwd, options = {}) {
         const dir = cwd ?? process.cwd();
         const configDir = findRunlineDir(dir);
         if (!configDir)
             return null;
         const config = loadConfigFrom(configDir);
-        const plugins = await discoverPlugins(configDir);
+        const builtinAllowlist = new Set(config.connections.map((c) => c.plugin));
+        const plugins = await discoverPlugins(configDir, {
+            builtinAllowlist,
+            builtinDir: options.builtinDir,
+        });
         const rl = new Runline({
             connections: config.connections,
             timeoutMs: config.timeoutMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",