@armadra/agent 0.0.0-stage → 0.2.1

package/dist/bundle/ama-sandbox.cjs

@@ -0,0 +1,324 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codemode/sandbox-entry.ts
+var sandbox_entry_exports = {};
+__export(sandbox_entry_exports, {
+  MAX_CONCURRENT: () => MAX_CONCURRENT,
+  MAX_STORE_TOTAL_CHARS: () => MAX_STORE_TOTAL_CHARS,
+  MAX_STORE_VALUE_CHARS: () => MAX_STORE_VALUE_CHARS,
+  describeError: () => describeError
+});
+module.exports = __toCommonJS(sandbox_entry_exports);
+var import_node_vm = require("node:vm");
+var MAX_CONCURRENT = 8;
+var MAX_STORE_VALUE_CHARS = 262144;
+var MAX_STORE_TOTAL_CHARS = 1048576;
+var SCRIPT_FILENAME = "codemode-script.js";
+var BOOTSTRAP = String.raw`(function (host, config) {
+  "use strict";
+  const MAX = config.maxConcurrent;
+  const stringify = JSON.stringify;
+  const parse = JSON.parse;
+  const pending = new Map();
+  const waiting = [];
+  let nextId = 0;
+  let active = 0;
+  let closed = false;
+  const decls = parse(config.tools);
+  const declByName = new Map();
+  const callName = new Map();
+  for (const decl of decls) {
+    declByName.set(decl.name, decl.declaration);
+    callName.set(decl.name.replace(/[^A-Za-z0-9_$]/g, "_"), decl.name);
+  }
+  const names = Object.freeze(decls.map((d) => d.name));
+
+  function format(value) {
+    if (typeof value === "string") return value;
+    if (value === undefined) return "undefined";
+    if (value instanceof Error) return value.name + ": " + value.message;
+    try {
+      const json = stringify(value, null, 2);
+      return json === undefined ? String(value) : json;
+    } catch (error) {
+      return String(value);
+    }
+  }
+  function text(...values) {
+    host("output", values.map(format).join(" "));
+  }
+
+  function callTool(name, input) {
+    if (closed) return Promise.reject(new Error("The script has already finished"));
+    let payload;
+    try {
+      payload = stringify({ name: name, input: input === undefined ? {} : input });
+    } catch (error) {
+      return Promise.reject(new Error("tools." + name + ": arguments must be JSON-serializable"));
+    }
+    return new Promise((resolve, reject) => {
+      const start = () => {
+        if (closed) return reject(new Error("The script has already finished"));
+        const id = ++nextId;
+        active++;
+        pending.set(id, { resolve: resolve, reject: reject });
+        host("tool_call", stringify(id) + "\n" + payload);
+      };
+      if (active < MAX) start();
+      else waiting.push(start);
+    });
+  }
+
+  function deliver(id, ok, json) {
+    const entry = pending.get(id);
+    if (entry === undefined) return;
+    pending.delete(id);
+    active--;
+    const next = waiting.shift();
+    if (next !== undefined) next();
+    if (ok) entry.resolve(json === undefined ? undefined : parse(json));
+    else entry.reject(new Error(json));
+  }
+
+  const toolsTarget = Object.create(null);
+  const tools = new Proxy(toolsTarget, {
+    get(target, prop) {
+      if (typeof prop !== "string" || prop === "then") return undefined;
+      const real = callName.get(prop);
+      if (real !== undefined) return (args) => callTool(real, args);
+      if (prop === "codemode") {
+        return () => Promise.reject(new Error("codemode cannot be called from a codemode script"));
+      }
+      return () =>
+        Promise.reject(new Error("Unknown tool " + prop + ". Callable tools: " + names.join(", ")));
+    },
+    has(target, prop) {
+      return typeof prop === "string" && callName.has(prop);
+    },
+    ownKeys() {
+      return [...callName.keys()];
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (typeof prop !== "string" || !callName.has(prop)) return undefined;
+      return { configurable: true, enumerable: true, writable: false, value: tools[prop] };
+    },
+    set() {
+      return false;
+    },
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+  });
+
+  const storeMap = new Map(Object.entries(parse(config.store)).map(([k, v]) => [k, stringify(v)]));
+  let storeChanged = false;
+  function store(key, value) {
+    if (typeof key !== "string" || key === "") throw new TypeError("store(key, value): key must be a non-empty string");
+    if (value === undefined) {
+      storeChanged = storeMap.delete(key) || storeChanged;
+      return;
+    }
+    let json;
+    try {
+      json = stringify(value);
+    } catch (error) {
+      throw new TypeError("store(" + stringify(key) + "): value must be JSON-serializable");
+    }
+    if (json === undefined) throw new TypeError("store(" + stringify(key) + "): value must be JSON-serializable");
+    if (json.length > config.maxValueChars) {
+      throw new RangeError("store(" + stringify(key) + "): value is " + json.length + " characters of JSON (limit " + config.maxValueChars + ")");
+    }
+    let total = json.length;
+    for (const [k, v] of storeMap) if (k !== key) total += v.length;
+    if (total > config.maxTotalChars) {
+      throw new RangeError("store(" + stringify(key) + "): store would hold " + total + " characters of JSON (limit " + config.maxTotalChars + ")");
+    }
+    storeMap.set(key, json);
+    storeChanged = true;
+  }
+  function load(key) {
+    const json = storeMap.get(key);
+    return json === undefined ? undefined : parse(json);
+  }
+  function describeTool(name) {
+    return declByName.get(callName.get(name) ?? name);
+  }
+
+  const consoleObject = Object.freeze({
+    log: text, info: text, warn: text, error: text, debug: text,
+  });
+  const globals = {
+    tools: tools,
+    text: (value) => text(value),
+    console: consoleObject,
+    store: store,
+    load: load,
+    ALL_TOOLS: names,
+    describeTool: describeTool,
+  };
+  for (const [key, value] of Object.entries(globals)) {
+    Object.defineProperty(globalThis, key, { value: value, writable: false, enumerable: false, configurable: false });
+  }
+
+  function finish() {
+    closed = true;
+    waiting.length = 0;
+    for (const entry of pending.values()) entry.reject(new Error("The script has finished"));
+    pending.clear();
+    if (!storeChanged) return undefined;
+    const out = {};
+    for (const [k, v] of storeMap) out[k] = parse(v);
+    return stringify(out);
+  }
+
+  async function run(main) {
+    const value = await main;
+    if (value !== undefined) text(value);
+  }
+
+  return { deliver: deliver, finish: finish, run: run };
+})`;
+function send(message) {
+  process.stdout.write(
+    `${JSON.stringify(message).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}
+`
+  );
+}
+function describeError(error) {
+  if (typeof error !== "object" || error === null) return String(error);
+  const e = error;
+  const base = typeof e.message === "string" ? `${typeof e.name === "string" ? e.name : "Error"}: ${e.message}` : String(error);
+  const stack = typeof e.stack === "string" ? e.stack : "";
+  const at = new RegExp(`${SCRIPT_FILENAME.replace(".", "\\.")}:(\\d+)(?::(\\d+))?`).exec(stack);
+  return at === null ? base : `${base} (line ${at[1]})`;
+}
+var started = false;
+var finished = false;
+var bridge;
+var startedAt = 0;
+function done(ok, error) {
+  if (finished) return;
+  finished = true;
+  if (bridge !== void 0) {
+    const snapshot = bridge.finish();
+    if (ok && snapshot !== void 0) {
+      send({ type: "store", entries: JSON.parse(snapshot) });
+    }
+  }
+  const message = { type: "done", ok, elapsedMs: Date.now() - startedAt };
+  if (error !== void 0) message.error = error;
+  send(message);
+  process.stdout.write("", () => process.exit(0));
+}
+function host(kind, payload) {
+  if (finished) return;
+  if (kind === "output") {
+    send({ type: "output", text: payload });
+    return;
+  }
+  if (kind === "tool_call") {
+    const newline = payload.indexOf("\n");
+    const id = Number(payload.slice(0, newline));
+    const call = JSON.parse(payload.slice(newline + 1));
+    send({ type: "tool_call", id, name: call.name, input: call.input });
+  }
+}
+function start(run) {
+  started = true;
+  startedAt = Date.now();
+  const context = (0, import_node_vm.createContext)(/* @__PURE__ */ Object.create(null), {
+    name: "codemode",
+    codeGeneration: { strings: false, wasm: false }
+  });
+  const config = {
+    maxConcurrent: MAX_CONCURRENT,
+    maxValueChars: MAX_STORE_VALUE_CHARS,
+    maxTotalChars: MAX_STORE_TOTAL_CHARS,
+    tools: JSON.stringify(run.tools),
+    store: JSON.stringify(run.store ?? {})
+  };
+  let main2;
+  try {
+    const factory = new import_node_vm.Script(BOOTSTRAP, { filename: "codemode-bootstrap.js" }).runInContext(
+      context
+    );
+    bridge = factory(host, config);
+    main2 = new import_node_vm.Script(`(async () => {
+${run.script}
+})()`, {
+      filename: SCRIPT_FILENAME,
+      lineOffset: -1
+    }).runInContext(context);
+  } catch (error) {
+    done(false, describeError(error));
+    return;
+  }
+  bridge.run(main2).then(
+    () => done(true),
+    (error) => done(false, describeError(error))
+  );
+}
+function handle(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (message.type === "run") {
+    if (!started) start(message);
+  } else if (message.type === "tool_result") {
+    if (message.ok) {
+      const json = message.value === void 0 ? void 0 : JSON.stringify(message.value);
+      bridge?.deliver(message.id, true, json);
+    } else bridge?.deliver(message.id, false, message.error);
+  } else if (message.type === "abort") {
+    done(false, "Script aborted");
+  }
+}
+function main() {
+  process.on("unhandledRejection", () => {
+  });
+  process.on("uncaughtException", (error) => done(false, describeError(error)));
+  let buffer = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) if (line.trim() !== "") handle(line);
+  });
+  process.stdin.on("end", () => {
+    if (buffer.trim() !== "") handle(buffer);
+    buffer = "";
+    done(false, "Script aborted: parent closed the channel");
+  });
+}
+if (process.argv.includes("--ama-codemode-sandbox")) main();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_CONCURRENT,
+  MAX_STORE_TOTAL_CHARS,
+  MAX_STORE_VALUE_CHARS,
+  describeError
+});