# nono-opencode-tinfoil A [`nono`](https://github.com/guybedford/nono) sandbox profile for running [OpenCode](https://opencode.ai) with access to [Tinfoil](https://tinfoil.sh) enclaves and other LLM providers. ## Quick Start ```bash git clone https://github.com/autonomic/nono-opencode-tinfoil.git cd nono-opencode-tinfoil make install # Ensure ~/.local/bin is in your PATH opencode ``` ## Install ### macOS / Linux ```bash git clone https://github.com/autonomic/nono-opencode-tinfoil.git cd nono-opencode-tinfoil make install ``` This installs: - The sandbox profile to `~/.config/nono/profiles/opencode-tinfoil.json` - A wrapper script to `~/.local/bin/opencode` - Sandbox-local OpenCode config/state directories: - `~/.config/opencode-sandbox/opencode` - `~/.local/state/opencode-sandbox/opencode` ### Requirements - [nono](https://github.com/guybedford/nono) **0.81+**, e.g. `brew install nono` - OpenCode **v2.2+**, installed globally. If not already installed, you can use any of: - **Homebrew**: `brew install opencode` - **npm**: `npm i -g opencode-ai` - **Other**: Any Node version manager (Volta, fnm, etc.) OpenCode v2 runs a background service, which is why this profile grants a localhost port and creates sandbox-local config/state directories. ## How it works ``` you type: opencode ↓ ~/.local/bin/opencode (wrapper) ↓ scans PATH for the real opencode binary (skips itself — finds brew, npm, volta, etc.) ↓ creates ~/.config/opencode-sandbox/opencode ~/.local/state/opencode-sandbox/opencode symlinks your real ~/.config/opencode/* into the sandbox (except service.json) writes {"port": 49376} to the sandbox service.json if missing ↓ runs nono run --profile opencode-tinfoil --allow-cwd -- ↓ opencode runs inside the sandbox and starts its own background service on 127.0.0.1:49376 ↓ when the sandbox exits, the wrapper stops the service so it never outlives the nono proxy ``` The wrapper resolves the real `opencode` binary at runtime by scanning every directory in your `PATH`. It skips itself, so it works regardless of: - Where opencode is installed (Homebrew on macOS/Linux, npm global, Volta, etc.) - PATH ordering between the wrapper and the real binary - PATH entries containing spaces - opencode version bumps You just type `opencode` from any project directory and it runs sandboxed. ### Sandbox-local service OpenCode v2 starts a background service on localhost. If the sandbox reused the host service (default `127.0.0.1:49374`), the agent would run outside the sandbox. To prevent that, the profile: - points `OPENCODE_CONFIG_DIR` at `~/.config/opencode-sandbox/opencode` - points `XDG_STATE_HOME` at `~/.local/state/opencode-sandbox` - grants localhost port `49376` for the sandboxed service The wrapper mirrors your normal OpenCode config into the sandbox config directory as symlinks, so your models, plugins, and `opencode.jsonc` still apply. `service.json` is deliberately **not** mirrored; the sandbox keeps its own copy pinning port `49376`. Your host OpenCode service on `49374` is left untouched. The sandboxed CLI only sees its own service registration in `~/.local/state/opencode-sandbox`. OpenCode spawns the service detached, so it would normally outlive the sandbox. That matters because the service sends model requests through the nono proxy, and the proxy exits with the sandbox. The wrapper therefore: - stops the sandboxed service when the last sandboxed instance exits - stops any stale service left behind by an abruptly killed session before the next launch - leaves a live service alone while another sandboxed instance is still running If you run multiple sandboxed instances at once, they share the service on `49376`, and it is stopped when the last instance exits. If the instance that started the service exits first, stop the service explicitly so the remaining instance starts a fresh one in its own sandbox: ```bash ~/.local/bin/opencode service stop ``` ### PATH ordering If a non-sandboxed `opencode` appears *earlier* on your `PATH` than the wrapper, typing `opencode` will bypass the sandbox. The installer detects and warns about this. Fix it by adding this to your shell config file (e.g., `~/.bashrc` or `~/.zshrc`): ```bash export PATH="$HOME/.local/bin:$PATH" ``` Or add an alias to your shell profile: ```bash alias opencode="$HOME/.local/bin/opencode" ``` ## Usage From any project directory: ```bash opencode ``` Or use the profile directly with a specific opencode binary. Note that the sandbox config/state directories and `service.json` must exist first; `make install` creates them, or you can launch the wrapper once: ```bash # Homebrew (macOS) nono run --profile opencode-tinfoil --allow-cwd -- /opt/homebrew/bin/opencode # Homebrew (Linux) nono run --profile opencode-tinfoil --allow-cwd -- /home/linuxbrew/.linuxbrew/bin/opencode # npm global nono run --profile opencode-tinfoil --allow-cwd -- $(npm root -g)/opencode/bin/opencode ``` ### Changing the sandbox service port Port `49376` is chosen to avoid OpenCode's default `49374` (host service) and `49375` (local channel). If `49376` is already in use, change it in **both** places: 1. `network.open_port` in `profiles/opencode-tinfoil.jsonc` 2. `SANDBOX_SERVICE_PORT` in `bin/opencode` (and the existing `~/.config/opencode-sandbox/opencode/service.json`) Then re-run `make install`. ## Tinfoil integration The profile allows network access to: - `*.tinfoil.sh` - `inference.tinfoil.sh` - `containers.tinfoil.sh` - `127.0.0.1` (Tinfoil local proxy at `http://127.0.0.1:3301/v1`) - `ghcr.io` It also grants read/write access to `~/.tinfoil` for Tinfoil credentials. The profile grants localhost ports: - `49376` — sandboxed OpenCode background service - `3301` — Tinfoil local proxy Other LLM provider network options (Anthropic, GLM, Kimi, etc.) are provided as commented-out entries in the profile for easy activation. ## Security model - Current working directory: read/write - OpenCode config and sandbox config/state: read/write - Tinfoil config: read/write - SSH private keys, AWS/GCP/Azure credentials, kubeconfig: denied - The OpenCode background service runs **inside** the sandbox; the host service on `127.0.0.1:49374` is not reused - The profile no longer uses `commands.allow` / `commands.deny`. Those fields are deprecated in nono and only applied at startup, so they were not enforced for child processes. Access is constrained by filesystem, network, and environment policy instead. ### Linux Landlock caveat On Linux, nono uses Landlock, which has no deny semantics. `filesystem.deny` globs are only enforced against paths that exist at sandbox start. Files created afterward that match a deny glob are **not** denied. This profile therefore avoids glob-based denies and relies on narrow allow grants plus the `deny_credentials` group. If you add your own glob denies, keep this limitation in mind or enable capability elevation in nono for runtime enforcement. ### Environment Variables | Status | Variables / Patterns | |--------|----------------------| | Allowed | `PATH`, `HOME`, `USER`, `SHELL`, `TERM` | | Denied | `AWS_*`, `GOOGLE_*`, `AZURE_*`, `GCP_*`, `KUBECONFIG`, `SSH_AUTH_SOCK` | ## Uninstall ```bash make uninstall ``` This removes the profile, the wrapper, and the sandbox config/state directories. Your real `~/.config/opencode` and `~/.local/state/opencode` are not touched. ## Troubleshooting **"command not found: opencode"** Ensure `~/.local/bin` is in your `PATH`. Add `export PATH="$HOME/.local/bin:$PATH"` to your `.bashrc` or `.zshrc` and restart your terminal. **Sandbox is being bypassed** If you have another version of `opencode` installed (e.g. via Homebrew) that appears earlier in your `PATH` than the wrapper, the sandbox will be bypassed. Check this using `which -a opencode`. The wrapper at `~/.local/bin/opencode` must come first. **`permission denied 127.0.0.1:49374` / `Server process exited with code 1`** This means the sandboxed OpenCode is still trying to use the host service port. The sandbox `service.json` is missing or stale, or the wrapper was bypassed. Re-run `make install`, then remove the sandbox config and relaunch: ```bash rm -rf ~/.config/opencode-sandbox ~/.local/state/opencode-sandbox opencode ``` Confirm the sandboxed service is on `49376`: ```bash ~/.local/bin/opencode service status # sandbox, should be 49376 /path/to/host/opencode service status # host, should still be 49374 ``` Use the real binary path for the host check (for example `/home/linuxbrew/.linuxbrew/bin/opencode`). If `~/.local/bin` comes first in your `PATH`, plain `opencode` invokes the sandbox wrapper. **`Failed to start server. Is port 49376 in use?`** The wrapper stops stale sandboxed services on startup, so this usually means an unrelated process is using the port. Pick a different port as described in [Changing the sandbox service port](#changing-the-sandbox-service-port). If you want to clear it manually, stop the sandboxed service from inside the sandbox: ```bash ~/.local/bin/opencode service stop ``` **`Unrecognized flag: --standalone`** `--standalone` is a top-level OpenCode flag, not a `serve` or `service` subcommand flag. Use `opencode --standalone ...` rather than `opencode serve --standalone`. **Landlock glob-deny warning** See [Linux Landlock caveat](#linux-landlock-caveat). ## License GPL-3.0