OpenCode v2.2 starts a background service on 127.0.0.1:49374, which nono blocks unless a localhost port is granted. Give the sandbox its own service on 49376 with isolated config/state, and clean up its lifecycle. - Grant localhost ports 49376 (sandboxed service) and 3301 (Tinfoil proxy) - Add sandbox config/state dirs and XDG_STATE_HOME/OPENCODE_CONFIG_DIR - Wrapper mirrors real config, pins the sandbox service port, and stops stale/orphaned services so they never outlive the nono proxy - Remove deprecated commands.allow/deny and the redundant SSH key glob deny - Update installer, uninstall cleanup, and README
9.3 KiB
nono-opencode-tinfoil
A nono sandbox profile for running
OpenCode with access to Tinfoil
enclaves and other LLM providers.
Quick Start
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
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 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.)
- Homebrew:
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 -- <real-opencode>
↓
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_DIRat~/.config/opencode-sandbox/opencode - points
XDG_STATE_HOMEat~/.local/state/opencode-sandbox - grants localhost port
49376for 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:
~/.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):
export PATH="$HOME/.local/bin:$PATH"
Or add an alias to your shell profile:
alias opencode="$HOME/.local/bin/opencode"
Usage
From any project directory:
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:
# 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:
network.open_portinprofiles/opencode-tinfoil.jsoncSANDBOX_SERVICE_PORTinbin/opencode(and the existing~/.config/opencode-sandbox/opencode/service.json)
Then re-run make install.
Tinfoil integration
The profile allows network access to:
*.tinfoil.shinference.tinfoil.shcontainers.tinfoil.sh127.0.0.1(Tinfoil local proxy athttp://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 service3301— 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:49374is 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
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:
rm -rf ~/.config/opencode-sandbox ~/.local/state/opencode-sandbox
opencode
Confirm the sandboxed service is on 49376:
~/.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. If you
want to clear it manually, stop the sandboxed service from inside the sandbox:
~/.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.
License
GPL-3.0