openrod 0.1.2 → 0.1.3

package/server/ingress.js

@@ -3,6 +3,7 @@ import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { gateway, iso, contextKey, contextSelection, runWithContext } from './gateway.js'
 import { stateDirectory } from './paths.js'
+import { assertCloudOperation } from './security.js'
 
 // Ingress: the ways into a sandbox. OpenShell sandboxes accept nothing inbound
 // on their own; every way in is something the gateway opened on purpose:
@@ -79,6 +80,7 @@ async function setDeadline(sandbox, name, expiresAt) {
 }
 
 export async function expose({ sandbox, name = '', port, closeAfterMinutes }) {
+  assertCloudOperation(['ingress', 'expose'])
   if (!SANDBOX.test(sandbox ?? '')) throw fail('Unknown sandbox.')
   if (!SERVICE.test(name)) throw fail('Service names use lowercase letters, digits and dashes (up to 32).')
   const targetPort = Number(port)
@@ -99,6 +101,7 @@ export async function close({ sandbox, name = '' }, reason = 'closed') {
 }
 
 async function extend({ sandbox, name = '', closeAfterMinutes }) {
+  assertCloudOperation(['ingress', 'extend'])
   if (!SANDBOX.test(sandbox ?? '') || !SERVICE.test(name)) throw fail('Unknown service.')
   const services = await listServices()
   if (!services.some((s) => s.sandbox === sandbox && s.name === name)) throw fail('That service is no longer open.')

package/server/local-cloud-native.js

@@ -10,6 +10,7 @@ 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'
+import { tokenCookie } from './launch-token.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' } }
@@ -65,13 +66,14 @@ export function createLocalCloudNative(dependencies = {}) {
     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 authFile = dependencies.token ? path.join(directory, `cloud_ssh_auth_${ownerId(origin)}`) : null
     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(' ')}`,
+      `  ProxyCommand ${[node, helper, '--origin', origin, '--sandbox', name, '--owner', ownerId(owner), ...(authFile ? ['--auth-file', authFile] : []), ...(context ? ['--context', context] : [])].map(proxyQuote).join(' ')}`,
     ].join('\n') + '\n'
     await serial(async () => {
       assertActive(services, grant)
@@ -79,6 +81,10 @@ export function createLocalCloudNative(dependencies = {}) {
       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)
+      if (authFile) {
+        assertActive(services, grant)
+        await writeManaged(authFile, JSON.stringify({ origin, cookie: tokenCookie(new URL(origin).port || '80', dependencies.token) }) + '\n')
+      }
       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')

package/server/local-cloud.js

@@ -9,7 +9,7 @@ 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})},
+ middleware(req,res,next){if(!cloudPath(req))return next();if(!isLocalApiRequest(req)){req.resume();return responseJson(res,403,{error:'Request rejected'})}if(requestPath(req)==='/api/local-cloud/status'&&req.method==='GET')return responseJson(res,200,{available:false,connected:false,reason:CLOUD_SOON});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}={}) {
@@ -31,7 +31,7 @@ export function createLocalCloud({origin=cloudOrigin(),allowTestHttp=false,nativ
  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}
+ const status=()=>({available:true,origin,...(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]
@@ -67,7 +67,7 @@ export function createLocalCloud({origin=cloudOrigin(),allowTestHttp=false,nativ
      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/machine'&&['GET','POST'].includes(req.method)){const current=assertOwner(req);if(req.method==='POST')await readJson(req);const machine=await call('/machine',{method:req.method,...(req.method==='POST'?{body:{}}:{})});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')

package/server/machines.js

@@ -1,14 +1,15 @@
 import http from 'node:http'
-import { createHash, randomBytes, randomUUID } from 'node:crypto'
+import { randomBytes, randomUUID } from 'node:crypto'
 import { signWorkerRequest } from './worker-auth.js'
+import { workerPrefix, workerAuthHeader, workerOwnerHash } from './cloud-deployment.js'
 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 machineName(uid,prefix='openrod-user') {
+ return `${workerPrefix(prefix)}-${workerOwnerHash(uid)}`
 }
-export function createMachineStore(db,{maxMachines=10,now=()=>Date.now()}={}) {
+export function createMachineStore(db,{maxMachines=10,now=()=>Date.now(),prefix='openrod-user'}={}) {
+ workerPrefix(prefix)
  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))
+ const ref=uid=>db.collection('machines').doc(machineName(uid,prefix))
  return {
   async reserve(identity) {
    const document=ref(identity.uid),fleet=db.collection('control').doc('fleet')
@@ -17,22 +18,22 @@ export function createMachineStore(db,{maxMachines=10,now=()=>Date.now()}={}) {
     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}
+    const record={uid:identity.uid,email:identity.email??null,name:machineName(identity.uid,prefix),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 byName(name){if(!new RegExp(`^${prefix}-[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}={}) {
+export function workerReady(record,address,{port=4600,protocol='current',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)})
+  const probe=requestProbe({hostname:address,port,path:request.url,method:request.method,headers:{host,[workerAuthHeader(protocol)]: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)
@@ -42,23 +43,36 @@ export function workerReady(record,address,{port=4600,host=new URL(process.env.O
   probe.end()
  })
 }
-export function createMachineManager(store,compute,{ready=workerReady}={}) {
+export function createMachineManager(store,compute,{ready=workerReady,ownerLabel='openrod_owner',allowProvisioning=true}={}) {
  const inflight=new Map(),readyCache=new Map()
- async function ensure(identity) {
+ async function ensure(identity,{provision=true}={}) {
   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 pending=inflight.get(identity.uid)
+  if(pending){
+   const result=await pending.task
+   // An explicit prepare arriving during a read-only inspection must retain
+   // its intent. Retry after that inspection releases the per-owner lease.
+   if(provision&&!pending.provision){if(inflight.get(identity.uid)===pending)inflight.delete(identity.uid);return ensure(identity,{provision:true})}
+   return result
+  }
   const task=(async()=>{
-   const record=await store.reserve(identity)
+   const existing=await store.get(identity.uid)
+   if(!existing&&provision&&!allowProvisioning)throw fail('New cloud environments are temporarily unavailable during deployment.')
+   const record=existing??(provision?await store.reserve(identity):null)
+   if(!record)return null
+   if(record.uid!==identity.uid)throw fail('Machine ownership mismatch',403)
    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.')
+     if(!provision)return record
+     if(!allowProvisioning)throw fail('Cloud provisioning is temporarily unavailable during deployment.')
      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)
+     if(instance.labels?.[ownerLabel]!==workerOwnerHash(record.uid))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)
@@ -71,8 +85,9 @@ export function createMachineManager(store,compute,{ready=workerReady}={}) {
    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)}
+  const entry={task,provision};inflight.set(identity.uid,entry)
+  try{return await task}finally{if(inflight.get(identity.uid)===entry)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}}
+ const publicStatus=r=>({name:r?.name??null,status:r?.state??'none',error:r?.error??null})
+ return {store,ensure,async status(identity){return publicStatus(await ensure(identity,{provision:false}))},async prepare(identity){return publicStatus(await ensure(identity))},async target(identity,{provision=true}={}){const r=await ensure(identity,{provision});if(!r)throw fail('Prepare your cloud environment before using this resource.',409);if(r.state!=='ready'||!r.address)throw fail('Your cloud machine is starting. Please try again shortly.');return r}}
 }

package/server/policy-template-store.js

@@ -61,6 +61,7 @@ export function createTemplateStore({ directory, builtins, legacy = [], validate
     save: (input) => mutate(async () => {
       const template = validate(input)
       const current = await state()
+      if (input.isNew && (await list(current)).some(item => item.id === template.id)) throw fail('A policy with this id already exists. Pick another identity.', 409)
       const catalog = (await list(current)).filter(item => item.id !== template.id).concat(template)
       // An edited addition must also remain compatible with saved combinations.
       for (const item of catalog) {

package/server/remote-gateway.js

@@ -102,17 +102,19 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
   const initial = contextSelection()
   let returnContext = contextConfigured() && localGateways().some(target => target.name === initial.gateway) ? initial : null
   let lastRemote = null, historyReady = null, historyWrites = Promise.resolve()
+  const forgottenHosts = new Set()
   const historyFile = path.join(stateDirectory(), 'remote-gateways', 'last-location.json')
   const validContext = value => value && /^[\w.-]{1,64}$/.test(value.gateway ?? '') && /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/.test(value.workspace ?? '')
   const loadHistory = () => historyReady ??= (async () => {
     try {
       const saved = JSON.parse(await fs.readFile(historyFile, 'utf8'))
+      for (const host of Array.isArray(saved.forgottenHosts) ? saved.forgottenHosts : []) if (typeof host === 'string') forgottenHosts.add(host)
       if (!returnContext && validContext(saved.returnContext) && localGateways().some(target => target.name === saved.returnContext.gateway)) returnContext = saved.returnContext
-      if (validContext(saved.remote) && /^console-ssh-[a-f0-9]{24}$/.test(saved.remote.gateway) && typeof saved.remote.host === 'string') lastRemote = { ...saved.remote, status: 'disconnected', error: null }
+      if (validContext(saved.remote) && /^console-ssh-[a-f0-9]{24}$/.test(saved.remote.gateway) && typeof saved.remote.host === 'string' && !forgottenHosts.has(saved.remote.host)) lastRemote = { ...saved.remote, status: 'disconnected', error: null }
     } catch (error) { if (error.code !== 'ENOENT') logger.warn(`Remote location history unavailable: ${error.message}`) }
   })()
   const saveHistory = () => {
-    const data = JSON.stringify({ returnContext, remote: lastRemote })
+    const data = JSON.stringify({ returnContext, remote: lastRemote, forgottenHosts: [...forgottenHosts] })
     historyWrites = historyWrites.catch(() => {}).then(async () => {
       await fs.mkdir(path.dirname(historyFile), { recursive: true, mode: 0o700 })
       const temporary = `${historyFile}.${randomUUID()}.tmp`
@@ -121,6 +123,12 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
     })
     return historyWrites.catch(error => logger.warn(`Remote location history could not be saved: ${error.message}`))
   }
+  // Adding, deleting or connecting to a host again undoes Forget for it, so
+  // its alias is never hidden for good.
+  const unforgetHost = async host => {
+    await loadHistory()
+    if (forgottenHosts.delete(host)) await saveHistory()
+  }
   async function locationSnapshot() {
     await loadHistory()
     const selected = defaultContextSelection()
@@ -134,7 +142,9 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
     if (!remote && /^console-ssh-[a-f0-9]{24}$/.test(selected.gateway)) {
       try {
         const owner = JSON.parse(await fs.readFile(path.join(CONFIG_DIR, 'gateways', selected.gateway, 'console-managed.json'), 'utf8'))
-        if (typeof owner.host === 'string') remote = { host: owner.host, ...selected, status: 'disconnected', error: null }
+        // Deleting a host undoes Forget but leaves its gateway registered, so
+        // a registration is retained only while its host still exists.
+        if (typeof owner.host === 'string' && !forgottenHosts.has(owner.host) && listSshHosts().some(host => host.name === owner.host)) remote = { host: owner.host, ...selected, status: 'disconnected', error: null }
       } catch { /* No managed registration to retain. */ }
     }
     if (!returnContext && (remote || contextConfigured())) {
@@ -292,6 +302,7 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
         return
       }
       if (!(await listSshHosts()).some(host => host.name === input.host)) throw fail('Choose a host from your SSH configuration.')
+      await unforgetHost(input.host)
       const installedVersion = await version(value)
       value.probe = await probeHost(input.host, installedVersion, { signal })
       await prepareRuntime(value)
@@ -319,7 +330,7 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
     async overview() {
       const snapshot = await locationSnapshot()
       const connection = snapshot.remote
-      return { hosts: await listSshHosts(), locals: localGateways().map(({ name, endpoint }) => ({ name, endpoint })), active: view(connection), job: view(job), tools: { ssh: Boolean(sshBinary()), gateway: Boolean(findExecutable('openshell-gateway')), openshell: Boolean(openshellBinary()), installCommand: installCommand(process.platform) } }
+      return { hosts: (await listSshHosts()).filter(host => !forgottenHosts.has(host.name)), forgottenHosts: [...forgottenHosts], locals: localGateways().map(({ name, endpoint }) => ({ name, endpoint })), active: view(connection), job: view(job), tools: { ssh: Boolean(sshBinary()), gateway: Boolean(findExecutable('openshell-gateway')), openshell: Boolean(openshellBinary()), installCommand: installCommand(process.platform) } }
     },
     changing: () => disconnecting || job?.status === 'working',
     // A fresh console connects to the CLI's local gateway the way "Use this
@@ -378,15 +389,24 @@ export function createRemoteConnections({ onSelected = () => {}, onDeselected =
     async forget() {
       if (disconnecting || job?.status === 'working') throw fail('Wait for the current connection change to finish.', 409)
       await loadHistory()
-      if (active?.status === 'connected' || active?.status === 'connecting') await this.disconnect()
+      const remote = (await locationSnapshot()).remote
+      if (remote || active?.status === 'connected' || active?.status === 'connecting') await this.disconnect()
+      if (remote) forgottenHosts.add(remote.host)
       active = null
       lastRemote = null
       await saveHistory()
       return { ok: true }
     },
+    async restoreHost(host) {
+      await loadHistory()
+      if (typeof host !== 'string' || !forgottenHosts.has(host)) throw fail('This host is not forgotten.', 409)
+      await unforgetHost(host)
+      return { ok: true }
+    },
+    unforgetHost,
     async disconnect() {
       idle()
-      const current = contextSelection()
+      const current = defaultContextSelection()
       const replaceSelection = current.gateway === active?.gateway || /^console-ssh-[a-f0-9]{24}$/.test(current.gateway)
       if (replaceSelection && process.env.OPENSHELL_GATEWAY) throw fail('Remove OPENSHELL_GATEWAY before disconnecting its selected gateway.', 409)
       disconnecting = true

package/server/remote-http.js

@@ -9,6 +9,6 @@ export function safeWorkspaceTarget(target,prefix){
  if(typeof target!=='string'||!target.startsWith(prefix+'/'))throw remoteFail('Invalid remote target',404)
  const suffix=target.slice(prefix.length),path=suffix.split('?')[0]
  if(/%2f|%5c|%2e|\\|\/\//i.test(path)||path.split('/').some(p=>p==='.'||p==='..'))throw remoteFail('Invalid remote target')
- if(!/^\/(context|inventory|overview|sandboxes|activity|activity-destinations|setups|cloud-export|cloud-import|cloud-transfer|policy|settings|secrets|profiles|templates|image-templates|org|egress|files|downloads|ingress|stream|editors|local-folder|terminal|ssh)(?:\/|$)/.test(path))throw remoteFail('Unknown remote operation',404)
+ if(!/^\/(capabilities|resource-imports|context|inventory|overview|sandboxes|activity|activity-destinations|setups|cloud-export|cloud-import|cloud-transfer|policy|settings|secrets|profiles|templates|image-templates|org|egress|files|downloads|ingress|stream|editors|local-folder|terminal|ssh)(?:\/|$)/.test(path))throw remoteFail('Unknown remote operation',404)
  return '/api/os'+suffix
 }

package/server/resource-import-portable.js

@@ -0,0 +1,155 @@
+import { createHash } from 'node:crypto'
+import { newRecipe, recipeErrors } from '../src/lib/image-templates.js'
+import { validateTemplate } from './policy.js'
+import { normalizeMcp } from './setup-discovery.js'
+import { validatePolicy } from './egress.js'
+
+export const IMPORT_TYPES = ['policyTemplates', 'groups', 'network', 'setups', 'templates', 'activity']
+export const IMPORT_BODY_LIMIT = 8 * 1024 * 1024
+export const importFail = (message, status = 400) => Object.assign(new Error(message), { status })
+const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value
+export const fingerprint = value => createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex')
+const sensitive = /(?:-----BEGIN [\w ]*PRIVATE KEY-----|\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[A-Z0-9]{16})|(?:api[_-]?key|token|password|secret|authorization)["']?\s*[:=]\s*["']?(?!\$|<|\{|YOUR_|your_|example|placeholder|process\.env|os\.environ)[A-Za-z0-9_+/.=-]{16,})/i
+const cleanText = (value, length = 400) => {
+  if (typeof value !== 'string' || value.length > length || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value) || sensitive.test(value)) throw importFail('Resource contains unsupported text or possible credentials. Remove it before importing.')
+  return value
+}
+const idPatterns = { policyTemplates: /^[a-z0-9][a-z0-9-]{0,47}$/, groups: /^[a-z0-9]([a-z0-9-]{0,46}[a-z0-9])?$/, network: /^[a-z0-9]([a-z0-9-]{0,38}[a-z0-9])?$/, setups: /^[a-f0-9]{24}$/, templates: /^[a-z0-9]([a-z0-9-]{0,17}[a-z0-9])?$/, activity: /^history-[a-f0-9]{24}$/ }
+export const validImportId = (type, id) => typeof id === 'string' && Boolean(idPatterns[type]?.test(id))
+
+function setupItems(items, warnings) {
+  if (!Array.isArray(items) || items.length > 500) throw importFail('Invalid setup items.')
+  return items.map((item, index) => {
+    const name = cleanText(item.name, 200)
+    const id = fingerprint({ kind: item.kind, name, index }).slice(0, 24)
+    if (item.kind === 'mcp') {
+      const credentialFields = [...new Set([...(item.credentialFields || []), ...Object.keys(item.credentialRef?.aliases || {}), ...Object.keys(item.credentialBindings || {})])].filter(key => /^[A-Za-z_][A-Za-z0-9_]{0,100}$/.test(key))
+      const raw = item.package ? { command: 'npx', args: [`${item.package.name}@${item.package.requested || item.package.version || 'latest'}`, ...(item.package.args || [])] } : { ...(item.config || {}) }
+      // Environment/header values and source provider references never cross locations.
+      if (Object.keys(raw.env || {}).length || Object.keys(raw.headers || {}).length || item.environment) warnings.push(`${name}: environment and HTTP header values are excluded; configure required values on the destination.`)
+      delete raw.env; delete raw.headers; delete raw.http_headers
+      const normalized = normalizeMcp(name, raw, 'import')
+      delete normalized._sourceCredentials
+      normalized.credentialFields = [...new Set([...normalized.credentialFields, ...credentialFields])]
+      normalized.credentialBindings = Object.fromEntries(Object.entries(item.credentialBindings || {}).filter(([key, binding]) => normalized.credentialFields.includes(key) && /^[A-Za-z0-9_-]{1,80}$/.test(binding?.header || '') && ['', 'Bearer '].includes(binding.prefix || '')).map(([key, binding]) => [key, { header: binding.header, prefix: binding.prefix || '' }]))
+      if (normalized.credentialFields.length) {
+        normalized.issues = [...new Set([...normalized.issues, `Connect credentials (${normalized.credentialFields.join(', ')}) to use this MCP. They’re kept in the gateway, never in the setup.`])]
+        warnings.push(`${name}: reconnect credentials on the destination.`)
+      }
+      if (item.auth?.mode === 'agent-session') { normalized.auth = { mode: 'agent-session', status: 'sign-in-required' }; warnings.push(`${name}: sign in again on the destination.`) }
+      if (normalized.package) warnings.push(`${name}: download and prepare this package on the destination before use.`)
+      return { ...normalized, id, ...(item.disabled ? { disabled: true } : {}) }
+    }
+    if (item.kind !== 'skill') throw importFail('Unsupported setup item.')
+    if (!Array.isArray(item.files) || item.files.length > 200) throw importFail('Invalid skill files.')
+    const files = [], seen = new Set()
+    let bytes = 0
+    for (const file of item.files) {
+      if (typeof file.path !== 'string' || file.path.length > 200 || !/^[a-zA-Z0-9_ ./@+-]+$/.test(file.path) || file.path.split('/').some(part => !part || part === '.' || part === '..' || part.startsWith('.')) || seen.has(file.path)) throw importFail('Invalid or duplicate skill file path.')
+      seen.add(file.path)
+      if (file.encoding) { warnings.push(`${name}: binary/archive file ${file.path} is excluded; re-import it on the destination.`); continue }
+      const content = cleanText(file.content, 512 * 1024)
+      bytes += Buffer.byteLength(content)
+      if (bytes > 4 * 1024 * 1024) throw importFail('Skill exceeds the 4 MiB limit.', 413)
+      files.push({ path: file.path, content, executable: file.executable === true })
+    }
+    if (!files.some(file => file.path === 'SKILL.md')) throw importFail('Imported skills require SKILL.md.')
+    return { id, kind: 'skill', name, sources: ['import'], files, bytes, digest: fingerprint(files), requirements: [], credentialFields: [], issues: [] }
+  })
+}
+
+// Both exports and incoming bundles pass through the same allow-list. Never trust
+// the browser to preserve redaction or source schemas.
+export function portableResource(type, raw) {
+  if (!IMPORT_TYPES.includes(type) || !raw || typeof raw !== 'object') throw importFail('Unsupported import resource.')
+  const id = raw.id ?? raw.name
+  if (!validImportId(type, id)) throw importFail(`Invalid ${type} resource identity.`)
+  const warnings = [], dependencies = []
+  let data
+  if (type === 'policyTemplates') {
+    if (raw.accessTemplates?.length) throw importFail('Base policy additions must be materialized before import.')
+    const template = validateTemplate(raw)
+    const select = (value, keys) => Object.fromEntries(keys.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]))
+    const rules = template.rules.map(rule => ({
+      name: rule.name, binaries: rule.binaries,
+      endpoints: rule.endpoints.map(endpoint => ({
+        ...select(endpoint, ['host', 'ports', 'protocol', 'access', 'enforcement', 'tlsSkip', 'allowedIps']),
+        ...(endpoint.allow ? { allow: endpoint.allow.map(entry => select(entry, ['method', 'path'])) } : {}),
+        ...(endpoint.deny ? { deny: endpoint.deny.map(entry => select(entry, ['method', 'path'])) } : {}),
+      })),
+    }))
+    data = validateTemplate({ ...template, rules, accessTemplates: [] })
+    cleanText(JSON.stringify(data), 256 * 1024)
+    warnings.push('The source base policy and its access additions are copied into a separate destination policy; existing destination policies are unchanged.')
+  } else if (type === 'groups') {
+    const template = raw.template ? String(raw.template) : null
+    if (template && !validImportId('policyTemplates', template)) throw importFail('Invalid group base policy.')
+    if (template) dependencies.push(`policyTemplates:${template}`)
+    data = { id, name: cleanText(raw.name || id, 80), description: cleanText(raw.description || ''), template, outside: 'block' }
+  } else if (type === 'network') {
+    data = validatePolicy(raw)
+    if (data.appliesTo.everyone || data.appliesTo.sandboxes.length) throw importFail('Legacy global or sandbox-specific network rules require destination group selection before import.')
+    data.name = cleanText(data.name, 80)
+    cleanText(JSON.stringify(data), 128 * 1024)
+    if (data.advanced?.privateIps.length) warnings.push('This rule includes private addresses. Verify that they refer to the intended cloud services.')
+    dependencies.push(...data.appliesTo.groups.map(id => `groups:${id}`), ...data.appliesTo.setups.map(id => `setups:${id}`))
+    if (data.setup) dependencies.push(`setups:${data.setup.id}`)
+  } else if (type === 'setups') {
+    data = { id, name: cleanText(raw.name, 80), items: setupItems(raw.items, warnings) }
+  } else if (type === 'activity') {
+    if (!Array.isArray(raw.events) || raw.events.length > 500) throw importFail('Activity imports support up to 500 events per batch.')
+    const origin = { gateway: cleanText(raw.origin?.gateway || '', 160), workspace: cleanText(raw.origin?.workspace || '', 160) }
+    const seen = new Set()
+    const fields = ['sandbox', 'sandboxId', 'binary', 'category', 'severity', 'level', 'kind', 'direction', 'verdict', 'outcome', 'action', 'method', 'destination', 'policy', 'sessionId', 'correlationId', 'reason', 'message', 'detail']
+    const events = raw.events.map(event => {
+      if (!/^[a-f0-9]{64}$/.test(event.id || '') || seen.has(event.id)) throw importFail('Invalid or duplicate activity event identity.')
+      if (!Number.isFinite(Date.parse(event.at || event.receivedAt))) throw importFail('Activity events require a valid original timestamp.')
+      seen.add(event.id)
+      const safe = { id: event.id, at: new Date(Date.parse(event.at || event.receivedAt)).toISOString() }
+      if (event.receivedAt && Number.isFinite(Date.parse(event.receivedAt))) safe.receivedAt = new Date(Date.parse(event.receivedAt)).toISOString()
+      for (const field of fields) if (typeof event[field] === 'string') {
+        const text = event[field].slice(0, field === 'message' || field === 'detail' ? 4096 : 512)
+        safe[field] = sensitive.test(text) || /(?:Bearer\s+|[?&](?:token|api[_-]?key|password|secret)=)/i.test(text) ? '[redacted]' : text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+      }
+      safe.sandbox ||= 'imported-history'
+      return safe
+    })
+    data = { id, name: cleanText(raw.name, 80), origin, events }
+    warnings.push('Normalized event fields are copied with original timestamps and source identity. Raw event payloads are excluded and detected credential values are redacted.')
+  } else {
+    if (raw.status && raw.status !== 'ready') throw importFail('Wait for this template build to finish before exporting its recipe.')
+    const rawRecipe = raw.recipe || raw
+    const recipe = newRecipe(Object.fromEntries(Object.keys(newRecipe()).filter(key => key in rawRecipe).map(key => [key, rawRecipe[key]])))
+    recipe.name = id
+    if (recipe.environment.length) warnings.push('Template environment values are excluded. Re-enter required values on the destination.')
+    recipe.environment = []
+    recipe.setupRevisions = {}
+    if (Object.keys(recipeErrors(recipe)).length) throw importFail(Object.values(recipeErrors(recipe))[0])
+    cleanText(JSON.stringify(recipe), 16000)
+    if (recipe.source === 'image') {
+      if (recipe.image.startsWith('openshell-template/')) throw importFail('A local-only template image cannot be copied. Rebuild from its recipe on the destination.')
+      warnings.push('The destination must be able to pull this image; registry credentials are not copied.')
+    } else warnings.push('The template will be rebuilt on the destination; build commands may download dependencies.')
+    dependencies.push(...recipe.setups.map(id => `setups:${id}`))
+    data = { name: id, recipe }
+  }
+  return { key: `${type}:${id}`, type, id, name: type === 'templates' ? id : data.name, revision: fingerprint(data), data, dependencies: [...new Set(dependencies)], warnings: [...new Set(warnings)], ...(type === 'network' && raw.sourceOrganizationBlock === true && data.action === 'block' ? { requiredForGroups: [...data.appliesTo.groups] } : {}) }
+}
+
+export function validateImportBundle(bundle) {
+  if (bundle?.version !== 1 || !Array.isArray(bundle.resources) || bundle.resources.length > 500 || Buffer.byteLength(JSON.stringify(bundle)) > IMPORT_BODY_LIMIT) throw importFail('Invalid or oversized configuration bundle.', 400)
+  const seen = new Set()
+  const resources = bundle.resources.map(resource => {
+    const safe = portableResource(resource.type, resource.data)
+    if (seen.has(safe.key)) throw importFail('Duplicate import resource.')
+    seen.add(safe.key)
+    if (resource.requiredForGroups !== undefined) {
+      if (safe.type !== 'network' || safe.data.action !== 'block' || !Array.isArray(resource.requiredForGroups) || resource.requiredForGroups.some(id => !safe.data.appliesTo.groups.includes(id))) throw importFail('Invalid required organization restriction.')
+      safe.requiredForGroups = [...new Set(resource.requiredForGroups)]
+    }
+    safe.warnings = [...new Set([...safe.warnings, ...(resource.warnings || []).slice(0, 50).map(warning => cleanText(warning, 500))])]
+    return safe
+  })
+  const context = bundle.source?.context || {}
+  return { version: 1, source: { kind: ['local', 'host', 'cloud'].includes(bundle.source?.kind) ? bundle.source.kind : 'host', label: cleanText(bundle.source?.label || 'Source', 160), context: { gateway: cleanText(context.gateway || '', 160), workspace: cleanText(context.workspace || '', 160) } }, resources }
+}