runline 0.27.0 → 0.27.2

package/dist/core/engine.d.ts

@@ -46,6 +46,13 @@ export interface EngineHooks {
  * ignores resourceLimits, so the watchdog is the only memory backstop.
  */
 export declare function shouldArmRssWatchdog(versions?: Partial<Record<string, string>>): boolean;
+/**
+ * Ceiling on an armed timeout: setTimeout stores its delay in an int32,
+ * so past ~24.8 days it overflows and fires at 0ms. Oversized values are
+ * rejected with an error that teaches the caller to pass 0 — the explicit
+ * "no timeout" — instead of overflowing into an instant kill.
+ */
+export declare const MAX_TIMEOUT_MS: number;
 /**
  * Executes agent code in a node:worker_threads worker.
  *

package/dist/core/engine.js

@@ -48,6 +48,13 @@ function workerShape(pluginNames, helpData, memoryLimitMb) {
 export function shouldArmRssWatchdog(versions = process.versions) {
     return Boolean(versions.bun);
 }
+/**
+ * Ceiling on an armed timeout: setTimeout stores its delay in an int32,
+ * so past ~24.8 days it overflows and fires at 0ms. Oversized values are
+ * rejected with an error that teaches the caller to pass 0 — the explicit
+ * "no timeout" — instead of overflowing into an instant kill.
+ */
+export const MAX_TIMEOUT_MS = 2 ** 31 - 1;
 // Extra slack on top of the configured memory limit for the RSS watchdog,
 // since whole-process RSS includes the host's own working set.
 const RSS_WATCHDOG_SLACK_BYTES = 128 * 1024 * 1024;
@@ -149,6 +156,16 @@ export class ExecutionEngine {
         const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
         const memoryLimitBytes = options?.memoryLimitBytes ?? this.config.memoryLimitBytes;
         const logs = [];
+        if (!Number.isFinite(timeoutMs) ||
+            timeoutMs < 0 ||
+            timeoutMs > MAX_TIMEOUT_MS) {
+            return {
+                result: null,
+                error: `Invalid timeoutMs: ${timeoutMs}. ` +
+                    `Pass 0 (no timeout) or 1..${MAX_TIMEOUT_MS} ms.`,
+                logs,
+            };
+        }
         const plugins = this.registry.listPlugins();
         const pluginNames = plugins.map((p) => p.name);
         const helpData = buildHelpData(plugins);
@@ -190,21 +207,28 @@ export class ExecutionEngine {
                 settled = true;
                 clearTimeout(timeoutTimer);
                 clearInterval(rssTimer);
+                worker.unref?.();
                 worker.off("message", onMessage);
                 worker.off("error", onError);
                 worker.off("exit", onExit);
                 this.release(entry, pooled, retire);
                 resolve(r);
             };
+            // The acquire-time unref must not let the host exit mid-run: hold
+            // the loop for the run's duration, whether or not a timer is armed.
+            worker.ref?.();
             // A spinning body blocks the worker's event loop, so it can never be
             // asked to stop — terminate is the only remedy and the worker is gone.
-            const timeoutTimer = setTimeout(() => {
-                finish({
-                    result: null,
-                    error: `Execution timed out after ${timeoutMs}ms`,
-                    logs,
-                }, true);
-            }, timeoutMs);
+            // 0 means no timeout: the caller explicitly opted out of the backstop.
+            const timeoutTimer = timeoutMs === 0
+                ? undefined
+                : setTimeout(() => {
+                    finish({
+                        result: null,
+                        error: `Execution timed out after ${timeoutMs}ms`,
+                        logs,
+                    }, true);
+                }, timeoutMs);
             let rssTimer;
             if (shouldArmRssWatchdog()) {
                 const baselineRss = process.memoryUsage().rss;
@@ -435,6 +459,12 @@ function formatError(cause) {
 // code gets a cwd-relative `require`, so a bare specifier would resolve
 // against the caller's cwd instead of runline's own node_modules.
 const ferrosearchPath = createRequire(import.meta.url).resolve("@shift-labs/ferrosearch");
+// typebox ships ESM only; require() of an .mjs works everywhere runline
+// runs (bun, and node since 22.12's require(esm)). Resolved host-side
+// for the same reason as ferrosearch: eval'd worker code gets a
+// cwd-relative require, so a bare specifier would resolve against the
+// caller's cwd instead of runline's own node_modules.
+const typeboxValuePath = createRequire(import.meta.url).resolve("typebox/value");
 function buildHelpData(plugins) {
     const data = {};
     for (const p of plugins) {
@@ -443,6 +473,7 @@ function buildHelpData(plugins) {
             access: a.access,
             description: a.description,
             inputs: helpInputs(a.inputSchema),
+            ...(isTypedInputSchema(a.inputSchema) ? { schema: a.inputSchema } : {}),
         }));
     }
     return data;
@@ -570,6 +601,9 @@ const __toJson = (v) => v === undefined ? undefined : JSON.parse(JSON.stringify(
 // also means an index built by agent code is invisible to that limit.
 const { FerroSearch } = require(${JSON.stringify(ferrosearchPath)});
 
+// The host's own validator, for actions.check on typed schemas.
+const { Check: __schemaCheck, Errors: __schemaErrors } = require(${JSON.stringify(typeboxValuePath)});
+
 const __help = ${JSON.stringify(helpData)};
 
 const __makeProxy = (path = []) => new Proxy(() => undefined, {
@@ -629,6 +663,82 @@ const __search = (() => {
   return index;
 })();
 
+// instancePath "/members/0/externalId" → ["members", "0", "externalId"],
+// with JSON-pointer escapes (~1 for /, ~0 for ~) undone per part.
+const __pointerParts = (instancePath) =>
+  String(instancePath || '').split('/').filter((p) => p.length)
+    .map((p) => p.replace(/~1/g, '/').replace(/~0/g, '~'));
+
+// ["members", "0", "externalId"] → "members[0].externalId"
+const __fieldPath = (instancePath, prop) => {
+  const parts = __pointerParts(instancePath);
+  if (prop !== undefined) parts.push(String(prop));
+  let out = '';
+  for (const part of parts) {
+    if (/^\\d+$/.test(part)) out += '[' + part + ']';
+    else out += out ? '.' + part : part;
+  }
+  return out;
+};
+
+const __valueAt = (root, instancePath) => {
+  let v = root;
+  for (const part of __pointerParts(instancePath)) {
+    if (v == null) return undefined;
+    v = v[part];
+  }
+  return v;
+};
+
+const __valueType = (v) => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v;
+
+// Deep validation for typed schemas (SHFT-1187): the same Check/Errors
+// the host runs before execute, on the same schema, so the preflight
+// verdict and the execution verdict cannot diverge. The familiar
+// missing/unknown/typeErrors buckets are derived from the validator's
+// structured errors — keyword and params, never message parsing — and
+// the errors array carries each raw "<path> <message>" line exactly as
+// a rejected execution would report it. Grouping type errors by instance
+// path keeps a failed union one typeError instead of one per branch.
+const __checkTyped = (entry, provided, signature) => {
+  if (__schemaCheck(entry.schema, provided)) {
+    return { ok: true, missing: [], unknown: [], typeErrors: [], errors: [], signature };
+  }
+  const missing = [];
+  const unknown = [];
+  const errors = [];
+  const byPath = new Map();
+  for (const err of __schemaErrors(entry.schema, provided)) {
+    errors.push((err.instancePath || '/') + ' ' + err.message);
+    const params = err.params || {};
+    if (err.keyword === 'required') {
+      for (const prop of params.requiredProperties || []) missing.push(__fieldPath(err.instancePath, prop));
+    } else if (err.keyword === 'additionalProperties') {
+      for (const prop of params.additionalProperties || []) unknown.push(__fieldPath(err.instancePath, prop));
+    } else {
+      const group = byPath.get(err.instancePath) || [];
+      group.push(err);
+      byPath.set(err.instancePath, group);
+    }
+  }
+  const typeErrors = [];
+  for (const [instancePath, group] of byPath) {
+    const field = __fieldPath(instancePath) || '(input)';
+    const value = __valueAt(provided, instancePath);
+    const consts = group.filter((e) => e.keyword === 'const' && 'allowedValue' in (e.params || {}));
+    const typeErr = group.find((e) => e.keyword === 'type' && (e.params || {}).type);
+    if (consts.length) {
+      // A union of literals: the branches ARE the allowed values.
+      typeErrors.push({ field, expected: consts.map((e) => String(e.params.allowedValue)).join(' | '), actual: __fmt(value) });
+    } else if (typeErr) {
+      typeErrors.push({ field, expected: String(typeErr.params.type), actual: __valueType(value) });
+    } else {
+      typeErrors.push({ field, expected: group[0].message, actual: __fmt(value) });
+    }
+  }
+  return { ok: false, missing, unknown, typeErrors, errors, signature };
+};
+
 const __actionsApi = {
   list(plugin) {
     const paths = Object.keys(__index);
@@ -667,6 +777,13 @@ const __actionsApi = {
       const near = __actionsApi.find(path, 3).map((n) => n.path);
       return { ok: false, error: 'Unknown action: ' + path, suggestions: near };
     }
+    const signature = __formatSignature(hit.plugin, hit.entry);
+    if (hit.entry.schema) {
+      // Mirror the host's normalizeActionInput: a check with no args is
+      // a call with an empty argument set; anything else — null, a
+      // scalar — is validated as given, exactly as execute would.
+      return __checkTyped(hit.entry, args === undefined ? {} : args, signature);
+    }
     const inputs = hit.entry.inputs || {};
     const provided = args && typeof args === 'object' ? args : {};
     const missing = [];
@@ -695,7 +812,8 @@ const __actionsApi = {
       missing,
       unknown,
       typeErrors,
-      signature: __formatSignature(hit.plugin, hit.entry),
+      errors: [],
+      signature,
     };
   },
 };

package/package.json

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