Migrate from E2B

# E2B
from e2b_code_interpreter import Sandbox
sbx = Sandbox()

# PandaStack
from pandastack import Sandbox
sandbox = Sandbox.create(template="code-interpreter")

# Options map directly:
sandbox = Sandbox.create(
    template="code-interpreter",
    ttl_seconds=600,                  # ≈ E2B's timeout
    metadata={"run_id": "abc123"},    # same concept as E2B metadata
)

with Sandbox.create(template="code-interpreter") as sandbox:
    print(sandbox.exec("echo hello").stdout)

// E2B
import { Sandbox } from "@e2b/code-interpreter";
const sbx = await Sandbox.create();

// PandaStack
import { Sandbox } from "@pandastack/sdk";
const sandbox = await Sandbox.create({ template: "code-interpreter" });

// Options map directly:
const sandbox2 = await Sandbox.create({
  template: "code-interpreter",
  ttlSeconds: 600,                    // ≈ E2B's timeoutMs
  metadata: { runId: "abc123" },
});

pandastack sandbox create --template code-interpreter --ttl 600 --metadata run_id=abc123

# E2B
result = sbx.commands.run("ls -la /home/user")
print(result.stdout, result.exit_code)

# PandaStack — either spelling works
result = sandbox.exec("ls -la /root")
result = sandbox.commands.run("ls -la /root", timeout=30)
print(result.stdout, result.exit_code)

# check=True raises CommandFailed on non-zero exit (like subprocess.run)
sandbox.exec("make test", timeout_seconds=300, check=True)

exit_code = sandbox.exec_stream(
    "pip install -r requirements.txt",
    on_stdout=lambda chunk: print(chunk, end=""),
    on_stderr=lambda chunk: print(chunk, end=""),
)

// E2B
const result = await sbx.commands.run("ls -la /home/user");

// PandaStack — either spelling works
const result2 = await sandbox.exec("ls -la /root");
const result3 = await sandbox.commands.run("ls -la /root", { timeoutSeconds: 30 });
console.log(result2.stdout, result2.exitCode);

// Streaming (≈ E2B's onStdout / onStderr)
const exitCode = await sandbox.execStream("pip install -r requirements.txt", {
  onStdout: (chunk) => process.stdout.write(chunk),
  onStderr: (chunk) => process.stderr.write(chunk),
});

pandastack sandbox exec <sandbox-id> --timeout 30 -- "ls -la /root"

# E2B
execution = sbx.run_code("x = 1; x + 1")

# PandaStack
ctx = sandbox.create_code_context()          # persistent kernel
ctx.run_code("x = 41")
ex = ctx.run_code("x + 1")                   # state persists
print(ex.text)                               # "42"

ex = ctx.run_code("import matplotlib.pyplot as plt; plt.plot([1,2,3]); plt.show()")
png_base64 = ex.results[0].png               # like E2B's execution.results
print(ex.logs)                               # {"stdout": ..., "stderr": ...}

// E2B
const execution = await sbx.runCode("x = 1; x + 1");

// PandaStack
const ctx = await sandbox.createCodeContext();   // persistent kernel
await ctx.runCode("x = 41");
const ex = await ctx.runCode("x + 1");           // state persists
console.log(ex.text);                            // "42"

const chart = await ctx.runCode("import matplotlib.pyplot as plt; plt.plot([1,2,3]); plt.show()");
const pngBase64 = chart.results[0]?.png;         // like E2B's execution.results

# E2B
sbx.files.write("/home/user/data.csv", "a,b\n1,2")
content = sbx.files.read("/home/user/data.csv")
entries = sbx.files.list("/home/user")

# PandaStack
sandbox.filesystem.write("/root/data.csv", "a,b\n1,2")     # str or bytes
content = sandbox.filesystem.read("/root/data.csv")        # returns bytes
entries = sandbox.filesystem.listdir("/root")              # list[FileInfo]
info = sandbox.filesystem.stat("/root/data.csv")           # size, mode, mtime
ok = sandbox.filesystem.exists("/root/data.csv")

# Local ↔ sandbox transfer helpers
sandbox.filesystem.upload("./local.csv", "/root/data.csv")
sandbox.filesystem.download("/root/out.json", "./out.json")

// E2B
await sbx.files.write("/home/user/data.csv", "a,b\n1,2");
const content = await sbx.files.read("/home/user/data.csv");

// PandaStack
await sandbox.filesystem.write("/root/data.csv", "a,b\n1,2");
const text = await sandbox.filesystem.read("/root/data.csv");   // string
const entries = await sandbox.filesystem.list("/root");         // FileInfo[]
const info = await sandbox.filesystem.stat("/root/data.csv");
const ok = await sandbox.filesystem.exists("/root/data.csv");

// Local ↔ sandbox transfer helpers
await sandbox.filesystem.upload("./local.csv", "/root/data.csv");
await sandbox.filesystem.download("/root/out.json", "./out.json");

pandastack fs write <sandbox-id> --path /root/data.csv --content "a,b"
pandastack fs read <sandbox-id> --path /root/data.csv
pandastack fs upload <sandbox-id> --local ./local.csv --remote /root/data.csv
pandastack fs download <sandbox-id> --remote /root/out.json --local ./out.json

# E2B (beta)
sbx.pause()
sbx = Sandbox.resume(sandbox_id)

# PandaStack
sandbox.hibernate()          # memory + disk persisted, VM stops
# ...later, from anywhere:
sandbox = Sandbox.get(sandbox_id)
sandbox.exec("echo back")    # auto-wakes transparently
# or force it without a workload request:
sandbox.wake()

// E2B (beta)
await sbx.pause();
const resumed = await Sandbox.resume(sandboxId);

// PandaStack
await sandbox.hibernate();
// ...later:
const sb = await Sandbox.get(sandboxId);
await sb.exec("echo back");    // auto-wakes transparently
// or: await sb.wake();

pandastack sandbox hibernate <sandbox-id>
pandastack sandbox wake <sandbox-id>