whale-code 6.5.4 → 6.5.6

package/dist/server/lib/code-worker.js

@@ -1,6 +1,7 @@
 // server/lib/code-worker.ts — Isolated code execution worker
 // Runs as a child process via fork(). Receives code + context via IPC,
 // executes in a fresh vm context, returns result. Crash here cannot take down the server.
+
 import { runInNewContext } from "node:vm";
 import { randomUUID } from "node:crypto";
 /**
@@ -9,180 +10,189 @@ import { randomUUID } from "node:crypto";
  * undefined instead of the host Function constructor.
  */
 function safeFunction(fn) {
-    // Create a wrapper function whose .constructor and .prototype are severed.
-    // We can't make a callable null-prototype object directly, so we override them on a regular function.
-    const safe = function (...args) {
-        return fn.apply(this, args);
-    };
-    Object.defineProperty(safe, "constructor", { value: undefined, writable: false, configurable: false });
-    Object.defineProperty(safe, "prototype", { value: undefined, writable: false, configurable: false });
-    // Freeze to prevent re-assignment of constructor
-    Object.freeze(safe);
-    return safe;
+  // Create a wrapper function whose .constructor and .prototype are severed.
+  // We can't make a callable null-prototype object directly, so we override them on a regular function.
+  const safe = function (...args) {
+    return fn.apply(this, args);
+  };
+  Object.defineProperty(safe, "constructor", {
+    value: undefined,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(safe, "prototype", {
+    value: undefined,
+    writable: false,
+    configurable: false
+  });
+  // Freeze to prevent re-assignment of constructor
+  Object.freeze(safe);
+  return safe;
 }
+
 /**
  * Create a safe namespace object (like Math, JSON, Buffer) whose properties
  * cannot reach the host Function constructor through any prototype chain.
  * All function-valued properties are wrapped via safeFunction().
  */
 function safeNamespace(source, keys) {
-    const ns = Object.create(null);
-    for (const key of keys) {
-        const val = source[key];
-        if (typeof val === "function") {
-            ns[key] = safeFunction(val);
-        }
-        else {
-            ns[key] = val;
-        }
+  const ns = Object.create(null);
+  for (const key of keys) {
+    const val = source[key];
+    if (typeof val === "function") {
+      ns[key] = safeFunction(val);
+    } else {
+      ns[key] = val;
     }
-    return Object.freeze(ns);
+  }
+  return Object.freeze(ns);
 }
+
 // Only run when forked as a child process
 if (process.send) {
-    process.on("message", (msg) => {
-        if (msg.type !== "execute")
-            return;
-        const logs = [];
-        // Validate code for dangerous patterns (defense-in-depth — sandbox isolation is primary defense)
-        const dangerousPatterns = [
-            /constructor\s*\[/i,
-            /constructor\s*\(/i,
-            /\.constructor/i,
-            /__proto__/i,
-            /prototype\s*\[/i,
-            /\bprocess\b/,
-            /\brequire\b/,
-            /\bimport\b/,
-            /\bglobalThis\b/,
-            /\bglobal\b/,
-            /\bFunction\b/,
-            /\beval\b/,
-            /\bReflect\b/,
-            /\bProxy\b/,
-            /\bSymbol\b/,
-            /\bWeakRef\b/,
-        ];
-        for (const pattern of dangerousPatterns) {
-            if (pattern.test(msg.code)) {
-                const result = {
-                    type: "result",
-                    success: false,
-                    error: `Code contains blocked pattern: ${pattern.source}`,
-                };
-                process.send(result);
-                return;
-            }
-        }
-        // Build hardened sandbox — NO host constructors or direct function references.
-        // vm.runInNewContext provides its own Array, Object, String, Number, Boolean in the
-        // sandbox context. We do NOT pass host realm constructors, which would allow
-        // escaping via .constructor.constructor('return process')().
-        const sandbox = Object.create(null);
-        sandbox.steps = JSON.parse(JSON.stringify(msg.context.steps));
-        sandbox.trigger = JSON.parse(JSON.stringify(msg.context.trigger));
-        sandbox.input = msg.context.input != null ? JSON.parse(JSON.stringify(msg.context.input)) : undefined;
-        sandbox.output = undefined;
-        // console — safe: null-prototype object with wrapped log function
-        const logFn = safeFunction((...args) => logs.push(args.map(String).join(" ")));
-        const consoleObj = Object.create(null);
-        consoleObj.log = logFn;
-        sandbox.console = Object.freeze(consoleObj);
-        // JSON — safe namespace with only parse/stringify
-        sandbox.JSON = safeNamespace(JSON, ["parse", "stringify"]);
-        // Math — safe namespace (all methods wrapped, numeric constants preserved)
-        const mathKeys = [
-            "abs", "ceil", "floor", "round", "max", "min", "pow", "sqrt", "log", "log2", "log10",
-            "random", "sign", "trunc", "cbrt", "hypot", "clz32", "imul", "fround",
-            "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "sinh", "cosh", "tanh",
-            "PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2",
-        ];
-        sandbox.Math = safeNamespace(Math, mathKeys);
-        // Date — only expose Date.now() as a safe function, not the Date constructor itself.
-        // The Date constructor is a host function whose .constructor leads to Function.
-        const dateNs = Object.create(null);
-        dateNs.now = safeFunction(Date.now);
-        sandbox.Date = Object.freeze(dateNs);
-        // Utility functions — each wrapped to sever .constructor chain
-        sandbox.parseInt = safeFunction(parseInt);
-        sandbox.parseFloat = safeFunction(parseFloat);
-        sandbox.isNaN = safeFunction(isNaN);
-        sandbox.isFinite = safeFunction(isFinite);
-        sandbox.encodeURIComponent = safeFunction(encodeURIComponent);
-        sandbox.decodeURIComponent = safeFunction(decodeURIComponent);
-        // URL — safe namespace with only parse method (no constructor exposure)
-        const urlNs = Object.create(null);
-        urlNs.parse = safeFunction((input) => {
-            try {
-                const u = new URL(input);
-                return { href: u.href, protocol: u.protocol, host: u.host, hostname: u.hostname,
-                    port: u.port, pathname: u.pathname, search: u.search, hash: u.hash,
-                    origin: u.origin, searchParams: Object.fromEntries(u.searchParams) };
-            }
-            catch {
-                return null;
-            }
-        });
-        urlNs.format = safeFunction((parts) => {
-            try {
-                return new URL(`${parts.protocol || "https:"}//${parts.host || parts.hostname || ""}${parts.pathname || ""}${parts.search || ""}`).href;
-            }
-            catch {
-                return null;
-            }
-        });
-        sandbox.URL = Object.freeze(urlNs);
-        // Buffer — safe namespace with wrapped from/alloc
-        const bufferNs = Object.create(null);
-        bufferNs.from = safeFunction((...args) => Buffer.from(args[0], args[1]));
-        bufferNs.alloc = safeFunction((size) => Buffer.alloc(size));
-        sandbox.Buffer = Object.freeze(bufferNs);
-        // crypto — safe namespace with wrapped randomUUID
-        const cryptoNs = Object.create(null);
-        cryptoNs.randomUUID = safeFunction(randomUUID);
-        sandbox.crypto = Object.freeze(cryptoNs);
-        // DO NOT expose host constructors: Array, Object, String, Number, Boolean.
-        // vm.runInNewContext creates its own versions of these in the sandbox context.
-        // Passing host constructors would allow: [].constructor.constructor('return process')()
-        // Block dangerous globals explicitly
-        sandbox.process = undefined;
-        sandbox.require = undefined;
-        sandbox.global = undefined;
-        sandbox.globalThis = undefined;
-        sandbox.Function = undefined;
-        sandbox.eval = undefined;
-        sandbox.setTimeout = undefined;
-        sandbox.setInterval = undefined;
-        sandbox.Reflect = undefined;
-        sandbox.Proxy = undefined;
-        sandbox.Symbol = undefined;
-        sandbox.WeakRef = undefined;
-        try {
-            const result = runInNewContext(msg.code, sandbox, {
-                timeout: msg.timeoutMs,
-                filename: "workflow-code-step",
-                breakOnSigint: true,
-                microtaskMode: "afterEvaluate",
-            });
-            const workerResult = {
-                type: "result",
-                success: true,
-                output: { result: sandbox.output ?? result, logs },
-            };
-            process.send(workerResult);
-        }
-        catch (err) {
-            const workerResult = {
-                type: "result",
-                success: false,
-                error: err.code === "ERR_SCRIPT_EXECUTION_TIMEOUT"
-                    ? `Code execution timed out after ${msg.timeoutMs}ms`
-                    : `Code error: ${err.message}`,
-                logs,
-            };
-            process.send(workerResult);
-        }
+  process.on("message", msg => {
+    if (msg.type !== "execute") return;
+    const logs = [];
+
+    // Validate code for dangerous patterns (defense-in-depth — sandbox isolation is primary defense)
+    const dangerousPatterns = [/constructor\s*\[/i, /constructor\s*\(/i, /\.constructor/i, /__proto__/i, /prototype\s*\[/i, /\bprocess\b/, /\brequire\b/, /\bimport\b/, /\bglobalThis\b/, /\bglobal\b/, /\bFunction\b/, /\beval\b/, /\bReflect\b/, /\bProxy\b/, /\bSymbol\b/, /\bWeakRef\b/];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(msg.code)) {
+        const result = {
+          type: "result",
+          success: false,
+          error: `Code contains blocked pattern: ${pattern.source}`
+        };
+        process.send(result);
+        return;
+      }
+    }
+
+    // Build hardened sandbox — NO host constructors or direct function references.
+    // vm.runInNewContext provides its own Array, Object, String, Number, Boolean in the
+    // sandbox context. We do NOT pass host realm constructors, which would allow
+    // escaping via .constructor.constructor('return process')().
+    const sandbox = Object.create(null);
+    sandbox.steps = JSON.parse(JSON.stringify(msg.context.steps));
+    sandbox.trigger = JSON.parse(JSON.stringify(msg.context.trigger));
+    sandbox.input = msg.context.input != null ? JSON.parse(JSON.stringify(msg.context.input)) : undefined;
+    sandbox.output = undefined;
+
+    // console — safe: null-prototype object with wrapped log function
+    const logFn = safeFunction((...args) => logs.push(args.map(String).join(" ")));
+    const consoleObj = Object.create(null);
+    consoleObj.log = logFn;
+    sandbox.console = Object.freeze(consoleObj);
+
+    // JSON — safe namespace with only parse/stringify
+    sandbox.JSON = safeNamespace(JSON, ["parse", "stringify"]);
+
+    // Math — safe namespace (all methods wrapped, numeric constants preserved)
+    const mathKeys = ["abs", "ceil", "floor", "round", "max", "min", "pow", "sqrt", "log", "log2", "log10", "random", "sign", "trunc", "cbrt", "hypot", "clz32", "imul", "fround", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "sinh", "cosh", "tanh", "PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"];
+    sandbox.Math = safeNamespace(Math, mathKeys);
+
+    // Date — only expose Date.now() as a safe function, not the Date constructor itself.
+    // The Date constructor is a host function whose .constructor leads to Function.
+    const dateNs = Object.create(null);
+    dateNs.now = safeFunction(Date.now);
+    sandbox.Date = Object.freeze(dateNs);
+
+    // Utility functions — each wrapped to sever .constructor chain
+    sandbox.parseInt = safeFunction(parseInt);
+    sandbox.parseFloat = safeFunction(parseFloat);
+    sandbox.isNaN = safeFunction(isNaN);
+    sandbox.isFinite = safeFunction(isFinite);
+    sandbox.encodeURIComponent = safeFunction(encodeURIComponent);
+    sandbox.decodeURIComponent = safeFunction(decodeURIComponent);
+
+    // URL — safe namespace with only parse method (no constructor exposure)
+    const urlNs = Object.create(null);
+    urlNs.parse = safeFunction(input => {
+      try {
+        const u = new URL(input);
+        return {
+          href: u.href,
+          protocol: u.protocol,
+          host: u.host,
+          hostname: u.hostname,
+          port: u.port,
+          pathname: u.pathname,
+          search: u.search,
+          hash: u.hash,
+          origin: u.origin,
+          searchParams: Object.fromEntries(u.searchParams)
+        };
+      } catch {
+        return null;
+      }
+    });
+    urlNs.format = safeFunction(parts => {
+      try {
+        return new URL(`${parts.protocol || "https:"}//${parts.host || parts.hostname || ""}${parts.pathname || ""}${parts.search || ""}`).href;
+      } catch {
+        return null;
+      }
     });
-    // Signal ready
-    process.send({ type: "ready" });
+    sandbox.URL = Object.freeze(urlNs);
+
+    // Buffer — safe namespace with wrapped from/alloc
+    const bufferNs = Object.create(null);
+    bufferNs.from = safeFunction((...args) => Buffer.from(args[0], args[1]));
+    bufferNs.alloc = safeFunction(size => Buffer.alloc(size));
+    sandbox.Buffer = Object.freeze(bufferNs);
+
+    // crypto — safe namespace with wrapped randomUUID
+    const cryptoNs = Object.create(null);
+    cryptoNs.randomUUID = safeFunction(randomUUID);
+    sandbox.crypto = Object.freeze(cryptoNs);
+
+    // DO NOT expose host constructors: Array, Object, String, Number, Boolean.
+    // vm.runInNewContext creates its own versions of these in the sandbox context.
+    // Passing host constructors would allow: [].constructor.constructor('return process')()
+
+    // Block dangerous globals explicitly
+    sandbox.process = undefined;
+    sandbox.require = undefined;
+    sandbox.global = undefined;
+    sandbox.globalThis = undefined;
+    sandbox.Function = undefined;
+    sandbox.eval = undefined;
+    sandbox.setTimeout = undefined;
+    sandbox.setInterval = undefined;
+    sandbox.Reflect = undefined;
+    sandbox.Proxy = undefined;
+    sandbox.Symbol = undefined;
+    sandbox.WeakRef = undefined;
+    try {
+      const result = runInNewContext(msg.code, sandbox, {
+        timeout: msg.timeoutMs,
+        filename: "workflow-code-step",
+        breakOnSigint: true,
+        microtaskMode: "afterEvaluate"
+      });
+      const workerResult = {
+        type: "result",
+        success: true,
+        output: {
+          result: sandbox.output ?? result,
+          logs
+        }
+      };
+      process.send(workerResult);
+    } catch (err) {
+      const workerResult = {
+        type: "result",
+        success: false,
+        error: err.code === "ERR_SCRIPT_EXECUTION_TIMEOUT" ? `Code execution timed out after ${msg.timeoutMs}ms` : `Code error: ${err.message}`,
+        logs
+      };
+      process.send(workerResult);
+    }
+  });
+
+  // Signal ready
+  process.send({
+    type: "ready"
+  });
 }
+//# sourceMappingURL=code-worker.js.map

package/dist/server/lib/code-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-worker.js","names":["runInNewContext","randomUUID","safeFunction","fn","safe","args","apply","Object","defineProperty","value","undefined","writable","configurable","freeze","safeNamespace","source","keys","ns","create","key","val","process","send","on","msg","type","logs","dangerousPatterns","pattern","test","code","result","success","error","sandbox","steps","JSON","parse","stringify","context","trigger","input","output","logFn","push","map","String","join","consoleObj","log","console","mathKeys","Math","dateNs","now","Date","parseInt","parseFloat","isNaN","isFinite","encodeURIComponent","decodeURIComponent","urlNs","u","URL","href","protocol","host","hostname","port","pathname","search","hash","origin","searchParams","fromEntries","format","parts","bufferNs","from","Buffer","alloc","size","cryptoNs","crypto","require","global","globalThis","Function","eval","setTimeout","setInterval","Reflect","Proxy","Symbol","WeakRef","timeout","timeoutMs","filename","breakOnSigint","microtaskMode","workerResult","err","message"],"sources":["../../../src/server/lib/code-worker.ts"],"sourcesContent":["// server/lib/code-worker.ts — Isolated code execution worker\n// Runs as a child process via fork(). Receives code + context via IPC,\n// executes in a fresh vm context, returns result. Crash here cannot take down the server.\n\nimport { runInNewContext } from \"node:vm\";\nimport { randomUUID } from \"node:crypto\";\n\ninterface WorkerMessage {\n  type: \"execute\";\n  code: string;\n  context: {\n    steps: Record<string, unknown>;\n    trigger: Record<string, unknown>;\n    input?: unknown;\n  };\n  timeoutMs: number;\n}\n\ninterface WorkerResult {\n  type: \"result\";\n  success: boolean;\n  output?: unknown;\n  logs?: string[];\n  error?: string;\n}\n\n/**\n * Create a safe wrapper function that cannot be used to reach the host Function constructor.\n * Wraps a host function in a proxy whose prototype chain is severed — .constructor returns\n * undefined instead of the host Function constructor.\n */\nfunction safeFunction<T extends (...args: any[]) => any>(fn: T): T {\n  // Create a wrapper function whose .constructor and .prototype are severed.\n  // We can't make a callable null-prototype object directly, so we override them on a regular function.\n  const safe = function (this: unknown, ...args: unknown[]) {\n    return fn.apply(this, args);\n  };\n  Object.defineProperty(safe, \"constructor\", { value: undefined, writable: false, configurable: false });\n  Object.defineProperty(safe, \"prototype\", { value: undefined, writable: false, configurable: false });\n  // Freeze to prevent re-assignment of constructor\n  Object.freeze(safe);\n  return safe as unknown as T;\n}\n\n/**\n * Create a safe namespace object (like Math, JSON, Buffer) whose properties\n * cannot reach the host Function constructor through any prototype chain.\n * All function-valued properties are wrapped via safeFunction().\n */\nfunction safeNamespace(source: Record<string, unknown>, keys: string[]): Readonly<Record<string, unknown>> {\n  const ns = Object.create(null) as Record<string, unknown>;\n  for (const key of keys) {\n    const val = source[key];\n    if (typeof val === \"function\") {\n      ns[key] = safeFunction(val as (...args: any[]) => any);\n    } else {\n      ns[key] = val;\n    }\n  }\n  return Object.freeze(ns);\n}\n\n// Only run when forked as a child process\nif (process.send) {\n  process.on(\"message\", (msg: WorkerMessage) => {\n    if (msg.type !== \"execute\") return;\n\n    const logs: string[] = [];\n\n    // Validate code for dangerous patterns (defense-in-depth — sandbox isolation is primary defense)\n    const dangerousPatterns = [\n      /constructor\\s*\\[/i,\n      /constructor\\s*\\(/i,\n      /\\.constructor/i,\n      /__proto__/i,\n      /prototype\\s*\\[/i,\n      /\\bprocess\\b/,\n      /\\brequire\\b/,\n      /\\bimport\\b/,\n      /\\bglobalThis\\b/,\n      /\\bglobal\\b/,\n      /\\bFunction\\b/,\n      /\\beval\\b/,\n      /\\bReflect\\b/,\n      /\\bProxy\\b/,\n      /\\bSymbol\\b/,\n      /\\bWeakRef\\b/,\n    ];\n    for (const pattern of dangerousPatterns) {\n      if (pattern.test(msg.code)) {\n        const result: WorkerResult = {\n          type: \"result\",\n          success: false,\n          error: `Code contains blocked pattern: ${pattern.source}`,\n        };\n        process.send!(result);\n        return;\n      }\n    }\n\n    // Build hardened sandbox — NO host constructors or direct function references.\n    // vm.runInNewContext provides its own Array, Object, String, Number, Boolean in the\n    // sandbox context. We do NOT pass host realm constructors, which would allow\n    // escaping via .constructor.constructor('return process')().\n    const sandbox = Object.create(null) as Record<string, unknown>;\n    sandbox.steps = JSON.parse(JSON.stringify(msg.context.steps));\n    sandbox.trigger = JSON.parse(JSON.stringify(msg.context.trigger));\n    sandbox.input = msg.context.input != null ? JSON.parse(JSON.stringify(msg.context.input)) : undefined;\n    sandbox.output = undefined;\n\n    // console — safe: null-prototype object with wrapped log function\n    const logFn = safeFunction((...args: unknown[]) => logs.push(args.map(String).join(\" \")));\n    const consoleObj = Object.create(null) as Record<string, unknown>;\n    consoleObj.log = logFn;\n    sandbox.console = Object.freeze(consoleObj);\n\n    // JSON — safe namespace with only parse/stringify\n    sandbox.JSON = safeNamespace(JSON as unknown as Record<string, unknown>, [\"parse\", \"stringify\"]);\n\n    // Math — safe namespace (all methods wrapped, numeric constants preserved)\n    const mathKeys = [\n      \"abs\", \"ceil\", \"floor\", \"round\", \"max\", \"min\", \"pow\", \"sqrt\", \"log\", \"log2\", \"log10\",\n      \"random\", \"sign\", \"trunc\", \"cbrt\", \"hypot\", \"clz32\", \"imul\", \"fround\",\n      \"sin\", \"cos\", \"tan\", \"asin\", \"acos\", \"atan\", \"atan2\", \"sinh\", \"cosh\", \"tanh\",\n      \"PI\", \"E\", \"LN2\", \"LN10\", \"LOG2E\", \"LOG10E\", \"SQRT2\", \"SQRT1_2\",\n    ];\n    sandbox.Math = safeNamespace(Math as unknown as Record<string, unknown>, mathKeys);\n\n    // Date — only expose Date.now() as a safe function, not the Date constructor itself.\n    // The Date constructor is a host function whose .constructor leads to Function.\n    const dateNs = Object.create(null) as Record<string, unknown>;\n    dateNs.now = safeFunction(Date.now);\n    sandbox.Date = Object.freeze(dateNs);\n\n    // Utility functions — each wrapped to sever .constructor chain\n    sandbox.parseInt = safeFunction(parseInt);\n    sandbox.parseFloat = safeFunction(parseFloat);\n    sandbox.isNaN = safeFunction(isNaN);\n    sandbox.isFinite = safeFunction(isFinite);\n    sandbox.encodeURIComponent = safeFunction(encodeURIComponent);\n    sandbox.decodeURIComponent = safeFunction(decodeURIComponent);\n\n    // URL — safe namespace with only parse method (no constructor exposure)\n    const urlNs = Object.create(null) as Record<string, unknown>;\n    urlNs.parse = safeFunction((input: string) => {\n      try {\n        const u = new URL(input);\n        return { href: u.href, protocol: u.protocol, host: u.host, hostname: u.hostname,\n                 port: u.port, pathname: u.pathname, search: u.search, hash: u.hash,\n                 origin: u.origin, searchParams: Object.fromEntries(u.searchParams) };\n      } catch { return null; }\n    });\n    urlNs.format = safeFunction((parts: Record<string, string>) => {\n      try { return new URL(`${parts.protocol || \"https:\"}//${parts.host || parts.hostname || \"\"}${parts.pathname || \"\"}${parts.search || \"\"}`).href; }\n      catch { return null; }\n    });\n    sandbox.URL = Object.freeze(urlNs);\n\n    // Buffer — safe namespace with wrapped from/alloc\n    const bufferNs = Object.create(null) as Record<string, unknown>;\n    bufferNs.from = safeFunction((...args: unknown[]) => Buffer.from(args[0] as any, args[1] as any));\n    bufferNs.alloc = safeFunction((size: number) => Buffer.alloc(size));\n    sandbox.Buffer = Object.freeze(bufferNs);\n\n    // crypto — safe namespace with wrapped randomUUID\n    const cryptoNs = Object.create(null) as Record<string, unknown>;\n    cryptoNs.randomUUID = safeFunction(randomUUID);\n    sandbox.crypto = Object.freeze(cryptoNs);\n\n    // DO NOT expose host constructors: Array, Object, String, Number, Boolean.\n    // vm.runInNewContext creates its own versions of these in the sandbox context.\n    // Passing host constructors would allow: [].constructor.constructor('return process')()\n\n    // Block dangerous globals explicitly\n    sandbox.process = undefined;\n    sandbox.require = undefined;\n    sandbox.global = undefined;\n    sandbox.globalThis = undefined;\n    sandbox.Function = undefined;\n    sandbox.eval = undefined;\n    sandbox.setTimeout = undefined;\n    sandbox.setInterval = undefined;\n    sandbox.Reflect = undefined;\n    sandbox.Proxy = undefined;\n    sandbox.Symbol = undefined;\n    sandbox.WeakRef = undefined;\n\n    try {\n      const result = runInNewContext(msg.code, sandbox, {\n        timeout: msg.timeoutMs,\n        filename: \"workflow-code-step\",\n        breakOnSigint: true,\n        microtaskMode: \"afterEvaluate\",\n      });\n\n      const workerResult: WorkerResult = {\n        type: \"result\",\n        success: true,\n        output: { result: sandbox.output ?? result, logs },\n      };\n      process.send!(workerResult);\n    } catch (err: any) {\n      const workerResult: WorkerResult = {\n        type: \"result\",\n        success: false,\n        error: err.code === \"ERR_SCRIPT_EXECUTION_TIMEOUT\"\n          ? `Code execution timed out after ${msg.timeoutMs}ms`\n          : `Code error: ${err.message}`,\n        logs,\n      };\n      process.send!(workerResult);\n    }\n  });\n\n  // Signal ready\n  process.send({ type: \"ready\" });\n}\n"],"mappings":"AAAA;AACA;AACA;;AAEA,SAASA,eAAe,QAAQ,SAAS;AACzC,SAASC,UAAU,QAAQ,aAAa;AAqBxC;AACA;AACA;AACA;AACA;AACA,SAASC,YAAYA,CAAoCC,EAAK,EAAK;EACjE;EACA;EACA,MAAMC,IAAI,GAAG,SAAAA,CAAyB,GAAGC,IAAe,EAAE;IACxD,OAAOF,EAAE,CAACG,KAAK,CAAC,IAAI,EAAED,IAAI,CAAC;EAC7B,CAAC;EACDE,MAAM,CAACC,cAAc,CAACJ,IAAI,EAAE,aAAa,EAAE;IAAEK,KAAK,EAAEC,SAAS;IAAEC,QAAQ,EAAE,KAAK;IAAEC,YAAY,EAAE;EAAM,CAAC,CAAC;EACtGL,MAAM,CAACC,cAAc,CAACJ,IAAI,EAAE,WAAW,EAAE;IAAEK,KAAK,EAAEC,SAAS;IAAEC,QAAQ,EAAE,KAAK;IAAEC,YAAY,EAAE;EAAM,CAAC,CAAC;EACpG;EACAL,MAAM,CAACM,MAAM,CAACT,IAAI,CAAC;EACnB,OAAOA,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA,SAASU,aAAaA,CAACC,MAA+B,EAAEC,IAAc,EAAqC;EACzG,MAAMC,EAAE,GAAGV,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;EACzD,KAAK,MAAMC,GAAG,IAAIH,IAAI,EAAE;IACtB,MAAMI,GAAG,GAAGL,MAAM,CAACI,GAAG,CAAC;IACvB,IAAI,OAAOC,GAAG,KAAK,UAAU,EAAE;MAC7BH,EAAE,CAACE,GAAG,CAAC,GAAGjB,YAAY,CAACkB,GAA8B,CAAC;IACxD,CAAC,MAAM;MACLH,EAAE,CAACE,GAAG,CAAC,GAAGC,GAAG;IACf;EACF;EACA,OAAOb,MAAM,CAACM,MAAM,CAACI,EAAE,CAAC;AAC1B;;AAEA;AACA,IAAII,OAAO,CAACC,IAAI,EAAE;EAChBD,OAAO,CAACE,EAAE,CAAC,SAAS,EAAGC,GAAkB,IAAK;IAC5C,IAAIA,GAAG,CAACC,IAAI,KAAK,SAAS,EAAE;IAE5B,MAAMC,IAAc,GAAG,EAAE;;IAEzB;IACA,MAAMC,iBAAiB,GAAG,CACxB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,UAAU,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,aAAa,CACd;IACD,KAAK,MAAMC,OAAO,IAAID,iBAAiB,EAAE;MACvC,IAAIC,OAAO,CAACC,IAAI,CAACL,GAAG,CAACM,IAAI,CAAC,EAAE;QAC1B,MAAMC,MAAoB,GAAG;UAC3BN,IAAI,EAAE,QAAQ;UACdO,OAAO,EAAE,KAAK;UACdC,KAAK,EAAE,kCAAkCL,OAAO,CAACb,MAAM;QACzD,CAAC;QACDM,OAAO,CAACC,IAAI,CAAES,MAAM,CAAC;QACrB;MACF;IACF;;IAEA;IACA;IACA;IACA;IACA,MAAMG,OAAO,GAAG3B,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IAC9DgB,OAAO,CAACC,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,SAAS,CAACd,GAAG,CAACe,OAAO,CAACJ,KAAK,CAAC,CAAC;IAC7DD,OAAO,CAACM,OAAO,GAAGJ,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,SAAS,CAACd,GAAG,CAACe,OAAO,CAACC,OAAO,CAAC,CAAC;IACjEN,OAAO,CAACO,KAAK,GAAGjB,GAAG,CAACe,OAAO,CAACE,KAAK,IAAI,IAAI,GAAGL,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,SAAS,CAACd,GAAG,CAACe,OAAO,CAACE,KAAK,CAAC,CAAC,GAAG/B,SAAS;IACrGwB,OAAO,CAACQ,MAAM,GAAGhC,SAAS;;IAE1B;IACA,MAAMiC,KAAK,GAAGzC,YAAY,CAAC,CAAC,GAAGG,IAAe,KAAKqB,IAAI,CAACkB,IAAI,CAACvC,IAAI,CAACwC,GAAG,CAACC,MAAM,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACzF,MAAMC,UAAU,GAAGzC,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IACjE8B,UAAU,CAACC,GAAG,GAAGN,KAAK;IACtBT,OAAO,CAACgB,OAAO,GAAG3C,MAAM,CAACM,MAAM,CAACmC,UAAU,CAAC;;IAE3C;IACAd,OAAO,CAACE,IAAI,GAAGtB,aAAa,CAACsB,IAAI,EAAwC,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;;IAEhG;IACA,MAAMe,QAAQ,GAAG,CACf,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EACpF,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EACrE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC5E,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,CAChE;IACDjB,OAAO,CAACkB,IAAI,GAAGtC,aAAa,CAACsC,IAAI,EAAwCD,QAAQ,CAAC;;IAElF;IACA;IACA,MAAME,MAAM,GAAG9C,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IAC7DmC,MAAM,CAACC,GAAG,GAAGpD,YAAY,CAACqD,IAAI,CAACD,GAAG,CAAC;IACnCpB,OAAO,CAACqB,IAAI,GAAGhD,MAAM,CAACM,MAAM,CAACwC,MAAM,CAAC;;IAEpC;IACAnB,OAAO,CAACsB,QAAQ,GAAGtD,YAAY,CAACsD,QAAQ,CAAC;IACzCtB,OAAO,CAACuB,UAAU,GAAGvD,YAAY,CAACuD,UAAU,CAAC;IAC7CvB,OAAO,CAACwB,KAAK,GAAGxD,YAAY,CAACwD,KAAK,CAAC;IACnCxB,OAAO,CAACyB,QAAQ,GAAGzD,YAAY,CAACyD,QAAQ,CAAC;IACzCzB,OAAO,CAAC0B,kBAAkB,GAAG1D,YAAY,CAAC0D,kBAAkB,CAAC;IAC7D1B,OAAO,CAAC2B,kBAAkB,GAAG3D,YAAY,CAAC2D,kBAAkB,CAAC;;IAE7D;IACA,MAAMC,KAAK,GAAGvD,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IAC5D4C,KAAK,CAACzB,KAAK,GAAGnC,YAAY,CAAEuC,KAAa,IAAK;MAC5C,IAAI;QACF,MAAMsB,CAAC,GAAG,IAAIC,GAAG,CAACvB,KAAK,CAAC;QACxB,OAAO;UAAEwB,IAAI,EAAEF,CAAC,CAACE,IAAI;UAAEC,QAAQ,EAAEH,CAAC,CAACG,QAAQ;UAAEC,IAAI,EAAEJ,CAAC,CAACI,IAAI;UAAEC,QAAQ,EAAEL,CAAC,CAACK,QAAQ;UACtEC,IAAI,EAAEN,CAAC,CAACM,IAAI;UAAEC,QAAQ,EAAEP,CAAC,CAACO,QAAQ;UAAEC,MAAM,EAAER,CAAC,CAACQ,MAAM;UAAEC,IAAI,EAAET,CAAC,CAACS,IAAI;UAClEC,MAAM,EAAEV,CAAC,CAACU,MAAM;UAAEC,YAAY,EAAEnE,MAAM,CAACoE,WAAW,CAACZ,CAAC,CAACW,YAAY;QAAE,CAAC;MAC/E,CAAC,CAAC,MAAM;QAAE,OAAO,IAAI;MAAE;IACzB,CAAC,CAAC;IACFZ,KAAK,CAACc,MAAM,GAAG1E,YAAY,CAAE2E,KAA6B,IAAK;MAC7D,IAAI;QAAE,OAAO,IAAIb,GAAG,CAAC,GAAGa,KAAK,CAACX,QAAQ,IAAI,QAAQ,KAAKW,KAAK,CAACV,IAAI,IAAIU,KAAK,CAACT,QAAQ,IAAI,EAAE,GAAGS,KAAK,CAACP,QAAQ,IAAI,EAAE,GAAGO,KAAK,CAACN,MAAM,IAAI,EAAE,EAAE,CAAC,CAACN,IAAI;MAAE,CAAC,CAChJ,MAAM;QAAE,OAAO,IAAI;MAAE;IACvB,CAAC,CAAC;IACF/B,OAAO,CAAC8B,GAAG,GAAGzD,MAAM,CAACM,MAAM,CAACiD,KAAK,CAAC;;IAElC;IACA,MAAMgB,QAAQ,GAAGvE,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IAC/D4D,QAAQ,CAACC,IAAI,GAAG7E,YAAY,CAAC,CAAC,GAAGG,IAAe,KAAK2E,MAAM,CAACD,IAAI,CAAC1E,IAAI,CAAC,CAAC,CAAC,EAASA,IAAI,CAAC,CAAC,CAAQ,CAAC,CAAC;IACjGyE,QAAQ,CAACG,KAAK,GAAG/E,YAAY,CAAEgF,IAAY,IAAKF,MAAM,CAACC,KAAK,CAACC,IAAI,CAAC,CAAC;IACnEhD,OAAO,CAAC8C,MAAM,GAAGzE,MAAM,CAACM,MAAM,CAACiE,QAAQ,CAAC;;IAExC;IACA,MAAMK,QAAQ,GAAG5E,MAAM,CAACW,MAAM,CAAC,IAAI,CAA4B;IAC/DiE,QAAQ,CAAClF,UAAU,GAAGC,YAAY,CAACD,UAAU,CAAC;IAC9CiC,OAAO,CAACkD,MAAM,GAAG7E,MAAM,CAACM,MAAM,CAACsE,QAAQ,CAAC;;IAExC;IACA;IACA;;IAEA;IACAjD,OAAO,CAACb,OAAO,GAAGX,SAAS;IAC3BwB,OAAO,CAACmD,OAAO,GAAG3E,SAAS;IAC3BwB,OAAO,CAACoD,MAAM,GAAG5E,SAAS;IAC1BwB,OAAO,CAACqD,UAAU,GAAG7E,SAAS;IAC9BwB,OAAO,CAACsD,QAAQ,GAAG9E,SAAS;IAC5BwB,OAAO,CAACuD,IAAI,GAAG/E,SAAS;IACxBwB,OAAO,CAACwD,UAAU,GAAGhF,SAAS;IAC9BwB,OAAO,CAACyD,WAAW,GAAGjF,SAAS;IAC/BwB,OAAO,CAAC0D,OAAO,GAAGlF,SAAS;IAC3BwB,OAAO,CAAC2D,KAAK,GAAGnF,SAAS;IACzBwB,OAAO,CAAC4D,MAAM,GAAGpF,SAAS;IAC1BwB,OAAO,CAAC6D,OAAO,GAAGrF,SAAS;IAE3B,IAAI;MACF,MAAMqB,MAAM,GAAG/B,eAAe,CAACwB,GAAG,CAACM,IAAI,EAAEI,OAAO,EAAE;QAChD8D,OAAO,EAAExE,GAAG,CAACyE,SAAS;QACtBC,QAAQ,EAAE,oBAAoB;QAC9BC,aAAa,EAAE,IAAI;QACnBC,aAAa,EAAE;MACjB,CAAC,CAAC;MAEF,MAAMC,YAA0B,GAAG;QACjC5E,IAAI,EAAE,QAAQ;QACdO,OAAO,EAAE,IAAI;QACbU,MAAM,EAAE;UAAEX,MAAM,EAAEG,OAAO,CAACQ,MAAM,IAAIX,MAAM;UAAEL;QAAK;MACnD,CAAC;MACDL,OAAO,CAACC,IAAI,CAAE+E,YAAY,CAAC;IAC7B,CAAC,CAAC,OAAOC,GAAQ,EAAE;MACjB,MAAMD,YAA0B,GAAG;QACjC5E,IAAI,EAAE,QAAQ;QACdO,OAAO,EAAE,KAAK;QACdC,KAAK,EAAEqE,GAAG,CAACxE,IAAI,KAAK,8BAA8B,GAC9C,kCAAkCN,GAAG,CAACyE,SAAS,IAAI,GACnD,eAAeK,GAAG,CAACC,OAAO,EAAE;QAChC7E;MACF,CAAC;MACDL,OAAO,CAACC,IAAI,CAAE+E,YAAY,CAAC;IAC7B;EACF,CAAC,CAAC;;EAEF;EACAhF,OAAO,CAACC,IAAI,CAAC;IAAEG,IAAI,EAAE;EAAQ,CAAC,CAAC;AACjC","ignoreList":[]}

package/dist/server/lib/compaction-service.d.ts

@@ -1,21 +1,11 @@
 import Anthropic from "@anthropic-ai/sdk";
+export { preCompact } from "../../shared/compaction.js";
+export type { PreCompactResult, PreCompactOptions } from "../../shared/compaction.js";
 export interface CompactionResult {
     success: boolean;
     content?: string;
     error?: string;
 }
-export interface PreCompactResult {
-    messages: Array<Record<string, unknown>>;
-    bytesRemoved: number;
-}
-/**
- * Pre-compaction pass: strip redundant data before calling LLM summarizer.
- * Mechanically removes large tool results already processed by the agent
- * and thinking blocks from older turns. Returns modified messages array
- * with reduced content so the LLM summarizer (or API context_management)
- * has less to work with.
- */
-export declare function preCompact(messages: Array<Record<string, unknown>>): PreCompactResult;
 /**
  * Generate a compaction summary using Haiku.
  *