@sanlabs/sanbox-cli 0.0.9 → 0.0.10

package/README.md

@@ -15,8 +15,9 @@ 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.10 adds per-run Hermes email and Telegram channels,
+Supabase user authorization, and removes the retired run-chat commands.
+CLI 0.0.9 added user login for private SSH access to running Hermes Computers.
 CLI 0.0.6 added Anthropic self-hosted environment inspection and administration.
 
 ## Configure
@@ -82,12 +83,26 @@ 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.
+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 +121,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 +141,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,8 +240,9 @@ 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
 
@@ -197,22 +258,8 @@ Ed25519 identity, pins the microVM's runtime host key, and tunnels the SSH strea
 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
-
-```bash
-sanbox runs messages <run-id> --json
-sanbox runs message <run-id> "Summarize the retained output" --wait --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.
-
-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.
+OpenCode and Browser Use runs are one-shot agent executions. Create a new run for additional agent
+work. A persisted sandbox can still be resumed manually for inspection when a snapshot exists.
 
 ## 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`));
     }

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] [--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,7 @@ 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 ssh <run-id>
   sanbox init [--force]
   sanbox init agent [--write]
@@ -83,6 +82,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 +95,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:
@@ -134,8 +148,8 @@ Usage:
 
 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.
+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 +245,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.
 `;
@@ -429,7 +437,7 @@ const flagSets = {
         "harness",
         "llm-budget-usd",
         "web-access",
-        "telegram-allowed-user",
+        "channel",
         "browser-domain",
         "browser-max-steps",
         "browser-step-timeout-seconds",
@@ -439,7 +447,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 +460,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 +472,7 @@ 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"],
     ssh: ["api-url", "help"],
     "ssh-proxy": [],
     login: ["api-url", "json", "no-browser", "help"],
@@ -482,6 +488,8 @@ 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] === "model-providers" ||
         command[0] === "anthropic-environments" ||
         command[0] === "templates" ||
@@ -493,14 +501,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", "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) {
@@ -571,7 +580,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 +589,7 @@ const validatePositionals = (command, flags) => {
         "runs.cancel": 3,
         "runs.resume": 3,
         "runs.pause": 3,
+        "runs.supabase": 4,
         ssh: 2,
         "ssh-proxy": 1,
         login: 1,
@@ -692,6 +701,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 +716,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 +743,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 +800,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 +911,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") {
@@ -1120,8 +1156,10 @@ 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);
+        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 +1175,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 +1185,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 {
@@ -1175,8 +1211,7 @@ const commandTemplates = async (command, flags) => {
                 } : {}),
                 ...(harness === "hermes" ? {
                     harness,
-                    telegram_bot_token: telegramBotToken,
-                    telegram_allowed_users: telegramAllowedUsers
+                    channels: channels
                 } : {})
             });
         }
@@ -1186,8 +1221,14 @@ 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>" : "<task>",
+                    "--template",
+                    payload.template.id
+                ], harness === "hermes"
+                    ? "Start the always-on computer and activate only the channels this run needs."
                     : "Create a run with the new template.")
             ]);
             return;
@@ -1215,6 +1256,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 +1290,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,106 +1425,6 @@ 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.");
-        }
-        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`);
-            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);
-            }
-            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);
-            if (hasFlag(flags, "json")) {
-                printSuccess(commandName, {
-                    ...publicRunPayload(submitted),
-                    message: submitted.message,
-                    chat_job: submitted.chat_job,
-                    messages: messages.messages,
-                    followup_event: terminalEvent
-                }, jsonContext(client));
-            }
-            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`);
-            }
-            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;
-        }
-        finally {
-            process.off("SIGINT", onInterrupt);
-        }
-        return;
-    }
     throw new Error(`Unknown runs action: ${action}`);
 };
 const commandDoctor = async (flags) => {
@@ -1717,6 +1664,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")
@@ -1747,6 +1696,9 @@ 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] === "ssh" || 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.10";

package/package.json

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