@lunora/agent 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/sandboxComponent-DR3pTwBL.mjs

@@ -0,0 +1,194 @@
+import { LunoraError } from '@lunora/errors';
+import { initLunora } from '@lunora/server';
+import { v } from '@lunora/values';
+import { t as toBase64 } from './base64-BVwtgRJV.mjs';
+
+const { internalAction } = initLunora.dataModel().create();
+const sandboxScrapeDocument = () => globalThis.document?.documentElement?.outerHTML ?? "";
+const MAX_FS_BYTES = 1e6;
+const MAX_LS_PAGES = 20;
+const fsEncoder = new TextEncoder();
+const runBrowserOp = async (browser, request) => {
+  const url = request.url ?? "";
+  switch (request.op) {
+    case "content": {
+      return browser.content(url);
+    }
+    case "pdf": {
+      return { data: toBase64(await browser.pdf(url)), encoding: "base64", mediaType: "application/pdf" };
+    }
+    case "scrape": {
+      return browser.scrape(url, sandboxScrapeDocument);
+    }
+    case "screenshot": {
+      const bytes = await browser.screenshot(url, {
+        ...request.fullPage === void 0 ? {} : { fullPage: request.fullPage },
+        ...request.type === void 0 ? {} : { type: request.type }
+      });
+      return { data: toBase64(bytes), encoding: "base64", mediaType: request.type === "jpeg" ? "image/jpeg" : "image/png" };
+    }
+    default: {
+      throw new LunoraError("INTERNAL", `@lunora/agent: sandbox browser op "${request.op}" is not supported`);
+    }
+  }
+};
+const runContainerOp = async (accessor, request) => {
+  const handle = accessor.any();
+  if (request.op === "exec") {
+    const response = await handle.fetch("/exec", {
+      body: JSON.stringify({ args: request.args ?? [], command: request.command ?? "" }),
+      headers: { "content-type": "application/json" },
+      method: "POST"
+    });
+    return response.text();
+  }
+  if (request.op === "fetch") {
+    const response = await handle.fetch(request.path ?? "/", {
+      ...request.body === void 0 ? {} : { body: request.body },
+      method: request.method ?? "GET"
+    });
+    return response.text();
+  }
+  throw new LunoraError("INTERNAL", `@lunora/agent: sandbox container op "${request.op}" is not supported`);
+};
+const trimSlashes = (value) => {
+  let start = 0;
+  let end = value.length;
+  while (start < end && value[start] === "/") {
+    start += 1;
+  }
+  while (end > start && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(start, end);
+};
+const resolveFsKey = (root, path) => {
+  const base = trimSlashes(root);
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      if (segments.length === 0) {
+        throw new LunoraError("BAD_REQUEST", "@lunora/agent: fs path escapes the sandbox root");
+      }
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  const relative = segments.join("/");
+  return base && relative ? `${base}/${relative}` : base || relative;
+};
+const listFsEntries = async (bucket, key, base) => {
+  const prefix = key.length > 0 ? `${key}/` : "";
+  const strip = base.length > 0 ? base.length + 1 : 0;
+  const entries = [];
+  let cursor;
+  for (let page = 0; page < MAX_LS_PAGES; page += 1) {
+    const result = await bucket.list({ prefix, ...cursor === void 0 ? {} : { cursor } });
+    for (const object of result.objects) {
+      entries.push(object.key.slice(strip));
+    }
+    if (!result.truncated || result.cursor === void 0) {
+      return { entries, truncated: false };
+    }
+    cursor = result.cursor;
+  }
+  return { entries, truncated: true };
+};
+const runFsOp = async (bucket, root, request) => {
+  const base = trimSlashes(root);
+  const key = resolveFsKey(root, request.path ?? "");
+  switch (request.op) {
+    case "ls": {
+      const { entries, truncated } = await listFsEntries(bucket, key, base);
+      return truncated ? { entries, truncated: true } : { entries };
+    }
+    case "read": {
+      const head = await bucket.head(key);
+      if (head && head.size > MAX_FS_BYTES) {
+        throw new LunoraError(
+          "BAD_REQUEST",
+          `@lunora/agent: fs read: "${request.path ?? ""}" is ${String(head.size)} bytes (max ${String(MAX_FS_BYTES)})`
+        );
+      }
+      const object = await bucket.get(key);
+      if (!object) {
+        throw new LunoraError("NOT_FOUND", `@lunora/agent: fs read: no file at "${request.path ?? ""}"`);
+      }
+      return object.text();
+    }
+    case "rm": {
+      await bucket.delete(key);
+      return { path: request.path ?? "", removed: true };
+    }
+    case "stat": {
+      const head = await bucket.head(key);
+      return head ? { exists: true, size: head.size } : { exists: false };
+    }
+    case "write": {
+      const content = request.content ?? "";
+      const bytes = fsEncoder.encode(content).length;
+      if (bytes > MAX_FS_BYTES) {
+        throw new LunoraError("BAD_REQUEST", `@lunora/agent: fs write: ${String(bytes)} bytes exceeds the max (${String(MAX_FS_BYTES)})`);
+      }
+      await bucket.put(key, content);
+      return { bytes, path: request.path ?? "", wrote: true };
+    }
+    default: {
+      throw new LunoraError("INTERNAL", `@lunora/agent: sandbox fs op "${request.op}" is not supported`);
+    }
+  }
+};
+const sandboxComponent = () => {
+  const invoke = internalAction.input({
+    args: v.optional(v.array(v.string())),
+    body: v.optional(v.string()),
+    bucket: v.optional(v.string()),
+    command: v.optional(v.string()),
+    content: v.optional(v.string()),
+    fullPage: v.optional(v.boolean()),
+    kind: v.union(v.literal("browser"), v.literal("container"), v.literal("fs")),
+    method: v.optional(v.string()),
+    name: v.optional(v.string()),
+    op: v.string(),
+    path: v.optional(v.string()),
+    root: v.optional(v.string()),
+    selector: v.optional(v.string()),
+    type: v.optional(v.string()),
+    url: v.optional(v.string())
+  }).action(async ({ args, ctx: context }) => {
+    const surface = context;
+    const request = args;
+    if (request.kind === "browser") {
+      if (!surface.browser) {
+        throw new LunoraError("INTERNAL", "@lunora/agent: sandbox browser op needs `ctx.browser` — install @lunora/browser and run codegen");
+      }
+      return runBrowserOp(surface.browser, request);
+    }
+    if (request.kind === "fs") {
+      const bucket = surface.env?.[request.bucket ?? ""];
+      if (!bucket || typeof bucket.get !== "function") {
+        throw new LunoraError(
+          "INTERNAL",
+          `@lunora/agent: sandbox fs op found no R2 bucket "${request.bucket ?? ""}" on env — declare the r2_bucket binding in wrangler.jsonc and run codegen`
+        );
+      }
+      return runFsOp(bucket, request.root ?? "", request);
+    }
+    const name = request.name ?? "";
+    const accessor = surface.containers?.[name];
+    if (!accessor) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: sandbox container op found no ctx.containers["${name}"] — declare the container in lunora/containers.ts and run codegen`
+      );
+    }
+    return runContainerOp(accessor, request);
+  });
+  return { invoke };
+};
+
+export { resolveFsKey, runFsOp, sandboxComponent };

package/dist/packem_shared/sentryTelemetry-CgqFJyLO.mjs

@@ -0,0 +1,36 @@
+import { r as readField, t as toolInputOf } from './common-DAeFCot5.mjs';
+
+const stringOr = (value, fallback) => typeof value === "string" && value.length > 0 ? value : fallback;
+const sentryTelemetry = (options) => {
+  const { functionId, recordInputs = false, Sentry: sentry } = options;
+  return {
+    executeLanguageModelCall: (options_) => {
+      const attributes = {
+        "gen_ai.operation.name": stringOr(functionId, "language_model_call"),
+        "gen_ai.request.model": readField(options_, "modelId"),
+        "gen_ai.system": readField(options_, "provider")
+      };
+      if (recordInputs) {
+        attributes["gen_ai.prompt"] = readField(options_, "messages");
+      }
+      return sentry.startSpan({ attributes, name: stringOr(functionId, "language_model_call"), op: "gen_ai.generate" }, () => options_.execute());
+    },
+    executeTool: (options_) => {
+      const toolName = readField(readField(options_, "toolCall"), "toolName");
+      const attributes = {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.call.id": readField(options_, "toolCallId"),
+        "gen_ai.tool.name": toolName
+      };
+      if (recordInputs) {
+        attributes["gen_ai.tool.input"] = toolInputOf(options_);
+      }
+      return sentry.startSpan({ attributes, name: `execute_tool ${stringOr(toolName, "tool")}`, op: "gen_ai.execute_tool" }, () => options_.execute());
+    },
+    onError: (error) => {
+      sentry.captureException(error);
+    }
+  };
+};
+
+export { sentryTelemetry };