@sanlabs/sanbox-cli 0.0.9 → 0.0.11

package/README.md

@@ -15,8 +15,11 @@ installed_cli_version="$(sanbox --version)"
 test "$installed_cli_version" = "$latest_cli_version"
 ```
 
-Always use the latest published CLI. CLI 0.0.9 adds user login for private SSH access to running
-Hermes Computers.
+Always use the latest published CLI. CLI 0.0.11 adds OpenCode Computer templates and short-lived
+native SDK connections for HTTP, SSE streaming, and interactive steering.
+CLI 0.0.10 added per-run Hermes email and Telegram channels, Supabase user authorization, and
+removed the retired run-chat commands.
+CLI 0.0.9 added user login for private SSH access to supported running sandboxes.
 CLI 0.0.6 added Anthropic self-hosted environment inspection and administration.
 
 ## Configure
@@ -81,13 +84,39 @@ sanbox doctor --json
 
 Model IDs are provider-scoped. The CLI never guesses or silently substitutes a provider, model, or template.
 For waited task runs, choose a template with `runnable: true`, `template_type: "runner"`, and
-`runner_config.harness: "opencode"` or `"browser-use"`. Browser Use is for one-shot web tasks whose
-target domains are already approved. Hermes service templates are always-on.
+`runner_config.harness: "opencode"` or `"browser-use"`. OpenCode remains the default one-shot mode,
+while OpenCode Computer runs a retained private OpenCode server:
+
+```bash
+sanbox templates create \
+  --name "OpenCode Computer" \
+  --harness opencode \
+  --mode computer \
+  --model-provider openai \
+  --model '<model-id>'
+```
+
+Existing templates keep their current names, IDs, slugs, and task behavior. Browser Use is for one-shot
+web tasks whose target domains are already approved. Hermes service templates are always-on. A Hermes template
+declares which optional channels its runs may activate:
+
+```bash
+sanbox templates create \
+  --name "Customer assistant" \
+  --harness hermes \
+  --model-provider openai \
+  --model '<model-id>' \
+  --channel email \
+  --channel telegram
+```
+
+Omit both `--channel` flags for a WebUI-only computer. Channel credentials never belong to the
+template.
 
 ## Create A Browser Use Template
 
 Browser Use runs local headless Chromium inside the Firecracker sandbox. It requires OpenAI,
-Anthropic, or Google Gemini and at least one explicit browser target:
+Anthropic, Google Gemini, or Hetzner Inference and at least one explicit browser target:
 
 ```bash
 sanbox templates create \
@@ -106,7 +135,7 @@ sanbox templates create \
 
 Targets are limited to hostnames and leading wildcards on ports 80 and 443. The remaining browser
 security controls are fixed. Runs return `browser-use-response.md`, a sanitized run ledger, and any
-allowed downloads. Browser Use templates do not support retained follow-up messages.
+allowed downloads. Browser Use templates are one-shot agent executions.
 
 ## Run Idempotently
 
@@ -126,6 +155,51 @@ sanbox run "Review this repo and write output/report.md" \
 
 Repeat `--input` for files, directories, or globs. The CLI excludes common secrets and applies `.sanboxignore`. `--include` is a deprecated compatibility alias.
 
+For a Hermes template that allows `email`, optionally request an address from one of the AgentMail
+domains listed in the Sanbox console:
+
+```bash
+sanbox run "Handle customer email for this project" \
+  --template "$SANBOX_TEMPLATE" \
+  --email-address research-agent@agentmail.to \
+  --json
+```
+
+`--email-address` is optional. When supplied, AgentMail must be connected and Sanbox does not
+generate a fallback address; use `agentmail.to` or one of the domains listed for the connected Pod.
+
+For a Hermes template that allows `telegram`, pass the bot token and at least one numeric user ID on
+the run. Both values are optional unless the run needs Telegram:
+
+```bash
+sanbox run "Handle Telegram messages for this project" \
+  --template "$SANBOX_TEMPLATE" \
+  --telegram-bot-token '<telegram-bot-token>' \
+  --telegram-allowed-user '<numeric-telegram-user-id>' \
+  --json
+```
+
+You can set `SANBOX_TELEGRAM_BOT_TOKEN` instead of passing `--telegram-bot-token`. Do not use both.
+
+For a long-running Hermes Computer that should act as one Supabase user, provide that user's
+Supabase Auth UUID. Sanbox automatically uses the organization's connected Supabase project:
+
+```bash
+sanbox run "Act as this user's procurement assistant" \
+  --template "$SANBOX_TEMPLATE" \
+  --external-run-id "hermes:<tenant-id>:<user-id>" \
+  --supabase-user-id "<supabase-auth-user-uuid>" \
+  --json
+
+sanbox runs supabase authorize <run-id> --open
+```
+
+The run stays in `awaiting_grant` until the expected Supabase user approves the browser consent
+flow. Without `--open`, the authorize command prints the URL for copying into any browser. The
+callback lands on a Sanbox-hosted completion page, so a CLI demo does not need a customer web app.
+Customer integrations may use `--return-url <https-url>` when its origin matches the return origin
+configured on the organization Supabase connection.
+
 Reuse the same external ID when retrying an ambiguous submission. To stream activity, replace `--wait --json` with `--jsonl`. Ctrl-C detaches without canceling unless `--cancel-on-interrupt` is supplied.
 
 ## Inspect And Recover
@@ -180,39 +254,61 @@ sanbox runs pause <run-id> --wait --json
 
 Resume restores the latest writable Firecracker snapshot without starting the configured agent
 harness. It acquires an exclusive manual lease and leaves the sandbox running for live filesystem
-access until Pause creates the next snapshot generation. Do not submit agent work while that lease is
-active. Paused state has no retention TTL and remains available until explicitly deleted.
+access until Pause creates the next snapshot generation. Before resuming, require
+`sandbox_state: "paused"` and a positive `snapshot_generation`. Do not submit agent work while that
+lease is active. Paused state has no retention TTL and remains available until explicitly deleted.
 
-## SSH Into A Hermes Computer
+## SSH Into A Running Sandbox
 
 ```bash
 sanbox login
 sanbox ssh <run-id>
 ```
 
-The run must be a currently running Hermes Computer created from the SSH-capable template artifact.
+The run must be a currently running OpenCode run or Hermes Computer created from an SSH-capable
+artifact.
 The signed-in user must own the run or be an organization admin. The command uses your local OpenSSH
 client, but it does not expose the microVM on a public IP or port. The CLI generates a temporary
 Ed25519 identity, pins the microVM's runtime host key, and tunnels the SSH stream over a one-time
 authenticated WebSocket. The temporary key is deleted when the connection closes, and the saved
 user token is not passed to the OpenSSH child process.
 
-## Continue An OpenCode Run
+OpenCode and Browser Use runs are one-shot agent executions. OpenCode Computer keeps its private
+server running after the initial task so it can accept later steering. A persisted task sandbox can
+still be resumed manually for inspection when a snapshot exists.
+
+## Connect The OpenCode SDK
+
+Create a short-lived connection for a currently running OpenCode Computer:
 
 ```bash
-sanbox runs messages <run-id> --json
-sanbox runs message <run-id> "Summarize the retained output" --wait --json
+sanbox opencode connect <run-id> --expires 1h --json
+sanbox opencode connections list <run-id> --json
+sanbox opencode connections revoke <run-id> <connection-id> --json
 ```
 
-The JSON response includes the user `message`, submitted `chat_job`, matching terminal
-`followup_event`, and conversation messages. The waiter matches `payload.chat_job_id`, so another
-concurrent follow-up cannot complete the wrong command. The follow-up resumes OpenCode for one turn,
-then pauses the sandbox again.
+The create response contains `url`, `access_token`, and connection metadata. The plaintext token is
+returned only once, but it can authenticate all OpenCode SDK requests and SSE reconnects until it
+expires, is revoked, or the runtime session ends. Multiple connections can coexist. Organization API
+keys use their existing organization role and require member access or higher; no additional API-key
+or connection-token scopes are introduced.
+
+```ts
+import { createOpencodeClient } from "@opencode-ai/sdk"
+
+const client = createOpencodeClient({
+  baseUrl: connection.url,
+  headers: { Authorization: `Bearer ${connection.access_token}` },
+})
+
+const events = await client.event.subscribe()
+```
 
-Check `sanbox runs get <run-id> --json` before a follow-up and require `sandbox_state: "paused"` with
-a positive `snapshot_generation`. Do not submit concurrent follow-ups to one run.
-Treat `browser_use_followup_unsupported` as a signal to create a new browser agent run; its persisted
-sandbox can still be resumed manually when a snapshot exists.
+Sanbox proxies the native HTTP and SSE API through its private Firecracker management path. The
+microVM never exposes an inbound port. Only security-sensitive OpenCode configuration,
+authentication, credential mutation, server-administration, raw PTY, and public-share routes are
+denied; core session, event, file, command, and session-shell APIs remain native. See
+[OpenCode SDK access](../docs/opencode-sdk-access.md) for the API and lifecycle contract.
 
 ## Batch Work
 

package/dist/api.js

@@ -183,6 +183,12 @@ export class SanboxClient {
     async getRun(runId, signal) {
         return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}`), { signal });
     }
+    async authorizeRunSupabase(runId, returnUrl) {
+        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/supabase/authorize`), {
+            method: "POST",
+            body: JSON.stringify(returnUrl ? { return_url: returnUrl } : {})
+        });
+    }
     async createSSHSession(runId, publicKey) {
         return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/ssh-sessions`), {
             method: "POST",
@@ -210,15 +216,6 @@ export class SanboxClient {
             body: "{}"
         });
     }
-    async sendMessage(runId, message, payload = {}) {
-        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/messages`), {
-            method: "POST",
-            body: JSON.stringify({ message, payload })
-        });
-    }
-    async listMessages(runId) {
-        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/messages`));
-    }
     async listArtifacts(runId) {
         return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/artifacts`));
     }
@@ -234,6 +231,18 @@ export class SanboxClient {
     async revokeFileAccessPoint(runId, accessPointId) {
         return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/file-access-points/${encodeURIComponent(accessPointId)}`), { method: "DELETE" });
     }
+    async listOpenCodeConnections(runId) {
+        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/opencode-connections`));
+    }
+    async createOpenCodeConnection(runId, expiresInSeconds) {
+        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/opencode-connections`), {
+            method: "POST",
+            body: JSON.stringify({ expires_in_seconds: expiresInSeconds })
+        });
+    }
+    async revokeOpenCodeConnection(runId, connectionId) {
+        return this.request(await this.orgPath(`/runs/${encodeURIComponent(runId)}/opencode-connections/${encodeURIComponent(connectionId)}`), { method: "DELETE" });
+    }
     async downloadArtifact(runId, artifactPath) {
         return this.rawRequest(`${await this.orgPath(`/runs/${encodeURIComponent(runId)}/artifacts`)}?path=${encodeURIComponent(artifactPath)}`);
     }

package/dist/args.js

@@ -2,6 +2,7 @@ const multiFlags = new Set([
     "input",
     "include",
     "artifact",
+    "channel",
     "telegram-allowed-user",
     "browser-domain"
 ]);
@@ -19,6 +20,7 @@ export const booleanFlags = new Set([
     "force",
     "write",
     "overwrite",
+    "open",
     "no-browser"
 ]);
 export const parseArgs = (argv) => {

package/dist/cli.js

@@ -13,7 +13,7 @@ import { previewInputs } from "./inputs.js";
 import { printError, printJsonlError, printRun, printSuccess, publicRun, publicRunPayload } from "./output.js";
 import { createRun, isTerminalRun, readTasks, runPool, stableBatchId, waitForRun, waitForSandboxState } from "./runs.js";
 import { version } from "./version.js";
-import { WatchInterruptedError, watchEventsUntil, watchRun } from "./watch.js";
+import { WatchInterruptedError, watchRun } from "./watch.js";
 import { openSSH, runSSHProxy } from "./ssh.js";
 import { userSessionStore } from "./userSession.js";
 const help = `Sanbox CLI
@@ -40,14 +40,13 @@ Commands:
   sanbox templates list [--json]
   sanbox templates get <template-id> [--json]
   sanbox templates validate <template-id> [--json]
-  sanbox templates create --name "..." --model-provider <provider-id> --model <model-id> [--harness opencode|hermes|browser-use] [--browser-domain <hostname>] [--llm-budget-usd <amount>] [--json]
-  sanbox run "task" --template <template-id> [--input <path>] [--wait | --watch] [--json | --jsonl]
-  sanbox run --task "..." --template <template-id> [--input <path>] [--wait | --watch] [--json | --jsonl]
+  sanbox templates create --name "..." --model-provider <provider-id> --model <model-id> [--harness opencode|hermes|browser-use] [--mode task|computer] [--channel email|telegram] [--browser-domain <hostname>] [--llm-budget-usd <amount>] [--json]
+  sanbox run "task" --template <template-id> [--email-address <address>] [--telegram-bot-token <token>] [--telegram-allowed-user <id>] [--input <path>] [--wait | --watch] [--json | --jsonl]
+  sanbox run --task "..." --template <template-id> [--email-address <address>] [--telegram-bot-token <token>] [--telegram-allowed-user <id>] [--input <path>] [--wait | --watch] [--json | --jsonl]
   sanbox batch --tasks tasks.json --template <template-id> [--input <path>] [--max-parallel 5] [--wait] [--json]
   sanbox runs list [--limit 50] [--json]
   sanbox runs get <run-id> [--json]
   sanbox runs events <run-id> [--after-event-id 0] [--json]
-  sanbox runs messages <run-id> [--json]
   sanbox runs artifacts <run-id> [--json]
   sanbox runs share <run-id> [--expires 1h] [--name "Debug access"] [--json]
   sanbox runs shares <run-id> [--json]
@@ -57,7 +56,10 @@ Commands:
   sanbox runs cancel <run-id> [--json]
   sanbox runs resume <run-id> [--wait] [--json]
   sanbox runs pause <run-id> [--wait] [--json]
-  sanbox runs message <run-id> "..." [--wait | --watch] [--json | --jsonl]
+  sanbox runs supabase authorize <run-id> [--open] [--return-url <https-url>] [--json]
+  sanbox opencode connect <run-id> [--expires 1h] [--json]
+  sanbox opencode connections list <run-id> [--json]
+  sanbox opencode connections revoke <run-id> <connection-id> [--json]
   sanbox ssh <run-id>
   sanbox init [--force]
   sanbox init agent [--write]
@@ -67,12 +69,24 @@ const sshHelp = `Sanbox SSH
 Usage:
   sanbox ssh <run-id>
 
-Opens the running Hermes Computer with your local OpenSSH client. Sanbox creates an ephemeral
-Ed25519 key, authorizes it for one connection, verifies the microVM host key, and tunnels SSH over
-the authenticated private management path. Run sanbox login first. The computer owner and
+Opens a running OpenCode run or Hermes Computer with your local OpenSSH client. Sanbox creates an
+ephemeral Ed25519 key, authorizes it for one connection, verifies the microVM host key, and tunnels
+SSH over the authenticated private management path. Run sanbox login first. The run owner and
 organization admins can connect; organization API keys cannot open interactive sessions. The guest
 does not expose port 22 publicly.
 `;
+const openCodeHelp = `Sanbox OpenCode SDK access
+
+Usage:
+  sanbox opencode connect <run-id> [--expires 1h] [--json]
+  sanbox opencode connections list <run-id> [--json]
+  sanbox opencode connections revoke <run-id> <connection-id> [--json]
+
+Creates short-lived bearer credentials for the native OpenCode SDK. The token is bound to one
+running OpenCode Computer and its current runtime session. Its plaintext value is returned only
+when created. Multiple connections may be active at once; each expires and can be revoked
+independently. Organization API keys require member access or higher.
+`;
 const runHelp = `Sanbox run
 
 Usage:
@@ -83,6 +97,10 @@ Options:
   --input <path>                File, directory, or glob to upload. Repeatable.
   --template <id>               Template id or slug. Required unless SANBOX_TEMPLATE or project config sets it.
   --external-run-id <id>        Idempotency key for retries.
+  --supabase-user-id <id>       Supabase Auth user UUID expected during OAuth consent.
+  --email-address <address>     Optional for Hermes computers; must use a listed AgentMail domain.
+  --telegram-bot-token <token> Optional Telegram bot token; SANBOX_TELEGRAM_BOT_TOKEN is also supported.
+  --telegram-allowed-user <id> Numeric Telegram user allowed to reach this run. Repeatable.
   --dry-run                     Preview included files without creating a run.
   --wait                        Poll until terminal status.
   --watch                       Stream activity until terminal status.
@@ -92,6 +110,17 @@ Options:
   --cancel-on-interrupt         Request run cancellation when Ctrl-C is pressed.
   --json                        Print JSON.
 `;
+const runsSupabaseHelp = `Sanbox Supabase run authorization
+
+Usage:
+  sanbox runs supabase authorize <run-id>
+  sanbox runs supabase authorize <run-id> --open
+
+Options:
+  --open                       Open the consent URL in the default browser.
+  --return-url <https-url>     Override the built-in Sanbox completion page with an allowlisted customer URL.
+  --json                       Print JSON.
+`;
 const doctorHelp = `Sanbox doctor
 
 Usage:
@@ -130,12 +159,14 @@ Usage:
   sanbox templates list [--json]
   sanbox templates get <template-id> [--json]
   sanbox templates validate <template-id> [--json]
-  sanbox templates create --name "Code review" --model-provider <provider-id> --model <model-id> [--harness opencode|hermes|browser-use] [--browser-domain <hostname>] [--llm-budget-usd <amount>] [--json]
+  sanbox templates create --name "Code review" --model-provider <provider-id> --model <model-id> [--harness opencode|hermes|browser-use] [--mode task|computer] [--browser-domain <hostname>] [--llm-budget-usd <amount>] [--json]
 
 Template creation requires an exact provider id and that provider's exact model id.
 LiteLLM budgets are optional USD amounts and apply separately to each run.
-Hermes templates are always-on Telegram gateways. Set SANBOX_TELEGRAM_BOT_TOKEN
-and repeat --telegram-allowed-user <numeric-id> for every permitted user.
+OpenCode defaults to --mode task. Use --mode computer for a retained private OpenCode server;
+per-run LiteLLM budgets are not available for that retained mode yet.
+Hermes templates are always-on computers. Use repeatable --channel email|telegram to select which
+channels runs may activate. Email and Telegram credentials are supplied only when creating a run.
 Browser Use templates run local headless Chromium inside a one-shot sandbox. They require OpenAI
 or Anthropic and at least one repeatable --browser-domain hostname or leading wildcard.
 Optional controls: --browser-max-steps, --browser-step-timeout-seconds,
@@ -231,17 +262,11 @@ exclusive manual lease and leaves the sandbox running until pause snapshots it a
 agent work while the manual lease is active. Before resume, require sandbox_state: "paused" and a
 positive snapshot_generation.
 
-For an OpenCode follow-up, use \`sanbox runs message <run-id> "..." --wait --json\`. Follow-up waits
-are correlated to the returned chat_job.id. Never submit concurrent follow-ups to one run. Retry
-sandbox_not_paused only after the run returns to paused; treat sandbox_not_resumable,
-sandbox_snapshot_missing, sandbox_worker_missing, hermes_uses_channel, and
-browser_use_followup_unsupported as blockers.
-
 For independent fan-out, use \`sanbox batch\` with a stable external_run_id per task and keep the
 client alive until submission completes.
 
-Do not claim completion until the run is completed, required artifacts are downloaded and verified,
-and required follow-ups succeeded. Report run/external/template IDs, status, sandbox state, snapshot
+Do not claim completion until the run is completed and required artifacts are downloaded and verified.
+Report run/external/template IDs, status, sandbox state, snapshot
 generation, artifact paths/digests, and blockers. The CLI excludes common secrets by default; add
 .sanboxignore for project rules.
 `;
@@ -427,9 +452,10 @@ const flagSets = {
         "model-provider",
         "model",
         "harness",
+        "mode",
         "llm-budget-usd",
         "web-access",
-        "telegram-allowed-user",
+        "channel",
         "browser-domain",
         "browser-max-steps",
         "browser-step-timeout-seconds",
@@ -439,7 +465,9 @@ const flagSets = {
         "browser-additional-instructions"
     ],
     run: [
-        ...commonFlags, "task", "input", "template", "external-run-id",
+        ...commonFlags, "task", "input", "template", "external-run-id", "email-address",
+        "supabase-user-id",
+        "telegram-bot-token", "telegram-allowed-user",
         "dry-run", "wait", "watch", "jsonl", "view", "after-event-id", "cancel-on-interrupt",
         "poll-interval-ms", "event-page-size", "timeout-seconds", "verbose"
     ],
@@ -450,7 +478,6 @@ const flagSets = {
     "runs.list": [...commonFlags, "limit"],
     "runs.get": commonFlags,
     "runs.events": [...commonFlags, "after-event-id"],
-    "runs.messages": commonFlags,
     "runs.artifacts": commonFlags,
     "runs.share": [...commonFlags, "expires", "name"],
     "runs.shares": commonFlags,
@@ -463,10 +490,9 @@ const flagSets = {
     "runs.cancel": commonFlags,
     "runs.resume": [...commonFlags, "wait", "poll-interval-ms", "timeout-seconds"],
     "runs.pause": [...commonFlags, "wait", "poll-interval-ms", "timeout-seconds"],
-    "runs.message": [
-        ...commonFlags, "message", "wait", "watch", "jsonl", "view",
-        "poll-interval-ms", "event-page-size", "timeout-seconds"
-    ],
+    "runs.supabase": [...commonFlags, "open", "return-url"],
+    "opencode.connect": [...commonFlags, "expires"],
+    "opencode.connections": commonFlags,
     ssh: ["api-url", "help"],
     "ssh-proxy": [],
     login: ["api-url", "json", "no-browser", "help"],
@@ -482,10 +508,15 @@ const commandKey = (command) => {
         return "version";
     if (command[0] === "auth")
         return `auth.${command[1] || ""}`;
+    if (command[0] === "runs" && command[1] === "supabase")
+        return "runs.supabase";
+    if (command[0] === "opencode" && command[1] === "connections")
+        return "opencode.connections";
     if (command[0] === "model-providers" ||
         command[0] === "anthropic-environments" ||
         command[0] === "templates" ||
-        command[0] === "runs") {
+        command[0] === "runs" ||
+        command[0] === "opencode") {
         return `${command[0]}.${command[1] || ""}`;
     }
     if (command[0] === "init" && command[1] === "agent")
@@ -493,14 +524,15 @@ const commandKey = (command) => {
     return command[0];
 };
 const requiredValueFlags = new Set([
-    "api-url", "template", "task", "input", "include", "external-run-id",
+    "api-url", "template", "task", "input", "include", "external-run-id", "email-address",
+    "supabase-user-id", "return-url",
+    "telegram-bot-token", "telegram-allowed-user", "channel",
     "tasks", "max-parallel", "batch-id", "poll-interval-ms",
     "event-page-size", "timeout-seconds", "view", "after-event-id", "limit", "name",
-    "model-provider", "model", "harness", "llm-budget-usd", "telegram-allowed-user",
+    "model-provider", "model", "harness", "mode", "llm-budget-usd",
     "browser-domain", "browser-max-steps", "browser-step-timeout-seconds",
     "browser-vision-mode", "browser-viewport", "browser-download-policy",
-    "browser-additional-instructions", "expires",
-    "message", "output", "artifact"
+    "browser-additional-instructions", "expires", "output", "artifact"
 ]);
 const validateFlagValues = (flags) => {
     for (const flag of requiredValueFlags) {
@@ -539,7 +571,7 @@ const validateFlags = (command, flags) => {
     }
     const knownRoots = new Set([
         "auth", "context", "doctor", "model-providers", "anthropic-environments", "templates",
-        "run", "batch", "runs", "ssh", "ssh-proxy", "login", "logout", "init", "version"
+        "run", "batch", "runs", "opencode", "ssh", "ssh-proxy", "login", "logout", "init", "version"
     ]);
     const allowed = flagSets[key] ?? (knownRoots.has(command[0] || "") ? commonFlags : null);
     if (!allowed)
@@ -571,7 +603,6 @@ const validatePositionals = (command, flags) => {
         "runs.list": 2,
         "runs.get": 3,
         "runs.events": 3,
-        "runs.messages": 3,
         "runs.artifacts": 3,
         "runs.share": 3,
         "runs.shares": 3,
@@ -581,6 +612,9 @@ const validatePositionals = (command, flags) => {
         "runs.cancel": 3,
         "runs.resume": 3,
         "runs.pause": 3,
+        "runs.supabase": 4,
+        "opencode.connect": 3,
+        "opencode.connections": 5,
         ssh: 2,
         "ssh-proxy": 1,
         login: 1,
@@ -692,6 +726,11 @@ const commandRun = async (command, flags) => {
         throw new Error("--wait cannot be combined with --watch or --jsonl.");
     }
     validateWatchFlags(flags);
+    const supabaseUserId = flagString(flags, "supabase-user-id").trim();
+    if (supabaseUserId &&
+        !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(supabaseUserId)) {
+        throw new CliError("invalid_supabase_user_id", "--supabase-user-id must be a UUID.");
+    }
     if (hasFlag(flags, "dry-run")) {
         if (wantsWatch(flags))
             throw new Error("--dry-run cannot be combined with --watch or --jsonl.");
@@ -702,6 +741,24 @@ const commandRun = async (command, flags) => {
             printPreview(preview, hasFlag(flags, "verbose"));
         return;
     }
+    const tokenFlag = flagString(flags, "telegram-bot-token").trim();
+    const telegramAllowedUsers = [...new Set(flagList(flags, "telegram-allowed-user")
+            .map((value) => value.trim())
+            .filter(Boolean))];
+    const telegramRequested = Boolean(tokenFlag || telegramAllowedUsers.length > 0);
+    const tokenEnvironment = telegramRequested
+        ? process.env.SANBOX_TELEGRAM_BOT_TOKEN?.trim() || ""
+        : "";
+    if (tokenFlag && tokenEnvironment) {
+        throw new CliError("telegram_token_ambiguous", "Use either --telegram-bot-token or SANBOX_TELEGRAM_BOT_TOKEN, not both.");
+    }
+    const telegramBotToken = tokenFlag || tokenEnvironment;
+    if (!telegramBotToken && telegramAllowedUsers.length > 0) {
+        throw new CliError("telegram_bot_token_required", "--telegram-allowed-user requires --telegram-bot-token or SANBOX_TELEGRAM_BOT_TOKEN.");
+    }
+    if (telegramBotToken && telegramAllowedUsers.length === 0) {
+        throw new CliError("telegram_allowed_user_required", "Telegram requires at least one --telegram-allowed-user.");
+    }
     const client = makeClient(flags);
     const template = readTemplateSelection(flags);
     let payload;
@@ -711,6 +768,10 @@ const commandRun = async (command, flags) => {
             instruction: task,
             inputs: flagList(flags, "input"),
             externalRunId: flagString(flags, "external-run-id") || undefined,
+            supabaseUserId: supabaseUserId || undefined,
+            emailAddress: flagString(flags, "email-address") || undefined,
+            telegramBotToken: telegramBotToken || undefined,
+            telegramAllowedUsers,
             templateId: template.id
         });
     }
@@ -764,6 +825,7 @@ const commandBatch = async (flags) => {
                 instruction: task.task,
                 inputs: task.input || inputs,
                 externalRunId: task.external_run_id || `sanbox-batch-${batchId}-${index + 1}`,
+                emailAddress: task.email_address,
                 templateId: template.id
             });
         }
@@ -874,8 +936,7 @@ const commandModelProviders = async (command, flags) => {
             printSuccess("model_providers.get", payload, jsonContext(client), nextActions);
             return;
         }
-        process.stdout.write(`${providerId(payload.provider)}${payload.provider.status ? ` ${payload.provider.status}` : ""}` +
-            `${payload.provider.base_url ? ` base_url=${payload.provider.base_url}` : ""}\n`);
+        process.stdout.write(`${providerId(payload.provider)}${payload.provider.status ? ` ${payload.provider.status}` : ""}\n`);
         return;
     }
     if (action === "models") {
@@ -1108,6 +1169,14 @@ const commandTemplates = async (command, flags) => {
         if (harness !== "opencode" && harness !== "hermes" && harness !== "browser-use") {
             throw new CliError("invalid_harness", "templates create --harness must be opencode, hermes, or browser-use.");
         }
+        const modeFlag = flagString(flags, "mode");
+        const mode = modeFlag || "task";
+        if (mode !== "task" && mode !== "computer") {
+            throw new CliError("invalid_opencode_mode", "templates create --mode must be task or computer.");
+        }
+        if (harness !== "opencode" && modeFlag) {
+            throw new CliError("opencode_mode_not_supported", "templates create --mode requires --harness opencode.");
+        }
         const budgetRaw = flagString(flags, "llm-budget-usd");
         const parsedBudgetUsd = budgetRaw ? Number(budgetRaw) : undefined;
         const llmBudgetUsd = parsedBudgetUsd === undefined
@@ -1120,8 +1189,13 @@ const commandTemplates = async (command, flags) => {
         if (harness === "hermes" && llmBudgetUsd !== undefined) {
             throw new CliError("hermes_budget_unsupported", "Always-on Hermes templates do not support --llm-budget-usd yet.");
         }
-        const telegramBotToken = process.env.SANBOX_TELEGRAM_BOT_TOKEN?.trim() || "";
-        const telegramAllowedUsers = flagList(flags, "telegram-allowed-user").map((value) => value.trim()).filter(Boolean);
+        if (harness === "opencode" && mode === "computer" && llmBudgetUsd !== undefined) {
+            throw new CliError("opencode_computer_budget_unsupported", "OpenCode Computer templates do not support --llm-budget-usd yet.");
+        }
+        const channels = [...new Set(flagList(flags, "channel").map((value) => value.trim()).filter(Boolean))];
+        if (channels.some((channel) => channel !== "email" && channel !== "telegram")) {
+            throw new CliError("invalid_hermes_channels", "--channel must be email or telegram.");
+        }
         const browserFlagNames = [
             "browser-domain",
             "browser-max-steps",
@@ -1137,8 +1211,9 @@ const commandTemplates = async (command, flags) => {
         if (harness === "browser-use" &&
             modelProvider !== "openai" &&
             modelProvider !== "anthropic" &&
-            modelProvider !== "google") {
-            throw new CliError("browser_use_provider_unsupported", "Browser Use templates require --model-provider openai, anthropic, or google.");
+            modelProvider !== "google" &&
+            modelProvider !== "hetzner") {
+            throw new CliError("browser_use_provider_unsupported", "Browser Use templates require --model-provider openai, anthropic, google, or hetzner.");
         }
         const browserDomains = harness === "browser-use"
             ? parseBrowserDomains(flagList(flags, "browser-domain"))
@@ -1146,11 +1221,8 @@ const commandTemplates = async (command, flags) => {
         const browserUse = harness === "browser-use"
             ? parseBrowserUseConfig(flags)
             : undefined;
-        if (harness === "hermes" && !telegramBotToken) {
-            throw new CliError("telegram_bot_token_required", "Hermes template creation requires SANBOX_TELEGRAM_BOT_TOKEN.");
-        }
-        if (harness === "hermes" && telegramAllowedUsers.length === 0) {
-            throw new CliError("telegram_allowed_user_required", "Hermes template creation requires at least one --telegram-allowed-user.");
+        if (harness !== "hermes" && channels.length > 0) {
+            throw new CliError("hermes_channels_not_supported", "--channel requires --harness hermes.");
         }
         let payload;
         try {
@@ -1158,6 +1230,7 @@ const commandTemplates = async (command, flags) => {
                 name,
                 provider_id: modelProvider,
                 model_id: model,
+                ...(harness === "opencode" && modeFlag ? { mode: mode } : {}),
                 ...(llmBudgetUsd === undefined ? {} : { llm_budget_usd: llmBudgetUsd }),
                 ...(harness === "browser-use" ? {
                     harness,
@@ -1175,8 +1248,7 @@ const commandTemplates = async (command, flags) => {
                 } : {}),
                 ...(harness === "hermes" ? {
                     harness,
-                    telegram_bot_token: telegramBotToken,
-                    telegram_allowed_users: telegramAllowedUsers
+                    channels: channels
                 } : {})
             });
         }
@@ -1186,8 +1258,20 @@ const commandTemplates = async (command, flags) => {
         if (hasFlag(flags, "json")) {
             printSuccess("templates.create", payload, jsonContext(client), [
                 commandAction(["sanbox", "templates", "validate", payload.template.id, "--json"], "Validate the new template before running it."),
-                commandAction(["sanbox", "run", harness === "hermes" ? "<agent role and instructions>" : "<task>", "--template", payload.template.id], harness === "hermes"
-                    ? "Start the always-on gateway; interact with it through the configured Telegram bot."
+                commandAction([
+                    "sanbox",
+                    "run",
+                    harness === "hermes"
+                        ? "<agent role and instructions>"
+                        : harness === "opencode" && mode === "computer"
+                            ? "<computer role and instructions>"
+                            : "<task>",
+                    "--template",
+                    payload.template.id
+                ], harness === "hermes" || (harness === "opencode" && mode === "computer")
+                    ? harness === "hermes"
+                        ? "Start the always-on computer and activate only the channels this run needs."
+                        : "Start the retained OpenCode computer."
                     : "Create a run with the new template.")
             ]);
             return;
@@ -1215,6 +1299,23 @@ const commandRuns = async (command, flags) => {
         }
         return;
     }
+    if (action === "supabase") {
+        if (command[2] !== "authorize") {
+            throw new CliError("supabase_action_required", "runs supabase requires the action: authorize.");
+        }
+        const runId = requiredPositional(command[3], "run_id_required", "runs supabase authorize requires a run id.");
+        const payload = await client.authorizeRunSupabase(runId, flagString(flags, "return-url").trim() || undefined);
+        if (hasFlag(flags, "open") && !openBrowser(payload.authorization_url)) {
+            process.stderr.write("Could not open a browser. Open the printed consent URL manually.\n");
+        }
+        if (hasFlag(flags, "json")) {
+            printSuccess("runs.supabase.authorize", payload, jsonContext(client));
+        }
+        else {
+            process.stdout.write(`${payload.authorization_url}\n`);
+        }
+        return;
+    }
     const runId = requiredPositional(command[2], "run_id_required", `runs ${action} requires a run id.`);
     if (action === "get") {
         const payload = await client.getRun(runId);
@@ -1232,17 +1333,6 @@ const commandRuns = async (command, flags) => {
             payload.events.forEach((event) => process.stdout.write(`${event.id} ${event.level} ${event.kind} ${event.message}\n`));
         return;
     }
-    if (action === "messages") {
-        const payload = await client.listMessages(runId);
-        if (hasFlag(flags, "json")) {
-            printSuccess("runs.messages", payload, jsonContext(client));
-            return;
-        }
-        for (const message of payload.messages) {
-            process.stdout.write(`${message.role}\t${message.created_at}\t${message.message}\n`);
-        }
-        return;
-    }
     if (action === "artifacts") {
         const payload = await client.listArtifacts(runId);
         if (hasFlag(flags, "json")) {
@@ -1378,107 +1468,58 @@ const commandRuns = async (command, flags) => {
         }
         return;
     }
-    if (action === "message") {
-        const commandName = "runs.message";
-        const flaggedMessage = flagString(flags, "message");
-        const positionalMessage = positionalText(command, 3);
-        if (flaggedMessage && positionalMessage) {
-            throw new CliError("conflicting_arguments", "Use either --message or a positional message, not both.");
-        }
-        const message = flaggedMessage || positionalMessage;
-        if (!message)
-            throw new Error(`runs ${action} requires an instruction as positional text or --message.`);
-        if (wantsWatch(flags) && hasFlag(flags, "json")) {
-            throw new Error("--json cannot be combined with --watch or --jsonl.");
-        }
-        if (hasFlag(flags, "wait") && wantsWatch(flags)) {
-            throw new Error("--wait cannot be combined with --watch or --jsonl.");
+    throw new Error(`Unknown runs action: ${action}`);
+};
+const commandOpenCode = async (command, flags) => {
+    const client = makeClient(flags);
+    const action = command[1];
+    if (action === "connect") {
+        const runId = requiredPositional(command[2], "run_id_required", "opencode connect requires a run id.");
+        const expiresInSeconds = parseFileAccessExpiry(flagString(flags, "expires", "1h"));
+        if (expiresInSeconds > 24 * 60 * 60) {
+            throw new CliError("invalid_opencode_connection_expiry", "OpenCode connection expiry must be between 1 minute and 1 day.");
         }
-        const submitted = await client.sendMessage(runId, message);
-        if (!hasFlag(flags, "wait") && !wantsWatch(flags)) {
-            if (hasFlag(flags, "json")) {
-                printSuccess(commandName, {
-                    ...publicRunPayload(submitted),
-                    message: submitted.message,
-                    chat_job: submitted.chat_job
-                }, jsonContext(client));
-            }
-            else
-                process.stdout.write(`queued OpenCode follow-up for run ${runId}\n`);
+        const payload = await client.createOpenCodeConnection(runId, expiresInSeconds);
+        if (hasFlag(flags, "json")) {
+            printSuccess("opencode.connect", payload, jsonContext(client), [
+                commandAction(["sanbox", "opencode", "connections", "revoke", runId, payload.connection.id, "--json"], "Revoke this OpenCode SDK connection.")
+            ]);
             return;
         }
-        const chatJobId = submitted.chat_job.id;
-        const belongsToFollowup = (event) => event.payload.chat_job_id === chatJobId;
-        const queuedEventId = submitted.events.reduce((latest, event) => event.kind === "chat.queued" && belongsToFollowup(event) ? Math.max(latest, event.id) : latest, 0);
-        const receivedEventId = [...submitted.events]
-            .reverse()
-            .find((event) => event.kind === "message.received" && belongsToFollowup(event))?.id ?? queuedEventId;
-        const cursor = submitted.events.reduce((latest, event) => Math.max(latest, event.id), 0);
-        const completedInResponse = [...submitted.events]
-            .reverse()
-            .find((event) => (event.kind === "chat.completed" || event.kind === "chat.failed") && belongsToFollowup(event));
-        const view = parseActivityView(flagString(flags, "view", "activity"));
-        const jsonl = hasFlag(flags, "jsonl");
-        const controller = new AbortController();
-        const onInterrupt = () => controller.abort();
-        process.once("SIGINT", onInterrupt);
-        if (wantsWatch(flags) && !jsonl)
-            process.stdout.write(`Watching follow-up for run ${runId}. Ctrl-C detaches.\n`);
-        try {
-            const renderFollowupEvent = (event) => {
-                if (!belongsToFollowup(event))
-                    return;
-                if (!wantsWatch(flags) || !shouldRenderEvent(event, view))
-                    return;
-                process.stdout.write(`${jsonl ? formatActivityJsonl(event) : formatActivityLine(event, submitted.run.created_at)}\n`);
-            };
-            for (const event of submitted.events) {
-                if (event.id >= receivedEventId)
-                    renderFollowupEvent(event);
+        process.stdout.write(`URL ${payload.url}\nTOKEN ${payload.access_token}\nEXPIRES ${payload.connection.expires_at}\n`);
+        return;
+    }
+    if (action === "connections") {
+        const connectionAction = command[2];
+        if (connectionAction === "list") {
+            const runId = requiredPositional(command[3], "run_id_required", "opencode connections list requires a run id.");
+            if (command[4]) {
+                throw new CliError("unexpected_argument", `Unexpected positional argument: ${command[4]}`);
             }
-            const terminalEvent = completedInResponse ?? await watchEventsUntil(client, runId, {
-                afterEventId: cursor,
-                pageSize: integerFlag(flags, "event-page-size", 200, 1, 500),
-                pollIntervalMs: integerFlag(flags, "poll-interval-ms", 2000, 250, 60_000),
-                timeoutSeconds: integerFlag(flags, "timeout-seconds", 1800, 1, 604_800),
-                signal: controller.signal,
-                stopWhen: (event) => (event.kind === "chat.completed" || event.kind === "chat.failed") && belongsToFollowup(event),
-                onRetry: ({ error, attempt, delayMs }) => {
-                    const detail = error instanceof Error ? error.message : String(error);
-                    process.stderr.write(`Follow-up connection lost (${detail}); retry ${attempt} in ${delayMs}ms.\n`);
-                },
-                onEvent: renderFollowupEvent
-            });
-            const messages = await client.listMessages(runId);
+            const payload = await client.listOpenCodeConnections(runId);
             if (hasFlag(flags, "json")) {
-                printSuccess(commandName, {
-                    ...publicRunPayload(submitted),
-                    message: submitted.message,
-                    chat_job: submitted.chat_job,
-                    messages: messages.messages,
-                    followup_event: terminalEvent
-                }, jsonContext(client));
+                printSuccess("opencode.connections.list", payload, jsonContext(client));
+                return;
             }
-            else if (!jsonl) {
-                const assistant = [...messages.messages].reverse().find((item) => item.role === "assistant" && item.payload.chat_job_id === chatJobId);
-                if (assistant)
-                    process.stdout.write(`${assistant.message}\n`);
+            for (const connection of payload.connections) {
+                process.stdout.write(`${connection.id}\t${connection.status}\t${connection.expires_at}\t${connection.token_prefix}\n`);
             }
-            if (terminalEvent.kind === "chat.failed")
-                process.exitCode = 2;
-        }
-        catch (error) {
-            if (!(error instanceof WatchInterruptedError))
-                throw error;
-            process.stderr.write(`Detached from follow-up for run ${runId}; processing continues.\n`);
-            process.exitCode = 130;
+            return;
         }
-        finally {
-            process.off("SIGINT", onInterrupt);
+        if (connectionAction === "revoke") {
+            const runId = requiredPositional(command[3], "run_id_required", "opencode connections revoke requires a run id.");
+            const connectionId = requiredPositional(command[4], "opencode_connection_id_required", "opencode connections revoke requires a connection id.");
+            const payload = await client.revokeOpenCodeConnection(runId, connectionId);
+            if (hasFlag(flags, "json")) {
+                printSuccess("opencode.connections.revoke", payload, jsonContext(client));
+                return;
+            }
+            process.stdout.write(`revoked ${payload.connection.id}\n`);
+            return;
         }
-        return;
+        throw new CliError("opencode_connections_action_required", "opencode connections requires an action: list or revoke.");
     }
-    throw new Error(`Unknown runs action: ${action}`);
+    throw new CliError("opencode_action_required", "opencode requires an action: connect or connections.");
 };
 const commandDoctor = async (flags) => {
     const localConfig = readLocalConfig();
@@ -1717,6 +1758,8 @@ const commandInit = async (command, flags) => {
 const helpFor = (command) => {
     if (command[0] === "run")
         return runHelp;
+    if (command[0] === "runs" && command[1] === "supabase")
+        return runsSupabaseHelp;
     if (command[0] === "doctor")
         return doctorHelp;
     if (command[0] === "model-providers")
@@ -1725,6 +1768,8 @@ const helpFor = (command) => {
         return anthropicEnvironmentsHelp;
     if (command[0] === "templates")
         return templatesHelp;
+    if (command[0] === "opencode")
+        return openCodeHelp;
     if (command[0] === "ssh")
         return sshHelp;
     return help;
@@ -1747,8 +1792,16 @@ const commandId = (command) => {
         return "run.create";
     if (command[0] === "batch")
         return "batch.create";
+    if (command[0] === "runs" && command[1] === "supabase") {
+        return `runs.supabase.${command[2] || "unknown"}`;
+    }
     if (command[0] === "runs")
         return `runs.${command[1] || "unknown"}`;
+    if (command[0] === "opencode" && command[1] === "connections") {
+        return `opencode.connections.${command[2] || "unknown"}`;
+    }
+    if (command[0] === "opencode")
+        return `opencode.${command[1] || "unknown"}`;
     if (command[0] === "ssh" || command[0] === "ssh-proxy")
         return command[0];
     return command[0] || "help";
@@ -1796,6 +1849,8 @@ const main = async (command, flags) => {
         return commandBatch(flags);
     if (command[0] === "runs")
         return commandRuns(command, flags);
+    if (command[0] === "opencode")
+        return commandOpenCode(command, flags);
     if (command[0] === "ssh")
         return commandSSH(command, flags);
     if (command[0] === "ssh-proxy") {

package/dist/output.js

@@ -79,7 +79,10 @@ export const summarizeRun = (payload) => {
         run.provider_id ? `provider=${run.provider_id}` : "",
         run.model_id ? `model=${run.model_id}` : "",
         run.sandbox_state ? `sandbox=${run.sandbox_state}` : "",
-        run.snapshot_generation ? `snapshot=${run.snapshot_generation}` : ""
+        run.snapshot_generation ? `snapshot=${run.snapshot_generation}` : "",
+        run.email?.address ? `email=${run.email.address}` : run.email ? `email=${run.email.status}` : "",
+        run.channels?.telegram.enabled ? "telegram=enabled" : "",
+        run.supabase ? `supabase=${run.supabase.status}` : ""
     ].filter(Boolean).join(" ");
     return `${run.id} ${run.status}${selection ? ` ${selection}` : ""}${run.exit_code === null ? "" : ` exit=${run.exit_code}`}${run.error ? ` error=${run.error}` : ""}`;
 };

package/dist/runs.js

@@ -50,6 +50,12 @@ export const createRun = async (client, options) => {
         external_run_id: options.externalRunId,
         workload_id: options.templateId,
         instruction: options.instruction,
+        ...(options.supabaseUserId ? { supabase_user_id: options.supabaseUserId } : {}),
+        ...(options.emailAddress ? { email_address: options.emailAddress } : {}),
+        ...(options.telegramBotToken ? {
+            telegram_bot_token: options.telegramBotToken,
+            telegram_allowed_users: options.telegramAllowedUsers || []
+        } : {}),
         ...(inputCollectionId ? { input_collection_id: inputCollectionId } : {})
     });
 };
@@ -71,6 +77,7 @@ export const readTasks = async (tasksPath) => {
         return {
             task,
             external_run_id: record.external_run_id ? String(record.external_run_id) : undefined,
+            email_address: record.email_address ? String(record.email_address) : undefined,
             input: Array.isArray(record.input) ? record.input.map(String) : undefined
         };
     });

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.0.9";
+export const version = "0.0.11";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanlabs/sanbox-cli",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "private": false,
   "repository": {
     "type": "git",