runline 0.15.0 → 0.15.1

package/dist/core/engine.d.ts

@@ -37,5 +37,13 @@ export declare class ExecutionEngine {
     constructor(registry: PluginRegistry, config: RunlineConfig);
     execute(code: string, options?: EngineOptions): Promise<ExecuteResult>;
     private invokeAction;
+    /**
+     * A miss on "salesforce.status" is often a plugin that registered
+     * its action name with the plugin prefix ("salesforce.status" inside
+     * plugin "salesforce"), making the real path
+     * "salesforce.salesforce.status". Detect exactly that shape and
+     * teach the caller — agents read error messages and self-correct.
+     */
+    private selfPrefixHint;
     private resolveConnection;
 }

package/dist/core/engine.js

@@ -158,7 +158,7 @@ export class ExecutionEngine {
     async invokeAction(path, args) {
         const resolved = this.registry.resolveAction(path);
         if (!resolved) {
-            throw new Error(`Unknown action: ${path}`);
+            throw new Error(`Unknown action: ${path}${this.selfPrefixHint(path)}`);
         }
         const { plugin, action } = resolved;
         const connection = this.resolveConnection(plugin);
@@ -184,6 +184,25 @@ export class ExecutionEngine {
         }
         return action.execute(args, ctx);
     }
+    /**
+     * A miss on "salesforce.status" is often a plugin that registered
+     * its action name with the plugin prefix ("salesforce.status" inside
+     * plugin "salesforce"), making the real path
+     * "salesforce.salesforce.status". Detect exactly that shape and
+     * teach the caller — agents read error messages and self-correct.
+     */
+    selfPrefixHint(path) {
+        // A dot-less miss can still be the exact-name case: plugin "ping"
+        // registering action "ping" makes the callable path "ping.ping".
+        const dot = path.indexOf(".");
+        const pluginName = dot < 0 ? path : path.slice(0, dot);
+        const doubled = `${pluginName}.${path}`;
+        if (!this.registry.resolveAction(doubled))
+            return "";
+        return (`. Did you mean "${doubled}"? Plugin "${pluginName}" registered its ` +
+            `action name with the plugin prefix ("${path}"), so the full callable ` +
+            `path is "${doubled}".`);
+    }
     resolveConnection(plugin) {
         const conn = this.config.connections.find((c) => c.plugin === plugin.name);
         const base = conn ?? {

package/dist/plugin/api.js

@@ -59,14 +59,39 @@ export function createPluginAPI(pluginId) {
 export function isPluginFunction(val) {
     return typeof val === "function";
 }
+/**
+ * Action names are plugin-relative: plugin "salesforce" registering
+ * "salesforce.status" is callable as "salesforce.salesforce.status",
+ * which is almost never what the author meant. Warn at resolve time —
+ * the earliest point where both the final plugin name and the full
+ * action list are known (setName may be called after registerAction,
+ * and object exports never go through createPluginAPI).
+ */
+function warnSelfPrefixedActions(plugin) {
+    for (const action of plugin.actions) {
+        const prefixed = action.name.startsWith(`${plugin.name}.`);
+        if (!prefixed && action.name !== plugin.name)
+            continue;
+        const advice = prefixed
+            ? `Rename the action to "${action.name.slice(plugin.name.length + 1)}".`
+            : "Choose an action name that does not repeat the plugin name.";
+        console.warn(`[runline] Plugin "${plugin.name}" registered action "${action.name}", which repeats the plugin name. ` +
+            `Action names are plugin-relative, so this action is callable as "${plugin.name}.${action.name}" — ` +
+            `not "${action.name}". ${advice}`);
+    }
+}
 export function resolvePluginExport(exported, pluginId) {
     if (isPluginFunction(exported)) {
         const { api, resolve } = createPluginAPI(pluginId);
         exported(api);
-        return resolve();
+        const plugin = resolve();
+        warnSelfPrefixedActions(plugin);
+        return plugin;
     }
     if (exported && typeof exported === "object" && "actions" in exported) {
-        return exported;
+        const plugin = exported;
+        warnSelfPrefixedActions(plugin);
+        return plugin;
     }
     throw new Error(`Invalid plugin export from "${pluginId}": expected a function or { name, actions } object`);
 }

package/package.json

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