openrod 0.0.0 → 0.1.0

package/src/lib/sandbox-images.js

@@ -0,0 +1,38 @@
+import { TOOL_ACCESS } from '../../shared/agent-access.js'
+
+// Kept on sandboxes launched from an image template, so the name survives
+// the template's deletion.
+export const IMAGE_TEMPLATE_NAME = 'openshell.console/image-template-name'
+// Image tools (such as VS Code Server) chosen at creation, comma-separated.
+export const TOOLS_LABEL = 'openshell.console/tools'
+export const recipeTools = (recipe) => recipe?.source === 'build' ? [...new Set(recipe.runtimes ?? [])].filter((id) => TOOL_ACCESS[id]) : []
+export function imageTemplateLabels(template) {
+  if (!template) return {}
+  const tools = template.managed ? recipeTools(template.recipe) : []
+  return { [IMAGE_TEMPLATE_NAME]: template.name, ...(tools.length ? { [TOOLS_LABEL]: tools.join(',') } : {}) }
+}
+// The label is authoritative; older sandboxes fall back to their template's recipe.
+export function sandboxTools(sandbox, template) {
+  const label = sandbox?.labels?.[TOOLS_LABEL]
+  if (typeof label === 'string') return label.split(',').filter((id) => TOOL_ACCESS[id])
+  return template?.managed ? recipeTools(template.recipe) : []
+}
+export const hasVscodeServer = (sandbox) => Boolean(sandbox?.tools?.includes('vscode') || sandbox?.labels?.[TOOLS_LABEL]?.split(',').includes('vscode'))
+
+// Resolve the whole fleet once. The gateway records the template a sandbox
+// came from; otherwise use the name label, or a unique template whose image
+// matches, rather than guessing between shared images.
+export function nameSandboxImages(sandboxes, templates) {
+  const byImage = new Map(), byName = new Map(templates.map((template) => [template.name, template]))
+  for (const template of templates) {
+    if (!template.image) continue
+    const names = byImage.get(template.image) ?? new Set()
+    names.add(template.name)
+    byImage.set(template.image, names)
+  }
+  return sandboxes.map((sandbox) => {
+    const matches = byImage.get(sandbox.image)
+    const name = sandbox.workloadTemplate || sandbox.labels?.[IMAGE_TEMPLATE_NAME] || (matches?.size === 1 ? [...matches][0] : null)
+    return { ...sandbox, imageTemplateName: name || null, tools: sandboxTools(sandbox, name ? byName.get(name) : null) }
+  })
+}

package/src/lib/sandbox-session.js

@@ -0,0 +1,140 @@
+import { currentComputeTarget } from './compute-target.js'
+import { AGENTS } from "./image-templates.js"
+import { agentsOf } from "./agents.js"
+
+export const SESSION_LABEL = "openshell.console/session"
+// The folder under /sandbox that a started-from-files sandbox opens in. The
+// label is read back from the gateway, so its value is checked again here:
+// one path segment of letters, digits, '-', '_' and '.', never "." or "..".
+export const PROJECT_LABEL = "openshell.console/project"
+// Set on sandboxes created with persistentTerminalPolicy; older ones lack its PTY grants.
+export const PERSISTENT_TERMINAL_LABEL = "openshell.console/persistent-terminal"
+export const persistentGateway = target => Boolean(target?.remote && /^console-ssh-[a-f0-9]{24}$/.test(target.name ?? target.gateway ?? ''))
+export const persistentTerminals = (target, sandbox) => persistentGateway(target) && sandbox?.labels?.[PERSISTENT_TERMINAL_LABEL] === '1'
+export const projectOf = (sandbox) => {
+  const value = sandbox?.labels?.[PROJECT_LABEL]
+  return typeof value === "string" && /^[A-Za-z0-9]([A-Za-z0-9._-]{0,61}[A-Za-z0-9])?$/.test(value) ? value : null
+}
+
+// What each session runs when someone connects: a login shell, or an agent by
+// its own command. Labels come from the gateway, so only these ever run.
+const SESSIONS = { shell: "/bin/bash -l", ...Object.fromEntries(AGENTS.map((a) => [a.command, a.command])) }
+export const isSession = (session) => Object.hasOwn(SESSIONS, session ?? "")
+
+// A launch may select only Shell or a session explicitly included by the template.
+export function templateSession(saved, requested) {
+  const start = saved.recipe.command.trim()
+  const fallback = !start ? 'shell' : start !== 'shell' && isSession(start) ? start : null
+  if (requested == null) return fallback
+  const installed = saved.managed && saved.recipe.source === 'build'
+    ? AGENTS.filter((agent) => saved.recipe.agents.includes(agent.id)).map((agent) => agent.command) : []
+  if (requested !== 'shell' && requested !== fallback && !installed.includes(requested)) throw new Error('Choose Shell or an agent included in this template.')
+  if (!isSession(requested)) throw new Error('Unknown session type.')
+  return requested
+}
+
+export function sessionLaunch(session, command) {
+  if (isSession(session)) {
+    return {
+      command: ["/bin/sleep", "infinity"],
+      tty: false,
+      labels: { [SESSION_LABEL]: session, ...(session !== "shell" ? { "openshell.console/agents": session } : {}) },
+    }
+  }
+  return { command, tty: command.length > 0, labels: {} }
+}
+
+const shellQuote = (value) => `'${String(value).replaceAll("'", "'\\''")}'`
+
+// Both copied commands and native launches own a private config directory.
+// The shell must stay alive while ssh runs so its exit trap removes the config.
+export function nativeSshCommand({ alias, ssh = "ssh", directory, configCommand, configHome, remoteArgv }) {
+  const script = [
+    "umask 077",
+    ...(configHome ? [`export XDG_CONFIG_HOME=${shellQuote(configHome)}`] : []),
+    directory ? `dir=${shellQuote(directory)}` : 'dir=$(mktemp -d "${TMPDIR:-/tmp}/openshell-ssh.XXXXXXXX") || exit',
+    'trap \'rm -f -- "$dir/config"; rmdir -- "$dir"\' 0',
+    "trap 'exit 129' HUP",
+    "trap 'exit 130' INT",
+    "trap 'exit 143' TERM",
+    ...(configCommand ? [`${configCommand} > "$dir/config" || exit`] : []),
+    `${shellQuote(ssh)} ${remoteArgv ? '-t ' : ''}-F "$dir/config" ${shellQuote(alias)}${remoteArgv ? ' ' + shellQuote(remoteArgv.map(shellQuote).join(' ')) : ''}`,
+  ].join("; ")
+  return `sh -c ${shellQuote(script)}`
+}
+
+// Every mode is pinned to the displayed gateway and workspace. Direct SSH
+// opens a login shell; exec starts a new console session; attach uses its TTY.
+export function connectionPlan(sandbox, { gateway, workspace = sandbox.workspace || "default", mode = "exec", executable = "openshell", ssh = "ssh", configHome, remote = false } = {}) {
+  if (!["ssh", "exec", "attach"].includes(mode)) throw new Error("Unknown connection mode.")
+  if (mode === "attach" && !sandbox.tty) throw new Error("This sandbox has no canonical TTY session.")
+  const argv = ["--gateway", gateway, "--workspace", workspace, "sandbox"]
+  if (mode === "ssh") {
+    argv.push("ssh-config", sandbox.name)
+    const alias = `openshell-${sandbox.name}.${workspace}`
+    return {
+      mode,
+      alias,
+      command: nativeSshCommand({ alias, ssh, configHome, remoteArgv: remote ? persistentSessionArgv('shell') : null, configCommand: [executable, ...argv].map(shellQuote).join(" ") }),
+      session: null,
+      workdir: null,
+    }
+  }
+  if (mode === "attach") argv.push("connect", sandbox.name)
+  else {
+    const project = projectOf(sandbox)
+    argv.push("exec", "--name", sandbox.name)
+    if (project) argv.push("--workdir", `/sandbox/${project}`)
+    argv.push("--tty", "--", ...(remote ? persistentSessionArgv(defaultSession(sandbox)) : sessionArgv(defaultSession(sandbox))))
+  }
+  return {
+    mode,
+    argv,
+    command: `${configHome ? `env ${shellQuote(`XDG_CONFIG_HOME=${configHome}`)} ` : ""}${[executable, ...argv].map(shellQuote).join(" ")}`,
+    session: mode === "exec" ? defaultSession(sandbox) : null,
+    workdir: mode === "exec" && projectOf(sandbox) ? `/sandbox/${projectOf(sandbox)}` : null,
+  }
+}
+
+// The browser terminal runs the same programs. What a tab opens by default is
+// the session the sandbox was created for, or a shell for sandboxes started
+// with their own command.
+export const sessionArgv = (session) => (isSession(session) ? SESSIONS[session].split(" ") : null)
+// Each program has one named, reattachable remote terminal. Cancelling an
+// exec kills only the tmux client; the server owns the agent and its PTY.
+export function persistentSessionArgv(session) {
+  if (!isSession(session)) throw new Error('Unknown session type.')
+  const script = `command -v tmux >/dev/null 2>&1 || exec ${sessionArgv(session).map(shellQuote).join(' ')}; exec tmux -L openshell-console new-session -A -s ${shellQuote('console-' + session)} ${sessionArgv(session).map(shellQuote).join(' ')}`
+  return ['/bin/sh', '-c', script]
+}
+export function persistentTerminalPolicy(policy) {
+  return { ...policy, filesystem: { ...policy.filesystem,
+    // tmux allocates its own PTYs, unlike an SDK exec receiving one from the
+    // supervisor. Keep these device grants explicit and remote-only.
+    readWrite: [...new Set([...(policy.filesystem?.readWrite ?? []), '/dev/ptmx', '/dev/pts'])],
+  } }
+}
+export const defaultSession = (sandbox) => (isSession(sandbox?.labels?.[SESSION_LABEL]) ? sandbox.labels[SESSION_LABEL] : "shell")
+export const sessionName = (session) => (session === "shell" ? "Shell" : AGENTS.find((a) => a.command === session)?.name ?? session)
+// A shell, plus every installed agent the console knows how to launch.
+export function sessionChoices(sandbox) {
+  const current = defaultSession(sandbox)
+  const installed = agentsOf(sandbox).flatMap((agent) => AGENTS.filter((a) => a.name === agent.name).map((a) => a.command))
+  const commands = [...new Set([...(current === "shell" ? [] : [current]), ...installed])]
+  return [{ id: "shell", name: "Shell" }, ...commands.map((command) => ({ id: command, name: sessionName(command) }))]
+}
+// Pin a new terminal tab to its originating gateway/workspace, not whichever
+// context another console tab happens to select later.
+export function terminalHref(name, session, context, target = typeof context === "string" ? context : context?.target ?? currentComputeTarget()) {
+  const query = new URLSearchParams()
+  if (session) query.set("session", session)
+  const gateway = typeof context?.gateway === "string" ? context.gateway : context?.gateway?.name ?? context?.name
+  const workspace = context?.workspace ?? context?.gateway?.workspace
+  if (gateway && workspace) {
+    query.set("gateway", gateway)
+    query.set("workspace", workspace)
+    if (context?.remote) query.set('remote', '1')
+  }
+  const suffix = query.toString()
+  return `?target=${target}#terminal/${encodeURIComponent(name)}${suffix ? `?${suffix}` : ""}`
+}

package/src/lib/sandboxes.js

@@ -0,0 +1,78 @@
+import { groupsFromLabels } from "../../shared/group-membership.js"
+// Gateway phases folded onto the OpenRod Desk status palette. The palette has five
+// states and the gateway ten; the fold keeps each colour meaning one thing.
+export const STATUS = {
+  running: { label: "Ready", bar: "bg-emerald-500", strip: "bg-emerald-500", cell: "bg-emerald-500/85", ring: "ring-emerald-600/30" },
+  sleeping: { label: "Stopped", bar: "bg-stone-300", strip: "bg-stone-400", cell: "bg-stone-300", ring: "ring-stone-400/40" },
+  provisioning: { label: "Preparing", bar: "bg-amber-400", strip: "bg-amber-400", cell: "bg-amber-400", ring: "ring-amber-600/30" },
+  error: { label: "Needs attention", bar: "bg-red-500", strip: "bg-red-500", cell: "bg-red-500", ring: "ring-red-600/40" },
+  unknown: { label: "Unverified", bar: "bg-stone-200", strip: "bg-stone-300", cell: "bg-stone-200", ring: "ring-stone-400/30" },
+}
+export const STATUS_ORDER = ["running", "sleeping", "provisioning", "error", "unknown"]
+
+const FOLD = {
+  ready: "running",
+  provisioning: "provisioning", starting: "provisioning", stopping: "provisioning",
+  stopped: "sleeping", completed: "sleeping",
+  error: "error",
+  deleting: "unknown", unknown: "unknown", unspecified: "unknown",
+}
+
+// The gateway's own word, for the places that should be exact.
+export const PHASE_LABEL = {
+  ready: "Ready", provisioning: "Provisioning", starting: "Starting", stopping: "Stopping",
+  stopped: "Stopped", completed: "Completed", error: "Error", deleting: "Deleting",
+  unknown: "Unknown", unspecified: "Unknown",
+}
+
+export const statusOf = (phase) => FOLD[phase] ?? "unknown"
+export const styleOf = (phase) => STATUS[statusOf(phase)]
+
+// A sandbox is "Completed" when its main process exited; it cannot be
+// restarted, only replaced. Stop/start apply to the rest.
+export const canStop = (phase) => ["ready", "provisioning", "starting"].includes(phase)
+export const canStart = (phase) => phase === "stopped"
+
+export const commandText = (command) => (command?.length ? command.join(" ") : "Scratch shell")
+export const imageName = (image, templateName) => templateName || (/^sha256:[a-f0-9]{64}$/i.test(image ?? "") ? "Unknown template" : image) || "Gateway default"
+
+export function summarize(sandboxes) {
+  const status = Object.fromEntries(STATUS_ORDER.map((key) => [key, 0]))
+  for (const sandbox of sandboxes) status[statusOf(sandbox.phase)] += 1
+  return { total: sandboxes.length, status }
+}
+
+export const GROUP_LABEL = "openshell.console/group"
+
+export function groupKey(sandbox, by) {
+  if (by === "group") return groupsFromLabels(sandbox.labels).sort().join(", ") || "No group"
+  if (by === "image") return imageName(sandbox.image, sandbox.imageTemplateName)
+  if (by === "provider") return sandbox.providers.length ? sandbox.providers.join(", ") : "No provider"
+  return PHASE_LABEL[sandbox.phase] ?? "Unknown"
+}
+
+export function destinationOf(chunk) {
+  const endpoint = chunk.endpoints?.[0]
+  if (!endpoint) return chunk.ruleName
+  return endpoint.port ? `${endpoint.host}:${endpoint.port}` : endpoint.host
+}
+
+export const programName = (path) => (path ? path.split("/").pop() : "Unknown program")
+
+export const ownerOf = (sandbox) => sandbox.owner || sandbox.labels?.["openshell.console/owner"] || sandbox.labels?.owner || "Not reported"
+export const creatorOf = (sandbox) => sandbox.createdBy || sandbox.labels?.["openshell.console/created-by"] || "Not reported"
+
+export function elapsedSince(value, now = Date.now()) {
+  const time = Date.parse(value)
+  if (!Number.isFinite(time)) return "Not reported"
+  const minutes = Math.max(0, Math.floor((now - time) / 60000))
+  if (minutes < 1) return "<1m"
+  if (minutes < 60) return `${minutes}m`
+  if (minutes < 1440) return `${Math.floor(minutes / 60)}h ${minutes % 60}m`
+  return `${Math.floor(minutes / 1440)}d ${Math.floor(minutes % 1440 / 60)}h`
+}
+
+export function uptimeOf(sandbox, now = Date.now()) {
+  if (["stopped", "completed"].includes(sandbox.phase)) return "Not running"
+  return sandbox.phase === "ready" ? elapsedSince(sandbox.startedAt, now) : "-"
+}

package/src/lib/secret-inventory.js

@@ -0,0 +1,26 @@
+const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' })
+export function indexSecrets(providers, profiles, now = Date.now()) {
+  const byType = new Map(profiles.map((profile) => [profile.id, profile]))
+  return providers.map((secret) => {
+    const profile = byType.get(secret.type)
+    const expiry = Object.values(secret.expires ?? {}).map(Date.parse).filter(Number.isFinite).sort((a, b) => a - b)[0] ?? null
+    const status = expiry === null ? 'none' : expiry <= now ? 'expired' : expiry <= now + 7 * 86400000 ? 'expiring' : 'scheduled'
+    const hosts = (profile?.endpoints ?? []).map((endpoint) => endpoint.host)
+    return { secret, profile, expiry, status, service: profile?.name ?? secret.type, hosts,
+      search: [secret.name, secret.type, profile?.name, ...secret.credentialKeys, ...secret.attachedTo, ...hosts].join(' ').toLowerCase() }
+  })
+}
+export function filterSecrets(rows, { query, scope, service, expiry, sort }) {
+  const q = query.trim().toLowerCase()
+  return rows.filter((row) => (!q || row.search.includes(q))
+    && (scope === 'all' || (scope === 'attached' ? row.secret.attachedTo.length > 0 : row.secret.attachedTo.length === 0))
+    && (!service || row.secret.type === service) && (!expiry || row.status === expiry))
+    .sort((a, b) => {
+      const value = (row) => ({ name: row.secret.name, service: row.service, credentials: row.secret.credentialKeys.length, attached: row.secret.attachedTo.length, expiry: row.expiry })[sort.key]
+      const av = value(a), bv = value(b)
+      if (av === null) return bv === null ? collator.compare(a.secret.name, b.secret.name) : 1
+      if (bv === null) return -1
+      const delta = typeof av === 'number' ? av - bv : collator.compare(av, bv)
+      return (sort.direction === 'asc' ? delta : -delta) || collator.compare(a.secret.name, b.secret.name)
+    })
+}

package/src/lib/services.js

@@ -0,0 +1,41 @@
+// The services a secret can be for, as a person thinks of them: a logo, a
+// name, what it's for, and where to get a key. Each maps 1:1 to one of
+// NVIDIA's published provider profiles, which the console imports on demand.
+export const SERVICE_GROUPS = [
+  { id: "agent", label: "Agents" },
+  { id: "inference", label: "Models" },
+  { id: "code", label: "Code & packages" },
+  { id: "cloud", label: "Cloud" },
+]
+
+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
+export const logoOf = (type) => (serviceOf(type) ? `/logos/${type}.svg` : null)
+
+const AUTH = {
+  header: (c) => `in the ${c.headerName ?? "custom"} header`,
+  bearer: () => "as a Bearer token",
+  basic: () => "as basic auth",
+  query: (c) => `as ?${c.queryParam ?? "…"}`,
+  path: () => "in the request path",
+}
+export const injectionOf = (c) => (AUTH[c.authStyle] ?? (() => "by the proxy"))(c)
+export const programsOf = (profile) => [...new Set((profile?.binaries ?? []).map((b) => b.split("/").pop()))]

package/src/lib/setup-import-jobs.js

@@ -0,0 +1,62 @@
+import { importSetup } from './import-setup.js'
+
+const savedPolicy = (setup) => setup?.egressPolicy ? ` ${setup.egressPolicy.created ? 'Created' : 'Updated'} the egress policy “${setup.egressPolicy.name}”.` : setup?.egressPolicyError ? ' Its egress policy wasn’t saved.' : ''
+
+// Owned by the app session, not a dialog or route. Closing either cannot stop
+// polling, saving, or delivery of the result. Credentials are not stored here.
+export function createSetupImportJobs(api, workflow = importSetup) {
+  let snapshot = []
+  const listeners = new Set()
+  const active = new Map()
+  const update = (id, patch) => {
+    snapshot = snapshot.map(job => job.id === id ? { ...job, ...patch } : job)
+    listeners.forEach(listener => listener())
+  }
+  return {
+    subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener) },
+    getSnapshot: () => snapshot,
+    updateReview(id, review, prepared) {
+      if (active.has(id)) throw new Error('Wait for the import to finish before removing items.')
+      update(id, { review, prepared, preparation: null, status: 'needs-attention', message: review.items.length ? 'Import selection updated. Review it to finish importing.' : 'No items remain in this import.' })
+    },
+    dismiss(id) { snapshot = snapshot.filter(job => job.id !== id); listeners.forEach(listener => listener()) },
+    async cancel(id) {
+      const run = active.get(id)
+      if (!run) return
+      run.cancelled = true
+      const job = snapshot.find(job => job.id === id)
+      if (job?.preparation?.status === 'running') await run.api.cancelSetupPreparation(job.preparation.id)
+    },
+    start({ id = crypto.randomUUID(), review, name, choices = {}, resumeJob, saveOnly = false, api: ownerApi = api, location = null }, callbacks = {}) {
+      if (active.has(id)) return { id, promise: active.get(id).promise }
+      const run = { cancelled: false, api: ownerApi }
+      active.set(id, run)
+      snapshot = [...snapshot.filter(job => job.id !== id), { id, name, review, location, prepared: saveOnly, status: 'importing', message: saveOnly ? 'Saving your setup…' : 'Preparing your tools…' }]
+      listeners.forEach(listener => listener())
+      run.promise = (async () => {
+        try {
+          const result = saveOnly
+            ? { status: 'saved', setup: await ownerApi.saveSetup(review.token, name, true), inactive: review.items.filter(item => !item.disabled && item.issues?.length).map(item => item.name) }
+            : await workflow(ownerApi, review, name, choices, {
+              resumeJob,
+              isCancelled: () => run.cancelled,
+              onProgress: preparation => {
+                update(id, { preparation, message: preparation.message })
+                callbacks.onProgress?.(preparation)
+              },
+              onReview: next => {
+                update(id, { review: next, prepared: true })
+                callbacks.onReview?.(next)
+              },
+            })
+          update(id, { status: result.status, setup: result.setup, ...(result.status === 'cancelled' ? { prepared: false } : {}), message: result.status === 'saved' ? `Available in templates and sandboxes.${result.inactive?.length ? ` Inactive: ${result.inactive.join(', ')}.` : ''}${savedPolicy(result.setup)}` : result.status === 'needs-attention' ? 'Some items need attention. Open the import to remove or fix them.' :'Import cancelled. You can resume from the completed preparation.' })
+          return result
+        } catch (error) {
+          update(id, { status: 'failed', message: error.message })
+          throw error
+        } finally { active.delete(id) }
+      })()
+      return { id, promise: run.promise }
+    },
+  }
+}

package/src/lib/setup-imports.js

@@ -0,0 +1,4 @@
+import { api } from './api.js'
+import { createSetupImportJobs } from './setup-import-jobs.js'
+
+export const setupImports = createSetupImportJobs(api)

package/src/lib/setup-network.js

@@ -0,0 +1,39 @@
+import { hostMatches } from './egress.js'
+
+// Each saved setup gets one managed allow policy (server/setup-egress.js). A
+// Quick-setup snapshot uses the policy of the setup it was prepared from.
+export const setupPolicies = (policies, setup) => (policies ?? []).filter(p => p.action === 'allow' && (p.appliesTo?.setups ?? []).some(id => id === setup.id || id === setup.preparedFrom?.id))
+// Narrowed in Egress (programs, request rules, private addresses), a policy no longer settles access on its own; the server then asks for a grant.
+const unrestricted = (a = {}) => !a.programs?.length && (a.requests ?? 'any') === 'any' && !a.deny?.length && !a.privateIps?.length
+export const coveredBySetupPolicy = (policies, setup, r) => setupPolicies(policies, setup).some(p => unrestricted(p.advanced) && (p.advanced?.ports ?? [443, 80]).map(Number).includes(Number(r.port ?? 443)) && p.destinations.some(d => hostMatches(d, r.host)))
+
+// The policy opens an MCP's runtime hosts and its own sign-in host. An MCP
+// that sends credentials, and sign-in services named by an MCP's metadata,
+// are approved for each sandbox instead, when the setup is enabled there.
+export const credentialed = (item) => Boolean(item.credentialRef || item.credentialFields?.length)
+const same = (a, b) => String(a ?? '').toLowerCase() === String(b ?? '').toLowerCase()
+export const inSetupPolicy = (item, r) => !credentialed(item) && (r.phase === 'runtime' || (r.phase === 'auth' && (item.requirements ?? []).some(o => o.phase === 'runtime' && same(o.host, r.host))))
+
+const hostPort = (r) => `${r.host}${Number(r.port ?? 443) === 443 ? '' : `:${r.port}`}`
+export const accessLabel = (r) => `${hostPort(r)}${r.path || ''}`
+// The runtime and sign-in hosts of the chosen setups, split into those their
+// egress policies already allow and those that still need approval. Without
+// policies (they failed to load), every host needs approval. Policies open
+// whole hosts, so covered ones are listed by host.
+export function setupAccess(setups, policies, itemsOf, requirementsOf = item => item.requirements ?? []) {
+  const covered = new Set(), uncovered = new Map()
+  for (const setup of setups) for (const item of itemsOf(setup)) for (const r of requirementsOf(item).filter(r => ['runtime', 'auth'].includes(r.phase))) {
+    if (policies && !(r.phase === 'runtime' && credentialed(item)) && coveredBySetupPolicy(policies, setup, r)) covered.add(hostPort(r))
+    else uncovered.set(accessLabel(r), hostPort(r))
+  }
+  const pending = new Set(uncovered.values())
+  return { covered: [...covered].filter(host => !pending.has(host)), uncovered: [...uncovered.keys()] }
+}
+
+// One row per website the saved policy allows, with the MCPs that need it.
+// Websites added by hand have no MCP.
+export function policyRows(policy) {
+  const hosts = policy?.hosts ?? []
+  const names = (host) => [...new Set(hosts.filter(h => h.host === host).flatMap(h => h.items ?? []))]
+  return [...new Set(policy?.destinations ?? hosts.map(h => h.host))].filter(host => !policy?.blocked?.includes(host)).map(host => ({ host, items: names(host) }))
+}

package/src/lib/setup-template-build.js

@@ -0,0 +1,17 @@
+import { newRecipe } from './image-templates.js'
+import { prepareQuickSetups } from './quick-setup.js'
+
+export async function buildTemplateWithSetups(api, recipe, replace, options = {}) {
+  const prepared = await prepareQuickSetups(api, recipe.setups || [], null, {
+    ...options, expectedRevisions: recipe.setupRevisions,
+  })
+  if (options.signal?.aborted) throw new DOMException('Preparation cancelled.', 'AbortError')
+  const pinned = newRecipe({
+    ...recipe,
+    setups: prepared.setups.map(s => s.id),
+    setupRevisions: Object.fromEntries(prepared.setups.map(s => [s.id, s.revision])),
+  })
+  options.onPrepared?.()
+  options.onProgress?.('Starting image build…')
+  return api.buildImageTemplate(pinned, replace)
+}

package/src/lib/utils.js

@@ -0,0 +1,6 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs) {
+  return twMerge(clsx(inputs))
+}