@sanlabs/sanbox-cli 0.0.4 → 0.0.9

package/dist/cli.js

@@ -5,34 +5,42 @@ import { formatActivityJsonl, formatActivityLine, parseActivityView, shouldRende
 import { ArtifactExistsError, downloadArtifacts } from "./artifacts.js";
 import { booleanFlags, flagList, flagString, hasFlag, parseArgs } from "./args.js";
 import { SanboxApiError, SanboxClient } from "./api.js";
-import { defaultApiUrl, readConfig, readLocalConfig, readTemplateSelection } from "./config.js";
+import { defaultApiUrl, readConfig, readLocalConfig, readTemplateSelection, readUserConfig, resolveApiUrl } from "./config.js";
+import { loginWithBrowser, openBrowser, revokeUserSession } from "./deviceLogin.js";
 import { CliError, commandAction, consoleAction } from "./errors.js";
+import { parseFileAccessExpiry } from "./fileAccess.js";
 import { previewInputs } from "./inputs.js";
 import { printError, printJsonlError, printRun, printSuccess, publicRun, publicRunPayload } from "./output.js";
-import { createRun, isTerminalRun, readTasks, runPool, stableBatchId, waitForRun } from "./runs.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 { openSSH, runSSHProxy } from "./ssh.js";
+import { userSessionStore } from "./userSession.js";
 const help = `Sanbox CLI
 
 Environment:
   SANBOX_API_URL   Sanbox API base URL
-  SANBOX_ORG       Organization slug
-  SANBOX_API_KEY   Org API key
+  SANBOX_API_KEY   Org API key for automation (no interactive access)
   SANBOX_TEMPLATE  Explicit template id or slug for run and batch
 
 Commands:
   sanbox --version
+  sanbox login [--no-browser]
+  sanbox logout
   sanbox auth check [--json]
-  sanbox orgs list [--json]
   sanbox context [--json]
   sanbox doctor [--json]
   sanbox model-providers list [--json]
   sanbox model-providers get <provider-id> [--json]
   sanbox model-providers models <provider-id> [--json]
+  sanbox anthropic-environments list [--json]
+  sanbox anthropic-environments get <environment-id> [--json]
+  sanbox anthropic-environments connect <environment-id> [--json]
+  sanbox anthropic-environments disconnect <environment-id> --force [--json]
   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> [--llm-budget-usd <amount>] [--web-access] [--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 batch --tasks tasks.json --template <template-id> [--input <path>] [--max-parallel 5] [--wait] [--json]
@@ -41,13 +49,30 @@ Commands:
   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]
+  sanbox runs unshare <run-id> <access-point-id> [--json]
   sanbox runs download <run-id> --output <directory> [--artifact <path>] [--overwrite] [--json]
   sanbox runs watch <run-id> [--after-event-id 0] [--view activity|logs|compact] [--jsonl]
   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 ssh <run-id>
   sanbox init [--force]
   sanbox init agent [--write]
 `;
+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
+organization admins can connect; organization API keys cannot open interactive sessions. The guest
+does not expose port 22 publicly.
+`;
 const runHelp = `Sanbox run
 
 Usage:
@@ -58,7 +83,6 @@ 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.
-  --retention-ttl-seconds <n>   Workspace retention TTL. Default: 86400.
   --dry-run                     Preview included files without creating a run.
   --wait                        Poll until terminal status.
   --watch                       Stream activity until terminal status.
@@ -73,7 +97,7 @@ const doctorHelp = `Sanbox doctor
 Usage:
   sanbox doctor [--json]
 
-Checks local configuration, API health, auth, org visibility, and template access.
+Checks local configuration, API health, auth, organization discovery, and template access.
 SANBOX_API_KEY is still read only from the environment.
 `;
 const modelProvidersHelp = `Sanbox model providers
@@ -86,32 +110,59 @@ Usage:
 Provider credentials are configured by organization admins in the Sanbox console.
 Model ids are scoped to their provider and are never deduplicated across providers.
 `;
+const anthropicEnvironmentsHelp = `Sanbox Anthropic environments
+
+Usage:
+  sanbox anthropic-environments list [--json]
+  sanbox anthropic-environments get <environment-id> [--json]
+  ANTHROPIC_ENVIRONMENT_KEY=<key> sanbox anthropic-environments connect <environment-id> [--json]
+  sanbox anthropic-environments disconnect <environment-id> --force [--json]
+
+Create the self-hosted environment and generate its environment key in Claude Console first.
+The connect command reads the key only from ANTHROPIC_ENVIRONMENT_KEY so it does not enter argv.
+Connect, key replacement, and disconnect require an organization-admin user session or operator
+credential. Organization-scoped member API keys can list and inspect environments but cannot
+manage their credentials.
+`;
 const templatesHelp = `Sanbox templates
 
 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> [--llm-budget-usd <amount>] [--web-access] [--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]
 
 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.
+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,
+--browser-vision-mode auto|always|never, --browser-viewport WIDTHxHEIGHT,
+--browser-download-policy allow|deny, and --browser-additional-instructions.
 `;
 const agentInstructions = `# Operate Sanbox Autonomously
 
 Use the \`sanbox\` CLI for focused, isolated, long-running, risky, or parallel work. The canonical
-protocol is https://console.sanbox.cloud/agent.md. This workflow requires CLI 0.0.4 or newer.
+protocol is https://console.sanbox.cloud/agent.md.
+
+Always use the latest published CLI. Install and verify it at the start of every operating session:
+\`\`\`bash
+npm install -g @sanlabs/sanbox-cli@latest
+latest_cli_version="$(npm view @sanlabs/sanbox-cli version)"
+installed_cli_version="$(sanbox --version)"
+test "$installed_cli_version" = "$latest_cli_version"
+\`\`\`
 
 Human bootstrap:
-- A human/admin supplies SANBOX_API_KEY and configures provider credentials plus a runnable template.
+- A human/admin supplies an organization-scoped SANBOX_API_KEY and configures provider credentials plus a runnable template.
 - Never print, persist, prompt with, or upload API keys or provider credentials.
 - If the key or a runnable template is unavailable, stop with the exact human action required.
 
 Deterministic startup:
 \`\`\`bash
 sanbox --version
-sanbox orgs list --json
-export SANBOX_ORG=<returned-org-slug>
 sanbox auth check --json
 sanbox context --json
 sanbox templates list --json
@@ -120,8 +171,12 @@ sanbox templates validate "$SANBOX_TEMPLATE" --json
 sanbox doctor --json
 \`\`\`
 
-Never guess opaque IDs. Select a discovered org/template automatically only when exactly one valid
-choice exists; otherwise ask the user. Provider credentials and template administration are
+Never guess opaque IDs. The CLI derives the organization from the API key and requires the key to
+resolve to exactly one organization. For task execution, select only a template with runnable: true,
+template_type: "runner", and runner_config.harness: "opencode" or "browser-use". Select Browser Use
+only for a one-shot web task whose target domains are already approved on the template. Never select
+a Hermes service template for a waited task because it is always-on. Select automatically only when exactly one task
+template qualifies; otherwise ask the user. Provider credentials and template administration are
 console-only.
 
 Use --json for request/response commands and --jsonl for streams. Parse the versioned envelope:
@@ -139,7 +194,7 @@ sanbox run "Investigate one focused task and write output/report.md" \\
 
 Reuse the same --external-run-id after ambiguous failures. Retry network errors, HTTP 429, HTTP 5xx,
 and workspace_busy with bounded backoff. Do not retry other 4xx errors unless next_actions directs
-recovery.
+recovery. Terminal statuses are completed, failed, and canceled.
 
 Recover and retrieve results:
 \`\`\`bash
@@ -154,33 +209,53 @@ sanbox runs download <run-id> --output .sanbox/output/<run-id> --json
 Tasks must put durable files under /workspace/output. Downloads preserve relative paths and report
 byte counts plus SHA-256 digests; existing files require explicit --overwrite.
 
-Continue through the retained workspace:
+While a sandbox is running, create one read-only capability URL for its entire root filesystem:
 \`\`\`bash
-sanbox runs messages <run-id> --json
-sanbox runs message <run-id> "Summarize the retained output" --wait --json
+sanbox runs share <run-id> --expires 1h --json
+sanbox runs shares <run-id> --json
+sanbox runs unshare <run-id> <access-point-id> --json
 \`\`\`
+The URL starts at /, supports directory JSON with ?format=json, and stops working when the sandbox
+stops, the link expires, or it is revoked. Treat the URL as a bearer secret.
+
+Manage the retained sandbox independently of its agent harness:
+\`\`\`bash
+sanbox runs get <run-id> --json
+sanbox runs resume <run-id> --wait --json
+sanbox runs share <run-id> --expires 1h --json
+sanbox runs pause <run-id> --wait --json
+\`\`\`
+
+Resume restores the latest Firecracker snapshot without starting an agent command. It creates an
+exclusive manual lease and leaves the sandbox running until pause snapshots it again. Do not submit
+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.
 
-Follow-up waits are correlated to the returned chat_job.id. Keep dependent follow-ups sequential.
 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, artifact paths/digests,
-and blockers. The CLI excludes common secrets by default; add .sanboxignore for project rules.
+and required follow-ups succeeded. 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.
 `;
 const cwd = () => process.cwd();
 const makeClient = (flags) => new SanboxClient(readConfig(flags));
-const makeAuthClient = (flags) => new SanboxClient(readConfig(flags, { requireOrg: false }));
 const jsonContext = (client) => ({
     api_url: client.config.apiUrl,
-    org: client.config.org
+    ...(client.resolvedOrganizationSlug() ? { org: client.resolvedOrganizationSlug() } : {})
 });
 const localJsonContext = (flags) => {
     try {
         const local = readLocalConfig();
         const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || local.api_url || defaultApiUrl).replace(/\/+$/, "");
-        const org = String(flags.org || process.env.SANBOX_ORG || local.org || "").trim();
-        return { api_url: apiUrl, ...(org ? { org } : {}) };
+        return { api_url: apiUrl };
     }
     catch {
         return {};
@@ -188,10 +263,12 @@ const localJsonContext = (flags) => {
 };
 const consolePathUrl = (client, pathname) => new URL(pathname, `${client.config.apiUrl}/`).toString();
 const consoleUrl = (client) => consolePathUrl(client, "/model-providers");
+const anthropicEnvironmentsConsoleUrl = (client) => consolePathUrl(client, "/anthropic-environments");
 const providerConsoleAction = (client) => consoleAction(consoleUrl(client), "Ask an organization admin to configure or repair the model provider in the Sanbox console.");
 const templateAdminConsoleAction = (client) => consoleAction(consolePathUrl(client, "/templates"), "Ask an organization admin to create a template in the Sanbox console.");
+const anthropicEnvironmentAdminConsoleAction = (client) => consoleAction(anthropicEnvironmentsConsoleUrl(client), "Ask an organization admin to manage the Anthropic environment in the Sanbox console.");
 const templateActions = () => [
-    commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the selected organization."),
+    commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the API key's organization."),
     commandAction(["sanbox", "templates", "validate", "<template-id>", "--json"], "Check whether a template is runnable.")
 ];
 const runReadinessCodes = new Set([
@@ -256,6 +333,62 @@ const requiredPositional = (value, code, message) => {
         throw new CliError(code, message);
     return normalized;
 };
+const browserDomainPattern = /^(?:\*\.)?[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/;
+const parseBrowserDomains = (values) => {
+    const domains = [...new Set(values.map((value) => value.trim().toLowerCase().replace(/\.$/, "")))];
+    if (domains.length < 1) {
+        throw new CliError("browser_domain_required", "Browser Use template creation requires at least one --browser-domain.");
+    }
+    if (domains.length > 64 ||
+        domains.some((domain) => !browserDomainPattern.test(domain) ||
+            /^\d+(?:\.\d+){3}$/.test(domain.startsWith("*.") ? domain.slice(2) : domain))) {
+        throw new CliError("invalid_browser_domain", "--browser-domain must be a public hostname or leading wildcard such as example.com or *.example.com.");
+    }
+    return domains;
+};
+const optionalBrowserInteger = (flags, key, fallback, minimum, maximum) => {
+    if (flags[key] === undefined)
+        return fallback;
+    const value = Number(flagString(flags, key));
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new CliError("invalid_browser_use_config", `--${key} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return value;
+};
+const parseBrowserUseConfig = (flags) => {
+    const maxSteps = optionalBrowserInteger(flags, "browser-max-steps", 30, 1, 100);
+    const stepTimeout = optionalBrowserInteger(flags, "browser-step-timeout-seconds", 120, 30, 300);
+    const visionMode = flagString(flags, "browser-vision-mode", "auto");
+    if (visionMode !== "auto" && visionMode !== "always" && visionMode !== "never") {
+        throw new CliError("invalid_browser_use_config", "--browser-vision-mode must be auto, always, or never.");
+    }
+    const normalizedVisionMode = visionMode;
+    const downloadPolicy = flagString(flags, "browser-download-policy", "allow");
+    if (downloadPolicy !== "allow" && downloadPolicy !== "deny") {
+        throw new CliError("invalid_browser_use_config", "--browser-download-policy must be allow or deny.");
+    }
+    const normalizedDownloadPolicy = downloadPolicy;
+    const viewportRaw = flagString(flags, "browser-viewport", "1280x720").toLowerCase();
+    const viewportMatch = /^(\d{3,4})x(\d{3,4})$/.exec(viewportRaw);
+    const width = Number(viewportMatch?.[1]);
+    const height = Number(viewportMatch?.[2]);
+    if (!viewportMatch || width < 320 || width > 1920 || height < 480 || height > 1080) {
+        throw new CliError("invalid_browser_use_config", "--browser-viewport must be WIDTHxHEIGHT from 320x480 through 1920x1080.");
+    }
+    const additionalInstructions = flagString(flags, "browser-additional-instructions");
+    if (additionalInstructions.length > 4_000 ||
+        /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(additionalInstructions)) {
+        throw new CliError("invalid_browser_use_config", "--browser-additional-instructions must contain at most 4000 printable characters.");
+    }
+    return {
+        max_steps: maxSteps,
+        step_timeout_seconds: stepTimeout,
+        vision_mode: normalizedVisionMode,
+        viewport: { width, height },
+        download_policy: normalizedDownloadPolicy,
+        additional_instructions: additionalInstructions.trim()
+    };
+};
 const providerId = (provider) => String(provider.provider_id || provider.id || "");
 const templateName = (template) => String(template.display_name || template.template_slug || template.id || "");
 const validationRunnable = (validation) => {
@@ -273,43 +406,71 @@ const formatBytes = (bytes) => {
 };
 const positionalText = (command, startIndex) => command.slice(startIndex).join(" ").trim();
 const runTask = (command, flags) => flagString(flags, "task") || positionalText(command, 1);
-const commonFlags = ["api-url", "org", "json", "help"];
+const commonFlags = ["api-url", "json", "help"];
 const flagSets = {
     "auth.check": commonFlags,
-    "orgs.list": commonFlags,
     context: [...commonFlags, "template"],
     doctor: [...commonFlags, "template"],
     "model-providers.list": commonFlags,
     "model-providers.get": commonFlags,
     "model-providers.models": commonFlags,
+    "anthropic-environments.list": commonFlags,
+    "anthropic-environments.get": commonFlags,
+    "anthropic-environments.connect": commonFlags,
+    "anthropic-environments.disconnect": [...commonFlags, "force"],
     "templates.list": commonFlags,
     "templates.get": commonFlags,
     "templates.validate": commonFlags,
-    "templates.create": [...commonFlags, "name", "model-provider", "model", "llm-budget-usd", "web-access"],
+    "templates.create": [
+        ...commonFlags,
+        "name",
+        "model-provider",
+        "model",
+        "harness",
+        "llm-budget-usd",
+        "web-access",
+        "telegram-allowed-user",
+        "browser-domain",
+        "browser-max-steps",
+        "browser-step-timeout-seconds",
+        "browser-vision-mode",
+        "browser-viewport",
+        "browser-download-policy",
+        "browser-additional-instructions"
+    ],
     run: [
-        ...commonFlags, "task", "input", "template", "external-run-id", "retention-ttl-seconds",
+        ...commonFlags, "task", "input", "template", "external-run-id",
         "dry-run", "wait", "watch", "jsonl", "view", "after-event-id", "cancel-on-interrupt",
         "poll-interval-ms", "event-page-size", "timeout-seconds", "verbose"
     ],
     batch: [
         ...commonFlags, "tasks", "template", "input", "max-parallel", "wait", "batch-id",
-        "retention-ttl-seconds", "poll-interval-ms", "timeout-seconds"
+        "poll-interval-ms", "timeout-seconds"
     ],
     "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,
+    "runs.unshare": commonFlags,
     "runs.download": [...commonFlags, "output", "artifact", "overwrite"],
     "runs.watch": [
         ...commonFlags, "after-event-id", "view", "jsonl", "cancel-on-interrupt",
         "poll-interval-ms", "event-page-size", "timeout-seconds"
     ],
     "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"
     ],
+    ssh: ["api-url", "help"],
+    "ssh-proxy": [],
+    login: ["api-url", "json", "no-browser", "help"],
+    logout: ["api-url", "json", "help"],
     init: [...commonFlags, "force", "template"],
     "init.agent": [...commonFlags, "write"],
     version: ["json", "help"]
@@ -321,9 +482,10 @@ const commandKey = (command) => {
         return "version";
     if (command[0] === "auth")
         return `auth.${command[1] || ""}`;
-    if (command[0] === "orgs")
-        return `orgs.${command[1] || ""}`;
-    if (command[0] === "model-providers" || command[0] === "templates" || command[0] === "runs") {
+    if (command[0] === "model-providers" ||
+        command[0] === "anthropic-environments" ||
+        command[0] === "templates" ||
+        command[0] === "runs") {
         return `${command[0]}.${command[1] || ""}`;
     }
     if (command[0] === "init" && command[1] === "agent")
@@ -331,10 +493,14 @@ const commandKey = (command) => {
     return command[0];
 };
 const requiredValueFlags = new Set([
-    "api-url", "org", "template", "task", "input", "include", "external-run-id",
-    "retention-ttl-seconds", "tasks", "max-parallel", "batch-id", "poll-interval-ms",
+    "api-url", "template", "task", "input", "include", "external-run-id",
+    "tasks", "max-parallel", "batch-id", "poll-interval-ms",
     "event-page-size", "timeout-seconds", "view", "after-event-id", "limit", "name",
-    "model-provider", "model", "llm-budget-usd", "message", "output", "artifact"
+    "model-provider", "model", "harness", "llm-budget-usd", "telegram-allowed-user",
+    "browser-domain", "browser-max-steps", "browser-step-timeout-seconds",
+    "browser-vision-mode", "browser-viewport", "browser-download-policy",
+    "browser-additional-instructions", "expires",
+    "message", "output", "artifact"
 ]);
 const validateFlagValues = (flags) => {
     for (const flag of requiredValueFlags) {
@@ -372,8 +538,8 @@ const validateFlags = (command, flags) => {
         return;
     }
     const knownRoots = new Set([
-        "auth", "orgs", "context", "doctor", "model-providers", "templates",
-        "run", "batch", "runs", "init", "version"
+        "auth", "context", "doctor", "model-providers", "anthropic-environments", "templates",
+        "run", "batch", "runs", "ssh", "ssh-proxy", "login", "logout", "init", "version"
     ]);
     const allowed = flagSets[key] ?? (knownRoots.has(command[0] || "") ? commonFlags : null);
     if (!allowed)
@@ -388,12 +554,15 @@ const validatePositionals = (command, flags) => {
         return;
     const maximums = {
         "auth.check": 2,
-        "orgs.list": 2,
         context: 1,
         doctor: 1,
         "model-providers.list": 2,
         "model-providers.get": 3,
         "model-providers.models": 3,
+        "anthropic-environments.list": 2,
+        "anthropic-environments.get": 3,
+        "anthropic-environments.connect": 3,
+        "anthropic-environments.disconnect": 3,
         "templates.list": 2,
         "templates.get": 3,
         "templates.validate": 3,
@@ -404,9 +573,18 @@ const validatePositionals = (command, flags) => {
         "runs.events": 3,
         "runs.messages": 3,
         "runs.artifacts": 3,
+        "runs.share": 3,
+        "runs.shares": 3,
+        "runs.unshare": 4,
         "runs.download": 3,
         "runs.watch": 3,
         "runs.cancel": 3,
+        "runs.resume": 3,
+        "runs.pause": 3,
+        ssh: 2,
+        "ssh-proxy": 1,
+        login: 1,
+        logout: 1,
         init: 1,
         "init.agent": 2,
         version: 1
@@ -533,8 +711,7 @@ const commandRun = async (command, flags) => {
             instruction: task,
             inputs: flagList(flags, "input"),
             externalRunId: flagString(flags, "external-run-id") || undefined,
-            templateId: template.id,
-            retentionTtlSeconds: integerFlag(flags, "retention-ttl-seconds", 86400, 0, Number.MAX_SAFE_INTEGER)
+            templateId: template.id
         });
     }
     catch (error) {
@@ -587,8 +764,7 @@ const commandBatch = async (flags) => {
                 instruction: task.task,
                 inputs: task.input || inputs,
                 externalRunId: task.external_run_id || `sanbox-batch-${batchId}-${index + 1}`,
-                templateId: template.id,
-                retentionTtlSeconds: integerFlag(flags, "retention-ttl-seconds", 86400, 0, Number.MAX_SAFE_INTEGER)
+                templateId: template.id
             });
         }
         catch (error) {
@@ -617,50 +793,28 @@ const commandBatch = async (flags) => {
 };
 const commandAuthCheck = async (flags) => {
     const client = makeClient(flags);
-    const me = await client.me();
-    const org = client.config.org;
-    const organizations = Array.isArray(me.organizations)
-        ? me.organizations
-        : [];
-    const selected = organizations.find((item) => item.slug === org) || null;
-    const output = { ok: Boolean(selected), org, selected, me };
+    const [me, selected] = await Promise.all([client.me(), client.organization()]);
+    const org = selected.slug;
+    const output = { ok: true, org, selected, me };
     if (hasFlag(flags, "json"))
         printSuccess("auth.check", output, jsonContext(client));
     else
-        process.stdout.write(selected ? `ok org=${org}\n` : `authenticated, but org ${org} is not visible\n`);
-    if (!selected)
-        process.exitCode = 2;
-};
-const commandOrganizations = async (command, flags) => {
-    if (command[1] !== "list")
-        throw new CliError("orgs_action_required", "orgs requires the list action.");
-    const client = makeAuthClient(flags);
-    const payload = await client.listOrganizations();
-    if (hasFlag(flags, "json")) {
-        printSuccess("orgs.list", payload, { api_url: client.config.apiUrl });
-        return;
-    }
-    for (const organization of payload.organizations) {
-        process.stdout.write(`${organization.slug}${organization.name ? `\t${organization.name}` : ""}${organization.membership_role ? `\t${organization.membership_role}` : ""}\n`);
-    }
+        process.stdout.write(`ok org=${org}\n`);
 };
 const commandContext = async (flags) => {
     const client = makeClient(flags);
     const selection = readTemplateSelection(flags, { required: false });
-    const [me, providerPayload, templatePayload] = await Promise.all([
+    const [organization, me, providerPayload, templatePayload] = await Promise.all([
+        client.organization(),
         client.me(),
         client.listModelProviders(),
         client.listTemplates()
     ]);
-    const organizations = Array.isArray(me.organizations)
-        ? me.organizations
-        : [];
-    const selectedOrganization = organizations.find((item) => item.slug === client.config.org) || null;
     const selectedTemplate = selection
         ? templatePayload.templates.find((item) => item.id === selection.id || item.template_slug === selection.id) || null
         : null;
     const output = {
-        organization: selectedOrganization,
+        organization,
         authentication: me.auth || null,
         template_selection: selection
             ? { id: selection.id, source: selection.source, found: Boolean(selectedTemplate), template: selectedTemplate }
@@ -669,22 +823,17 @@ const commandContext = async (flags) => {
         templates: templatePayload.templates
     };
     const nextActions = [];
-    if (!selectedOrganization) {
-        nextActions.push(commandAction(["sanbox", "auth", "check", "--json"], "Verify that the API key can access the selected organization."));
-    }
     if (!selection) {
         nextActions.push(commandAction(["sanbox", "templates", "list", "--json"], "List available templates."), commandAction(["sanbox", "context", "--json"], "Select a template for this shell and inspect the resolved context.", { SANBOX_TEMPLATE: "<template-id>" }));
     }
     else if (!selectedTemplate) {
         nextActions.push(commandAction(["sanbox", "templates", "list", "--json"], "Choose a template that exists in this organization."));
     }
-    if (!selectedOrganization)
-        process.exitCode = 2;
     if (hasFlag(flags, "json")) {
         printSuccess("context.get", output, jsonContext(client), nextActions);
         return;
     }
-    process.stdout.write(`org=${client.config.org}\n`);
+    process.stdout.write(`org=${organization.slug}\n`);
     process.stdout.write(`template=${selection ? `${selection.id} source=${selection.source}${selectedTemplate ? "" : " missing"}` : "not selected"}\n`);
     process.stdout.write(`model_providers=${providerPayload.providers.map((item) => providerId(item)).filter(Boolean).join(",") || "none"}\n`);
     process.stdout.write(`templates=${templatePayload.templates.map((item) => item.template_slug || item.id).join(",") || "none"}\n`);
@@ -725,7 +874,8 @@ 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}` : ""}\n`);
+        process.stdout.write(`${providerId(payload.provider)}${payload.provider.status ? ` ${payload.provider.status}` : ""}` +
+            `${payload.provider.base_url ? ` base_url=${payload.provider.base_url}` : ""}\n`);
         return;
     }
     if (action === "models") {
@@ -760,6 +910,125 @@ const commandModelProviders = async (command, flags) => {
     }
     throw new CliError("model_providers_action_required", "model-providers requires an action: list, get, or models.");
 };
+const anthropicEnvironmentIdPattern = /^env_[A-Za-z0-9_-]{1,196}$/;
+const requiredAnthropicEnvironmentId = (value, action) => {
+    const environmentId = requiredPositional(value, "anthropic_environment_required", `anthropic-environments ${action} requires an environment id.`);
+    if (!anthropicEnvironmentIdPattern.test(environmentId)) {
+        throw new CliError("invalid_anthropic_environment", "The environment id must start with env_ and contain only letters, numbers, underscores, or hyphens.");
+    }
+    return environmentId;
+};
+const anthropicEnvironmentError = (error, client, environmentId) => {
+    if (!(error instanceof SanboxApiError))
+        return error;
+    if (error.status === 403) {
+        return new CliError(error.code, error.message, {
+            status: error.status,
+            details: { environment_id: environmentId },
+            nextActions: [anthropicEnvironmentAdminConsoleAction(client)]
+        });
+    }
+    if (error.status === 404) {
+        return new CliError("anthropic_environment_not_found", error.message, {
+            status: error.status,
+            details: { environment_id: environmentId },
+            nextActions: [commandAction(["sanbox", "anthropic-environments", "list", "--json"], "List Anthropic environments connected to this organization.")]
+        });
+    }
+    return error;
+};
+const commandAnthropicEnvironments = async (command, flags) => {
+    const client = makeClient(flags);
+    const action = command[1];
+    if (action === "list") {
+        const payload = await client.listAnthropicEnvironments();
+        const nextActions = payload.environments.length === 0
+            ? [anthropicEnvironmentAdminConsoleAction(client)]
+            : [];
+        if (hasFlag(flags, "json")) {
+            printSuccess("anthropic_environments.list", payload, jsonContext(client), nextActions);
+            return;
+        }
+        for (const environment of payload.environments) {
+            process.stdout.write(`${environment.environment_id}\t${environment.status}` +
+                `\tworker=${environment.assigned_worker_id || "unassigned"}` +
+                `\tverified=${environment.last_verified_at || "never"}\n`);
+        }
+        return;
+    }
+    if (action === "get") {
+        const environmentId = requiredAnthropicEnvironmentId(command[2], action);
+        let payload;
+        try {
+            payload = await client.getAnthropicEnvironment(environmentId);
+        }
+        catch (error) {
+            throw anthropicEnvironmentError(error, client, environmentId);
+        }
+        if (hasFlag(flags, "json")) {
+            printSuccess("anthropic_environments.get", payload, jsonContext(client));
+            return;
+        }
+        const environment = payload.environment;
+        process.stdout.write(`${environment.environment_id} ${environment.status}` +
+            ` worker=${environment.assigned_worker_id || "unassigned"}` +
+            ` verified=${environment.last_verified_at || "never"}\n`);
+        return;
+    }
+    if (action === "connect") {
+        const environmentId = requiredAnthropicEnvironmentId(command[2], action);
+        const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY?.trim() || "";
+        if (!environmentKey) {
+            throw new CliError("anthropic_environment_key_required", "ANTHROPIC_ENVIRONMENT_KEY is required for anthropic-environments connect.", {
+                details: { environment_id: environmentId },
+                nextActions: [commandAction(["sanbox", "anthropic-environments", "connect", environmentId, "--json"], "Connect or replace the environment key without placing the secret in argv.", { ANTHROPIC_ENVIRONMENT_KEY: "<environment-key>" })]
+            });
+        }
+        if (environmentKey.length < 16 ||
+            environmentKey.length > 20_000 ||
+            /[\r\n\u0000]/.test(environmentKey)) {
+            throw new CliError("invalid_anthropic_environment_key", "ANTHROPIC_ENVIRONMENT_KEY must be a single-line Anthropic environment credential.");
+        }
+        let payload;
+        try {
+            payload = await client.connectAnthropicEnvironment(environmentId, environmentKey);
+        }
+        catch (error) {
+            throw anthropicEnvironmentError(error, client, environmentId);
+        }
+        const nextActions = [commandAction(["sanbox", "anthropic-environments", "get", environmentId, "--json"], "Check whether the first authenticated queue poll connected the environment.")];
+        if (hasFlag(flags, "json")) {
+            printSuccess("anthropic_environments.connect", payload, jsonContext(client), nextActions);
+            return;
+        }
+        process.stdout.write(`${payload.environment.environment_id} ${payload.environment.status}` +
+            ` key=${payload.environment.key_hint || "stored"}\n`);
+        return;
+    }
+    if (action === "disconnect") {
+        const environmentId = requiredAnthropicEnvironmentId(command[2], action);
+        if (!hasFlag(flags, "force")) {
+            throw new CliError("confirmation_required", "anthropic-environments disconnect requires --force.", {
+                details: { environment_id: environmentId },
+                nextActions: [commandAction(["sanbox", "anthropic-environments", "disconnect", environmentId, "--force", "--json"], "Disconnect the environment while preserving its session workspace mappings.")]
+            });
+        }
+        let payload;
+        try {
+            payload = await client.disconnectAnthropicEnvironment(environmentId);
+        }
+        catch (error) {
+            throw anthropicEnvironmentError(error, client, environmentId);
+        }
+        if (hasFlag(flags, "json")) {
+            printSuccess("anthropic_environments.disconnect", payload, jsonContext(client));
+            return;
+        }
+        process.stdout.write(`${payload.environment_id} ${payload.disconnected ? "disconnected" : "not found"}\n`);
+        return;
+    }
+    throw new CliError("anthropic_environments_action_required", "anthropic-environments requires an action: list, get, connect, or disconnect.");
+};
 const commandTemplates = async (command, flags) => {
     const client = makeClient(flags);
     const action = command[1];
@@ -767,7 +1036,7 @@ const commandTemplates = async (command, flags) => {
         const payload = await client.listTemplates();
         const nextActions = payload.templates.length === 0
             ? [
-                commandAction(["sanbox", "context", "--json"], "Inspect the selected organization and current authentication role."),
+                commandAction(["sanbox", "context", "--json"], "Inspect the API key's organization and current authentication role."),
                 templateAdminConsoleAction(client)
             ]
             : [];
@@ -791,7 +1060,7 @@ const commandTemplates = async (command, flags) => {
                 throw new CliError("template_not_found", error.message, {
                     status: error.status,
                     details: { template_id: id },
-                    nextActions: [commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the selected organization.")]
+                    nextActions: [commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the API key's organization.")]
                 });
             }
             throw error;
@@ -814,7 +1083,7 @@ const commandTemplates = async (command, flags) => {
                 throw new CliError("template_validation_failed", error.message, {
                     status: error.status,
                     details: { template_id: id },
-                    nextActions: [commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the selected organization.")]
+                    nextActions: [commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the API key's organization.")]
                 });
             }
             throw error;
@@ -835,6 +1104,10 @@ const commandTemplates = async (command, flags) => {
         const name = requiredPositional(flagString(flags, "name"), "template_name_required", "templates create requires --name.");
         const modelProvider = requiredPositional(flagString(flags, "model-provider"), "model_provider_required", "templates create requires --model-provider.");
         const model = requiredPositional(flagString(flags, "model"), "model_required", "templates create requires --model.");
+        const harness = flagString(flags, "harness", "opencode");
+        if (harness !== "opencode" && harness !== "hermes" && harness !== "browser-use") {
+            throw new CliError("invalid_harness", "templates create --harness must be opencode, hermes, or browser-use.");
+        }
         const budgetRaw = flagString(flags, "llm-budget-usd");
         const parsedBudgetUsd = budgetRaw ? Number(budgetRaw) : undefined;
         const llmBudgetUsd = parsedBudgetUsd === undefined
@@ -844,14 +1117,67 @@ const commandTemplates = async (command, flags) => {
             (!Number.isFinite(parsedBudgetUsd) || llmBudgetUsd <= 0 || llmBudgetUsd > 100_000)) {
             throw new CliError("invalid_llm_budget", "templates create --llm-budget-usd must be at least 0.000001 and no more than 100000.");
         }
+        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 browserFlagNames = [
+            "browser-domain",
+            "browser-max-steps",
+            "browser-step-timeout-seconds",
+            "browser-vision-mode",
+            "browser-viewport",
+            "browser-download-policy",
+            "browser-additional-instructions"
+        ];
+        if (harness !== "browser-use" && browserFlagNames.some((name) => flags[name] !== undefined)) {
+            throw new CliError("browser_use_config_requires_browser_use", "Browser settings require --harness browser-use.");
+        }
+        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.");
+        }
+        const browserDomains = harness === "browser-use"
+            ? parseBrowserDomains(flagList(flags, "browser-domain"))
+            : [];
+        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.");
+        }
         let payload;
         try {
             payload = await client.createTemplate({
                 name,
                 provider_id: modelProvider,
                 model_id: model,
-                web_access: hasFlag(flags, "web-access"),
-                ...(llmBudgetUsd === undefined ? {} : { llm_budget_usd: llmBudgetUsd })
+                ...(llmBudgetUsd === undefined ? {} : { llm_budget_usd: llmBudgetUsd }),
+                ...(harness === "browser-use" ? {
+                    harness,
+                    browser_use: browserUse,
+                    network_policy: {
+                        default_action: "deny",
+                        rules: browserDomains.map((destination) => ({
+                            destination,
+                            ports: [
+                                { from: 80, to: 80 },
+                                { from: 443, to: 443 }
+                            ]
+                        }))
+                    }
+                } : {}),
+                ...(harness === "hermes" ? {
+                    harness,
+                    telegram_bot_token: telegramBotToken,
+                    telegram_allowed_users: telegramAllowedUsers
+                } : {})
             });
         }
         catch (error) {
@@ -860,7 +1186,9 @@ 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", "<task>", "--template", payload.template.id], "Create a run with the new template.")
+                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."
+                    : "Create a run with the new template.")
             ]);
             return;
         }
@@ -926,6 +1254,43 @@ const commandRuns = async (command, flags) => {
         }
         return;
     }
+    if (action === "share") {
+        const expiresInSeconds = parseFileAccessExpiry(flagString(flags, "expires", "1h"));
+        const name = flagString(flags, "name").trim();
+        const payload = await client.createFileAccessPoint(runId, {
+            expires_in_seconds: expiresInSeconds,
+            ...(name ? { name } : {})
+        });
+        if (hasFlag(flags, "json")) {
+            printSuccess("runs.share", payload, jsonContext(client), [
+                commandAction(["sanbox", "runs", "unshare", runId, payload.access_point.id, "--json"], "Revoke this root filesystem link.")
+            ]);
+            return;
+        }
+        process.stdout.write(`${payload.url}\n`);
+        return;
+    }
+    if (action === "shares") {
+        const payload = await client.listFileAccessPoints(runId);
+        if (hasFlag(flags, "json")) {
+            printSuccess("runs.shares", payload, jsonContext(client));
+            return;
+        }
+        for (const accessPoint of payload.access_points) {
+            process.stdout.write(`${accessPoint.id}\t${accessPoint.status}\t${accessPoint.expires_at}\t${accessPoint.name}\n`);
+        }
+        return;
+    }
+    if (action === "unshare") {
+        const accessPointId = requiredPositional(command[3], "file_access_point_id_required", "runs unshare requires an access point id.");
+        const payload = await client.revokeFileAccessPoint(runId, accessPointId);
+        if (hasFlag(flags, "json")) {
+            printSuccess("runs.unshare", payload, jsonContext(client));
+            return;
+        }
+        process.stdout.write(`revoked ${payload.access_point.id}\n`);
+        return;
+    }
     if (action === "download") {
         const outputDirectory = requiredPositional(flagString(flags, "output"), "output_directory_required", "runs download requires --output.");
         const payload = await client.listArtifacts(runId);
@@ -992,7 +1357,29 @@ const commandRuns = async (command, flags) => {
             printRun(payload);
         return;
     }
+    if (action === "resume" || action === "pause") {
+        const submitted = action === "resume"
+            ? await client.resumeRun(runId)
+            : await client.pauseRun(runId);
+        const payload = hasFlag(flags, "wait")
+            ? await waitForSandboxState(client, runId, action === "resume" ? "running" : "paused", {
+                pollIntervalMs: integerFlag(flags, "poll-interval-ms", 2000, 250, 60_000),
+                timeoutSeconds: integerFlag(flags, "timeout-seconds", 1800, 1, 604_800)
+            })
+            : submitted;
+        if (hasFlag(flags, "json")) {
+            printSuccess(`runs.${action}`, publicRunPayload(payload), jsonContext(client));
+        }
+        else if (hasFlag(flags, "wait")) {
+            printRun(payload);
+        }
+        else {
+            process.stdout.write(`sandbox ${action} requested for run ${runId}\n`);
+        }
+        return;
+    }
     if (action === "message") {
+        const commandName = "runs.message";
         const flaggedMessage = flagString(flags, "message");
         const positionalMessage = positionalText(command, 3);
         if (flaggedMessage && positionalMessage) {
@@ -1000,7 +1387,7 @@ const commandRuns = async (command, flags) => {
         }
         const message = flaggedMessage || positionalMessage;
         if (!message)
-            throw new Error("--message or a positional message is required.");
+            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.");
         }
@@ -1010,14 +1397,14 @@ const commandRuns = async (command, flags) => {
         const submitted = await client.sendMessage(runId, message);
         if (!hasFlag(flags, "wait") && !wantsWatch(flags)) {
             if (hasFlag(flags, "json")) {
-                printSuccess("runs.message", {
+                printSuccess(commandName, {
                     ...publicRunPayload(submitted),
                     message: submitted.message,
                     chat_job: submitted.chat_job
                 }, jsonContext(client));
             }
             else
-                process.stdout.write(`queued follow-up for run ${runId}\n`);
+                process.stdout.write(`queued OpenCode follow-up for run ${runId}\n`);
             return;
         }
         const chatJobId = submitted.chat_job.id;
@@ -1064,7 +1451,7 @@ const commandRuns = async (command, flags) => {
             });
             const messages = await client.listMessages(runId);
             if (hasFlag(flags, "json")) {
-                printSuccess("runs.message", {
+                printSuccess(commandName, {
                     ...publicRunPayload(submitted),
                     message: submitted.message,
                     chat_job: submitted.chat_job,
@@ -1096,9 +1483,23 @@ const commandRuns = async (command, flags) => {
 const commandDoctor = async (flags) => {
     const localConfig = readLocalConfig();
     const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || localConfig.api_url || defaultApiUrl).replace(/\/+$/, "");
-    const org = String(flags.org || process.env.SANBOX_ORG || localConfig.org || "").trim();
-    const apiKey = process.env.SANBOX_API_KEY || "";
+    const environmentApiKey = process.env.SANBOX_API_KEY || "";
+    let savedUserSession = null;
+    if (!environmentApiKey) {
+        try {
+            savedUserSession = userSessionStore.read(apiUrl);
+            if (savedUserSession && Date.parse(savedUserSession.expiresAt) <= Date.now()) {
+                userSessionStore.delete(apiUrl);
+                savedUserSession = null;
+            }
+        }
+        catch {
+            savedUserSession = null;
+        }
+    }
+    const apiKey = environmentApiKey || savedUserSession?.accessToken || "";
     const selection = readTemplateSelection(flags, { required: false });
+    let resolvedOrg = "";
     const checks = [];
     const nextActions = [];
     const add = (name, ok, detail, data) => checks.push({
@@ -1109,13 +1510,13 @@ const commandDoctor = async (flags) => {
     });
     add("node", Number(process.versions.node.split(".")[0]) >= 20, process.version);
     add("api_url", Boolean(apiUrl), apiUrl);
-    add("org", Boolean(org), org || "missing SANBOX_ORG, --org, or .sanbox/config.json org");
-    add("api_key", Boolean(apiKey), apiKey ? "present in environment" : "missing SANBOX_API_KEY");
-    if (!org) {
-        nextActions.push(commandAction(["sanbox", "doctor", "--json"], "Select an organization and run the checks again.", { SANBOX_ORG: "<org-slug>" }));
-    }
+    add("authentication", Boolean(apiKey), environmentApiKey
+        ? "organization API key present in environment"
+        : savedUserSession
+            ? `signed in as ${savedUserSession.email}`
+            : "not signed in");
     if (!apiKey) {
-        nextActions.push(commandAction(["sanbox", "doctor", "--json"], "Set a Sanbox control-plane API key and run the checks again.", { SANBOX_API_KEY: "<sanbox-api-key>" }));
+        nextActions.push(commandAction(["sanbox", "login"], "Sign in with your Sanbox user account."));
     }
     try {
         const res = await fetch(`${apiUrl}/health`);
@@ -1124,50 +1525,50 @@ const commandDoctor = async (flags) => {
     catch (error) {
         add("api_health", false, error instanceof Error ? error.message : String(error));
     }
-    if (org && apiKey) {
-        const client = new SanboxClient({ apiUrl, org, apiKey });
+    if (apiKey) {
+        const client = new SanboxClient({ apiUrl, apiKey });
         try {
-            const me = await client.me();
-            const organizations = Array.isArray(me.organizations)
-                ? me.organizations
-                : [];
+            const organization = await client.organization();
+            resolvedOrg = organization.slug;
             add("auth", true, "authenticated");
-            add("org_visible", organizations.some((item) => item.slug === org), org);
+            add("organization", true, organization.slug, organization);
         }
         catch (error) {
             add("auth", false, error instanceof Error ? error.message : String(error));
         }
-        try {
-            const providers = await client.listModelProviders();
-            add("model_providers", true, providers.providers.map((item) => `${providerId(item)}:${item.status || (item.configured ? "configured" : "not_configured")}`).join(", ") || "none", providers.providers);
-        }
-        catch (error) {
-            add("model_providers", false, error instanceof Error ? error.message : String(error));
-        }
-        if (!selection) {
-            add("template", false, "not selected; use --template, SANBOX_TEMPLATE, or .sanbox/config.json default_template");
-            nextActions.push(...templateActions());
-        }
-        else {
+        if (resolvedOrg) {
             try {
-                const template = await client.getTemplate(selection.id);
-                add("template", true, `${template.template.id}; source=${selection.source}`, template.template);
+                const providers = await client.listModelProviders();
+                add("model_providers", true, providers.providers.map((item) => `${providerId(item)}:${item.status || (item.configured ? "configured" : "not_configured")}`).join(", ") || "none", providers.providers);
+            }
+            catch (error) {
+                add("model_providers", false, error instanceof Error ? error.message : String(error));
+            }
+            if (!selection) {
+                add("template", false, "not selected; use --template, SANBOX_TEMPLATE, or .sanbox/config.json default_template");
+                nextActions.push(...templateActions());
+            }
+            else {
                 try {
-                    const validation = await client.validateTemplate(selection.id);
-                    const runnable = validationRunnable(validation);
-                    add("template_readiness", runnable, runnable ? "ready" : "blocked", validation);
-                    if (!runnable) {
-                        nextActions.push(commandAction(["sanbox", "model-providers", "list", "--json"], "Inspect model-provider status."), providerConsoleAction(client));
+                    const template = await client.getTemplate(selection.id);
+                    add("template", true, `${template.template.id}; source=${selection.source}`, template.template);
+                    try {
+                        const validation = await client.validateTemplate(selection.id);
+                        const runnable = validationRunnable(validation);
+                        add("template_readiness", runnable, runnable ? "ready" : "blocked", validation);
+                        if (!runnable) {
+                            nextActions.push(commandAction(["sanbox", "model-providers", "list", "--json"], "Inspect model-provider status."), providerConsoleAction(client));
+                        }
+                    }
+                    catch (error) {
+                        add("template_readiness", false, error instanceof Error ? error.message : String(error));
                     }
                 }
                 catch (error) {
-                    add("template_readiness", false, error instanceof Error ? error.message : String(error));
+                    add("template", false, error instanceof Error ? error.message : String(error));
+                    nextActions.push(...templateActions());
                 }
             }
-            catch (error) {
-                add("template", false, error instanceof Error ? error.message : String(error));
-                nextActions.push(...templateActions());
-            }
         }
     }
     try {
@@ -1183,7 +1584,7 @@ const commandDoctor = async (flags) => {
         checks
     };
     if (hasFlag(flags, "json")) {
-        printSuccess("doctor", output, { api_url: apiUrl, ...(org ? { org } : {}) }, nextActions);
+        printSuccess("doctor", output, { api_url: apiUrl, ...(resolvedOrg ? { org: resolvedOrg } : {}) }, nextActions);
     }
     else {
         for (const check of checks) {
@@ -1193,6 +1594,69 @@ const commandDoctor = async (flags) => {
     if (!output.ok)
         process.exitCode = 2;
 };
+const commandSSH = async (command, flags) => {
+    const runId = requiredPositional(command[1], "run_id_required", "ssh requires a run id.");
+    const client = new SanboxClient(readUserConfig(flags));
+    const exitCode = await openSSH(client, runId);
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
+};
+const commandLogin = async (flags) => {
+    const apiUrl = resolveApiUrl(flags);
+    const previousSession = userSessionStore.read(apiUrl);
+    const session = await loginWithBrowser({
+        apiUrl,
+        launchBrowser: hasFlag(flags, "no-browser") ? () => false : openBrowser,
+        onPrompt: (request, browserOpened) => {
+            process.stderr.write(`${browserOpened ? "Complete sign-in in your browser" : "Open this URL in your browser"}:\n` +
+                `${request.verification_url}\n\nConfirm code: ${request.user_code}\n`);
+        }
+    });
+    userSessionStore.write(session);
+    if (previousSession && previousSession.accessToken !== session.accessToken) {
+        try {
+            await revokeUserSession(apiUrl, previousSession.accessToken);
+        }
+        catch {
+            process.stderr.write("Warning: the previous local CLI session could not be revoked and will expire automatically.\n");
+        }
+    }
+    if (hasFlag(flags, "json")) {
+        printSuccess("auth.login", {
+            email: session.email,
+            organization: session.organization,
+            expires_at: session.expiresAt
+        }, { api_url: apiUrl, org: session.organization.slug });
+    }
+    else {
+        process.stdout.write(`Signed in as ${session.email} for ${session.organization.name}.\n`);
+    }
+};
+const commandLogout = async (flags) => {
+    const apiUrl = resolveApiUrl(flags);
+    const session = userSessionStore.read(apiUrl);
+    if (session) {
+        let revokeError = null;
+        try {
+            await revokeUserSession(apiUrl, session.accessToken);
+        }
+        catch (error) {
+            revokeError = error;
+        }
+        finally {
+            userSessionStore.delete(apiUrl);
+        }
+        if (revokeError) {
+            throw new CliError("logout_revoke_failed", "The local session was removed, but the server session could not be revoked and will expire automatically.");
+        }
+    }
+    if (hasFlag(flags, "json")) {
+        printSuccess("auth.logout", { signed_out: Boolean(session) }, { api_url: apiUrl });
+    }
+    else {
+        process.stdout.write(session ? "Signed out.\n" : "No saved Sanbox user session.\n");
+    }
+};
 const commandInit = async (command, flags) => {
     const dir = path.join(cwd(), ".sanbox");
     if (command[1] === "agent") {
@@ -1220,11 +1684,9 @@ const commandInit = async (command, flags) => {
     const force = hasFlag(flags, "force");
     const localConfig = readLocalConfig();
     const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || localConfig.api_url || defaultApiUrl).replace(/\/+$/, "");
-    const org = String(flags.org || process.env.SANBOX_ORG || localConfig.org || "").trim();
     const template = readTemplateSelection(flags, { required: false });
     const config = {
         api_url: apiUrl,
-        org,
         ...(template ? { default_template: template.id } : {})
     };
     const sanboxIgnore = [
@@ -1245,7 +1707,7 @@ const commandInit = async (command, flags) => {
         printSuccess("init", {
             files: results.map(([file, status]) => ({ file, status })),
             template_selection: template
-        }, { api_url: apiUrl, ...(org ? { org } : {}) }, template ? [] : templateActions());
+        }, { api_url: apiUrl }, template ? [] : templateActions());
     }
     else {
         for (const [file, status] of results)
@@ -1259,8 +1721,12 @@ const helpFor = (command) => {
         return doctorHelp;
     if (command[0] === "model-providers")
         return modelProvidersHelp;
+    if (command[0] === "anthropic-environments")
+        return anthropicEnvironmentsHelp;
     if (command[0] === "templates")
         return templatesHelp;
+    if (command[0] === "ssh")
+        return sshHelp;
     return help;
 };
 const commandId = (command) => {
@@ -1268,12 +1734,13 @@ const commandId = (command) => {
         return "version";
     if (command[0] === "auth")
         return "auth.check";
-    if (command[0] === "orgs")
-        return `orgs.${command[1] || "unknown"}`;
     if (command[0] === "context")
         return "context.get";
     if (command[0] === "model-providers")
         return `model_providers.${command[1] || "unknown"}`;
+    if (command[0] === "anthropic-environments") {
+        return `anthropic_environments.${command[1] || "unknown"}`;
+    }
     if (command[0] === "templates")
         return `templates.${command[1] || "unknown"}`;
     if (command[0] === "run")
@@ -1282,6 +1749,8 @@ const commandId = (command) => {
         return "batch.create";
     if (command[0] === "runs")
         return `runs.${command[1] || "unknown"}`;
+    if (command[0] === "ssh" || command[0] === "ssh-proxy")
+        return command[0];
     return command[0] || "help";
 };
 const main = async (command, flags) => {
@@ -1306,14 +1775,19 @@ const main = async (command, flags) => {
     }
     if (command[0] === "auth" && command[1] === "check")
         return commandAuthCheck(flags);
-    if (command[0] === "orgs")
-        return commandOrganizations(command, flags);
+    if (command[0] === "login")
+        return commandLogin(flags);
+    if (command[0] === "logout")
+        return commandLogout(flags);
     if (command[0] === "context")
         return commandContext(flags);
     if (command[0] === "doctor")
         return commandDoctor(flags);
     if (command[0] === "model-providers")
         return commandModelProviders(command, flags);
+    if (command[0] === "anthropic-environments") {
+        return commandAnthropicEnvironments(command, flags);
+    }
     if (command[0] === "templates")
         return commandTemplates(command, flags);
     if (command[0] === "run")
@@ -1322,6 +1796,14 @@ const main = async (command, flags) => {
         return commandBatch(flags);
     if (command[0] === "runs")
         return commandRuns(command, flags);
+    if (command[0] === "ssh")
+        return commandSSH(command, flags);
+    if (command[0] === "ssh-proxy") {
+        const exitCode = await runSSHProxy();
+        if (exitCode !== 0)
+            process.exitCode = exitCode;
+        return;
+    }
     if (command[0] === "init")
         return commandInit(command, flags);
     throw new CliError("unknown_command", `Unknown command: ${command.join(" ")}`);