runline 0.25.0 → 0.27.0

package/dist/core/engine.d.ts

@@ -8,6 +8,8 @@ export interface ExecuteResult {
 export interface EngineOptions {
     timeoutMs?: number;
     memoryLimitBytes?: number;
+    /** Delivered to every action's `ctx.context` for this run. */
+    context?: unknown;
 }
 /**
  * One resolved action call, observed at the engine's dispatch point.

package/dist/core/engine.js

@@ -161,6 +161,16 @@ export class ExecutionEngine {
         try {
             acquired = this.acquire(shape, () => new Worker(buildWorkerSource(pluginNames, helpData), {
                 eval: true,
+                // Empty by construction: without an `env` option the worker
+                // inherits a copy of the host's entire environment, and
+                // Runline lives inside credential-bearing hosts (vex's
+                // server process, the pi agent process). Bodies hold a real
+                // `require` and a live `process`, so an inherited env is one
+                // line of agent code away from every host secret. Nothing
+                // in the worker needs an environment: actions execute
+                // host-side, connection configs are hydrated host-side, and
+                // ferrosearch is required by absolute path.
+                env: {},
                 resourceLimits: { maxOldGenerationSizeMb: memoryLimitMb },
             }));
         }
@@ -233,7 +243,7 @@ export class ExecutionEngine {
                     logs.push(`[${msg.level}] ${msg.line}`);
                 }
                 else if (msg.t === "invoke") {
-                    this.invokeAction(msg.path, msg.args).then((value) => {
+                    this.invokeAction(msg.path, msg.args, options?.context).then((value) => {
                         let serialized;
                         try {
                             serialized = toPlainJson(value);
@@ -295,7 +305,7 @@ export class ExecutionEngine {
             reply({ t: "run", runId, body });
         });
     }
-    async invokeAction(path, rawArgs) {
+    async invokeAction(path, rawArgs, context) {
         // A call written with no arguments reaches the action as `{}`, not
         // `undefined`, so plugins can read `input.foo` without guarding.
         const args = normalizeActionInput(rawArgs);
@@ -307,6 +317,7 @@ export class ExecutionEngine {
         const connection = this.resolveConnection(plugin);
         const ctx = {
             connection,
+            context,
             log: {
                 info: (msg) => console.log(`[${plugin.name}] ${msg}`),
                 warn: (msg) => console.warn(`[${plugin.name}] ${msg}`),

package/dist/plugin/types.d.ts

@@ -51,6 +51,13 @@ export interface ConnectionConfig {
 }
 export interface ActionContext {
     connection: ConnectionConfig;
+    /**
+     * Opaque per-run value from the embedder's `execute()` options.
+     * Host-supplied and invisible to worker code, so actions may
+     * derive authority from it (e.g. per-call identity on a shared
+     * engine). Absent when the embedder passed none.
+     */
+    context?: unknown;
     log: {
         info(msg: string): void;
         warn(msg: string): void;

package/dist/sdk.d.ts

@@ -24,6 +24,8 @@ export interface RunlineOptions {
 export interface RunlineExecuteOptions {
     timeoutMs?: number;
     memoryLimitBytes?: number;
+    /** Delivered to every action's `ctx.context` for this run. */
+    context?: unknown;
 }
 export declare class Runline {
     private _registry;

package/package.json

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