sandboxedjs 0.1.39 → 0.1.41

package/README.md

@@ -37,6 +37,50 @@ npm install sandboxedjs
 
 Node 18.17+. Everything is pure JavaScript and WebAssembly — no compilation step.
 
+## Deep Agents
+
+`SandboxedJsBackend` lets [LangChain Deep Agents](https://github.com/langchain-ai/deepagents)
+use a `sandboxedjs` container as its execution and filesystem sandbox. Install the two packages
+in the host application (plus the LangChain model adapter for your provider):
+
+```bash
+npm install sandboxedjs deepagents
+```
+
+Create a container, pass its backend to `createDeepAgent`, and dispose the container when the run
+is finished:
+
+```ts
+import { createContainer } from "sandboxedjs";
+import { SandboxedJsBackend, installSandboxSkills } from "sandboxedjs/agent";
+import { createDeepAgent } from "deepagents";
+
+const box = await createContainer({
+  cwd: "/app",
+  network: { allowOutbound: true }, // required for npm installs or other downloads
+});
+
+await installSandboxSkills(box); // optional: installs the bundled sandbox workflow skills
+
+// `model` is any chat model supported by Deep Agents, configured by your application.
+const agent = createDeepAgent({
+  model,
+  backend: new SandboxedJsBackend(box, { cwd: "/app" }),
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "Create and test a small Node.js service in /app." }],
+});
+
+box.dispose();
+```
+
+The adapter mirrors `deepagents@1.13.2`'s `SandboxBackendProtocolV2` and provides shell execution plus
+`ls`, `read`, `readRaw`, `write`, `edit`, `grep`, `glob`, `delete`, file upload, and file download
+operations. Paths passed to filesystem tools must be absolute. `deepagents` is intentionally not a
+runtime dependency of `sandboxedjs`; applications that use this integration install and configure
+it alongside their model provider.
+
 ## What's inside
 
 | | |

package/dist/agent.d.cts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-BsPKqY9R.cjs';
+import { C as Container } from './container-CZn9USBQ.cjs';
 
 /**
  * Structural copies of the LangChain Deep Agents backend contract.

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-BsPKqY9R.js';
+import { C as Container } from './container-CZn9USBQ.js';
 
 /**
  * Structural copies of the LangChain Deep Agents backend contract.

package/dist/{container-BsPKqY9R.d.cts → container-CZn9USBQ.d.cts}

@@ -30,6 +30,13 @@ interface ChildSpawnConfig {
      * types and one that reads to end-of-input and stops.
      */
     inheritStdio?: boolean;
+    /**
+     * The child was told to ignore its input (`stdio: "ignore"`).
+     *
+     * It then has no input at all, so its stdin is closed at once rather than
+     * left open on a parent that will never write to it.
+     */
+    stdinIgnored?: boolean;
 }
 type SpawnChild = (config: ChildSpawnConfig) => ChildHandle;
 /**
@@ -440,6 +447,21 @@ declare class Pipe implements InputStream, OutputStream {
      * every character appears twice.
      */
     private raw;
+    /**
+     * Translate carriage returns on the way in, the way `ICRNL` does.
+     *
+     * A terminal sends CR when Enter is pressed — xterm and every browser
+     * terminal emulator do — while everything that reads a line looks for LF.
+     * A real tty reconciles the two in its line discipline, which is on by
+     * default; without it `read name` waits forever on input the user already
+     * typed, and the only visible symptom is a hang.
+     *
+     * Deliberately opt-in rather than implied by `isTTY`, because stdout is a
+     * tty too and a bare CR there is how every progress bar and menu redraw
+     * returns to the start of the line. Translating those would corrupt exactly
+     * the output this runtime exists to render faithfully.
+     */
+    icrnl: boolean;
     onRawMode?: (enabled: boolean) => void;
     get rawMode(): boolean;
     set rawMode(enabled: boolean);

package/dist/{container-BsPKqY9R.d.ts → container-CZn9USBQ.d.ts}

@@ -30,6 +30,13 @@ interface ChildSpawnConfig {
      * types and one that reads to end-of-input and stops.
      */
     inheritStdio?: boolean;
+    /**
+     * The child was told to ignore its input (`stdio: "ignore"`).
+     *
+     * It then has no input at all, so its stdin is closed at once rather than
+     * left open on a parent that will never write to it.
+     */
+    stdinIgnored?: boolean;
 }
 type SpawnChild = (config: ChildSpawnConfig) => ChildHandle;
 /**
@@ -440,6 +447,21 @@ declare class Pipe implements InputStream, OutputStream {
      * every character appears twice.
      */
     private raw;
+    /**
+     * Translate carriage returns on the way in, the way `ICRNL` does.
+     *
+     * A terminal sends CR when Enter is pressed — xterm and every browser
+     * terminal emulator do — while everything that reads a line looks for LF.
+     * A real tty reconciles the two in its line discipline, which is on by
+     * default; without it `read name` waits forever on input the user already
+     * typed, and the only visible symptom is a hang.
+     *
+     * Deliberately opt-in rather than implied by `isTTY`, because stdout is a
+     * tty too and a bare CR there is how every progress bar and menu redraw
+     * returns to the start of the line. Translating those would corrupt exactly
+     * the output this runtime exists to render faithfully.
+     */
+    icrnl: boolean;
     onRawMode?: (enabled: boolean) => void;
     get rawMode(): boolean;
     set rawMode(enabled: boolean);

package/dist/index.cjs

@@ -4768,6 +4768,8 @@ init_path();
 init_errno();
 var encoder2 = new TextEncoder();
 var decoder2 = new TextDecoder();
+var CR = 13;
+var LF = 10;
 function toBytes(data) {
   return typeof data === "string" ? encoder2.encode(data) : data;
 }
@@ -4800,6 +4802,21 @@ var Pipe = class _Pipe {
    * every character appears twice.
    */
   raw = false;
+  /**
+   * Translate carriage returns on the way in, the way `ICRNL` does.
+   *
+   * A terminal sends CR when Enter is pressed — xterm and every browser
+   * terminal emulator do — while everything that reads a line looks for LF.
+   * A real tty reconciles the two in its line discipline, which is on by
+   * default; without it `read name` waits forever on input the user already
+   * typed, and the only visible symptom is a hang.
+   *
+   * Deliberately opt-in rather than implied by `isTTY`, because stdout is a
+   * tty too and a bare CR there is how every progress bar and menu redraw
+   * returns to the start of the line. Translating those would corrupt exactly
+   * the output this runtime exists to render faithfully.
+   */
+  icrnl = false;
   onRawMode;
   get rawMode() {
     return this.raw;
@@ -4822,7 +4839,7 @@ var Pipe = class _Pipe {
   write(data) {
     if (this.readerClosed) throw new exports.SysError("EPIPE", "write");
     if (this.writerClosed) return;
-    const bytes2 = toBytes(data);
+    const bytes2 = this.icrnl && !this.raw ? translateCarriageReturns(toBytes(data)) : toBytes(data);
     if (bytes2.length === 0) return;
     this.chunks.push(bytes2);
     this.buffered += bytes2.length;
@@ -4915,6 +4932,21 @@ var Pipe = class _Pipe {
     return p;
   }
 };
+function translateCarriageReturns(bytes2) {
+  if (!bytes2.includes(CR)) return bytes2;
+  const out = new Uint8Array(bytes2.length);
+  let length = 0;
+  for (let index = 0; index < bytes2.length; index += 1) {
+    const byte = bytes2[index];
+    if (byte === CR) {
+      out[length++] = LF;
+      if (bytes2[index + 1] === LF) index += 1;
+    } else {
+      out[length++] = byte;
+    }
+  }
+  return out.subarray(0, length);
+}
 var NullOutput = class {
   closed = false;
   isTTY = false;
@@ -17313,7 +17345,8 @@ ${stdinPath === null ? "" : `(function () {
 }
 async function execute(ctx, invocation) {
   const { pod } = ctx.kernel;
-  const interactive = ctx.stdin.interactive || ctx.stdin.isTTY;
+  const live = ctx.stdin.interactive || ctx.stdin.isTTY;
+  const tty = ctx.stdin.isTTY;
   let exitCode = 0;
   try {
     const proc = await pod.spawn("node", [invocation.script], {
@@ -17325,7 +17358,8 @@ async function execute(ctx, invocation) {
        * program's stdin has to stay open and be fed as it arrives — and be
        * reported as a terminal, since that is what decides whether a CLI
        * prompts or takes its defaults. */
-      ...interactive ? { interactiveStdin: true, tty: true } : {}
+      ...live ? { interactiveStdin: true } : {},
+      ...tty ? { tty: true } : {}
     });
     proc.on("output", (chunk) => {
       try {
@@ -17343,7 +17377,7 @@ async function execute(ctx, invocation) {
       ctx.stdin.rawMode = enabled;
     });
     let forwarding = false;
-    if (interactive) {
+    if (live) {
       forwarding = true;
       void (async () => {
         while (forwarding) {
@@ -21635,10 +21669,9 @@ var KernelChildProcess = class {
   started = false;
   cancelled = false;
   constructor(kernel, cred, config, pid) {
-    if (config.inheritStdio) {
-      this.stdin.isTTY = true;
-      this.stdin.interactive = true;
-    }
+    this.stdin.interactive = true;
+    if (config.inheritStdio) this.stdin.isTTY = true;
+    if (config.stdinIgnored) this.stdin.end();
     this.stdin.onRawMode = (enabled) => this.emit("rawmode", enabled);
     this.kernel = kernel;
     this.cred = cred;
@@ -24234,13 +24267,19 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv
     const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
     return { file: shell, args: ["-c", command] };
   };
+  const stdinIgnored = (options) => {
+    const stdio = options.stdio;
+    if (stdio === "ignore") return true;
+    return Array.isArray(stdio) && stdio[0] === "ignore";
+  };
   const start2 = (file3, args, options) => {
     const resolved = options.shell ? throughShell([file3, ...args].join(" "), options) : { file: file3, args };
     const handle = spawnChild({
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      env: environmentFor(options)
+      env: environmentFor(options),
+      ...stdinIgnored(options) ? { stdinIgnored: true } : {}
     });
     return new ChildProcess(handle, resolved.file, resolved.args);
   };
@@ -28001,6 +28040,8 @@ var Container = class _Container {
     const stdout = new Pipe();
     const stderr = new Pipe();
     if (opts.tty) {
+      stdin.isTTY = true;
+      stdin.icrnl = true;
       stdout.isTTY = true;
       stderr.isTTY = true;
       stdout.columns = opts.columns ?? 80;
@@ -28725,6 +28766,20 @@ function serveContainerOn(port, box) {
   };
   port.start?.();
 }
+var LOOPBACK_HOST = /^(?:localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[?::1\]?)$/i;
+function containerTarget(value) {
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  if (!LOOPBACK_HOST.test(url.hostname)) return null;
+  const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  return { port, path: `${url.pathname}${url.search}` };
+}
 async function createPreview(box, options = {}) {
   if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) return null;
   const scriptUrl = options.scriptUrl ?? new URL("./service-worker.js?no-inline", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
@@ -28760,8 +28815,16 @@ async function createPreview(box, options = {}) {
   serveContainerOn(channel.port1, box);
   worker.postMessage({ type: "sandboxedjs:connect" }, [channel.port2]);
   const base2 = registration.scope.replace(/\/$/, "");
+  const urlFor = (port) => `${base2}/__sbx__/${port}/`;
   return {
-    urlFor: (port) => `${base2}/__sbx__/${port}/`,
+    urlFor,
+    resolve: (value) => {
+      const target = containerTarget(value);
+      if (!target) return null;
+      if (!box.net.listening().some((entry) => entry.port === target.port)) return null;
+      const path = target.path.startsWith("/") ? target.path : `/${target.path}`;
+      return `${urlFor(target.port).replace(/\/$/, "")}${path}`;
+    },
     dispose: async () => {
       channel.port1.close();
       await registration.unregister();
@@ -28836,6 +28899,7 @@ exports.builtinNames = builtinNames;
 exports.captureStdio = captureStdio;
 exports.configureCPython = configureCPython;
 exports.configurePython = configurePython;
+exports.containerTarget = containerTarget;
 exports.createChildProcessModule = createChildProcessModule;
 exports.createContainer = createContainer;
 exports.createContext = createContext;