openrod 0.1.1 → 0.1.2-rc.2

package/server/launch-token.js

@@ -13,7 +13,7 @@ export const tokenUrl = (host, port, token) => `http://${host.includes(':') ? `[
 const digest = value => createHash('sha256').update(String(value)).digest()
 const isApi = pathname => pathname === '/api' || pathname.startsWith('/api/')
 
-export function createTokenGate(token) {
+export function createTokenGate(token, { onReuse = () => {} } = {}) {
   if (typeof token !== 'string' || token.length < 32) throw Error('A launch token of at least 32 characters is required')
   const expected = digest(token)
   const valid = value => typeof value === 'string' && value.length <= 256 && timingSafeEqual(digest(value), expected)
@@ -21,6 +21,26 @@ export function createTokenGate(token) {
     const prefix = `${tokenCookieName(req.socket?.localPort)}=`
     return (req.headers.cookie ?? '').split(';').map(part => part.trim()).filter(part => part.startsWith(prefix)).some(part => valid(part.slice(prefix.length)))
   }
+  // A browser OpenRod opens itself gets a one-time code instead of the token:
+  // the opener's arguments are visible to other local users, and on Linux a
+  // browser it starts keeps them for its whole life. Whoever uses the code
+  // first gets the cookie, so a second use is reported: someone else may have
+  // been first.
+  const codes = new Map(), spent = new Set()
+  const launchCode = () => {
+    const now = Date.now()
+    for (const [code, expires] of codes) if (expires <= now) codes.delete(code)
+    const code = createLaunchToken()
+    codes.set(code, now + 120_000)
+    return code
+  }
+  const spend = value => {
+    if (spent.has(value)) { onReuse(); return false }
+    const expires = codes.get(value)
+    if (expires === undefined) return false
+    codes.delete(value); spent.add(value)
+    return expires > Date.now()
+  }
   const denied = res => { res.writeHead(401, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); res.end(JSON.stringify({ error: 'Open the link printed by `openrod` in your terminal.', code: TOKEN_REQUIRED })) }
   // Handlers downstream also read the raw target, so a path the URL parser rewrites (dot segments, %2e) must never reach them.
   const rewritten = (req, pathname) => req.url.split('?', 1)[0] !== pathname
@@ -38,7 +58,7 @@ export function createTokenGate(token) {
     const location = `${url.pathname}${url.search}`
     res.writeHead(302, {
       Location: location.startsWith('//') ? '/' : location, 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer',
-      ...(valid(supplied) ? { 'Set-Cookie': `${tokenCookie(req.socket.localPort, token)}; Path=/; HttpOnly; SameSite=Strict` } : {}),
+      ...(valid(supplied) || spend(supplied) ? { 'Set-Cookie': `${tokenCookie(req.socket.localPort, token)}; Path=/; HttpOnly; SameSite=Strict` } : {}),
     }).end()
     return true
   }
@@ -51,5 +71,5 @@ export function createTokenGate(token) {
     socket.end(`HTTP/1.1 ${invalid ? '400 Bad Request' : '401 Unauthorized'}\r\nConnection: close\r\n\r\n`)
     return true
   }
-  return { allowed, http, upgrade }
+  return { allowed, http, upgrade, launchCode }
 }

package/server/openshell-cli.js

@@ -9,7 +9,7 @@ const DEFAULT_OUTPUT_LIMIT = 64 * 1024
 const SEARCH_DIRS = ['/opt/homebrew/bin', '/usr/local/bin', path.join(os.homedir(), '.local/bin')]
 
 export const fail = (message, status = 400) => Object.assign(new Error(message), { status })
-const pathDirs = (env = process.env) => (env.PATH ?? '').split(path.delimiter).filter(Boolean)
+export const pathDirs = (env = process.env) => (env.PATH ?? '').split(path.delimiter).filter(Boolean)
 
 export function findExecutable(binary, dirs = [...pathDirs(), ...SEARCH_DIRS]) {
   if (!binary) return null

package/server/openshell-install.js

@@ -0,0 +1,189 @@
+import { execFile, spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import readline from 'node:readline/promises'
+import { findExecutable, openshellBinary, pathDirs } from './openshell-cli.js'
+import { localGateways } from './gateway.js'
+import { INSTALL_SHA256, INSTALL_URL, OPENSHELL_TAG, OPENSHELL_VERSION, installCommand } from '../shared/openshell-release.js'
+
+const SUPPORTED = ['darwin-arm64', 'linux-arm64', 'linux-x64']
+const BREW_DIRS = ['/opt/homebrew/bin', '/usr/local/bin']
+const MAX_SCRIPT_BYTES = 1024 * 1024
+
+const addCommand = (platform) => `openshell gateway add https://${platform === 'darwin' ? 'localhost' : '127.0.0.1'}:17670 --local --name openshell`
+const restartCommand = (platform) => platform === 'darwin' ? 'brew services restart nvidia/openshell/openshell' : 'systemctl --user enable openshell-gateway && systemctl --user restart openshell-gateway'
+
+function cliVersion(bin) {
+  return new Promise((resolve) => execFile(bin, ['--version'], { timeout: 5000 }, (error, stdout) => resolve(error ? null : String(stdout))))
+}
+
+// Resolves to true, false (installed but not answering) or 'missing'.
+function dockerRunning(find, env) {
+  const docker = find('docker', [...BREW_DIRS, '/Applications/Docker.app/Contents/Resources/bin'])
+  if (!docker) return 'missing'
+  return new Promise((resolve) => execFile(docker, ['info'], { timeout: 10_000, env }, (error) => resolve(!error)))
+}
+
+// Resolves to the answer, or null on Ctrl-C. Ctrl-D counts as "no".
+async function askTerminal(question) {
+  // Drop keys typed before the question, like an extra Enter during npx's download.
+  const drop = () => {}
+  process.stdin.setRawMode?.(true); process.stdin.on('data', drop)
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  process.stdin.off('data', drop); process.stdin.pause(); process.stdin.setRawMode?.(false)
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    return await new Promise((resolve) => {
+      rl.on('SIGINT', () => { process.stdout.write('\n'); resolve(null) })
+      rl.on('close', () => resolve('n'))
+      rl.question(question).then(resolve, () => resolve('n'))
+    })
+  } finally { rl.close() }
+}
+
+// stdio is inherited so brew and sudo can talk to the user. Ctrl-C reaches the
+// installer; this process ignores it until the installer exits.
+function runInstaller(command, args, { env }) {
+  const ignore = () => {}
+  process.on('SIGINT', ignore)
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'inherit', env })
+    child.once('error', reject)
+    child.once('close', (code, signal) => resolve({ code, signal }))
+  }).finally(() => process.off('SIGINT', ignore))
+}
+
+async function download(fetch, expected) {
+  const response = await fetch(INSTALL_URL, { signal: AbortSignal.timeout(30_000), redirect: 'follow' })
+  if (!response.ok) throw new Error(`HTTP ${response.status}`)
+  const chunks = []
+  let bytes = 0
+  for await (const chunk of response.body ?? []) {
+    bytes += chunk.length
+    // The pinned file is far smaller, so anything this big cannot match it.
+    if (bytes > MAX_SCRIPT_BYTES) throw Object.assign(new Error('checksum mismatch'), { code: 'CHECKSUM' })
+    chunks.push(chunk)
+  }
+  const body = Buffer.concat(chunks)
+  if (createHash('sha256').update(body).digest('hex') !== expected) throw Object.assign(new Error('checksum mismatch'), { code: 'CHECKSUM' })
+  return body
+}
+
+const exists = (file) => fs.access(file).then(() => true, () => false)
+
+// On macOS OpenRod runs local sandboxes in OpenShell's MicroVM driver. A fresh
+// install would auto-select the Docker driver, which needs Docker Desktop's
+// host networking (off by default). The VM driver needs e2fsprogs, and the
+// gateway service reads its driver from gateway.env.
+async function prepareMac({ brew, home, env, run, has, read, log }) {
+  const prefix = path.dirname(path.dirname(brew))
+  if (!await has(path.join(prefix, 'opt/e2fsprogs/sbin/mke2fs'))) {
+    log.info('Installing e2fsprogs, which OpenShell’s VM driver needs…')
+    const result = await run(brew, ['install', 'e2fsprogs'], { env: installerEnv(env, 'darwin') }).catch((error) => ({ error }))
+    if (result.signal === 'SIGINT' || result.code === 130) return 'cancelled'
+    if (result.error || result.code) log.warn('Could not install e2fsprogs. VM sandboxes need it, so run: brew install e2fsprogs')
+  }
+  // The service reads $HOME/.config (launchd sets no XDG_CONFIG_HOME), else the
+  // Homebrew prefix copy. An existing file is someone's setup and stays as is.
+  const file = path.join(home, '.config/openshell/gateway.env')
+  const hint = () => log.info(`To run sandboxes in VMs, add OPENSHELL_COMPUTE_DRIVER=vm to ${file}.`)
+  const envs = [file, path.join(prefix, 'var/openshell/gateway.env')]
+  const tomls = [path.join(home, '.config/openshell/gateway.toml'), path.join(prefix, 'var/openshell/gateway.toml')]
+  const kept = (await Promise.all(envs.map(has))).findIndex(Boolean)
+  if (kept >= 0) { if (!/^\s*(?:export\s+)?OPENSHELL_COMPUTE_DRIVER=/m.test(await read(envs[kept]))) hint(); return 'kept' }
+  for (const toml of tomls) if (/^\s*compute_driver\s*=/m.test(await read(toml))) return 'kept'
+  try {
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+    await fs.writeFile(file, "# Added by OpenRod: run sandboxes in OpenShell's MicroVM driver.\nOPENSHELL_COMPUTE_DRIVER=vm\n", { mode: 0o600, flag: 'wx' })
+  } catch (error) { log.warn(`Could not write ${file} (${error.code ?? error.message}).`); hint(); return 'kept' }
+  return 'written'
+}
+
+export function installerEnv(env, platform) {
+  const next = { ...env, OPENSHELL_VERSION: OPENSHELL_TAG }
+  if (platform === 'darwin') {
+    next.PATH = [...BREW_DIRS, env.PATH].filter(Boolean).join(path.delimiter)
+    next.HOMEBREW_NO_AUTO_UPDATE ??= '1'
+  }
+  return next
+}
+
+// Offers to install the pinned OpenShell release when its CLI is missing.
+// Never installs over an existing CLI: the installer always reinstalls and
+// restarts the gateway service, which stops running sandboxes.
+export async function offerOpenShellInstall({
+  env = process.env, platform = process.platform, arch = process.arch,
+  interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && !env.CI),
+  // Homebrew's own directories go first for brew, as in installerEnv.
+  find = (bin, extra = []) => findExecutable(bin, bin === 'brew' ? [...extra, ...pathDirs(env)] : [...pathDirs(env), ...extra]),
+  cli = () => openshellBinary(env), version = cliVersion, gateways = localGateways,
+  dockerReady = () => dockerRunning(find, env), ask = askTerminal, fetch = globalThis.fetch,
+  run = runInstaller, expected = INSTALL_SHA256, log = console, home = os.homedir(), has = exists,
+  read = (file) => fs.readFile(file, 'utf8').catch(() => ''), uid = process.getuid?.(),
+} = {}) {
+  const command = installCommand(platform)
+  const manual = (line) => { log.info(line); log.info(`  ${command}`) }
+  const bin = cli()
+  if (env.OPENSHELL_BIN && !bin) { log.warn(`OPENSHELL_BIN points to a missing file: ${env.OPENSHELL_BIN}`); return 'skipped' }
+  if (bin) {
+    const found = /\b(\d+\.\d+\.\d+)\b/.exec(await version(bin) ?? '')?.[1]
+    if (found && found !== OPENSHELL_VERSION) log.warn(`OpenRod is tested with OpenShell ${OPENSHELL_VERSION}; this computer has ${found}.`)
+    if (!gateways().length) { log.info('OpenShell is installed, but no local gateway is registered. Run:'); log.info(`  ${addCommand(platform)}`) }
+    return 'present'
+  }
+  if (!SUPPORTED.includes(`${platform}-${arch}`)) { log.info('OpenShell needs Apple Silicon macOS or Linux. SSH hosts still work.'); return 'skipped' }
+  if (platform === 'darwin' && uid === 0) { log.info('Run npx openrod without sudo to install OpenShell: Homebrew doesn’t run as root.'); return 'skipped' }
+  if (platform === 'darwin' && !find('brew', BREW_DIRS)) { log.info('OpenShell installs with Homebrew. Install it from https://brew.sh, then run npx openrod again.'); return 'skipped' }
+  if (!find('curl')) { manual("OpenShell isn't installed, and its installer needs curl. Install curl, then run:"); return 'skipped' }
+  if (platform === 'linux' && !find('dpkg') && !find('rpm')) { log.info('OpenShell installs from .deb or .rpm packages, and this Linux has neither. SSH hosts still work.'); return 'skipped' }
+  if (!interactive) { manual("OpenShell isn't installed. To install it, run:"); return 'skipped' }
+
+  log.info("OpenShell isn't installed. OpenRod uses it to run sandboxes on this computer.")
+  const docker = await dockerReady()
+  // The Linux packages run sandboxes in Docker; on macOS the VM driver only needs it for images OpenRod builds.
+  const needs = platform === 'darwin' ? 'OpenRod needs it to build sandbox images.' : "OpenShell's gateway won't start without it."
+  if (docker === 'missing') log.info(`Docker isn't installed. ${needs}`)
+  else if (!docker) log.info(`Docker isn't running. ${needs}`)
+  let answer = await ask(`Install OpenShell ${OPENSHELL_VERSION} now? ${platform === 'darwin' ? 'It uses Homebrew and runs sandboxes in VMs.' : 'It uses sudo and may ask for your password.'} [Y/n] `)
+  // Anything but yes or no (a key from another keyboard layout, say) asks again.
+  for (let tries = 0; answer !== null && !['', 'y', 'yes', 'n', 'no'].includes(answer.trim().toLowerCase()) && tries < 3; tries++) answer = await ask('Please answer y or n. [Y/n] ')
+  if (answer === null) return 'cancelled'
+  if (!['', 'y', 'yes'].includes(answer.trim().toLowerCase())) { manual('Skipped. To install it later, run:'); return 'skipped' }
+
+  log.info(`Installing OpenShell ${OPENSHELL_VERSION}…`)
+  let script
+  try { script = await download(fetch, expected) } catch (error) {
+    if (error.code === 'CHECKSUM') { log.error('The OpenShell installer did not match the pinned release. Nothing was installed.'); return 'failed' }
+    log.error(`Could not download the OpenShell installer: ${error.cause?.message ?? error.message}. To install it yourself, run:`)
+    log.error(`  ${command}`)
+    return 'failed'
+  }
+  if (platform === 'darwin' && await prepareMac({ brew: find('brew', BREW_DIRS), home, env, run, has, read, log }) === 'cancelled') return 'cancelled'
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'openrod-openshell-'))
+  let result = {}
+  try {
+    const file = path.join(dir, 'install.sh')
+    await fs.writeFile(file, script, { mode: 0o600 })
+    result = await run('/bin/sh', [file], { env: installerEnv(env, platform) })
+  } catch (error) { log.error(`Could not run the OpenShell installer: ${error.message}`) }
+  finally { await fs.rm(dir, { recursive: true, force: true }) }
+  if (result.signal === 'SIGINT' || result.code === 130) return 'cancelled'
+
+  // The installer's exit code is not reliable: it can exit 0 without a gateway
+  // and 1 after a slow gateway start. Check what is actually there instead.
+  if (cli()) {
+    if (gateways().length) {
+      log.info(result.code === 0 ? `OpenShell ${OPENSHELL_VERSION} is ready.` : `OpenShell ${OPENSHELL_VERSION} is installed, but its gateway isn't answering yet. ${platform === 'darwin' ? 'Give it a minute' : 'Make sure Docker is running'}, then click Use this computer.`)
+      return 'ready'
+    }
+    log.warn("OpenShell is installed, but its gateway isn't registered. Run:")
+    log.warn(`  ${restartCommand(platform)}`)
+    log.warn(`  ${addCommand(platform)}`)
+    return 'partial'
+  }
+  log.error('OpenShell install failed. The reason is above. To try again, run:')
+  log.error(`  ${command}`)
+  return 'failed'
+}

package/server/policy.js

@@ -315,11 +315,9 @@ function profileView(p) {
 // `openshell` CLI, which already knows how to turn profile YAML into the
 // gateway's shape; the console only ever passes one of these fixed URLs.
 export const PROFILE_CATALOG = [
-  ['claude-code', 'Claude Code', 'agent'], ['codex', 'Codex', 'agent'], ['copilot', 'GitHub Copilot', 'agent'], ['cursor', 'Cursor', 'agent'],
-  ['anthropic', 'Anthropic', 'inference'], ['openai', 'OpenAI', 'inference'], ['openrouter', 'OpenRouter', 'inference'], ['nvidia', 'NVIDIA', 'inference'],
-  ['deepinfra', 'DeepInfra', 'inference'], ['google-vertex-ai', 'Google Vertex AI', 'inference'], ['aws-bedrock', 'AWS Bedrock', 'inference'],
-  ['github', 'GitHub', 'source_control'], ['pypi', 'PyPI', 'data'],
-  ['aws', 'AWS', 'other'], ['aws-s3', 'AWS S3', 'other'], ['google-cloud', 'Google Cloud', 'other'],
+  ['claude-code', 'Claude Code', 'agent'], ['codex', 'Codex', 'agent'], ['copilot', 'GitHub Copilot', 'agent'],
+  ['openai', 'OpenAI', 'inference'], ['openrouter', 'OpenRouter', 'inference'],
+  ['github', 'GitHub', 'source_control'],
 ].map(([id, name, category]) => ({ id, name, category }))
 
 async function secrets() {

package/server/remote-gateway.js

@@ -8,17 +8,17 @@ import { randomUUID } from 'node:crypto'
 import { Transform } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
 import { setTimeout as delay } from 'node:timers/promises'
-import { CONFIG_DIR, clearConsoleContext, contextConfigured, contextSelection, defaultContextSelection, listGateways, gatewayWorkspaces, selectConsoleContext } from './gateway.js'
+import { CONFIG_DIR, clearConsoleContext, contextConfigured, contextSelection, defaultContextSelection, localGateways, gatewayWorkspaces, selectConsoleContext, unchosenCliGateway } from './gateway.js'
 import { stateDirectory } from './paths.js'
-import { fail, findExecutable, runCli, sshBinary } from './openshell-cli.js'
+import { fail, findExecutable, openshellBinary, runCli, sshBinary } from './openshell-cli.js'
 import { listSshHosts, probeHost, installDocker as installHostDocker, installRuntime, sshArgs } from './remote-hosts.js'
 import { prepareGatewayState, registerManagedGateway } from './remote-gateway-state.js'
 import { ensureGateway } from './gateway-install.js'
+import { installCommand } from '../shared/openshell-release.js'
 import { startRemoteRuntime } from './remote-runtime.js'
 import { reapOrphans } from './orphan-processes.js'
 
 const PACKAGE_LIMIT = 4 * 1024 ** 3
-const localGateways = () => listGateways().filter(target => target.name !== 'aws-eks' && target.supported && !target.remote && ['localhost', '127.0.0.1', '[::1]'].includes(new URL(target.endpoint).hostname))
 
 function ownedProcess(executable, args, env, onExit) {
   const child = spawn(executable, args, { env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] })
@@ -319,9 +319,16 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
     async overview() {
       const snapshot = await locationSnapshot()
       const connection = snapshot.remote
-      return { hosts: await listSshHosts(), locals: localGateways().map(({ name, endpoint }) => ({ name, endpoint })), active: view(connection), job: view(job), tools: { ssh: Boolean(sshBinary()), gateway: Boolean(findExecutable('openshell-gateway')) } }
+      return { hosts: await listSshHosts(), locals: localGateways().map(({ name, endpoint }) => ({ name, endpoint })), active: view(connection), job: view(job), tools: { ssh: Boolean(sshBinary()), gateway: Boolean(findExecutable('openshell-gateway')), openshell: Boolean(openshellBinary()), installCommand: installCommand(process.platform) } }
     },
     changing: () => disconnecting || job?.status === 'working',
+    // A fresh console connects to the CLI's local gateway the way "Use this
+    // computer" does, but only once it answers; otherwise setup stays up.
+    async autoSelect() {
+      const name = unchosenCliGateway()
+      if (!name || job?.status === 'working' || !localGateways().some(target => target.name === name)) return false
+      try { await select(name); return true } catch { return false }
+    },
     architecture: () => active?.status === 'connected' ? active.architecture : null,
     begin,
     job: id => view(getJob(id)),

package/shared/openshell-release.js

@@ -0,0 +1,13 @@
+// The OpenShell release OpenRod is tested with. Bump all of these together, and
+// also gateway-install.js (VERSION, RELEASES digests), remote-runtime.js (image and
+// version check), remote-hosts.js (chart) and policy.js (provider URL).
+export const OPENSHELL_VERSION = '0.1.2'
+export const OPENSHELL_TAG = `v${OPENSHELL_VERSION}`
+export const INSTALL_URL = `https://raw.githubusercontent.com/NVIDIA/OpenShell/${OPENSHELL_TAG}/install.sh`
+// install.sh at tag v0.1.2 (commit 6648bd0c290efbc41ba131ee9831ee45cd431f94), 45210 bytes.
+export const INSTALL_SHA256 = '5c98a86a4b811c471b212219cb2a62d458244220ffa71ac8e3baf3700b17b871'
+export const INSTALL_COMMAND = `curl -LsSf ${INSTALL_URL} | OPENSHELL_VERSION=${OPENSHELL_TAG} sh`
+// On macOS sandboxes run in the MicroVM driver (e2fsprogs plus gateway.env), set
+// up before the installer so its first gateway start already uses it.
+export const MAC_INSTALL_COMMAND = `brew install e2fsprogs && mkdir -p ~/.config/openshell && { [ -e ~/.config/openshell/gateway.env ] || echo OPENSHELL_COMPUTE_DRIVER=vm > ~/.config/openshell/gateway.env; } && ${INSTALL_COMMAND}`
+export const installCommand = (platform) => platform === 'darwin' ? MAC_INSTALL_COMMAND : INSTALL_COMMAND

package/src/lib/api.js

@@ -52,7 +52,7 @@ export function createApi(target, signal, locationContext = null, boundOwner = c
     currentSignal?.throwIfAborted()
     if (payload.code === LINK_REQUIRED) window.dispatchEvent(new Event(LINK_REQUIRED))
     else if (response.status === 401 || payload.code === 'CLOUD_OWNER_CHANGED') window.dispatchEvent(new Event('openrod-session-expired'))
-    if (!response.ok) throw Object.assign(new Error(payload.error ?? `Request failed (${response.status})`), { code: payload.code, sandboxes: payload.sandboxes })
+    if (!response.ok) throw Object.assign(new Error(payload.error ?? `Request failed (${response.status})`), { code: payload.code, sandboxes: payload.sandboxes, fix: payload.fix })
     return payload
   }
   return {
@@ -77,6 +77,9 @@ export function createApi(target, signal, locationContext = null, boundOwner = c
     forgetRemote: () => request('/connections/forget', { method: 'POST', body: {} }),
     disconnectRemote: () => request('/connections/disconnect', { method: 'POST', body: {} }),
     syncLocalCatalog: () => request('/local-catalog', { method: 'POST', body: {} }),
+    gatewayDocker: (fresh = false) => request(`/gateway-docker${fresh ? '?fresh=1' : ''}`, { scoped: false }),
+    connectGatewayDocker: (seen = [], confirm = true) => request('/gateway-docker/connect', { method: 'POST', body: { confirm, seen }, scoped: false }),
+    undoGatewayDocker: (seen = []) => request('/gateway-docker/undo', { method: 'POST', body: { confirm: true, seen }, scoped: false }),
   setups: () => request('/setups'),
   discoverSetups: (sources) => request('/setups/scan', { method: 'POST', body: { sources } }),
   reviewSetup: (token, ids) => request('/setups/review', { method: 'POST', body: { token, ids } }),

package/src/lib/gateway-docker-store.js

@@ -0,0 +1,5 @@
+import { createApi } from './api.js'
+import { createGatewayDocker } from './gateway-docker.js'
+
+// Machine-wide: always this computer's server, whatever page is open.
+export const gatewayDocker = createGatewayDocker(createApi('local'))

package/src/lib/gateway-docker.js

@@ -0,0 +1,77 @@
+// Follows whether OpenShell's VM driver can see the Docker that OpenRod builds
+// template images with (NVIDIA/OpenShell#4155). The server makes the change;
+// this store polls its status and asks before anything restarts.
+
+// The driver's message when it fell through to Docker Hub for a local image.
+export const dockerImageProblem = (p) => /failed to resolve .*image/i.test(p ?? '') && /docker\.io/.test(p ?? '')
+
+const restartsNothing = (s) => Array.isArray(s?.sandboxes) && !s.sandboxes.length && !s.stranded?.length && !s.conflict
+const seenKeys = (sandboxes) => (sandboxes ?? []).map((s) => typeof s === 'string' ? s : `${s.workspace}/${s.name}`)
+
+export function createGatewayDocker(api, { schedule = setTimeout, cancel = clearTimeout } = {}) {
+  let snapshot = { status: null, asking: null, error: null }
+  let timer = null, after = null
+  const listeners = new Set()
+  const set = (patch) => { snapshot = { ...snapshot, ...patch }; listeners.forEach((listener) => listener()) }
+
+  function poll() {
+    cancel(timer); timer = null
+    if (listeners.size) timer = schedule(() => { void refresh() }, snapshot.status?.state === 'working' ? 2000 : 15_000)
+  }
+
+  // Runs `then` once the job the user started has finished.
+  function follow(status) {
+    if (!after || status?.job?.status === 'working') return
+    const { id, then } = after
+    after = null
+    if (status?.job?.id === id && status.job.status === 'done') then?.()
+  }
+
+  async function refresh(fresh = false) {
+    try {
+      const status = await api.gatewayDocker(fresh)
+      set({ status })
+      follow(status)
+      return status
+    } catch { return snapshot.status } finally { poll() }
+  }
+
+  async function run(kind, seen, then, confirm = true) {
+    set({ asking: snapshot.asking && { ...snapshot.asking, busy: true }, error: null })
+    try {
+      const status = await (kind === 'undo' ? api.undoGatewayDocker(seenKeys(seen)) : api.connectGatewayDocker(seenKeys(seen), confirm))
+      set({ status, asking: null })
+      if (status.state === 'working' && status.job) after = { id: status.job.id, then }
+      else if (status.state !== 'mismatch') then?.()
+      return status
+    } catch (error) {
+      if (error.code === 'GATEWAY_DOCKER_MISMATCH' && !(kind === 'undo' && error.fix === 'manual')) {
+        // Something changed since the user looked: show them the current list.
+        const status = await refresh(true)
+        set({ asking: { kind: error.fix === 'manual' ? 'steps' : kind, then, sandboxes: kind === 'undo' ? error.sandboxes ?? null : status?.sandboxes ?? error.sandboxes ?? null, busy: false } })
+      } else set({ error: error.message, asking: { ...(snapshot.asking ?? { kind, then, sandboxes: snapshot.status?.sandboxes ?? null }), busy: false } })
+      return null
+    } finally { poll() }
+  }
+
+  return {
+    subscribe(listener) {
+      listeners.add(listener)
+      if (listeners.size === 1) void refresh()
+      return () => { listeners.delete(listener); if (!listeners.size) { cancel(timer); timer = null } }
+    },
+    getSnapshot: () => snapshot,
+    refresh,
+    // `seen` is the sandboxes the user was shown; the server refuses if more would restart.
+    connect: (seen = snapshot.asking?.sandboxes) => run('connect', seen, snapshot.asking?.then),
+    undo: (seen = snapshot.asking?.sandboxes) => run('undo', seen, snapshot.asking?.then),
+    ask({ kind, then } = {}) {
+      const s = snapshot.status
+      kind ??= s?.fix === 'manual' ? 'steps' : 'connect'
+      // A stale or unloaded status can't vouch for the restart: let the server ask.
+      if (kind === 'connect' && (s?.state !== 'mismatch' || restartsNothing(s))) return run('connect', [], then, s?.state === 'mismatch')
+      set({ asking: { kind, then, sandboxes: kind === 'connect' ? s?.sandboxes ?? null : null, busy: false }, error: null })
+    },
+    close: () => set({ asking: null, error: null }),
+  }
+}

package/src/lib/sandbox-creations.js

@@ -29,7 +29,7 @@ export function createSandboxCreations() {
       update(id, { status: "created", sandbox: { ...sandbox, location: sandbox.location ?? job.location }, message: "" })
     }).catch((error) => {
       if (controller.signal.aborted || error.name === "AbortError") update(id, { status: "cancelled", message: "Creation cancelled." })
-      else update(id, { status: "failed", error: error.message, message: "" })
+      else update(id, { status: "failed", error: error.message, code: error.code ?? null, fix: error.fix ?? null, message: "" })
     })
   }
 
@@ -44,7 +44,8 @@ export function createSandboxCreations() {
       run(id)
       return id
     },
-    retry(id) { if (runs.has(id)) run(id) },
+    // Only a failed job reruns; a late retry (Connect's `then`) must not start a second task.
+    retry(id) { if (runs.has(id) && snapshot.find((job) => job.id === id)?.status === "failed") run(id) },
     cancel(id) {
       const job = snapshot.find((item) => item.id === id)
       if (job?.status !== "preparing") return

package/src/lib/services.js

@@ -4,27 +4,16 @@
 export const SERVICE_GROUPS = [
   { id: "agent", label: "Agents" },
   { id: "inference", label: "Models" },
-  { id: "code", label: "Code & packages" },
-  { id: "cloud", label: "Cloud" },
+  { id: "code", label: "Code" },
 ]
 
 export const SERVICES = [
   { id: "claude-code", name: "Claude Code", group: "agent", blurb: "Anthropic's coding agent", keyUrl: "https://console.anthropic.com/settings/keys", keyHint: "sk-ant-…" },
   { id: "codex", name: "Codex", group: "agent", blurb: "Existing Codex OAuth session", helpUrl: "https://developers.openai.com/codex/auth/" },
   { id: "copilot", name: "Copilot", group: "agent", blurb: "GitHub Copilot CLI" },
-  { id: "cursor", name: "Cursor", group: "agent", blurb: "Cursor bootstrap network access" },
-  { id: "anthropic", name: "Anthropic", group: "inference", blurb: "Claude API", keyUrl: "https://console.anthropic.com/settings/keys", keyHint: "sk-ant-…" },
   { id: "openai", name: "OpenAI", group: "inference", blurb: "GPT models API", keyUrl: "https://platform.openai.com/api-keys", keyHint: "sk-…" },
-  { id: "nvidia", name: "NVIDIA", group: "inference", blurb: "NIM model endpoints", keyUrl: "https://build.nvidia.com", keyHint: "nvapi-…" },
   { id: "openrouter", name: "OpenRouter", group: "inference", blurb: "One key, many models", keyUrl: "https://openrouter.ai/keys", keyHint: "sk-or-…" },
-  { id: "deepinfra", name: "DeepInfra", group: "inference", blurb: "Open models, hosted" },
-  { id: "google-vertex-ai", name: "Vertex AI", group: "inference", blurb: "Google Cloud models" },
-  { id: "aws-bedrock", name: "Bedrock", group: "inference", blurb: "Models on AWS" },
   { id: "github", name: "GitHub", group: "code", blurb: "Repos and API", keyUrl: "https://github.com/settings/personal-access-tokens", keyHint: "github_pat_…" },
-  { id: "pypi", name: "PyPI", group: "code", blurb: "Install Python packages" },
-  { id: "aws", name: "AWS", group: "cloud", blurb: "AWS APIs" },
-  { id: "aws-s3", name: "S3", group: "cloud", blurb: "Buckets and objects" },
-  { id: "google-cloud", name: "Google Cloud", group: "cloud", blurb: "GCP APIs" },
 ]
 
 export const serviceOf = (type) => SERVICES.find((s) => s.id === type) ?? null