runline 0.29.0 → 0.30.0

package/dist/sdk.d.ts

@@ -1,9 +1,13 @@
-import { type ActionInvocation, type ExecuteResult } from "./core/engine.js";
+import type { ConnectionProvider } from "./connections/types.js";
+import { type EngineHooks, type ExecuteResult } from "./core/engine.js";
 import type { PluginFunction } from "./plugin/api.js";
 import type { ActionAccess, ConnectionConfig, InputSchema, PluginDef } from "./plugin/types.js";
 export interface RunlineOptions {
     plugins?: Array<PluginDef | PluginFunction>;
+    /** Initial process-local connections. No environment lookup or disk writes. */
     connections?: ConnectionConfig[];
+    /** Host-owned credentials; mutually exclusive with initial connections. */
+    connectionProvider?: ConnectionProvider;
     timeoutMs?: number;
     memoryLimitBytes?: number;
     /**
@@ -19,7 +23,7 @@ export interface RunlineOptions {
      * never breaks a run. Not part of `RunlineConfig` on purpose —
      * config round-trips through JSON (`fromProject`), functions do not.
      */
-    onAction?: (info: ActionInvocation) => void;
+    onAction?: EngineHooks["onAction"];
 }
 export interface RunlineExecuteOptions {
     timeoutMs?: number;
@@ -30,10 +34,11 @@ export interface RunlineExecuteOptions {
 export declare class Runline {
     private _registry;
     private _config;
+    private readonly _connectionProvider;
+    private readonly _memoryConnections?;
     /**
      * One engine per Runline instance, so its pooled worker survives across
-     * `execute()` calls. Constructing an engine per call would spawn (and
-     * leak) a fresh worker every time — the exact bug pooling exists to fix.
+     * `execute()` calls and avoids per-execution thread allocation.
      */
     private _engine;
     private readonly _onAction;
@@ -65,7 +70,10 @@ export declare class Runline {
         actions: string[];
         connectionConfigSchema?: PluginDef["connectionConfigSchema"];
     }>;
-    /** Return all connections currently configured. */
+    /**
+     * Snapshot of process-local connections. Host-managed providers are not
+     * enumerated: their accounts can be caller-scoped and must be listed by the host.
+     */
     connections(): ConnectionConfig[];
     /**
      * Load runline from a project directory.

package/dist/sdk.js

@@ -1,6 +1,9 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { loadConfigFrom } from "./config/loader.js";
 import { DEFAULT_CONFIG } from "./config/types.js";
+import { FileConnectionProvider } from "./connections/file.js";
+import { MemoryConnectionProvider } from "./connections/memory.js";
 import { ExecutionEngine, } from "./core/engine.js";
 import { resolvePluginExport } from "./plugin/api.js";
 import { discoverPlugins } from "./plugin/loader.js";
@@ -8,22 +11,33 @@ import { PluginRegistry } from "./plugin/registry.js";
 export class Runline {
     _registry;
     _config;
+    _connectionProvider;
+    _memoryConnections;
     /**
      * One engine per Runline instance, so its pooled worker survives across
-     * `execute()` calls. Constructing an engine per call would spawn (and
-     * leak) a fresh worker every time — the exact bug pooling exists to fix.
+     * `execute()` calls and avoids per-execution thread allocation.
      */
     _engine = null;
     _onAction;
     constructor(options) {
         this._registry = new PluginRegistry();
         this._onAction = options.onAction;
+        if (options.connectionProvider && options.connections) {
+            throw new Error("Pass connections or connectionProvider, not both");
+        }
+        if (options.connectionProvider) {
+            this._connectionProvider = options.connectionProvider;
+        }
+        else {
+            this._memoryConnections = new MemoryConnectionProvider(options.connections);
+            this._connectionProvider = this._memoryConnections;
+        }
         for (const pluginOrFn of options.plugins ?? []) {
             const plugin = resolvePluginExport(pluginOrFn, "unknown");
             this._registry.register(plugin);
         }
         this._config = {
-            connections: options.connections ?? [],
+            connections: [],
             timeoutMs: options.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
             memoryLimitBytes: options.memoryLimitBytes ?? DEFAULT_CONFIG.memoryLimitBytes,
             ...(options.maxRunsPerWorker !== undefined
@@ -35,6 +49,7 @@ export class Runline {
         if (!this._engine) {
             this._engine = new ExecutionEngine(this._registry, this._config, {
                 onAction: this._onAction,
+                connectionProvider: this._connectionProvider,
             });
         }
         return this._engine;
@@ -58,15 +73,14 @@ export class Runline {
     /** 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],
-            };
+            if (!this._memoryConnections) {
+                throw new Error("Configure connections through the host connection provider");
+            }
+            this._memoryConnections.add(connections);
         }
-        // The pooled worker baked in the old plugin surface and the engine holds
-        // the old config object: both are stale now.
+        this._registry.register(plugin);
+        // Rebuild the worker's action surface; connection custody survives disposal.
         this.dispose();
     }
     /** List all available actions across all plugins. */
@@ -88,9 +102,12 @@ export class Runline {
             connectionConfigSchema: p.connectionConfigSchema,
         }));
     }
-    /** Return all connections currently configured. */
+    /**
+     * Snapshot of process-local connections. Host-managed providers are not
+     * enumerated: their accounts can be caller-scoped and must be listed by the host.
+     */
     connections() {
-        return [...this._config.connections];
+        return this._memoryConnections?.list() ?? [];
     }
     /**
      * Load runline from a project directory.
@@ -118,16 +135,17 @@ export class Runline {
         const configDir = findRunlineDir(dir);
         if (!configDir)
             return null;
-        const config = loadConfigFrom(configDir);
+        const config = loadConfigFrom(join(configDir, "config.json"));
         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,
+            connectionProvider: new FileConnectionProvider(join(configDir, "config.json")),
             timeoutMs: config.timeoutMs,
             memoryLimitBytes: config.memoryLimitBytes,
+            maxRunsPerWorker: config.maxRunsPerWorker,
         });
         for (const plugin of plugins) {
             rl._registry.register(plugin);
@@ -136,7 +154,7 @@ export class Runline {
     }
 }
 function findRunlineDir(from) {
-    let dir = from;
+    let dir = resolve(from);
     while (true) {
         if (existsSync(join(dir, ".runline")))
             return join(dir, ".runline");
@@ -147,15 +165,3 @@ function findRunlineDir(from) {
     }
     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/observer.d.ts

@@ -0,0 +1,2 @@
+/** Observers cannot fail an operation, whether they throw or reject asynchronously. */
+export declare function notifyObserver<T>(observer: ((event: T) => void | Promise<void>) | undefined, event: T): void;

package/dist/utils/observer.js

@@ -0,0 +1,11 @@
+/** Observers cannot fail an operation, whether they throw or reject asynchronously. */
+export function notifyObserver(observer, event) {
+    if (!observer)
+        return;
+    try {
+        void Promise.resolve(observer(event)).catch(() => { });
+    }
+    catch {
+        // Operational success does not depend on observability.
+    }
+}

package/package.json

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