openrod 0.0.0 → 0.1.0

package/src/lib/activity-inventory.js

@@ -0,0 +1,45 @@
+import { AGENTS } from './agents.js'
+
+export const activityKey = (e) => e.id || `${e.sandbox}|${e.at}|${e.source}|${e.target}|${e.message}`
+export const SEVERITY_RANK = { CRITICAL: 6, FATAL: 6, HIGH: 5, MED: 4, MEDIUM: 4, LOW: 3, INFO: 2, INFORMATIONAL: 2 }
+const REASONS = { policy_dns_ineligible: 'no rule allows this host', transparent_tcp_policy_denied: 'no rule allows this connection' }
+export const CATEGORY_NAMES = { NET: 'Network', HTTP: 'HTTP', SSH: 'Session', CONFIG: 'Configuration', PROC: 'Process', FILE: 'File', AUTH: 'Authentication', FINDING: 'Finding', EVENT: 'Event' }
+export function activityRow(event) {
+  const program = event.binary?.split('/').pop() || ''
+  const known = AGENTS.find((a) => a.commands.includes(program.toLowerCase()) && program.toLowerCase() !== 'agent')
+  const agent = known ? { name: known.name, logo: `/logos/agents/${known.logo}.svg` } : null
+  const direction = event.direction || (event.kind === 'inbound' && ['NET', 'HTTP', 'SSH'].includes(event.category) ? 'in' : event.kind === 'audit' && ['NET', 'HTTP'].includes(event.category) ? 'out' : 'unknown')
+  const values = {
+    time: event.at ?? '', sandbox: event.sandbox ?? '', scope: event.scope ?? '', sandboxId: event.sandboxId ?? event.original?.sandboxId ?? '', agent: agent?.name ?? 'Unknown',
+    category: CATEGORY_NAMES[event.category] ?? (event.kind === 'log' ? 'Log' : 'Unclassified'),
+    severity: event.severity || 'Not reported',
+    logLevel: event.level && event.level !== 'OCSF' ? event.level : 'Not reported', direction,
+    verdict: event.verdict || (['NET', 'HTTP', 'SSH', 'AUTH'].includes(event.category) ? 'not reported' : 'not applicable'),
+    outcome: event.outcome ?? 'unknown', process: event.binary ?? '',
+    action: [known ? '' : program, event.method || event.action].filter(Boolean).join(' · ') || 'Not reported',
+    destination: event.destination ?? '', policy: event.policy ?? '',
+    session: event.sessionId ?? '', correlation: event.correlationId ?? '',
+    why: REASONS[event.reason] ?? event.reason ?? '',
+  }
+  return { event, agent, key: activityKey(event), values, timestamp: Date.parse(event.at), search: [...Object.values(values), event.message, event.detail, event.source, event.target, JSON.stringify(event.original?.fields ?? event.original?.metadata ?? {})].join(' ').toLowerCase() }
+}
+export function filterActivity(rows, { query = '', direction = 'all', sandboxes = [], verdicts = [], agents = [], filters = {}, range = 'all', from = '', to = '', now = Date.now(), sort = { key: 'time', direction: 'desc' } } = {}) {
+  const names = new Set(sandboxes)
+  const q = query.trim().toLowerCase()
+  const start = range === 'custom' ? (from ? Date.parse(from) : -Infinity) : range === 'all' ? -Infinity : now - Number(range) * 60000
+  const end = range === 'custom' && to ? Date.parse(to) : Infinity
+  return rows.filter((r) => {
+    if (direction !== 'all' && r.values.direction !== direction) return false
+    if (names.size && !names.has(r.values.sandbox)) return false
+    if (agents.length && !agents.includes(r.values.agent)) return false
+    if (verdicts.length && !verdicts.includes(r.values.verdict)) return false
+    if (q && !r.search.includes(q)) return false
+    if (range !== 'all' && (!Number.isFinite(r.timestamp) || r.timestamp < start || r.timestamp > end)) return false
+    return Object.entries(filters).every(([key, f]) => !f?.value?.trim() || ((f.mode === 'equals' ? (r.values[key] ?? '').toLowerCase() === f.value.trim().toLowerCase() : (r.values[key] ?? '').toLowerCase().includes(f.value.trim().toLowerCase())) !== (f.mode === 'excludes')))
+  }).sort((a, b) => {
+    const av = sort.key === 'severity' ? (SEVERITY_RANK[a.values.severity.toUpperCase()] ?? -1) : sort.key === 'time' ? (Number.isFinite(a.timestamp) ? a.timestamp : 0) : a.values[sort.key] ?? ''
+    const bv = sort.key === 'severity' ? (SEVERITY_RANK[b.values.severity.toUpperCase()] ?? -1) : sort.key === 'time' ? (Number.isFinite(b.timestamp) ? b.timestamp : 0) : b.values[sort.key] ?? ''
+    const order = typeof av === 'number' ? av - bv : av.localeCompare(bv, undefined, { numeric: true })
+    return (sort.direction === 'asc' ? order : -order) || a.key.localeCompare(b.key)
+  })
+}

package/src/lib/agents.js

@@ -0,0 +1,41 @@
+export const AGENTS = [
+  { name: "Claude Code", logo: "claudecode", commands: ["claude", "claude-code"] },
+  { name: "Codex", logo: "codex", commands: ["codex"] },
+  { name: "GitHub Copilot", logo: "copilot", commands: ["copilot"] },
+  { name: "Cursor", logo: "cursor", commands: ["cursor-agent", "agent"], aliases: ["Cursor CLI"] },
+  { name: "Gemini CLI", logo: "gemini", commands: ["gemini"] },
+  { name: "OpenCode", logo: "opencode", commands: ["opencode"] },
+  { name: "OpenClaw", logo: "openclaw-color", commands: ["openclaw"] },
+  { name: "Pi", logo: "pi", commands: ["pi"] },
+  { name: "Antigravity CLI", logo: "antigravity", commands: ["agy"], aliases: ["Antigravity"] },
+  { name: "Kiro CLI", logo: "kiro", commands: ["kiro-cli"], aliases: ["Kiro"] },
+  { name: "Factory Droid", logo: "factory", commands: ["droid"], aliases: ["Droid", "Factory"] },
+  { name: "Aider", logo: "aider", commands: ["aider"] },
+]
+
+// A completed runtime inventory is authoritative, including an empty result.
+// Labels and launch commands remain a fallback until a scan is available.
+export function agentsOf(sandbox) {
+  const labels = sandbox?.labels ?? {}
+  const metadata = labels["openshell.console/agents"] || labels["openshell.console/agent"]
+  const names = typeof metadata === "string" ? metadata.split(/[,\n]/).map((name) => name.trim()).filter(Boolean) : []
+  const executable = Array.isArray(sandbox?.command) ? sandbox.command[0]?.split("/").pop() : null
+  const installed = sandbox?.agentInventory?.agents
+  const explicit = names.length > 0
+  // The generic launch name "agent" needs runtime identity evidence.
+  const values = Array.isArray(installed) ? installed : explicit ? names : executable && executable !== "agent" ? [executable] : []
+  const agents = values.flatMap((value) => {
+    const known = AGENTS.find((agent) => agent.name.toLowerCase() === value.toLowerCase() || agent.commands.includes(value.toLowerCase()) || agent.aliases?.some((alias) => alias.toLowerCase() === value.toLowerCase()))
+    if (known) return [{ resources: sandbox?.agentInventory?.resources?.[known.name], name: known.name, logo: `/logos/agents/${known.logo}.svg` }]
+    return explicit ? [{ name: value, logo: null }] : []
+  })
+  return agents.filter((agent, index) => agents.findIndex((item) => item.name.toLowerCase() === agent.name.toLowerCase()) === index)
+}
+
+export function agentInventoryLabel(sandbox) {
+  const inventory = sandbox?.agentInventory
+  if (inventory?.status === "checked") return inventory.agents.length ? "Installed agents" : "No supported agents found"
+  if (inventory?.checkedAt) return "Last detected agents · scan unavailable"
+  if (inventory?.status === "unavailable") return "Agent scan unavailable"
+  return "Agent inventory not checked"
+}

package/src/lib/api.js

@@ -0,0 +1,173 @@
+// Browser side of the console API. Every call is same-origin; the server
+// holds the gateway certificate, so nothing here carries a credential.
+
+import { computeApiPath, currentComputeTarget, currentCloudOwner } from './compute-target.js'
+
+// The local server answers 401 with this code until the browser opens the
+// tokened link that `openrod` prints; the app then shows how to get back in.
+export const LINK_REQUIRED = 'CONSOLE_TOKEN_REQUIRED'
+
+export function createApi(target, signal, locationContext = null, boundOwner = currentCloudOwner()) {
+  const selected = () => target ?? currentComputeTarget()
+  const owner = boundOwner
+  let binding, loadingBinding
+  const path = suffix => computeApiPath(selected(), suffix)
+  const requestSignal = extra => signal && extra ? AbortSignal.any([signal, extra]) : signal ?? extra
+  async function loadContext() {
+    signal?.throwIfAborted()
+    const response = await fetch(path('/context'), { signal, headers: selected() === 'cloud' && owner ? { 'x-openrod-local-owner': owner } : undefined })
+    const context = await response.json()
+    signal?.throwIfAborted()
+    if (context.code === LINK_REQUIRED) window.dispatchEvent(new Event(LINK_REQUIRED))
+    else if (response.status === 401 || context.code === 'CLOUD_OWNER_CHANGED') window.dispatchEvent(new Event('openrod-session-expired'))
+    if (!response.ok) throw new Error(context.error ?? 'Could not read gateway registrations.')
+    binding ??= JSON.stringify([context.gateway, context.workspace])
+    return context
+  }
+  async function contextKey() {
+    signal?.throwIfAborted()
+    if (locationContext != null) return locationContext
+    if (!binding) {
+      loadingBinding ??= loadContext().finally(() => { loadingBinding = null })
+      await loadingBinding
+    }
+    return binding
+  }
+  async function request(suffix, { method = 'GET', body, signal: extraSignal, scoped = true, raw = false } = {}) {
+    const currentSignal = requestSignal(extraSignal)
+    currentSignal?.throwIfAborted()
+    const context = scoped ? await contextKey() : null
+    currentSignal?.throwIfAborted()
+    const response = await fetch(path(suffix), {
+      method, signal: currentSignal,
+      headers: {
+        ...(selected() === 'cloud' && owner ? { 'x-openrod-local-owner': owner } : {}),
+        ...(context ? { 'x-openshell-context': context } : {}),
+        ...(context && locationContext ? { 'x-openshell-location': '1' } : {}),
+        ...(method === 'GET' ? {} : { 'content-type': raw ? 'application/octet-stream' : 'application/json', 'x-openshell-console': '1' }),
+      },
+      body: body === undefined ? undefined : raw ? body : JSON.stringify(body),
+    })
+    const payload = await response.json().catch(() => ({}))
+    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 })
+    return payload
+  }
+  return {
+    target, signal, path, owner,
+    url: (suffix, params = {}) => {
+      const query = new URLSearchParams({ ...params, ...(selected() === 'cloud' && owner ? { owner } : {}) })
+      return path(suffix) + (query.size ? '?' + query : '')
+    },
+    forContext: context => createApi(target, signal, context, owner),
+    inventory: extraSignal => request('/inventory', { signal: extraSignal, scoped: false }),
+    context: loadContext,
+    contextKey,
+    connections: extraSignal => request('/connections', { signal: extraSignal, scoped: false }),
+    connectionJob: (id, extraSignal) => request(`/connections/jobs/${encodeURIComponent(id)}`, { signal: extraSignal, scoped: false }),
+    connect: body => request('/connections/connect', { method: 'POST', body }),
+    installConnectionDocker: id => request(`/connections/jobs/${encodeURIComponent(id)}/docker`, { method: 'POST', body: { approve: true } }),
+    installConnectionRuntime: id => request(`/connections/jobs/${encodeURIComponent(id)}/install`, { method: 'POST', body: { method: 'download' } }),
+    uploadConnectionPackage: (id, file) => request(`/connections/jobs/${encodeURIComponent(id)}/package`, { method: 'POST', body: file, raw: true }),
+    scanSshHost: body => request('/connections/hosts/scan', { method: 'POST', body }),
+    addSshHost: token => request('/connections/hosts', { method: 'POST', body: { token } }),
+    removeSshHost: alias => request('/connections/hosts/remove', { method: 'POST', body: { alias } }),
+    forgetRemote: () => request('/connections/forget', { method: 'POST', body: {} }),
+    disconnectRemote: () => request('/connections/disconnect', { method: 'POST', body: {} }),
+    syncLocalCatalog: () => request('/local-catalog', { method: 'POST', body: {} }),
+  setups: () => request('/setups'),
+  discoverSetups: (sources) => request('/setups/scan', { method: 'POST', body: { sources } }),
+  reviewSetup: (token, ids) => request('/setups/review', { method: 'POST', body: { token, ids } }),
+  removeSetupReviewItem: (token, item) => request('/setups/remove-review-item', { method: 'POST', body: { token, item } }),
+  prepareSetup: (token, items) => request('/setups/prepare', { method: 'POST', body: { token, items, approved: true } }),
+  prepareLaunchSetup: (id, revision) => request(`/setups/${id}/prepare-launch`, { method: 'POST', body: { revision } }),
+  prepareSavedSetup: (id) => request(`/setups/${id}/prepare`, { method: 'POST', body: {} }),
+  setupPreparation: (id) => request(`/setups/preparations/${id}`),
+  cancelSetupPreparation: (id) => request(`/setups/preparations/${id}/cancel`, { method: 'POST', body: {} }),
+  setupFile: (token, item, path) => request('/setups/file', { method: 'POST', body: { token, item, path } }),
+  saveSetup: (token, name, acknowledged) => request('/setups/save', { method: 'POST', body: { token, name, acknowledged } }),
+  deleteSetup: (id, revision) => request(`/setups/${id}/delete`, { method: 'POST', body: { revision } }),
+  deleteSetupItem: (id, item, revision) => request(`/setups/${id}/delete-item`, { method: 'POST', body: { item, revision } }),
+  previewSetup: (id, sandbox, targets) => request(`/setups/${id}/preview`, { method: 'POST', body: { sandbox, targets } }),
+  enableSetup: (id, sandbox, token, approveAccess = false) => request(`/setups/${id}/enable`, { method: 'POST', body: { sandbox, token, approveAccess } }),
+  removeSetup: (id, sandbox, token) => request(`/setups/${id}/remove`, { method: 'POST', body: { sandbox, token } }),
+  setupJobs: (id) => request(`/setups/${id}/jobs`),
+  cloudExport: (name) => request(`/cloud-export?name=${encodeURIComponent(name)}`),
+  importCloud: (bundle) => request("/cloud-import", { method: "POST", body: bundle }),
+  cloudTransfer: (name, ticket) => request("/cloud-transfer", { method: "POST", body: { name, ticket } }),
+  selectContext: (body) => request("/context", { method: "POST", body }),
+  previewActivityDeletion: (body) => request('/activity/delete-preview', { method: 'POST', body }),
+  deleteActivity: (token) => request('/activity/delete', { method: 'POST', body: { token } }),
+  activityDestinations: () => request('/activity-destinations'),
+  createActivityDestination: (body) => request('/activity-destinations', { method: 'POST', body }),
+  activityDestinationAction: (id, action) => request(`/activity-destinations/${encodeURIComponent(id)}/${action}`, { method: 'POST', body: {} }),
+  overview: () => request("/overview"),
+  sandbox: (name) => request(`/sandboxes/${encodeURIComponent(name)}`),
+  activity: (options = {}) => request(`/activity?query=${encodeURIComponent(JSON.stringify(options))}`),
+  create: (spec) => request("/sandboxes", { method: "POST", body: spec }),
+  sshConnection: (name) => request(`/sandboxes/${encodeURIComponent(name)}/ssh`),
+  openSshTerminal: (name, mode) => request(`/sandboxes/${encodeURIComponent(name)}/ssh-open`, { method: "POST", body: { mode } }),
+  sshConfig: (name) => request(`/sandboxes/${encodeURIComponent(name)}/ssh-config`, { method: "POST", body: {} }),
+  terminalSession: (name, body) => request(`/sandboxes/${encodeURIComponent(name)}/terminal-session`, { method: "POST", body }),
+  lifecycle: (name, action) => request(`/sandboxes/${encodeURIComponent(name)}/${action}`, { method: "POST", body: {} }),
+  editors: () => request("/editors"),
+  openEditor: (name, editor) => request(`/sandboxes/${encodeURIComponent(name)}/editor`, { method: "POST", body: { editor } }),
+
+  // Policy center
+  fleetPolicy: () => request("/policy/fleet"),
+  policy: (sandbox) => request(`/policy/${encodeURIComponent(sandbox)}`),
+  revision: (sandbox, version) => request(`/policy/${encodeURIComponent(sandbox)}/revisions/${version}`),
+  applyOps: (sandbox, ops) => request(`/policy/${encodeURIComponent(sandbox)}/ops`, { method: "POST", body: { ops } }),
+  restore: (sandbox, version) => request(`/policy/${encodeURIComponent(sandbox)}/restore`, { method: "POST", body: { version } }),
+  globalPolicy: () => request("/policy/global"),
+  removeGlobal: () => request("/policy/global/remove", { method: "POST", body: {} }),
+  settings: (sandbox) => request(`/settings${sandbox ? `/${encodeURIComponent(sandbox)}` : ""}`),
+  setSetting: (body) => request("/settings", { method: "POST", body }),
+  secrets: () => request("/secrets"),
+  createSecret: (body) => request("/secrets", { method: "POST", body }),
+  rotateSecret: (name, credentials) => request(`/secrets/${encodeURIComponent(name)}/rotate`, { method: "POST", body: { credentials } }),
+  secretExpiry: (name, key, expiresAt) => request(`/secrets/${encodeURIComponent(name)}/expiry`, { method: "POST", body: { key, expiresAt } }),
+  deleteSecret: (name) => request(`/secrets/${encodeURIComponent(name)}/delete`, { method: "POST", body: {} }),
+  attachSecret: (name, sandbox, attach) => request(`/secrets/${encodeURIComponent(name)}/${attach ? "attach" : "detach"}`, { method: "POST", body: { sandbox } }),
+  importProfile: (id) => request("/profiles/import", { method: "POST", body: { id } }),
+  deleteTemplates: (ids) => request("/templates/delete", { method: "POST", body: { ids } }),
+  templates: () => request("/templates"),
+  imageTemplates: () => request("/image-templates"),
+  localImages: () => request("/image-templates/local-images"),
+  buildImageTemplate: (recipe, replace = false) => request("/image-templates", { method: "POST", body: { recipe, replace } }),
+  cancelImageBuild: (name) => request(`/image-templates/${encodeURIComponent(name)}/cancel`, { method: "POST", body: {} }),
+  dismissImageBuild: (name) => request(`/image-templates/${encodeURIComponent(name)}/dismiss`, { method: "POST", body: {} }),
+  imageTemplateUsage: (name) => request(`/image-templates/${encodeURIComponent(name)}/usage`),
+  deleteImageTemplate: (name) => request(`/image-templates/${encodeURIComponent(name)}/delete`, { method: "POST", body: {} }),
+  org: () => request("/org"),
+  saveOrg: (org) => request("/org", { method: "POST", body: org }),
+  saveGroup: (group) => request("/org/groups", { method: "POST", body: group }),
+  deleteGroup: (id) => request(`/org/groups/${encodeURIComponent(id)}/delete`, { method: "POST", body: {} }),
+  setGroupMembers: (sandboxes, groups, mode = "replace") => request("/org/members", { method: "POST", body: { sandboxes, groups, mode } }),
+  savePolicy: (policy) => request("/egress/policies", { method: "POST", body: policy }),
+  deletePolicy: (id) => request(`/egress/policies/${encodeURIComponent(id)}/delete`, { method: "POST", body: {} }),
+  saveTemplate: (template) => request("/templates", { method: "POST", body: template }),
+  deleteTemplate: (id) => request(`/templates/${encodeURIComponent(id)}/delete`, { method: "POST", body: {} }),
+
+  // Files
+  localFolder: (path) => request("/local-folder", { method: "POST", body: { path } }),
+  files: (sandbox, path) => request(`/files/${encodeURIComponent(sandbox)}?path=${encodeURIComponent(path)}`),
+  seed: (sandbox) => request(`/files/${encodeURIComponent(sandbox)}/seed`),
+  retrySeed: (sandbox) => request(`/files/${encodeURIComponent(sandbox)}/seed/retry`, { method: "POST", body: {} }),
+  prepareDownload: (sandbox, path) => request(`/files/${encodeURIComponent(sandbox)}/download`, { method: "POST", body: { path } }),
+  startUpload: (sandbox) => request(`/files/${encodeURIComponent(sandbox)}/uploads`, { method: "POST", body: {} }),
+  uploadFile: (sandbox, id, filePath, file, uploadSignal) => request(`/files/${encodeURIComponent(sandbox)}/uploads/${id}?path=${encodeURIComponent(filePath)}`, { method: 'POST', body: file, raw: true, signal: uploadSignal }),
+  commitUpload: (sandbox, id, dir) => request(`/files/${encodeURIComponent(sandbox)}/uploads/${id}/commit`, { method: "POST", body: { dir } }),
+  cancelUpload: (sandbox, id) => request(`/files/${encodeURIComponent(sandbox)}/uploads/${id}/cancel`, { method: "POST", body: {} }),
+
+  // Ingress
+  ingress: () => request("/ingress"),
+  exposeService: (body) => request("/ingress/expose", { method: "POST", body }),
+  closeService: (service) => request("/ingress/close", { method: "POST", body: { sandbox: service.sandbox, name: service.name } }),
+  extendService: (service, closeAfterMinutes) => request("/ingress/extend", { method: "POST", body: { sandbox: service.sandbox, name: service.name, closeAfterMinutes } }),
+}
+}
+
+export const api = createApi()

package/src/lib/cloud-machine.js

@@ -0,0 +1,9 @@
+export function cloudHandoff(hash) {
+ try {
+  if(!hash.startsWith('#handoff='))return null
+  const value=JSON.parse(atob(hash.slice(9).replaceAll('-','+').replaceAll('_','/')))
+  const origin=new URL(value.origin)
+  if(origin.origin!==value.origin||origin.protocol!=='http:'||!['localhost','127.0.0.1','[::1]'].includes(origin.hostname)||!/^\d{1,5}$/.test(origin.port)||!/^[a-f0-9-]{36}$/.test(value.nonce))return null
+  return {origin:origin.origin,nonce:value.nonce}
+ }catch{return null}
+}

package/src/lib/cloud-origin.js

@@ -0,0 +1,6 @@
+/* global __OPENROD_CLOUD_ORIGIN__ */
+// Set at build time from OPENROD_CLOUD_ORIGIN; unset keeps every cloud action disabled.
+const configured = typeof __OPENROD_CLOUD_ORIGIN__ === 'string' ? __OPENROD_CLOUD_ORIGIN__ : ''
+export const CLOUD_ORIGIN = /^https:\/\/[a-z0-9.-]+(:\d+)?$/i.test(configured) ? configured : ''
+export const CLOUD_AVAILABLE = Boolean(CLOUD_ORIGIN)
+export const CLOUD_SOON = "Cloud is coming soon. We're still working on it."

package/src/lib/cloud-transfer.js

@@ -0,0 +1,22 @@
+import { CLOUD_ORIGIN } from './cloud-origin.js'
+export { CLOUD_ORIGIN }
+
+export function cloudHandoffUrl(origin, nonce, cloud = CLOUD_ORIGIN) {
+  if (!cloud) throw new Error('Cloud is coming soon.')
+  const encoded = btoa(JSON.stringify({ origin, nonce })).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '')
+  return `${cloud}/?handoff=1#handoff=${encoded}`
+}
+
+export function isCloudReadyMessage(event, popup, nonce, cloud = CLOUD_ORIGIN) {
+  return Boolean(cloud && popup && event.source === popup && event.origin === cloud
+    && event.data?.type === 'openrod-cloud-ready' && event.data.nonce === nonce
+    && typeof event.data.ticket === 'string' && /^openrod-user-[a-f0-9]{24}\.[a-f0-9]{64}$/.test(event.data.ticket))
+}
+
+export const LOCAL_ORIGIN = 'http://127.0.0.1:4600'
+export const localHandoffUrl = (nonce) => `${LOCAL_ORIGIN}/?handoff=cloud&target=local#cloud-return=${encodeURIComponent(nonce)}`
+
+export function isLocalHandoffMessage(event, popup, nonce, type) {
+  return Boolean(popup && event.source === popup && event.origin === LOCAL_ORIGIN
+    && event.data?.type === type && event.data.nonce === nonce)
+}

package/src/lib/compute-target.js

@@ -0,0 +1,46 @@
+export const COMPUTE_KEY = 'openrod.compute-target'
+export function initialComputeTarget(url, storage) {
+  const location = new URL(url)
+  if (location.hash.startsWith('#cloud-return=')) return 'local'
+  const pin = location.searchParams.get('target')
+  if (pin === 'local' || pin === 'cloud') return pin
+  try { return storage?.getItem(COMPUTE_KEY) === 'cloud' ? 'cloud' : 'local' } catch { return 'local' }
+}
+export function computeApiPath(target, path) {
+  if (!['local', 'cloud'].includes(target)) throw new Error('Unknown compute target')
+  return `${target === 'cloud' ? '/api/remote/os' : '/api/os'}${path}`
+}
+let target = 'local'
+export const currentComputeTarget = () => target
+export function setComputeTarget(value) {
+  if (!['local', 'cloud'].includes(value)) throw new Error('Unknown compute target')
+  target = value
+}
+export const computeStorageKey = (key, selected = currentComputeTarget()) => `${key}:${selected}`
+export function pendingComputeRecipe(key, storage, selected = currentComputeTarget()) {
+  try {
+    const saved = JSON.parse(storage.getItem(computeStorageKey(key, selected)) ?? (selected === 'local' ? storage.getItem(key) : null))
+    return saved?.recipe && typeof saved.recipe.name === 'string' ? saved : null
+  } catch { return null }
+}
+export function saveComputeRecipe(key, value, storage, selected = currentComputeTarget()) {
+  storage.setItem(computeStorageKey(key, selected), JSON.stringify(value))
+  if (selected === 'local') storage.removeItem(key)
+}
+export function clearComputeRecipe(key, storage, selected = currentComputeTarget()) {
+  storage.removeItem(computeStorageKey(key, selected))
+  if (selected === 'local') storage.removeItem(key)
+}
+
+// First sign-in can complete an already-open cloud copy dialog. Retire its
+// session only when an existing authenticated owner leaves or is replaced.
+export function advanceComputeOwner(previous, uid) {
+  const next = uid ?? null
+  return { uid: next, revision: previous.revision + (previous.uid && previous.uid !== next ? 1 : 0) }
+}
+
+let cloudOwner = null
+export const currentCloudOwner = () => cloudOwner
+export function setCloudOwner(value) {
+  cloudOwner = typeof value === 'string' && /^[a-f0-9]{16}$/.test(value) ? value : null
+}

package/src/lib/delete-network-policies.js

@@ -0,0 +1,15 @@
+// Sequential requests let each deletion see the preceding policy change,
+// including the server's protection for a sandbox's last inherited network rule.
+export async function deleteNetworkPolicies(policies, remove) {
+  const deleted = [], failed = [], syncFailures = []
+  for (const policy of policies) {
+    try {
+      const result = await remove(policy.id)
+      deleted.push(policy.id)
+      for (const failure of result.failed ?? []) syncFailures.push({ ...failure, rule: policy.name })
+    } catch (error) {
+      failed.push({ id: policy.id, name: policy.name, message: error.message })
+    }
+  }
+  return { deleted, failed, syncFailures }
+}

package/src/lib/egress-groups.js

@@ -0,0 +1,24 @@
+// Scope every displayed value to the sandboxes in this group. A destination
+// shared by two groups can have different access, sources, ports and traffic.
+export function groupDestinations(destinations, query = "", sourceFilter = "all") {
+  const needle = query.trim().toLowerCase()
+  const groups = new Map()
+  for (const destination of destinations) {
+    for (const group of destination.groups) {
+      const grants = destination.grants.filter((grant) => grant.groupId === group.id)
+      const sources = new Set(grants.map((grant) => grant.source))
+      if (sourceFilter !== "all" && !sources.has(sourceFilter)) continue
+      if (needle && ![destination.host, group.name, ...grants.flatMap((grant) => [grant.sandbox, grant.key])].join(" ").toLowerCase().includes(needle)) continue
+      const sandboxes = new Set(grants.map((grant) => grant.sandbox))
+      const scoped = {
+        ...destination, groups: [group], grants, sandboxes, sources,
+        access: new Set(grants.flatMap((grant) => grant.access)),
+        ports: new Set(grants.flatMap((grant) => grant.ports)),
+        hits: [...sandboxes].reduce((sum, name) => sum + (destination.hitsBySandbox.get(name) ?? 0), 0),
+      }
+      if (!groups.has(group.id)) groups.set(group.id, { ...group, destinations: [] })
+      groups.get(group.id).destinations.push(scoped)
+    }
+  }
+  return [...groups.values()].sort((a, b) => a.id === null ? 1 : b.id === null ? -1 : a.name.localeCompare(b.name))
+}

package/src/lib/egress.js

@@ -0,0 +1,28 @@
+import { groupIds } from "../../shared/group-membership.js"
+
+// Network rule helpers shared by the server (server/egress.js, server/org.js)
+// and the Network page, so coverage shown in the browser matches what the
+// server writes into each sandbox.
+
+// A policy reaches every sandbox, the sandboxes in its groups, named ones, or
+// the sandboxes that use one of its MCPs & Skills setups.
+export const appliesTo = (policy, sandbox) => policy.appliesTo.everyone
+  || groupIds(sandbox.groups ?? sandbox.group).some((id) => policy.appliesTo.groups.includes(id))
+  || policy.appliesTo.sandboxes.includes(sandbox.name)
+  || (policy.appliesTo.setups ?? []).some((id) => (sandbox.setups ?? []).includes(id))
+
+// Blocking example.com also blocks its subdomains. OpenShell rejects `**.com`,
+// so a bare top-level name stays exact.
+export const blockHosts = (host) => (host.startsWith("*") || !host.includes(".") ? [host] : [host, `**.${host}`])
+export const blockPatterns = (hosts) => hosts.flatMap(blockHosts)
+
+// `*.a.com` is one label deep, `**.a.com` any depth; otherwise exact.
+export function hostMatches(pattern, host) {
+  host = String(host ?? "").toLowerCase()
+  if (pattern.startsWith("**.")) return host.endsWith(pattern.slice(2))
+  if (pattern.startsWith("*.")) {
+    const rest = pattern.slice(1)
+    return host.endsWith(rest) && !host.slice(0, -rest.length).includes(".") && host.length > rest.length
+  }
+  return host === pattern
+}

package/src/lib/files.js

@@ -0,0 +1,24 @@
+// Shared by the Files tab, New sandbox and the server's file routes.
+
+export const SANDBOX_ROOT = "/sandbox"
+// One transfer, either way. The microVM disk is about 4 GB in total.
+export const TRANSFER_LIMIT = 1024 ** 3
+
+export function formatBytes(bytes) {
+  if (bytes == null || !Number.isFinite(bytes)) return "-"
+  if (bytes < 1024) return `${bytes} B`
+  const units = ["KB", "MB", "GB", "TB"]
+  let value = bytes / 1024
+  let unit = 0
+  while (value >= 1024 && unit < units.length - 1) { value /= 1024; unit++ }
+  return `${value >= 10 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`
+}
+
+export function shellQuote(value) {
+  return /^[\w@%+=:,./~-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`
+}
+
+// The same transfers from a terminal. A leading ~/ stays unquoted so the shell expands it.
+const localArg = (local) => (local.startsWith("~/") ? `~/${shellQuote(local.slice(2))}` : shellQuote(local))
+export const uploadCommand = (sandbox, local, dest = SANDBOX_ROOT) => `openshell sandbox upload ${shellQuote(sandbox)} ${localArg(local)} ${shellQuote(dest)}`
+export const downloadCommand = (sandbox, remote, local = ".") => `openshell sandbox download ${shellQuote(sandbox)} ${shellQuote(remote)} ${localArg(local)}`

package/src/lib/fleet.js

@@ -0,0 +1,100 @@
+// What the gateway's proxy has decided, folded per sandbox and per host. Built
+// from the live audit buffer (the most recent decisions, not all of history),
+// so counts are "lately", and a sandbox with no entry has simply been quiet.
+import { hostOf } from "./policy-sources.js"
+export { hostOf }
+const isIp = (host) => /^\d+\.\d+\.\d+\.\d+$/.test(host)
+
+export function foldTraffic(events) {
+  const bySandbox = new Map()
+  const byHost = new Map()
+  let allowed = 0, denied = 0
+  for (const e of events) {
+    if (e.kind !== "audit" || !e.verdict) continue
+    const verdict = e.verdict === "allowed" ? "allowed" : "denied"
+    verdict === "allowed" ? allowed++ : denied++
+    let box = bySandbox.get(e.sandbox)
+    if (!box) bySandbox.set(e.sandbox, (box = { allowed: 0, denied: 0, hosts: new Map(), last: e.at }))
+    box[verdict] += 1
+    const host = hostOf(e.destination)
+    if (!host || isIp(host)) continue
+    const perBox = box.hosts.get(host) ?? { allowed: 0, denied: 0 }
+    perBox[verdict] += 1
+    box.hosts.set(host, perBox)
+    let entry = byHost.get(host)
+    if (!entry) byHost.set(host, (entry = { host, allowed: 0, denied: 0, sandboxes: new Set() }))
+    entry[verdict] += 1
+    entry.sandboxes.add(e.sandbox)
+  }
+  const hosts = [...byHost.values()].sort((a, b) => (b.allowed + b.denied) - (a.allowed + a.denied) || a.host.localeCompare(b.host))
+  return { bySandbox, hosts, allowed, denied }
+}
+
+export const rankHosts = (hosts) => [...hosts].map(([host, n]) => ({ host, ...n })).sort((a, b) => (b.allowed + b.denied) - (a.allowed + a.denied))
+
+// ---- development only: a synthetic fleet, to see the page at scale ----------
+// Opened with `?fleet=10000`. Never reached in a production build.
+
+const IMAGES = ["claude-sandbox:latest", "codex-sandbox:1.4", "python:3.12-slim", "node:22-alpine", "gateway default", "rust-agent:0.9", "browser-use:2"]
+const GROUPS = ["coding-agents", "research", "evals", "support-bots", "data-pipelines", null]
+const PROVIDERS = [["my-claude"], ["openai-prod"], ["my-claude", "github"], [], ["github"]]
+const HOSTS = ["api.anthropic.com", "api.openai.com", "github.com", "pypi.org", "registry.npmjs.org", "files.pythonhosted.org", "objects.githubusercontent.com", "huggingface.co", "sentry.io", "api.stripe.com", "pastebin.com", "ngrok.io", "s3.amazonaws.com"]
+const SUSPECT = new Set(["pastebin.com", "ngrok.io", "api.stripe.com"])
+const PHASES = [["ready", 0.78], ["stopped", 0.12], ["provisioning", 0.04], ["completed", 0.035], ["error", 0.025]]
+
+function seeded(seed) {
+  let s = seed >>> 0
+  return () => ((s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32)
+}
+const pick = (rand, list) => list[Math.floor(rand() * list.length)]
+function pickPhase(rand) {
+  let r = rand()
+  for (const [phase, p] of PHASES) { if ((r -= p) <= 0) return phase }
+  return "ready"
+}
+
+export function demoFleet(size) {
+  const rand = seeded(7)
+  const now = Date.now()
+  return Array.from({ length: size }, (_, i) => {
+    const group = pick(rand, GROUPS)
+    const providers = pick(rand, PROVIDERS)
+    const phase = pickPhase(rand)
+    return {
+      id: `demo-${i}`,
+      name: `${(group ?? "box").split("-")[0]}-${(i + 1).toString(36).padStart(4, "0")}`,
+      workspace: "default",
+      createdAt: new Date(now - rand() * 30 * 86400000).toISOString(),
+      phase,
+      image: pick(rand, IMAGES),
+      providers,
+      command: rand() > 0.3 ? ["claude"] : [],
+      tty: true,
+      labels: group ? { "openshell.console/group": group } : {},
+      policyVersion: 1 + Math.floor(rand() * 6),
+      conditions: [],
+      problem: phase === "error" ? "Supervisor session lost" : null,
+    }
+  })
+}
+
+export function demoEvent(sandboxes, rand = Math.random, at = new Date().toISOString()) {
+  const box = sandboxes[Math.floor(rand() ** 2.2 * sandboxes.length)]
+  const host = rand() < 0.08 ? pick(rand, [...SUSPECT]) : HOSTS[Math.floor(rand() ** 1.8 * (HOSTS.length - 3))]
+  const denied = SUSPECT.has(host) ? rand() < 0.9 : rand() < 0.03
+  return {
+    sandbox: box.name, at, kind: "audit", level: "OCSF", category: "NET", action: "OPEN", severity: denied ? "MED" : "INFO",
+    verdict: denied ? "denied" : "allowed", destination: `${host}:443`, binary: "/usr/local/bin/claude",
+    reason: denied ? "policy_dns_ineligible" : null, policy: denied ? null : "_provider_my_claude",
+    message: `NET:OPEN [${denied ? "MED" : "INFO"}] ${denied ? "DENIED" : "ALLOWED"} /usr/local/bin/claude(0) -> ${host}:443 #${Math.floor(rand() * 1e9)}`,
+    detail: `/usr/local/bin/claude(0) -> ${host}:443`,
+  }
+}
+
+export function demoHistory(sandboxes, count = 2000) {
+  const rand = seeded(11)
+  const now = Date.now()
+  const phase = new Map(sandboxes.map((s) => [s.name, s.phase]))
+  return Array.from({ length: count }, (_, i) => demoEvent(sandboxes, rand, new Date(now - i * 1500).toISOString()))
+    .filter((e) => ["ready", "error"].includes(phase.get(e.sandbox)))
+}

package/src/lib/format.js

@@ -0,0 +1,24 @@
+// Relative activity ("7m ago") and session uptime ("2h") - spec §7.
+
+export function relativeTime(iso) {
+  const minutes = Math.round((Date.now() - new Date(iso).getTime()) / 60_000)
+  if (minutes < 1) return "just now"
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.round(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  return `${Math.round(hours / 24)}d ago`
+}
+
+export function duration(iso) {
+  if (!iso || !Number.isFinite(Date.parse(iso))) return "Not reported"
+  const minutes = Math.max(1, Math.round((Date.now() - new Date(iso).getTime()) / 60_000))
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h`
+  return `${Math.floor(hours / 24)}d`
+}
+
+export function absoluteTime(iso) {
+  if (!iso || !Number.isFinite(Date.parse(iso))) return "Not reported"
+  return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" }).format(new Date(iso))
+}

package/src/lib/groups.js

@@ -0,0 +1,16 @@
+import { groupIds } from "../../shared/group-membership.js"
+import { appliesTo } from "@/lib/egress"
+
+// Groups collect sandboxes so egress policies can follow them. Membership is
+// stored by the console (server/org.js), so a sandbox can change groups.
+
+export const groupId = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48).replace(/-$/, "")
+
+// The group a sandbox is in, from the console's overview.
+export const groupFor = (org, name) => groupIds(org?.assignments?.[name])
+
+// The policies that reach one sandbox, whether or not it exists yet.
+export const policiesFor = (policies, sandbox) => (policies ?? []).filter((p) => appliesTo(p, sandbox))
+
+// The policies aimed at a group itself, not at every sandbox.
+export const groupPolicies = (policies, id) => (policies ?? []).filter((p) => !p.appliesTo.everyone && p.appliesTo.groups.includes(id))