openrod 0.0.0 → 0.1.0

package/server/local-catalog.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+import { contextKey, contextSelection, runWithContext, resolveGateway } from './gateway.js'
+import { policyDirectory, scopedStateDirectory } from './paths.js'
+import { listGroups, readOrg, serializeOrgWrite } from './org.js'
+import { listPolicies, validatePolicy } from './egress.js'
+import { listTemplates, validateTemplate } from './policy.js'
+import { getSetupStore } from './setups.js'
+import { artifactFile } from './setup-packages.js'
+import { hash } from './setup-discovery.js'
+import { PACKAGE_PENDING } from '../shared/setup-launch.js'
+import { composeTemplate } from '../shared/policy-templates.js'
+
+const fail = message => Object.assign(new Error(message), { status: 409 })
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex')
+
+// A catalog is a versioned snapshot, not a live grant. Changed local definitions
+// get new remote identities: neither existing remote rules nor memberships are
+// overwritten. Sandbox-specific grants and memberships never cross gateways.
+export function planLocalCatalog(snapshot, source, architecture) {
+  // Publish a new generation when the import format changes: old snapshots
+  // remain attached to their sandboxes and are never overwritten in place.
+  const generation = digest(['local-catalog-v2', contextKey(source), snapshot])
+  const id = (kind, original) => 'local-' + digest([generation, kind, original]).slice(0, 32)
+  const setupId = original => digest([generation, 'setup', original]).slice(0, 24)
+  const groups = new Map(snapshot.groups.map(g => [g.id, id('group', g.id)]))
+  const templates = new Map(snapshot.templates.map(t => [t.id, id('template', t.id)]))
+  const setups = new Map(snapshot.setups.map(s => [s.id, setupId(s.id)]))
+  const localSource = { context: contextKey(source), generation }
+  const copiedSetups = snapshot.setups.map(original => {
+    const items = original.items.map(originalItem => {
+      const item = structuredClone(originalItem)
+      if (item.credentialRef) {
+        // GetProvider deliberately redacts secrets. Copying its output would
+        // silently replace credentials with REDACTED. Require destination login.
+        item.credentialFields = Object.keys(item.credentialRef.aliases ?? {})
+        delete item.credentialRef
+        item.issues = [...new Set([...item.issues, `Connect credentials (${item.credentialFields.join(', ')}) on this remote gateway to use this MCP.`])]
+        item.state = 'needs-attention'
+      }
+      if (item.artifact && item.artifact.arch !== architecture && item.package) {
+        delete item.artifact
+        item.config = null
+        item.issues = [...new Set([...item.issues, PACKAGE_PENDING])]
+        item.state = 'needs-attention'
+      }
+      return item
+    })
+    return { ...original, id: setups.get(original.id), items, revision: hash(JSON.stringify(items)), localSource,
+      ...(original.preparedFrom ? { preparedFrom: { ...original.preparedFrom, id: setups.get(original.preparedFrom.id) ?? original.preparedFrom.id } } : {}) }
+  })
+  // Materialize composed access rules, including local edits to built-ins,
+  // rather than resolving those ids against the destination's built-ins.
+  const copiedTemplates = snapshot.templates.map(t => validateTemplate({ ...composeTemplate(t, [], snapshot.templates), id: templates.get(t.id), accessTemplates: [] }))
+  const copiedGroups = snapshot.groups.map(g => ({ ...g, id: groups.get(g.id), template: g.template ? templates.get(g.template) : null, localSource }))
+  const copiedPolicies = snapshot.policies.map(p => {
+    const appliesTo = { everyone: false, sandboxes: [], groups: p.appliesTo.everyone ? [...groups.values()] : p.appliesTo.groups.map(v => groups.get(v)).filter(Boolean), setups: p.appliesTo.setups.map(v => setups.get(v)).filter(Boolean) }
+    if (!appliesTo.groups.length && !appliesTo.setups.length) return null
+    const setup = p.setup && setups.has(p.setup.id) ? { ...p.setup, id: setups.get(p.setup.id) } : null
+    return validatePolicy({ ...p, id: setup ? `setup-${setup.id}` : id('policy', p.id), appliesTo, setup })
+  }).filter(Boolean)
+  for (let offset = 0; offset < snapshot.organization.blocked.length && copiedGroups.length; offset += 200) copiedPolicies.push(validatePolicy({
+    id: id('policy', 'organization-blocked-' + offset), name: 'Local organization restrictions', action: 'block',
+    destinations: snapshot.organization.blocked.slice(offset, offset + 200),
+    appliesTo: { everyone: false, groups: [...groups.values()], sandboxes: [], setups: [] },
+  }))
+  return { generation, groups: copiedGroups, templates: copiedTemplates, policies: copiedPolicies, setups: copiedSetups }
+}
+
+async function writeExclusive(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+  try { await fs.writeFile(file, JSON.stringify(value), { mode: 0o600, flag: 'wx' }) }
+  catch (error) { if (error.code !== 'EEXIST') throw error }
+}
+
+export async function syncLocalCatalog(source, { architecture, target = contextSelection() } = {}) {
+  if (!source) return { groups: [], setups: [], templates: [], available: false }
+  if (contextKey(source) === contextKey(target) || resolveGateway(source.gateway).remote || !resolveGateway(target.gateway).remote) throw fail('Choose a local source and a remote destination.')
+  const snapshot = await runWithContext(source, async () => {
+    const store = getSetupStore()
+    const [groups, templates, policies, organization, setupViews] = await Promise.all([listGroups(), listTemplates(), listPolicies(), readOrg(), store.list()])
+    const setups = await Promise.all(setupViews.filter(s => !s.localSource).map(s => store.get(s.id)))
+    return { groups, templates, policies, organization, setups }
+  })
+  const plan = planLocalCatalog(snapshot, source, architecture)
+  // Verify all package archives before publishing any selectable Setup.
+  const artifacts = await runWithContext(source, async () => Promise.all(
+    [...new Map(plan.setups.flatMap(s => s.items.filter(i => i.artifact).map(i => [i.artifact.digest, i.artifact]))).values()]
+      .map(async artifact => ({ artifact, data: (await artifactFile(artifact)).data })),
+  ))
+  const importedGroups = await runWithContext(target, () => serializeOrgWrite(async () => {
+    const policies = await policyDirectory(), state = scopedStateDirectory()
+    for (const { artifact, data } of artifacts) {
+      const file = path.join(state, 'setup-artifacts', artifact.digest + '.tar.gz')
+      await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+      try { await fs.writeFile(file, data, { mode: 0o600, flag: 'wx' }) } catch (error) { if (error.code !== 'EEXIST') throw error }
+    }
+    for (const template of plan.templates) await writeExclusive(path.join(policies, template.id + '.json'), template)
+    for (const group of plan.groups) await writeExclusive(path.join(policies, 'org/groups', group.id + '.json'), group)
+    for (const policy of plan.policies) await writeExclusive(path.join(policies, 'egress', policy.id + '.json'), policy)
+    for (const setup of plan.setups) await writeExclusive(path.join(state, 'setups', setup.id + '.json'), setup)
+    const groupFiles = await fs.readdir(path.join(policies, 'org/groups')).catch(error => { if (error.code === 'ENOENT') return []; throw error })
+    const imported = await Promise.all(groupFiles.filter(file => file.endsWith('.json')).map(async file => {
+      const group = JSON.parse(await fs.readFile(path.join(policies, 'org/groups', file), 'utf8'))
+      return group.localSource ? group.id : null
+    }))
+    return imported.filter(Boolean)
+  }))
+  return { available: true, generation: plan.generation, groups: plan.groups.map(g => g.id), importedGroups, setups: plan.setups.map(s => s.id), templates: plan.templates.map(t => t.id) }
+}

package/server/local-cloud-native.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createHash, randomUUID } from 'node:crypto'
+import { spawn } from 'node:child_process'
+import { connectionView, launchNativeTerminal } from './ssh.js'
+import { findExecutable, sshBinary, shellQuote, fail } from './openshell-cli.js'
+import { projectOf } from '../src/lib/sandbox-session.js'
+import { readJson, responseJson } from './remote-http.js'
+import { validateHostKeys } from './cloud-ssh.js'
+import { cloudOrigin } from './cloud-origin.js'
+
+const NAME = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/
+const EDITORS = { cursor: { label: 'Cursor', binary: 'cursor', app: 'Cursor.app' }, vscode: { label: 'VS Code', binary: 'code', app: 'Visual Studio Code.app' } }
+const ownerId = uid => createHash('sha256').update(uid).digest('hex').slice(0, 16)
+// SSH config quoted values and ProxyCommand percent expansion need distinct
+// escaping; neither ever contains a grant, gateway credential, or SSH secret.
+const configQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`
+const proxyQuote = value => shellQuote(String(value).replaceAll('%', '%%'))
+const scopedTarget = (target, context) => context ? `${target}?${new URLSearchParams({ context, location: '1' })}` : target
+
+async function readManaged(file) {
+  try {
+    const stat = await fs.lstat(file)
+    if (!stat.isFile() || stat.isSymbolicLink()) throw fail('OpenRod SSH config must be a regular file.', 409)
+    return await fs.readFile(file, 'utf8')
+  } catch (error) { if (error.code === 'ENOENT') return ''; throw error }
+}
+async function writeManaged(file, text) {
+  await readManaged(file)
+  const temp = `${file}.${randomUUID()}.tmp`
+  try { await fs.writeFile(temp, text, { mode: 0o600, flag: 'wx' }); await fs.rename(temp, file) }
+  finally { await fs.rm(temp, { force: true }) }
+}
+function launchEditor(file, args, { spawnProcess = spawn } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnProcess(file, args, { shell: false, detached: true, stdio: 'ignore' })
+    child.once('error', () => reject(fail('Could not launch the editor.', 502)))
+    child.once('spawn', () => { child.unref(); resolve() })
+  })
+}
+
+export function createLocalCloudNative(dependencies = {}) {
+  const home = dependencies.home ?? os.homedir(), env = dependencies.env ?? process.env
+  const platform = dependencies.platform ?? process.platform
+  const directory = path.join(home, '.config/openrod'), configFile = path.join(directory, 'cloud_ssh_config'), hostsFile = path.join(directory, 'cloud_known_hosts')
+  const helper = dependencies.helper ?? fileURLToPath(new URL('./cloud-ssh-proxy.cjs', import.meta.url)), node = dependencies.node ?? process.execPath
+  let queue = Promise.resolve()
+  const serial = task => { const result = queue.then(task, task); queue = result.catch(() => {}); return result }
+  const findEditor = dependencies.findEditor ?? (id => {
+    const editor = EDITORS[id]
+    return findExecutable(editor.binary, [...(env.PATH ?? '').split(path.delimiter).filter(Boolean), ...['/Applications', path.join(home, 'Applications')].map(root => path.join(root, editor.app, 'Contents/Resources/app/bin'))])
+  })
+  const aliasFor = (uid, name, context) => `openrod-cloud-${ownerId(uid)}-${name}${context ? '-' + ownerId(context) : ''}`
+  const commandFor = alias => `${shellQuote(sshBinary(env) ?? 'ssh')} -F ${shellQuote(configFile)} ${shellQuote(alias)}`
+
+  const assertActive = (services, grant) => { if (services.connection() !== grant) throw fail('Cloud connection changed. Open the sandbox from OpenRod again.', 403) }
+  async function install(name, origin, services, grant, requestedContext) {
+    assertActive(services, grant)
+    const owner = grant.user.uid
+    const ticket = await services.call(scopedTarget(`/os/sandboxes/${name}/ssh-ticket`, requestedContext), { method: 'POST', body: {} })
+    const keys = validateHostKeys(ticket.hostKeys)
+    const context = requestedContext ?? ticket.context
+    if (requestedContext && ticket.context !== requestedContext) throw fail('Cloud workspace changed. Open the sandbox from OpenRod again.', 409)
+    const alias = aliasFor(owner, name, context)
+    assertActive(services, grant)
+    const config = [
+      `Host ${alias}`, `  HostName ${alias}`, '  User sandbox', '  StrictHostKeyChecking yes',
+      `  UserKnownHostsFile ${configQuote(hostsFile)}`, '  GlobalKnownHostsFile /dev/null',
+      '  CheckHostIP no', '  UpdateHostKeys no', '  IdentityAgent none', '  IdentitiesOnly yes',
+      '  PubkeyAuthentication no', '  PasswordAuthentication no', '  KbdInteractiveAuthentication no',
+      '  ControlMaster no', '  ServerAliveInterval 15', '  ServerAliveCountMax 3',
+      `  ProxyCommand ${[node, helper, '--origin', origin, '--sandbox', name, '--owner', ownerId(owner), ...(context ? ['--context', context] : [])].map(proxyQuote).join(' ')}`,
+    ].join('\n') + '\n'
+    await serial(async () => {
+      assertActive(services, grant)
+      await fs.mkdir(directory, { recursive: true, mode: 0o700 })
+      const stat = await fs.lstat(directory)
+      if (stat.isSymbolicLink() || !stat.isDirectory()) throw fail('OpenRod SSH directory must be a regular directory.', 409)
+      await fs.chmod(directory, 0o700)
+      const oldHosts = await readManaged(hostsFile)
+      assertActive(services, grant)
+      await writeManaged(hostsFile, oldHosts.split('\n').filter(line => line && !line.startsWith(`${alias} `)).concat(keys.map(key => `${alias} ${key}`)).join('\n') + '\n')
+      const begin = `# OpenRod Cloud ${alias}\n`, end = `# End OpenRod Cloud ${alias}\n`
+      let oldConfig = await readManaged(configFile)
+      const start = oldConfig.indexOf(begin), finish = start < 0 ? -1 : oldConfig.indexOf(end, start)
+      if (start >= 0 && finish < 0) throw fail('OpenRod SSH config has an incomplete managed entry.', 409)
+      if (start >= 0) oldConfig = oldConfig.slice(0, start) + oldConfig.slice(finish + end.length)
+      assertActive(services, grant)
+      await writeManaged(configFile, oldConfig + begin + config + end)
+      await fs.mkdir(path.join(home, '.ssh'), { recursive: true, mode: 0o700 })
+      const userConfig = path.join(home, '.ssh/config'), oldUser = await readManaged(userConfig)
+      const include = `Include ${configQuote(configFile)}`
+      assertActive(services, grant)
+      if (!oldUser.split('\n').includes(include)) await writeManaged(userConfig, `${include}\n${oldUser}`)
+    })
+    assertActive(services, grant)
+    return { ticket, alias, config, command: commandFor(alias) }
+  }
+
+  return async function localCloudNative(req, res, target, services) {
+    const url = new URL(target, 'http://local'), parts = url.pathname.slice('/api/os/'.length).split('/')
+    if (req.method === 'GET' && parts.length === 1 && parts[0] === 'editors') {
+      responseJson(res, 200, Object.entries(EDITORS).map(([id, editor]) => ({ id, label: editor.label, installed: Boolean(findEditor(id)) }))); return true
+    }
+    if (parts[0] !== 'sandboxes' || parts.length !== 3 || !NAME.test(parts[1] ?? '') || !['ssh', 'ssh-open', 'ssh-config', 'ssh-ticket', 'editor'].includes(parts[2])) return false
+    const [, name, action] = parts
+    if (action === 'ssh' ? req.method !== 'GET' : req.method !== 'POST') return false
+    const input = req.method === 'POST' ? await readJson(req) : {}
+    const context = req.headers['x-openshell-context'] ?? url.searchParams.get('context') ?? input.context
+    if (context !== undefined && context !== null) {
+      let selection
+      try { selection = JSON.parse(context) } catch { throw fail('Invalid cloud workspace.') }
+      if (!Array.isArray(selection) || selection.length !== 2 || !selection.every(value => typeof value === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/.test(value))) throw fail('Invalid cloud workspace.')
+    }
+    const connection = services.connection(), owner = ownerId(connection.user.uid)
+    if (input.owner !== undefined && input.owner !== owner) throw fail('This SSH alias belongs to a different Google account. Open the sandbox from OpenRod again.', 403)
+    const sandbox = await services.call(scopedTarget(`/os/sandboxes/${name}`, context))
+    assertActive(services, connection)
+    const origin = `http://${req.headers.host}`
+    if (!/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(?::[0-9]+)?$/.test(origin)) throw fail('Invalid local origin.', 403)
+    let alias = aliasFor(connection.user.uid, name, context)
+    if (action === 'ssh') {
+      const view = connectionView(sandbox, { name: 'openrod-cloud', endpoint: dependencies.origin ?? cloudOrigin(), remote: true }, { env, platform })
+      const ready = sandbox.phase === 'ready'
+      if (ready) alias = (await install(name, origin, services, connection, context)).alias
+      assertActive(services, connection)
+      responseJson(res, 200, { ...view, alias, defaultMode: 'exec', cliInstalled: true, canOpenTerminal: ready && Boolean(sshBinary(env)) && view.terminalSupported, modes: ready ? { exec: { mode: 'exec', command: commandFor(alias), argv: ['-F', configFile, alias], workdir: projectOf(sandbox) ? `/sandbox/${projectOf(sandbox)}` : '/sandbox' } } : {} }); return true
+    }
+    if (sandbox.phase !== 'ready') throw fail('This sandbox is not running.', 409)
+    if (action === 'ssh-open' && input.mode !== undefined && input.mode !== 'exec') throw fail('Cloud SSH opens a fresh shell. Use the browser terminal for attach.')
+    let editor
+    if (action === 'editor') {
+      if (!Object.hasOwn(EDITORS, input.editor ?? '')) throw fail('Unknown editor.')
+      editor = findEditor(input.editor)
+      if (!editor) throw fail(`${EDITORS[input.editor].label} is not installed on this machine.`, 409)
+    }
+    if (action === 'ssh-open' && !sshBinary(env)) throw fail('OpenSSH is not installed on this machine.', 409)
+    const installed = await install(name, origin, services, connection, context)
+    assertActive(services, connection)
+    if (action === 'ssh-ticket') responseJson(res, 200, installed.ticket)
+    else if (action === 'ssh-config') responseJson(res, 200, { config: installed.config, alias, command: installed.command })
+    else if (action === 'ssh-open') {
+      await (dependencies.launchTerminal ?? launchNativeTerminal)(installed.command, { ...dependencies, platform }); responseJson(res, 200, { ok: true, mode: 'exec' })
+    } else {
+      await (dependencies.launchEditor ?? launchEditor)(editor, ['--remote', `ssh-remote+${alias}`, projectOf(sandbox) ? `/sandbox/${projectOf(sandbox)}` : '/sandbox'], dependencies)
+      responseJson(res, 200, { ok: true, editor: input.editor })
+    }
+    return true
+  }
+}

package/server/local-cloud.js

@@ -0,0 +1,123 @@
+import http from 'node:http'
+import https from 'node:https'
+import {randomBytes,randomUUID,createHash} from 'node:crypto'
+import {isLocalApiRequest,requestPath} from './security.js'
+import {validateLocalConnection} from './cloud-connections.js'
+import {readJson,responseJson,remoteFail,safeWorkspaceTarget} from './remote-http.js'
+import {cloudOrigin,CLOUD_SOON} from './cloud-origin.js'
+const PREFIX='/api/cloud/local-connect'
+const cloudPath=req=>{try{const path=requestPath(req);return path.startsWith('/api/local-cloud/')||path.startsWith('/api/remote/')}catch{return false}}
+// Without a configured cloud origin every sign-in, relay and socket route refuses before any cloud request.
+function unavailableLocalCloud(){return {close(){},setNative(){},
+ middleware(req,res,next){if(!cloudPath(req))return next();req.resume();responseJson(res,409,{error:CLOUD_SOON})},
+ upgrade(req,socket){if(!cloudPath(req))return false;socket.on('error',()=>{});socket.end(`HTTP/1.1 409 Conflict\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n${JSON.stringify({error:CLOUD_SOON})}`);return true},
+}}
+export function createLocalCloud({origin=cloudOrigin(),allowTestHttp=false,native}={}) {
+ if(!origin)return unavailableLocalCloud()
+ const url=new URL(origin)
+ if(url.origin!==origin||url.username||url.password||(!allowTestHttp&&url.protocol!=='https:'))throw Error('Invalid cloud origin')
+ const transport=url.protocol==='https:'?https:http
+ let pending,grant,expiry,generation=0
+ const active=new Set(),exchanging=new Map()
+ function clear(){grant=null;clearTimeout(expiry);for(const stream of active)stream.destroy();active.clear()}
+ function connection(){if(!grant||grant.expires<=Date.now()){clear();throw remoteFail('Connect to OpenRod Cloud first',401)}return grant}
+ function upstream(path,{method='GET',body,token,maxBytes=64000}={}) {
+  return new Promise((resolve,reject)=>{
+   const req=transport.request(new URL(PREFIX+path,origin),{method,headers:{origin,host:url.host,'content-type':'application/json','x-openshell-console':'1',...(token?{authorization:`Bearer ${token}`}:{})}},res=>{
+    let raw='';res.on('data',c=>{raw+=c;if(Buffer.byteLength(raw)>maxBytes)req.destroy(remoteFail('Cloud response too large',502))});res.on('end',()=>{let value;try{value=JSON.parse(raw)}catch{return reject(remoteFail('Invalid cloud response',502))}if(res.statusCode>=300)return reject(remoteFail(value.error??'Cloud connection unavailable',res.statusCode));resolve(value)})
+   });req.setTimeout(30000,()=>req.destroy(remoteFail('Cloud connection timed out',503)));req.on('error',reject);req.end(body===undefined?undefined:JSON.stringify(body))
+  })
+ }
+ const call=(path,options={})=>upstream(path,{...options,token:connection().token})
+ const ownerId=uid=>createHash('sha256').update(uid).digest('hex').slice(0,16)
+ const assertOwner=req=>{const current=connection(),supplied=req.headers['x-openrod-local-owner']??new URL(req.url,'http://local').searchParams.get('owner');if(supplied!==ownerId(current.user.uid))throw Object.assign(remoteFail('This cloud connection belongs to a different account. Sign in again in this tab.',403),{code:'CLOUD_OWNER_CHANGED'});return current}
+ const status=()=>grant?{connected:true,user:grant.user,owner:ownerId(grant.user.uid),expires:grant.expires}:{connected:false}
+ function relay(req,res,target){
+  const current=connection(),headers={host:url.host,origin,'x-openshell-console':'1',authorization:`Bearer ${current.token}`}
+  for(const k of ['content-type','content-length','accept','range','x-openshell-context','x-openshell-location'])if(req.headers[k])headers[k]=req.headers[k]
+  const proxy=transport.request(new URL(PREFIX+'/os'+target.slice('/api/os'.length),origin),{method:req.method,headers},remote=>{
+   if(remote.statusCode===401&&grant===current){active.delete(res);clear()}
+   const headers={...remote.headers};for(const key of ['set-cookie','connection','transfer-encoding','location'])delete headers[key]
+   res.writeHead(remote.statusCode,headers);remote.pipe(res);remote.on('error',()=>res.destroy())
+  })
+  proxy.setTimeout(35*60000,()=>proxy.destroy());active.add(res)
+  proxy.on('error',()=>{if(!res.headersSent)responseJson(res,503,{error:'Cloud compute is unavailable. Reconnect or try again.'});else res.destroy()})
+  let bytes=0;req.on('data',c=>{bytes+=c.length;if(bytes>36*1024*1024){proxy.destroy();if(!res.headersSent)responseJson(res,413,{error:'Upload exceeds limit'})}})
+  res.on('close',()=>{active.delete(res);proxy.destroy()});req.pipe(proxy)
+ }
+ function relaySocket(req,socket,head,target){
+  const current=connection()
+  const proxy=transport.request(new URL(PREFIX+'/os'+target.slice('/api/os'.length),origin),{headers:{host:url.host,origin,authorization:`Bearer ${current.token}`,upgrade:'websocket',connection:'Upgrade','sec-websocket-key':req.headers['sec-websocket-key'],'sec-websocket-version':req.headers['sec-websocket-version']}})
+  active.add(socket)
+  proxy.once('upgrade',(response,remote,remoteHead)=>{
+   socket.write(`HTTP/1.1 101 Switching Protocols\r\n${Object.entries(response.headers).filter(([k])=>!['set-cookie'].includes(k)).map(([k,v])=>`${k}: ${v}`).join('\r\n')}\r\n\r\n`)
+   if(remoteHead.length)socket.write(remoteHead);if(head.length)remote.write(head)
+   socket.pipe(remote);remote.pipe(socket);socket.on('close',()=>remote.destroy());remote.on('close',()=>socket.destroy());remote.on('error',()=>socket.destroy());socket.on('error',()=>remote.destroy())
+  })
+  proxy.once('response',res=>{if(res.statusCode===401&&grant===current)clear();socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n')})
+  proxy.once('error',()=>socket.destroy());socket.once('close',()=>{active.delete(socket);proxy.destroy()});proxy.end()
+ }
+ return {
+  call,connection,close:()=>{generation++;pending=null;clear()},setNative:handler=>{native=handler},
+  async middleware(req,res,next){
+   let path
+   try{path=requestPath(req);if(!path.startsWith('/api/local-cloud/')&&!path.startsWith('/api/remote/'))return next()
+    if(!isLocalApiRequest(req))throw remoteFail('Request rejected',403)
+    if(path==='/api/local-cloud/status'&&req.method==='GET'){
+     if(grant){const current=grant;try{const result=await call('/identity');if(grant===current&&result.user?.uid===current.user.uid)current.user=result.user;return responseJson(res,200,status())}catch(error){if(grant!==current)return responseJson(res,200,status());if([401,403].includes(error.status))clear();else return responseJson(res,200,{...status(),error:error.message})}}
+     return responseJson(res,200,status())
+    }
+    if(path==='/api/local-cloud/machine'&&req.method==='GET'){const current=assertOwner(req),machine=await call('/machine');if(grant!==current)throw remoteFail('Cloud connection changed. Try again.',401);return responseJson(res,200,{...status(),machine})}
+    if(path==='/api/local-cloud/inventory'&&req.method==='GET'){const current=assertOwner(req),inventory=await call('/inventory',{maxBytes:4*1024*1024});if(grant!==current)throw remoteFail('Cloud connection changed. Try again.',401);return responseJson(res,200,inventory)}
+    if(path==='/api/local-cloud/start'&&req.method==='POST'){
+     const body=await readJson(req),verifier=randomBytes(32).toString('hex'),nonce=randomUUID(),challenge=createHash('sha256').update(verifier).digest('hex')
+     const bound=validateLocalConnection({origin:body.origin,nonce,challenge})
+     if(body.origin!==`http://${req.headers.host}`)throw remoteFail('Local origin does not match this OpenRod instance',403)
+     pending={...bound,verifier,generation:++generation,expires:Date.now()+300000}
+     return responseJson(res,200,{nonce,challenge,url:`${origin}/?handoff=1#local-connect=${Buffer.from(JSON.stringify(bound)).toString('base64url')}`})
+    }
+    if(path==='/api/local-cloud/finish'&&req.method==='POST'){
+     const body=await readJson(req),current=pending
+     if(!current||current.expires<=Date.now()||body.nonce!==current.nonce||typeof body.code!=='string')throw remoteFail('Local sign-in expired. Try again.',401)
+     pending=null;exchanging.set(current.nonce,current)
+     const result=await upstream('/exchange',{method:'POST',body:{code:body.code,verifier:current.verifier,nonce:current.nonce}}).finally(()=>exchanging.delete(current.nonce))
+     if(current.cancelled||current.generation!==generation){if(result.token)await upstream('/revoke',{method:'POST',token:result.token,body:{}}).catch(()=>{});throw remoteFail('Local connection was cancelled. Try again.',401)}
+     if(typeof result.token!=='string'||!result.user?.uid||!Number.isFinite(result.expires)||result.expires<=Date.now()||result.expires>Date.now()+3600000)throw remoteFail('Invalid cloud authorization',502)
+     clear();grant={...result,nonce:current.nonce};expiry=setTimeout(clear,Math.max(1,result.expires-Date.now()));expiry.unref?.()
+     return responseJson(res,200,status())
+    }
+    if(path==='/api/local-cloud/cancel'&&req.method==='POST'){
+     const body=await readJson(req)
+     if(typeof body.nonce!=='string')throw remoteFail('Invalid sign-in attempt')
+     if(pending?.nonce===body.nonce){pending=null;generation++}
+     const current=exchanging.get(body.nonce)
+     if(current){current.cancelled=true;if(current.generation===generation)generation++}
+     if(grant?.nonce===body.nonce){const old=grant;clear();await upstream('/revoke',{method:'POST',token:old.token,body:{}}).catch(()=>{})}
+     return responseJson(res,200,status())
+    }
+    if(path==='/api/local-cloud/disconnect'&&req.method==='POST'){
+     await readJson(req);if(grant)assertOwner(req);const old=grant;generation++;pending=null;clear()
+     if(old)await upstream('/revoke',{method:'POST',token:old.token,body:{}}).catch(()=>{})
+     return responseJson(res,200,status())
+    }
+    if(path.startsWith('/api/remote/os/')){
+     const target=safeWorkspaceTarget(req.url,'/api/remote/os'),current=assertOwner(req)
+     const boundConnection=()=>{if(connection()!==current)throw Object.assign(remoteFail('Cloud connection changed. Open this sandbox again.',403),{code:'CLOUD_OWNER_CHANGED'});return current}
+     const boundCall=async(path,options={})=>{boundConnection();const result=await upstream(path,{...options,token:current.token});boundConnection();return result}
+     if(native&&await native(req,res,target,{call:boundCall,connection:boundConnection}))return
+     boundConnection()
+     return relay(req,res,target)
+    }
+    throw remoteFail('Not found',404)
+   }catch(error){if(!res.headersSent)responseJson(res,error.status??503,{error:error.status?error.message:'Cloud connection unavailable',...(error.code?{code:error.code}:{})});else res.destroy()}
+  },
+  upgrade(req,socket,head){
+   try{if(!requestPath(req).startsWith('/api/remote/'))return false
+    if(!isLocalApiRequest(req))throw remoteFail('Request rejected',403)
+    const target=safeWorkspaceTarget(req.url,'/api/remote/os');assertOwner(req)
+    if(!['/api/os/terminal','/api/os/ssh'].includes(target.split('?')[0]))throw remoteFail('Not found',404)
+    socket.on('error',()=>{});relaySocket(req,socket,head,target);return true
+   }catch{socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');return true}
+  },
+ }
+}

package/server/location-inventory.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { contextKey, defaultContextSelection, runWithContext } from './gateway.js'
+import { stateDirectory } from './paths.js'
+
+const fail = message => Object.assign(new Error(message), { status: 409 })
+const locationOf = (context, remote = false, host = null, connected = true, error = null) => ({
+  id: contextKey(context), context: contextKey(context), gateway: context.gateway, workspace: context.workspace,
+  label: remote ? `SSH · ${host}` : 'Local', remote, ...(remote && host ? { host } : {}), connected, ...(error ? { error } : {}),
+})
+
+export function createLocationInventory({ connections, listSandboxes, listTemplates, logger = console, directory = stateDirectory(), defaultLabel = 'Local' }) {
+  const file = path.join(directory, 'remote-gateways', 'last-inventory.json')
+  let cached = null, ready = null, writes = Promise.resolve(), refreshing = null
+  const availability = new Map()
+  const load = () => ready ??= (async () => {
+    if (!connections) return
+    try {
+      const value = JSON.parse(await fs.readFile(file, 'utf8'))
+      if (value.location?.remote && typeof value.location.context === 'string' && Array.isArray(value.sandboxes) && Array.isArray(value.templates)) cached = value
+    } catch (error) { if (error.code !== 'ENOENT') logger.warn(`Remote inventory cache unavailable: ${error.message}`) }
+  })()
+  const save = value => {
+    const data = JSON.stringify(value)
+    writes = writes.catch(() => {}).then(async () => {
+      await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+      const temporary = `${file}.${randomUUID()}.tmp`
+      await fs.writeFile(temporary, data, { mode: 0o600 })
+      await fs.rename(temporary, file)
+    })
+    return writes.catch(error => logger.warn(`Remote inventory cache could not be saved: ${error.message}`))
+  }
+  async function locations(includeAvailability = true) {
+    if (!connections) return [{ ...locationOf(defaultContextSelection()), label: defaultLabel }]
+    const { returnContext, remote } = await connections.locationSnapshot()
+    return [
+      ...(returnContext && returnContext.gateway !== 'aws-eks' ? [locationOf(returnContext)] : []),
+      ...(remote ? [locationOf(remote, true, remote.host,
+        remote.status === 'connected' && (!includeAvailability || availability.get(contextKey(remote))?.connected !== false),
+        remote.error || (includeAvailability ? availability.get(contextKey(remote))?.error : null))] : []),
+    ]
+  }
+  async function resolve(context) {
+    const owner = (await locations()).find(location => location.context === context)
+    if (!owner) throw fail('This location is no longer available. Refresh before continuing.')
+    if (!owner.connected) throw fail('This SSH location is disconnected. Reconnect before continuing.')
+    return { gateway: owner.gateway, workspace: owner.workspace }
+  }
+  async function collect() {
+    await load()
+    const sources = await locations(false)
+    const inventories = await Promise.all(sources.map(async location => {
+      const previous = location.remote && cached?.location.context === location.context ? cached : null
+      if (!location.connected) return { location, sandboxes: previous?.sandboxes ?? [], templates: previous?.templates ?? [] }
+      const result = await runWithContext(location, () => Promise.allSettled([listSandboxes(), listTemplates()]))
+      const errors = result.filter(item => item.status === 'rejected').map(item => item.reason.rawMessage ?? item.reason.message ?? 'Inventory request failed')
+      const entry = {
+        location: { ...location, ...(errors.length ? { error: [...new Set(errors)].join('; ') } : {}) },
+        sandboxes: result[0].status === 'fulfilled' ? result[0].value : previous?.sandboxes ?? [],
+        templates: result[1].status === 'fulfilled' ? result[1].value : previous?.templates ?? [],
+      }
+      // A disconnect can race a response. Keep the rows, but never advertise
+      // the stopped gateway as usable or let a response replace a newer host.
+      if (location.remote) {
+        const current = (await locations(false)).find(item => item.context === location.context)
+        const connected = Boolean(current?.connected) && errors.length === 0
+        entry.location = { ...entry.location, connected, ...(current?.error ? { error: current.error } : {}) }
+        availability.set(location.context, { connected, error: entry.location.error ?? null })
+        if (current && result.some(item => item.status === 'fulfilled')) {
+          cached = entry
+          await save(entry)
+        }
+      }
+      return entry
+    }))
+    return {
+      locations: inventories.map(entry => entry.location),
+      sandboxes: inventories.flatMap(entry => entry.sandboxes.map(record => ({ ...record, location: entry.location }))),
+      templates: inventories.flatMap(entry => entry.templates.map(record => ({ ...record, location: entry.location }))),
+    }
+  }
+  return {
+    locations, resolve,
+    // Drops the cached remote reading so a forgotten host leaves nothing behind.
+    async forget() {
+      await load()
+      cached = null
+      await writes.catch(() => {})
+      await fs.rm(file, { force: true })
+    },
+    refresh: () => refreshing ??= collect().finally(() => { refreshing = null }),
+  }
+}

package/server/machines.js

@@ -0,0 +1,84 @@
+import http from 'node:http'
+import { createHash, randomBytes, randomUUID } from 'node:crypto'
+import { signWorkerRequest } from './worker-auth.js'
+export const MACHINE_DATABASE='openrod-cloud'
+const fail=(message,status=503)=>Object.assign(Error(message),{status})
+export function machineName(uid) {
+ if(typeof uid!=='string'||!uid||uid.length>128)throw fail('Invalid account',400)
+ return `openrod-user-${createHash('sha256').update(uid).digest('hex').slice(0,24)}`
+}
+export function createMachineStore(db,{maxMachines=10,now=()=>Date.now()}={}) {
+ if(!Number.isInteger(maxMachines)||maxMachines<1||maxMachines>100)throw Error('Fleet limit must be between 1 and 100')
+ const ref=uid=>db.collection('machines').doc(machineName(uid))
+ return {
+  async reserve(identity) {
+   const document=ref(identity.uid),fleet=db.collection('control').doc('fleet')
+   return db.runTransaction(async tx=>{
+    const current=await tx.get(document)
+    if(current.exists){const record=current.data();if(record.uid!==identity.uid)throw fail('Machine ownership mismatch',403);return record}
+    const counter=await tx.get(fleet),count=counter.exists?counter.data().count:0
+    if(!Number.isInteger(count)||count<0||count>=maxMachines)throw fail('Cloud capacity is full. Please try again later.')
+    const record={uid:identity.uid,email:identity.email??null,name:machineName(identity.uid),key:randomBytes(32).toString('hex'),requestId:randomUUID(),createdAt:now(),state:'provisioning',leaseUntil:0}
+    tx.set(document,record);tx.set(fleet,{count:count+1});return record
+   })
+  },
+  async get(uid){const result=await ref(uid).get();return result.exists?result.data():null},
+  async byName(name){if(!/^openrod-user-[a-f0-9]{24}$/.test(name))return null;const r=await db.collection('machines').doc(name).get();return r.exists?r.data():null},
+  async lease(uid){return db.runTransaction(async tx=>{const r=ref(uid),s=await tx.get(r);if(!s.exists||s.data().leaseUntil>now())return false;tx.update(r,{leaseUntil:now()+120000});return true})},
+  async update(uid,values){return db.runTransaction(async tx=>{const r=ref(uid);await tx.get(r);tx.update(r,values)})},
+ }
+}
+export function workerReady(record,address,{port=4600,host=new URL(process.env.OPENROD_PUBLIC_ORIGIN||process.env.OPENROD_CLOUD_ORIGIN||'https://localhost').host,timeoutMs=5000,requestProbe=http.request}={}) {
+ const request={method:'GET',url:'/api/os/overview'}
+ return new Promise(resolve=>{
+  let settled=false,deadline
+  const finish=ready=>{if(settled)return;settled=true;clearTimeout(deadline);resolve(ready)}
+  const probe=requestProbe({hostname:address,port,path:request.url,method:request.method,headers:{host,'x-openrod-worker-auth':signWorkerRequest(record.key,{uid:record.uid,expires:Date.now()+60000},request)}},response=>{response.resume();finish(response.statusCode===200)})
+  // Socket inactivity does not include DNS or a pending connection. Bound the
+  // entire probe so an unreachable worker cannot hold a provisioning lease.
+  deadline=setTimeout(()=>{finish(false);probe.destroy()},timeoutMs)
+  probe.setTimeout(timeoutMs,()=>{finish(false);probe.destroy()})
+  probe.on('error',()=>finish(false))
+  probe.on('close',()=>finish(false))
+  probe.end()
+ })
+}
+export function createMachineManager(store,compute,{ready=workerReady}={}) {
+ const inflight=new Map(),readyCache=new Map()
+ async function ensure(identity) {
+  const cached=readyCache.get(identity.uid)
+  if(cached && cached.until>Date.now())return cached.record
+  if(inflight.has(identity.uid))return inflight.get(identity.uid)
+  const task=(async()=>{
+   const record=await store.reserve(identity)
+   if(!await store.lease(identity.uid))return record
+   try{
+    const instance=await compute.get(record.name)
+    if(!instance) {
+     if(record.everReady)throw fail('Your machine is missing. Contact your OpenRod administrator.')
+     await compute.create(record)
+     await store.update(identity.uid,{state:'provisioning',error:null})
+    }else {
+     if(instance.labels?.openrod_owner!==record.name.slice(9))throw fail('Machine ownership mismatch',403)
+     const address=instance.networkInterfaces?.[0]?.networkIP
+     if(address&&!/^10\.80\.0\.\d{1,3}$/.test(address))throw fail('Unexpected worker address')
+     const isReady=instance.status==='RUNNING'&&address&&await ready(record,address)
+     const stalled=!isReady && Date.now()-record.createdAt>30*60000
+     await store.update(identity.uid,{state:isReady?'ready':stalled?'error':'provisioning',address:address??null,everReady:Boolean(record.everReady||isReady),error:stalled?'Machine startup is taking longer than expected. Contact your OpenRod administrator.':null})
+    }
+   }catch(error){await store.update(identity.uid,{state:'error',error:'Machine provisioning failed. Try again or contact your OpenRod administrator.'});console.error(JSON.stringify({event:'openrod.provision.failed',machine:record.name,error:error.message}));throw error}
+   finally{await store.update(identity.uid,{leaseUntil:0})}
+   const result=await store.get(identity.uid)
+   if(result.state==='ready')readyCache.set(identity.uid,{record:result,until:Date.now()+30000})
+   return result
+  })()
+  inflight.set(identity.uid,task)
+  try{return await task}finally{inflight.delete(identity.uid)}
+ }
+ return {store,ensure,async status(identity){const r=await ensure(identity);return {name:r.name,status:r.state,error:r.error??null}},async target(identity){const r=await ensure(identity);if(r.state!=='ready'||!r.address)throw fail('Your cloud machine is starting. Please try again shortly.');return r}}
+}
+export async function firebaseMachines(config) {
+ const { getApps }=await import('firebase-admin/app'),{getFirestore}=await import('firebase-admin/firestore')
+ const { createCompute }=await import('./compute.js')
+ return createMachineManager(createMachineStore(getFirestore(getApps()[0],MACHINE_DATABASE),{maxMachines:Number(process.env.OPENROD_MAX_MACHINES??10)}),await createCompute(config))
+}