viberun 0.3.7 → 0.4.2

package/README.md

@@ -4,7 +4,7 @@
 
 # viberun
 
-`viberun` is a CLI-first, agent-native app host. Run `viberun <app>` locally and get dropped into an agent session inside a persistent Ubuntu container on a remote host. App data is stored under `/home/viberun` and survives container restarts or image updates.
+`viberun` is a shell-first, agent-native app host. Run `viberun` to open the shell, then `vibe <app>` to jump into a persistent Ubuntu container on a remote host. App data is stored under `/home/viberun` and survives container restarts or image updates.
 
 ## Quick start (end-to-end)
 
@@ -35,30 +35,39 @@ Or with env vars:
 curl -fsSL https://viberun.sh | VIBERUN_INSTALL_DIR=~/.local/bin VIBERUN_INSTALL_BIN=viberun bash
 ```
 
-### 2) Bootstrap a host (once per VM)
+### 2) Connect a host (once per VM)
 
-Use any SSH host alias (for example, `myhost` in `~/.ssh/config`):
+Start the shell:
 
 ```bash
-viberun bootstrap myhost
+viberun
 ```
 
-Optional: set it as your default host (and agent) so you can omit `@host` later:
+If this is the first time, you'll see a setup banner. Type:
 
 ```bash
-viberun config --host myhost --agent codex
+setup
+```
+
+Enter your SSH login (for example, `user@myhost` in `~/.ssh/config`).
+You can also run setup directly from the CLI:
+
+```bash
+viberun setup myhost
 ```
 
 ### 3) Start your first app
 
+Inside the shell:
+
 ```bash
-viberun hello-world
+vibe hello-world
 ```
 
-If this is the first run, the server will prompt to create the container. Press Enter to accept.
+If this is the first run, the server will create the container.
 
-Detach without stopping the agent: Ctrl-\\ . Reattach later with `viberun hello-world`.
-Paste clipboard images into the session with Ctrl-V; `viberun` uploads the image and inserts a `/tmp/viberun-clip-*.png` path.
+Detach without stopping the agent: Ctrl-\\ . Reattach later with `vibe hello-world`.
+Paste clipboard images into the session with Ctrl-V; viberun uploads the image and inserts a `/tmp/viberun-clip-*.png` path.
 
 ### 4) Hello-world prompt (paste inside the session)
 
@@ -68,35 +77,31 @@ Create a beautiful hello-world web app with a simple, tasteful landing page.
 
 ### 5) Open the app
 
-While the session is active, `viberun` starts a localhost proxy to the host port. The agent will print a URL like:
+From the shell:
 
-```
-http://localhost:8080
+```bash
+open hello-world
 ```
 
-Open it in your browser.
-If you've configured app URLs, `viberun <app> url` shows the HTTPS address.
+When the shell starts, viberun forwards app ports automatically. `open` prefers a public URL if configured; otherwise it uses the localhost URL.
 
 ## Common commands
 
+Shell commands (inside `viberun`):
+
 ```bash
-viberun myapp
-viberun myapp@hostb
-viberun --forward-agent myapp
-viberun myapp shell
-viberun myapp snapshot
-viberun myapp snapshots
-viberun myapp restore latest
-viberun myapp url
-viberun myapp users
-viberun myapp --delete -y
-viberun myapp update
-viberun bootstrap [<host>]
-viberun proxy setup
-viberun users list
-viberun wipe
-viberun config --host myhost --agent codex
-viberun version
+vibe myapp
+open myapp
+apps
+app myapp
+rm myapp
+```
+
+CLI commands (advanced):
+
+```bash
+viberun setup [<host>]
+viberun wipe [<host>]
 ```
 
 <details>
@@ -110,7 +115,7 @@ viberun version
   - [High-level flow](#high-level-flow)
   - [Core components](#core-components)
   - [Session lifecycle](#session-lifecycle)
-  - [Bootstrap pipeline](#bootstrap-pipeline)
+  - [Setup pipeline](#setup-pipeline)
   - [Networking and ports](#networking-and-ports)
   - [App URLs and proxy](#app-urls-and-proxy)
   - [Snapshots and restore](#snapshots-and-restore)
@@ -130,10 +135,10 @@ Git, SSH, and the GitHub CLI are installed in containers. viberun seeds `git con
 
 Choose one of these auth paths:
 
-- **SSH (agent forwarding)**: Run `viberun --forward-agent <app>`. For existing apps, run `viberun <app> update` once to recreate the container with the agent socket mounted. Then `ssh -T git@github.com` inside the container to verify access.
+- **SSH (agent forwarding)**: Start viberun with `VIBERUN_FORWARD_AGENT=1 viberun`, then `vibe <app>`. For existing apps, run `app <app>` followed by `update` once to recreate the container with the agent socket mounted. Then `ssh -T git@github.com` inside the container to verify access.
 - **HTTPS (GitHub CLI)**: Run `gh auth login` and choose HTTPS, then `gh auth setup-git`. Verify with `gh auth status`.
 
-If you update your local Git identity later, restart the app container (or run `viberun <app> update`) to re-apply the new values on startup.
+If you update your local Git identity later, restart the app container (or run `app <app>` then `update`) to re-apply the new values on startup.
 
 ## Development
 
@@ -182,23 +187,23 @@ bin/viberun-e2e-local
 bin/viberun-integration
 ```
 
-### Bootstrap in development
+### Setup in development
 
-When you run `viberun` via `go run` (or a dev build), bootstrap defaults to staging the local server binary and building the container image locally. This is equivalent to:
+When you run `viberun` via `go run` (or set `VIBERUN_DEV=1`), setup defaults to staging the local server binary and building the container image locally. Run:
 
 ```bash
-viberun bootstrap --local --local-image myhost
+viberun
+setup
 ```
 
-Under the hood, it builds a `viberun:dev` image for the host architecture, streams it over `ssh` with `docker save | docker load`, and tags it as `viberun:latest` on the host.
-
-If you want to explicitly pass a local server binary:
+Or directly:
 
 ```bash
-mise exec -- go build -o /tmp/viberun-server ./cmd/viberun-server
-viberun bootstrap --local-path /tmp/viberun-server myhost
+viberun setup myhost
 ```
 
+Under the hood, it builds a `viberun:dev` image for the host architecture, streams it over `ssh` with `docker save | docker load`, and tags it as `viberun:latest` on the host.
+
 For the full build/test/E2E flow, see `DEVELOPMENT.md`.
 
 ## Architecture
@@ -206,16 +211,17 @@ For the full build/test/E2E flow, see `DEVELOPMENT.md`.
 ### High-level flow
 
 ```
-viberun <app>
-  -> ssh <host>
-    -> viberun-server <app>
-      -> docker container viberun-<app>
-        -> agent session (tmux)
+viberun (shell)
+  -> vibe <app>
+    -> ssh <host>
+      -> viberun-server gateway (mux)
+        -> viberun-server <app>
+          -> docker container viberun-<app>
+            -> agent session (tmux)
 
 container port 8080
   -> host port (assigned per app)
-    -> ssh -L localhost:<port>
-      -> http://localhost:<port>
+    -> mux forward -> http://localhost:<port>
     -> (optional) host proxy (Caddy)
       -> https://<app>.<domain>
 ```
@@ -223,7 +229,7 @@ container port 8080
 ### Core components
 
 - Client: `viberun` CLI on your machine.
-- Server: `viberun-server` executed on the host via SSH (no long-running daemon required).
+- Server: `viberun-server gateway` executed on the host via SSH (no long-running daemon required).
 - Container: `viberun-<app>` Docker container built from the `viberun:latest` image.
 - Agent: runs inside the container in a tmux session (default provider: `codex`).
 - Host RPC: local Unix socket used by the container to request snapshot/restore operations.
@@ -231,14 +237,14 @@ container port 8080
 
 ### Session lifecycle
 
-1. `viberun <app>` resolves the host (from `@host` or your default config) and runs `viberun-server` over SSH.
-2. The server creates the container if needed, or starts it if it already exists.
+1. `viberun` connects to the host (from your saved config) and starts the `viberun-server gateway` over SSH.
+2. `vibe <app>` creates the container if needed, or starts it if it already exists.
 3. The agent process is attached via `docker exec` inside a tmux session so it persists across disconnects.
-4. `viberun` sets up a local port forward so you can open the app on `http://localhost:<port>`.
+4. `viberun` forwards app ports when the shell starts so you can open `http://localhost:<port>` immediately.
 
-### Bootstrap pipeline
+### Setup pipeline
 
-The bootstrap script (run on the host) does the following:
+The setup script (run on the host) does the following:
 
 - Verifies the host is Ubuntu.
 - Installs Docker (if missing) and enables it.
@@ -246,9 +252,9 @@ The bootstrap script (run on the host) does the following:
 - Pulls the `viberun` container image from GHCR (unless using local image mode).
 - Downloads and installs the `viberun-server` binary.
 
-If bootstrap is run from a TTY, it will offer to set up a public domain name (same as `viberun proxy setup`).
+If setup is run from a TTY, it will offer to set up a public domain name (same as `proxy setup` in the shell).
 
-Useful bootstrap overrides:
+Useful setup overrides:
 
 - `VIBERUN_SERVER_REPO`: GitHub repo for releases (default `shayne/viberun`).
 - `VIBERUN_SERVER_VERSION`: release tag or `latest`.
@@ -263,41 +269,41 @@ Useful bootstrap overrides:
 
 - Each app container exposes port `8080` internally.
 - The host port is assigned per app (starting at `8080`) and stored in the host server state.
-- `viberun` opens an SSH local forward so `http://localhost:<port>` connects to the host port.
+- `viberun` forwards app ports when the shell starts so `http://localhost:<port>` connects to the host port.
 - If the proxy is configured, apps can also be served over HTTPS at `https://<app>.<domain>` (or a custom domain). Access requires login by default and can be made public per app.
 
 ### App URLs and proxy
 
 `viberun` can optionally expose apps via a host-side proxy (Caddy + `viberun-auth`).
-Set it up once per host:
+Set it up once per host (inside the shell):
 
 ```bash
-viberun proxy setup [<host>]
+proxy setup [<host>]
 ```
 
 You'll be prompted for a base domain and public IP (for DNS), plus a primary username/password.
 Create an A record (or wildcard) pointing to the host's public IP.
 
-After setup:
+After setup, in the shell:
 
-- `viberun <app> url` shows the current URL and access status.
-- `viberun <app> url --make-public` or `--require-login` toggles access (default requires login).
-- `viberun <app> url --set-domain <domain>` or `--reset-domain` manages custom domains.
-- `viberun <app> url --disable` or `--enable` turns the URL off/on.
-- `viberun <app> url --open` opens the URL in your browser.
-- `viberun users ...` manages login accounts; `viberun <app> users` controls who can access the app.
+- `app <app>` then `url` shows the current URL and access status.
+- `url public` or `url private` toggles access (default requires login).
+- `url set-domain <domain>` or `url reset-domain` manages custom domains.
+- `url disable` or `url enable` turns the URL off/on.
+- `url open` opens the URL in your browser.
+- `users` manages login accounts; `app <app>` then `users` controls who can access the app.
 
-If URL settings change, run `viberun <app> update` to refresh `VIBERUN_PUBLIC_URL` and `VIBERUN_PUBLIC_DOMAIN` inside the container.
+If URL settings change, run `app <app>` then `update` to refresh `VIBERUN_PUBLIC_URL` and `VIBERUN_PUBLIC_DOMAIN` inside the container.
 
 ### Snapshots and restore
 
 Snapshots are Btrfs subvolume snapshots of the app's `/home/viberun` volume (auto-incremented versions).
 On the host, each app uses a loop-backed Btrfs file under `/var/lib/viberun/apps/<app>/home.btrfs`.
 
-- `viberun <app> snapshot` creates the next `vN` snapshot.
-- `viberun <app> snapshots` lists versions with timestamps.
-- `viberun <app> restore <vN|latest>` restores from a snapshot (`latest` picks the highest `vN`).
-- `viberun <app> --delete -y` removes the container, the app volume + snapshots, and the host RPC directory.
+- `app <app>` then `snapshot` creates the next `vN` snapshot.
+- `app <app>` then `snapshots` lists versions with timestamps.
+- `app <app>` then `restore <vN|latest>` restores from a snapshot (`latest` picks the highest `vN`).
+- `rm <app>` removes the container, the app volume + snapshots, and the host RPC directory.
 
 Restore details:
 - The host stops the container (if running) to safely unmount the volume.
@@ -331,19 +337,19 @@ Supported agent providers:
 - `ampcode` (alias: `amp`)
 - `opencode`
 
-Custom agents can be run via `npx:<pkg>` or `uvx:<pkg>` (for example, `viberun --agent npx:@sourcegraph/amp@latest <app>`).
+Custom agents can be run via `npx:<pkg>` or `uvx:<pkg>` (for example, set `config set agent npx:@sourcegraph/amp@latest` in the shell).
 
-Set globally with `viberun config --agent <provider>` or per-run with `viberun --agent <provider> <app>`.
-To forward your local SSH agent into the container, use `viberun --forward-agent <app>`. For existing apps, run `viberun <app> update` once to recreate the container with the agent socket mounted.
+Set the default agent with `config set agent <provider>` in the shell.
+To forward your local SSH agent into the container, start viberun with `VIBERUN_FORWARD_AGENT=1 viberun`. For existing apps, run `app <app>` then `update` once to recreate the container with the agent socket mounted.
 
 Base skills are shipped in `/opt/viberun/skills` and symlinked into each agent's skills directory. User skills can be added directly to the agent-specific skills directory under `/home/viberun`.
 
 ### Security model
 
-- All control traffic goes over SSH; the server is invoked on demand and does not expose a network port.
+- All control traffic goes over the mux over SSH; the server is invoked on demand and does not expose a network port.
 - The host RPC socket is local-only and protected by filesystem permissions and a per-session token.
 - Containers are isolated by Docker and only the app port is exposed.
-- App URLs are optional: the proxy requires login by default and can be made public per app with `viberun <app> url --make-public`.
+- App URLs are optional: the proxy requires login by default and can be made public per app with `app <app>` then `url public`.
 
 ### Wipe (safety)
 
@@ -372,9 +378,9 @@ Locally, it removes `~/.config/viberun/config.toml` (and legacy config if presen
 
 ### Troubleshooting
 
-- `unsupported OS: ... expected ubuntu`: bootstrap currently supports Ubuntu only.
-- `docker is required but was not found in PATH`: install Docker on the host or re-run bootstrap.
-- `missing btrfs on host`: rerun bootstrap to install `btrfs-progs` and ensure sudo access.
-- `no host provided and no default host configured`: run `viberun config --host myhost` or use `myapp@host`.
-- `container image architecture mismatch`: delete and recreate the app (`viberun <app> --delete -y`).
-- `proxy is not configured`: run `viberun proxy setup` (then retry `viberun <app> url`).
+- `unsupported OS: ... expected ubuntu`: setup currently supports Ubuntu only.
+- `docker is required but was not found in PATH`: install Docker on the host or rerun setup.
+- `missing btrfs on host`: rerun setup to install `btrfs-progs` and ensure sudo access.
+- `no host provided and no default host configured`: run `setup` in the shell or `viberun setup myhost`.
+- `container image architecture mismatch`: delete and recreate the app (`rm <app>`).
+- `proxy is not configured`: run `proxy setup` (then retry `app <app>` and `url`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viberun",
-  "version": "0.3.7",
+  "version": "0.4.2",
   "license": "BSD-3-Clause",
   "bin": {
     "viberun": "bin/viberun.js"