shellsim 0.1.2__tar.gz → 0.1.4__tar.gz

{shellsim-0.1.2 → shellsim-0.1.4}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.2 → shellsim-0.1.4}/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "shellsim"
-version = "0.1.2"
+version = "0.1.4"
 edition = "2021"
-description = "Deterministic, resource-constrained BusyBox-like environment for evaluating agents"
+description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/rjpower/shellsim"
@@ -58,5 +58,6 @@ python = []
 opt-level = 1
 
 [profile.release]
-opt-level = "s"
-lto = false
+opt-level = "z"
+lto = "fat"
+codegen-units = 1

shellsim-0.1.4/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: shellsim
+Version: 0.1.4
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+License-File: LICENSE
+Summary: In-process BusyBox-like environment for RL rollouts and agent tests
+Keywords: agents,containers,reinforcement-learning,sandbox,simulation,testing
+Author: The shellsim authors
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/rjpower/shellsim
+Project-URL: Issues, https://github.com/rjpower/shellsim/issues
+Project-URL: Repository, https://github.com/rjpower/shellsim
+
+# shellsim
+
+Shellsim is a BusyBox for containers: one small, deterministic process that provides a useful
+Unix-shaped environment without starting a VM, container runtime, or host subprocess. It is built
+for experimentation and testing with reinforcement-learning rollouts and agentic environments,
+where fast startup, reproducibility, isolation, and explicit resource limits matter more than
+cycle-accurate emulation.
+
+Shell programs, common command-line tools, logical processes, and Python run in-process against an
+in-memory filesystem. Simulated code cannot access the host filesystem, processes, network,
+environment, or clock. A trusted harness may copy a selected project into the virtual filesystem
+before execution; changes never write back to the host.
+
+## Compatibility
+
+Shellsim aims for broad compatibility inside clear boundaries. A supported facility should handle
+almost all ordinary uses, even when obscure flags or legacy behavior remain out of scope. A module
+or command with no coherent useful subset is omitted instead of being exposed as a misleading
+stub. Unsupported syntax, options, executable formats, and capabilities fail visibly and are
+included in structured results.
+
+The current environment includes:
+
+- a Bash-like shell with pipelines, redirections, functions, common expansions, control flow,
+  background jobs, signals, and job control;
+- common filesystem, text, archive, Git, Make, process, and system commands;
+- deterministic virtual time, network fixtures, `/proc`, `/dev`, processes, descriptors, and
+  bounded pipes;
+- a mostly complete Python language runtime with a deliberately selected standard-library and
+  third-party module surface.
+
+Python is source-compatible where supported, not ABI-compatible with CPython. Native extensions,
+network package installation, compilers, and arbitrary machine code are outside the simulation
+boundary. The simulated `pip` and `uv` paths can activate packages already bundled with
+shellsim; they reject other packages instead of fetching them. See
+[Python in shellsim](docs/python.md) for the current contract.
+
+`git` provides a porcelain subset backed by the virtual filesystem: staging, commits, history,
+diffs, branches, tags, merges, stashes, and search, with output that matches real Git where an
+agent is likely to parse it. Networked subcommands and content conflicts are refused rather than
+approximated. See [Git in shellsim](docs/git.md) for the supported surface and its boundaries.
+
+Common utilities accept clustered short options, long options, option values, and `--` through a
+shared parser. Each utility declares its supported options. For example, `grep` supports ordinary
+basic and extended regular expressions, recursive search, fixed strings, word and whole-line
+matching, pattern files, include and exclude filters, context, counts, line numbers, match limits,
+and common output controls. `sed` covers addresses and ranges plus the common substitution,
+selection, text, transliteration, and early-exit commands. `awk` parses a typed language subset
+with record rules, control flow, fields, associative arrays, arithmetic, regular expressions, and
+the usual scalar functions. Unsupported syntax and options exit nonzero with a direct diagnostic;
+text processing is UTF-8-only unless a command documents a byte-oriented mode.
+
+## Install and run
+
+Install the Python package and console command:
+
+```sh
+python -m pip install shellsim
+shellsim -c 'printf "b\na\n" | sort'
+shellsim --root ./project -c 'python3.14 test.py'
+```
+
+`--root` copies the selected host tree into a disposable `/work` snapshot. With no `-c` and a
+terminal attached, `shellsim` starts a persistent interactive session.
+
+To build the Rust binaries from source:
+
+```sh
+cargo build --release
+./target/release/shellsim -c 'echo hello'
+./target/release/shellsim eval --cpu 100k --memory 8m -c 'make test'
+./target/release/shellsim-python ./project/main.py -- arg1
+```
+
+Limits accept `k`, `m`, and `g` binary suffixes. `eval` emits a structured result containing the
+exit status, stdout and stderr, resource use, command trace, and unsupported behavior.
+`unsupported_commands` lists recognized or attempted commands that crossed the capability
+boundary; invocation records include trust, status, and the unsupported reason.
+
+The Python API exposes fresh and persistent environments:
+
+```python
+import shellsim
+
+environment = shellsim.Environment(cpu=100_000)
+environment.write_file("/work/main.py", "print(6 * 7)\n")
+result = environment.run("python3.14 /work/main.py")
+assert result.returncode == 0
+assert result.stdout == b"42\n"
+```
+
+Static HTTP fixtures use the same isolated environment. They do not enable sockets, DNS, TLS, or
+host-network access:
+
+```python
+environment = shellsim.Environment(http={
+    "https://api.test/items/*": shellsim.HttpResponse(
+        status=200,
+        headers={"Content-Type": "application/json"},
+        body='{"items": []}',
+    ),
+})
+result = environment.run("curl -s https://api.test/items/1")
+
+result = environment.run_python("""
+from urllib.request import urlopen
+print(urlopen('https://api.test/items/1').read())
+""")
+assert result.network_requests[0].matched
+```
+
+Python source can bypass shell parsing and quoting while using the same isolated runtime:
+
+```python
+result = shellsim.python.run("print(sum(range(10)))", argv=["example"])
+result.check_returncode()
+
+environment = shellsim.Environment()
+result = environment.run_python("print('persistent VFS, fresh Python interpreter')")
+```
+
+## Agent harness
+
+`shellsim serve --root ./project` runs a persistent newline-delimited JSON session. It supports
+bounded execution, streaming actions, VFS operations, checkpoints, workspace diffs, process and
+resource inspection, and deterministic session forks. `shellsim mcp` exposes the same environment
+as a stdio MCP server. `shellsim replay scenario.ndjson` reruns checked action transcripts.
+
+```sh
+printf '%s\n' \
+  '{"id":1,"op":"execute","source":"printf hello > result"}' \
+  '{"id":2,"op":"workspace_diff"}' \
+  | shellsim serve --root ./project
+```
+
+## Resource model
+
+CPU is deterministic fuel, memory is modeled working set, disk is current virtual-filesystem
+usage, and output bounds materialized stdout and stderr. The defaults are 10,000,000 CPU units,
+64 MiB memory, 64 MiB disk, and 4 MiB output. Costs are stable and intentionally approximate.
+Exhaustion is observable and never falls back to an ambient host implementation.
+
+For internals and contribution workflow, see [implementation](docs/implementation.md),
+[Python](docs/python.md), and [CONTRIBUTING.md](CONTRIBUTING.md).
+

shellsim-0.1.4/README.md

@@ -0,0 +1,144 @@
+# shellsim
+
+Shellsim is a BusyBox for containers: one small, deterministic process that provides a useful
+Unix-shaped environment without starting a VM, container runtime, or host subprocess. It is built
+for experimentation and testing with reinforcement-learning rollouts and agentic environments,
+where fast startup, reproducibility, isolation, and explicit resource limits matter more than
+cycle-accurate emulation.
+
+Shell programs, common command-line tools, logical processes, and Python run in-process against an
+in-memory filesystem. Simulated code cannot access the host filesystem, processes, network,
+environment, or clock. A trusted harness may copy a selected project into the virtual filesystem
+before execution; changes never write back to the host.
+
+## Compatibility
+
+Shellsim aims for broad compatibility inside clear boundaries. A supported facility should handle
+almost all ordinary uses, even when obscure flags or legacy behavior remain out of scope. A module
+or command with no coherent useful subset is omitted instead of being exposed as a misleading
+stub. Unsupported syntax, options, executable formats, and capabilities fail visibly and are
+included in structured results.
+
+The current environment includes:
+
+- a Bash-like shell with pipelines, redirections, functions, common expansions, control flow,
+  background jobs, signals, and job control;
+- common filesystem, text, archive, Git, Make, process, and system commands;
+- deterministic virtual time, network fixtures, `/proc`, `/dev`, processes, descriptors, and
+  bounded pipes;
+- a mostly complete Python language runtime with a deliberately selected standard-library and
+  third-party module surface.
+
+Python is source-compatible where supported, not ABI-compatible with CPython. Native extensions,
+network package installation, compilers, and arbitrary machine code are outside the simulation
+boundary. The simulated `pip` and `uv` paths can activate packages already bundled with
+shellsim; they reject other packages instead of fetching them. See
+[Python in shellsim](docs/python.md) for the current contract.
+
+`git` provides a porcelain subset backed by the virtual filesystem: staging, commits, history,
+diffs, branches, tags, merges, stashes, and search, with output that matches real Git where an
+agent is likely to parse it. Networked subcommands and content conflicts are refused rather than
+approximated. See [Git in shellsim](docs/git.md) for the supported surface and its boundaries.
+
+Common utilities accept clustered short options, long options, option values, and `--` through a
+shared parser. Each utility declares its supported options. For example, `grep` supports ordinary
+basic and extended regular expressions, recursive search, fixed strings, word and whole-line
+matching, pattern files, include and exclude filters, context, counts, line numbers, match limits,
+and common output controls. `sed` covers addresses and ranges plus the common substitution,
+selection, text, transliteration, and early-exit commands. `awk` parses a typed language subset
+with record rules, control flow, fields, associative arrays, arithmetic, regular expressions, and
+the usual scalar functions. Unsupported syntax and options exit nonzero with a direct diagnostic;
+text processing is UTF-8-only unless a command documents a byte-oriented mode.
+
+## Install and run
+
+Install the Python package and console command:
+
+```sh
+python -m pip install shellsim
+shellsim -c 'printf "b\na\n" | sort'
+shellsim --root ./project -c 'python3.14 test.py'
+```
+
+`--root` copies the selected host tree into a disposable `/work` snapshot. With no `-c` and a
+terminal attached, `shellsim` starts a persistent interactive session.
+
+To build the Rust binaries from source:
+
+```sh
+cargo build --release
+./target/release/shellsim -c 'echo hello'
+./target/release/shellsim eval --cpu 100k --memory 8m -c 'make test'
+./target/release/shellsim-python ./project/main.py -- arg1
+```
+
+Limits accept `k`, `m`, and `g` binary suffixes. `eval` emits a structured result containing the
+exit status, stdout and stderr, resource use, command trace, and unsupported behavior.
+`unsupported_commands` lists recognized or attempted commands that crossed the capability
+boundary; invocation records include trust, status, and the unsupported reason.
+
+The Python API exposes fresh and persistent environments:
+
+```python
+import shellsim
+
+environment = shellsim.Environment(cpu=100_000)
+environment.write_file("/work/main.py", "print(6 * 7)\n")
+result = environment.run("python3.14 /work/main.py")
+assert result.returncode == 0
+assert result.stdout == b"42\n"
+```
+
+Static HTTP fixtures use the same isolated environment. They do not enable sockets, DNS, TLS, or
+host-network access:
+
+```python
+environment = shellsim.Environment(http={
+    "https://api.test/items/*": shellsim.HttpResponse(
+        status=200,
+        headers={"Content-Type": "application/json"},
+        body='{"items": []}',
+    ),
+})
+result = environment.run("curl -s https://api.test/items/1")
+
+result = environment.run_python("""
+from urllib.request import urlopen
+print(urlopen('https://api.test/items/1').read())
+""")
+assert result.network_requests[0].matched
+```
+
+Python source can bypass shell parsing and quoting while using the same isolated runtime:
+
+```python
+result = shellsim.python.run("print(sum(range(10)))", argv=["example"])
+result.check_returncode()
+
+environment = shellsim.Environment()
+result = environment.run_python("print('persistent VFS, fresh Python interpreter')")
+```
+
+## Agent harness
+
+`shellsim serve --root ./project` runs a persistent newline-delimited JSON session. It supports
+bounded execution, streaming actions, VFS operations, checkpoints, workspace diffs, process and
+resource inspection, and deterministic session forks. `shellsim mcp` exposes the same environment
+as a stdio MCP server. `shellsim replay scenario.ndjson` reruns checked action transcripts.
+
+```sh
+printf '%s\n' \
+  '{"id":1,"op":"execute","source":"printf hello > result"}' \
+  '{"id":2,"op":"workspace_diff"}' \
+  | shellsim serve --root ./project
+```
+
+## Resource model
+
+CPU is deterministic fuel, memory is modeled working set, disk is current virtual-filesystem
+usage, and output bounds materialized stdout and stderr. The defaults are 10,000,000 CPU units,
+64 MiB memory, 64 MiB disk, and 4 MiB output. Costs are stable and intentionally approximate.
+Exhaustion is observable and never falls back to an ambient host implementation.
+
+For internals and contribution workflow, see [implementation](docs/implementation.md),
+[Python](docs/python.md), and [CONTRIBUTING.md](CONTRIBUTING.md).

{shellsim-0.1.2 → shellsim-0.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "shellsim"
 dynamic = ["version"]
-description = "Deterministic, resource-constrained shell and Python execution for tests"
+description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 readme = "README.md"
 requires-python = ">=3.9"
 license = { file = "LICENSE" }
@@ -22,7 +22,7 @@ classifiers = [
     "Topic :: Software Development :: Testing",
     "Typing :: Typed",
 ]
-keywords = ["sandbox", "shell", "simulation", "testing"]
+keywords = ["agents", "containers", "reinforcement-learning", "sandbox", "simulation", "testing"]
 
 [project.urls]
 Homepage = "https://github.com/rjpower/shellsim"
@@ -44,4 +44,27 @@ locked = true
 strip = true
 
 [tool.pytest.ini_options]
-testpaths = ["python_tests"]
+testpaths = ["tests/python_package", "tests/tooling"]
+
+[tool.marin-style]
+checks = ["ruff-check", "ruff-format"]
+include = [
+    "infra/*.py",
+    "infra/**/*.py",
+    "python/**/*.py",
+    "tests/python/test_*.py",
+    "tests/python_package/**/*.py",
+    "tests/tooling/**/*.py",
+    "tools/*.py",
+    "tools/**/*.py",
+]
+main_branch = "main"
+ruff_version = "0.14.3"
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "C4"]
+ignore = ["E501"]

{shellsim-0.1.2 → shellsim-0.1.4}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.2 → shellsim-0.1.4}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.2"
+version = "0.1.4"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"
@@ -20,5 +20,6 @@ serde_json = "1"
 shellsim = { path = "../.." }
 
 [profile.release]
-opt-level = "s"
-lto = false
+opt-level = "z"
+lto = "fat"
+codegen-units = 1

{shellsim-0.1.2 → shellsim-0.1.4}/python/native/src/lib.rs

@@ -17,6 +17,7 @@ use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use serde::Serialize;
+use shellsim::net::NetworkRequest;
 use shellsim::{CommandTrust, InvocationEvent, Limits, RunOutcome};
 
 const ACTION_STACK_BYTES: usize = 8 * 1024 * 1024;
@@ -35,10 +36,12 @@ struct RunMetadata {
     dropped_unsupported: u64,
     commands: Vec<String>,
     dropped_commands: u64,
-    noop_commands: Vec<String>,
+    unsupported_commands: Vec<String>,
     partial_commands: Vec<String>,
     invocations: Vec<InvocationEvent>,
     dropped_invocations: u64,
+    network_requests: Vec<NetworkRequest>,
+    dropped_network_requests: u64,
 }
 
 #[derive(Serialize)]
@@ -47,6 +50,17 @@ struct MountMetadata {
     skipped_directories: Vec<String>,
 }
 
+struct MetadataStart {
+    command: usize,
+    dropped_commands: u64,
+    unsupported: usize,
+    dropped_unsupported: u64,
+    invocation: u64,
+    dropped_invocations: u64,
+    network: usize,
+    dropped_network: u64,
+}
+
 /// One persistent simulated machine owned by Python.
 #[pyclass(module = "shellsim._native")]
 struct NativeEnvironment {
@@ -91,6 +105,31 @@ impl NativeEnvironment {
         ))
     }
 
+    /// Execute Python source directly without passing it through the shell parser.
+    fn run_python(
+        &self,
+        py: Python<'_>,
+        source: String,
+        argv: Vec<String>,
+        stdin: Vec<u8>,
+    ) -> PyResult<(String, Py<PyBytes>, Py<PyBytes>)> {
+        let (metadata, stdout, stderr) = py
+            .detach(|| {
+                let mut environment = self.lock_environment()?;
+                on_worker(&mut environment, move |environment| {
+                    Ok(run_python_action(environment, source, argv, stdin))
+                })
+            })
+            .map_err(SimulationError::new_err)?;
+        let metadata = serde_json::to_string(&metadata)
+            .map_err(|error| SimulationError::new_err(error.to_string()))?;
+        Ok((
+            metadata,
+            PyBytes::new(py, &stdout).unbind(),
+            PyBytes::new(py, &stderr).unbind(),
+        ))
+    }
+
     /// Write one byte string into the simulated filesystem.
     fn write_file(&self, py: Python<'_>, path: String, data: Vec<u8>, mode: u32) -> PyResult<()> {
         py.detach(|| {
@@ -139,6 +178,36 @@ impl NativeEnvironment {
         .map_err(SimulationError::new_err)
     }
 
+    /// Register one static response in the simulated HTTP broker.
+    fn route_http(
+        &self,
+        py: Python<'_>,
+        pattern: String,
+        method: Option<String>,
+        status: u16,
+        headers: Vec<(String, String)>,
+        body: Vec<u8>,
+    ) -> PyResult<()> {
+        py.detach(|| {
+            let mut environment = self.lock_environment()?;
+            on_worker(&mut environment, move |environment| {
+                environment
+                    .net
+                    .route(
+                        &pattern,
+                        method.as_deref(),
+                        shellsim::net::HttpResponse {
+                            status,
+                            headers,
+                            body,
+                        },
+                    )
+                    .map_err(|error| error.to_string())
+            })
+        })
+        .map_err(SimulationError::new_err)
+    }
+
     /// Import one explicitly selected trusted host tree into the simulated filesystem.
     fn mount(
         &self,
@@ -188,35 +257,77 @@ fn run_action(
     source: &str,
     stdin: &[u8],
 ) -> (RunMetadata, Vec<u8>, Vec<u8>) {
-    let command_start = environment.cmd_trace.len();
-    let dropped_commands_start = environment.cmd_trace.dropped();
-    let unsupported_start = environment.unsupported.len();
-    let dropped_unsupported_start = environment.unsupported.dropped();
-    let invocation_start = environment.invocations.next_sequence();
-    let dropped_invocations_start = environment.invocations.dropped();
+    let start = metadata_start(environment);
     let (outcome, stdout, stderr) = environment.run_script_capture_with_stdin(source, stdin);
-    let invocations = environment.invocations.events_since(invocation_start);
-    let metadata = RunMetadata {
+    (metadata_finish(environment, outcome, start), stdout, stderr)
+}
+
+fn run_python_action(
+    environment: &mut shellsim::Environment,
+    source: String,
+    arguments: Vec<String>,
+    stdin: Vec<u8>,
+) -> (RunMetadata, Vec<u8>, Vec<u8>) {
+    let start = metadata_start(environment);
+    let mut argv = vec!["python3.14".to_string(), "-c".to_string(), source];
+    argv.extend(arguments);
+    let mut stdout = Vec::new();
+    let mut stderr = Vec::new();
+    let status = shellsim::exec::exec(
+        environment,
+        &shellsim::shell::Node::ArgvCommand(argv),
+        stdin,
+        &mut stdout,
+        &mut stderr,
+    );
+    let outcome = environment.outcome(status);
+    (metadata_finish(environment, outcome, start), stdout, stderr)
+}
+
+fn metadata_start(environment: &shellsim::Environment) -> MetadataStart {
+    MetadataStart {
+        command: environment.cmd_trace.len(),
+        dropped_commands: environment.cmd_trace.dropped(),
+        unsupported: environment.unsupported.len(),
+        dropped_unsupported: environment.unsupported.dropped(),
+        invocation: environment.invocations.next_sequence(),
+        dropped_invocations: environment.invocations.dropped(),
+        network: environment.net.log.len(),
+        dropped_network: environment.net.dropped_requests,
+    }
+}
+
+fn metadata_finish(
+    environment: &shellsim::Environment,
+    outcome: RunOutcome,
+    start: MetadataStart,
+) -> RunMetadata {
+    let invocations = environment.invocations.events_since(start.invocation);
+    RunMetadata {
         outcome,
-        unsupported: environment.unsupported.values_since(unsupported_start),
+        unsupported: environment.unsupported.values_since(start.unsupported),
         dropped_unsupported: environment
             .unsupported
             .dropped()
-            .saturating_sub(dropped_unsupported_start),
-        commands: environment.cmd_trace.values_since(command_start),
+            .saturating_sub(start.dropped_unsupported),
+        commands: environment.cmd_trace.values_since(start.command),
         dropped_commands: environment
             .cmd_trace
             .dropped()
-            .saturating_sub(dropped_commands_start),
-        noop_commands: invocation_names(&invocations, CommandTrust::NoOp),
+            .saturating_sub(start.dropped_commands),
+        unsupported_commands: invocation_names(&invocations, CommandTrust::Unsupported),
         partial_commands: invocation_names(&invocations, CommandTrust::Partial),
         invocations,
         dropped_invocations: environment
             .invocations
             .dropped()
-            .saturating_sub(dropped_invocations_start),
-    };
-    (metadata, stdout, stderr)
+            .saturating_sub(start.dropped_invocations),
+        network_requests: environment.net.log[start.network..].to_vec(),
+        dropped_network_requests: environment
+            .net
+            .dropped_requests
+            .saturating_sub(start.dropped_network),
+    }
 }
 
 fn invocation_names(events: &[InvocationEvent], trust: CommandTrust) -> Vec<String> {

{shellsim-0.1.2 → shellsim-0.1.4}/python/shellsim/__init__.py

@@ -1,8 +1,11 @@
 """Typed Python interface to shellsim's deterministic execution environment."""
 
+from . import python as python
 from ._api import (
     CommandUsage,
     Environment,
+    HttpRequest,
+    HttpResponse,
     Invocation,
     Limits,
     MountResult,
@@ -15,6 +18,8 @@ from ._api import (
 __all__ = [
     "CommandUsage",
     "Environment",
+    "HttpRequest",
+    "HttpResponse",
     "Invocation",
     "Limits",
     "MountResult",
@@ -22,4 +27,5 @@ __all__ = [
     "SimulationError",
     "Usage",
     "run",
+    "python",
 ]

{shellsim-0.1.2 → shellsim-0.1.4}/python/shellsim/__main__.py

@@ -2,5 +2,4 @@
 
 from ._cli import main
 
-
 raise SystemExit(main())