openrod 0.1.2 → 0.1.3

package/src/lib/local-cloud.js

@@ -19,15 +19,15 @@ export function localConnectFromHash(hash) {
 export function isLocalConnectedMessage(event, popup, nonce, cloud = CLOUD_ORIGIN) {
   return Boolean(cloud && popup && event.source === popup && event.origin === cloud && event.data?.type === 'openrod-local-connected' && event.data.nonce === nonce && typeof event.data.code === 'string' && /^[a-f0-9]{64}\.[a-f0-9]{64}$/.test(event.data.code))
 }
-export async function localCloudRequest(path, body, {signal} = {}) {
+export async function localCloudRequest(path, body, {signal, owner = currentCloudOwner()} = {}) {
   const response = await fetch(`/api/local-cloud/${path}`, {
     signal,
     method: body === undefined ? 'GET' : 'POST',
-    headers: { ...(currentCloudOwner() ? { 'x-openrod-local-owner': currentCloudOwner() } : {}), ...(body === undefined ? {} : { 'content-type': 'application/json', 'x-openshell-console': '1' }) },
+    headers: { ...(owner ? { 'x-openrod-local-owner': owner } : {}), ...(body === undefined ? {} : { 'content-type': 'application/json', 'x-openshell-console': '1' }) },
     body: body === undefined ? undefined : JSON.stringify(body),
   })
   const value = await response.json().catch(() => ({}))
-  if (value.code === 'CLOUD_OWNER_CHANGED') window.dispatchEvent(new Event('openrod-session-expired'))
+  if (value.code === 'CLOUD_OWNER_CHANGED' || (response.status === 401 && ['machine', 'inventory'].includes(path))) window.dispatchEvent(new Event('openrod-session-expired'))
   if (!response.ok) throw Object.assign(new Error(value.error ?? 'Cloud connection unavailable'), {status:response.status})
   return value
 }
@@ -52,6 +52,19 @@ export async function waitForCloudReady(statusRequest, { signal, onProgress = ()
   }
   throw new Error('Your private machine is still preparing. Check its status before trying again.')
 }
+// Preparation is an explicit mutation. Every request remains bound to the
+// account selected before it began, including after an account switch.
+export async function prepareCloudMachine({ owner, signal, onProgress, request = localCloudRequest, wait, attempts } = {}) {
+  signal?.throwIfAborted()
+  const started = await request('machine', {}, { signal, owner })
+  let first = true
+  return waitForCloudReady(async () => {
+    const value = first ? started : await request('machine', undefined, { signal, owner })
+    first = false
+    if (value.owner !== owner) throw new Error('Your cloud account changed. Choose the destination again.')
+    return value
+  }, { signal, onProgress, wait, attempts })
+}
 export async function copyLocalSandbox(local, cloud, name, destinationGroups) {
   const exported = await local.cloudExport(name)
   const result = await cloud.importCloud(destinationGroups ? { ...exported.bundle, destinationGroups } : exported.bundle)

package/src/lib/location-choice.js

@@ -0,0 +1,7 @@
+// With only one reachable place to put it, a new resource goes straight there.
+// Any other location (a Remote, connected or saved, or Cloud) keeps the choice,
+// as does an OpenRod Cloud this console can connect but has not yet.
+export function directLocation(locations, { offerCloud = false } = {}) {
+  const [only] = locations
+  return locations.length === 1 && !only.remote && only.connected && !offerCloud ? only : null
+}

package/src/lib/location-data-reader.js

@@ -0,0 +1,25 @@
+// Read each source independently. A dead SSH host never prevents Local data
+// from loading, and cached readings keep their original owner.
+export async function readLocationData(locations, methods, apiFor, previous = []) {
+  const cached = new Map(previous.map(source => [source.location.id ?? source.location.context, source.data]))
+  return Promise.all(locations.map(async location => {
+    const before = cached.get(location.id ?? location.context)
+    if (!location.connected) return { location, data: before ?? null, error: null }
+    const results = await Promise.allSettled(methods.map(method => apiFor(location)[method]()))
+    const data = {}, errors = []
+    results.forEach((result, i) => {
+      if (result.status === 'fulfilled') data[methods[i]] = result.value
+      else { if (before?.[methods[i]] !== undefined) data[methods[i]] = before[methods[i]]; errors.push(result.reason.message) }
+    })
+    return { location: errors.length && errors.length === methods.length ? { ...location, connected: false } : location, data: Object.keys(data).length ? data : null, error: [...new Set(errors)].join('; ') || null }
+  }))
+}
+
+// Sources a combined page could not read: failed reads, and offline sources
+// with nothing cached. Unavailable means no source has a full reading to show.
+export function unreadSources(sources, methods) {
+  const complete = source => methods.every(method => source.data?.[method] !== undefined)
+  const failed = sources.filter(source => source.error)
+  const offline = sources.filter(source => !source.error && !complete(source) && source.location.connected === false)
+  return { failed, offline, any: failed.length + offline.length > 0, unavailable: sources.length > 0 && sources.every(source => !complete(source) && (source.error || source.location.connected === false)) }
+}

package/src/lib/locations.js

@@ -1,16 +1,26 @@
+import { analytics, classifyAnalyticsError } from './analytics.js'
+
 export const locationLabel = (location) => location?.label ?? (location?.target === 'cloud' ? 'Cloud' : location?.remote ? `SSH · ${location.host ?? location.gateway}` : 'Local')
 
 // Gateway/workspace identity is part of every resource key: names and even ids
 // can coincide on independent gateways.
 export const resourceKey = (record) => JSON.stringify([[record.location?.target ?? 'local', record.location?.context ?? ''], record.id ?? record.name])
 
-// Selecting a local gateway is a job; reload only after it has switched the context.
+const connectionAttempts = new WeakMap()
+
+// Selecting a local gateway is a job; continue only after the context switches.
 export async function connectLocalGateway(api, name, interval = 1000) {
-  let job = await api.connect({ localGateway: name })
-  while (job.status === 'working') {
-    await new Promise((resolve) => setTimeout(resolve, interval))
-    job = await api.connectionJob(job.id)
-  }
-  if (job.status !== 'ready') throw new Error(job.error || `Couldn’t connect to ${name}.`)
-  return job
+  const previous = connectionAttempts.get(api)
+  const tracked = analytics.startFlow('gateway_connection', { location_type: 'local' }, previous?.outcome === 'failed' ? previous : null)
+  connectionAttempts.set(api, tracked)
+  try {
+    let job = await api.connect({ localGateway: name })
+    while (job.status === 'working') {
+      await new Promise((resolve) => setTimeout(resolve, interval))
+      job = await api.connectionJob(job.id)
+    }
+    if (job.status !== 'ready') throw new Error(job.error || `Couldn’t connect to ${name}.`)
+    analytics.finishFlow(tracked, 'connected')
+    return job
+  } catch (error) { analytics.finishFlow(tracked, 'failed', classifyAnalyticsError(error)); throw error }
 }

package/src/lib/placement.js

@@ -6,4 +6,4 @@ export const PLACEMENTS = {
   cloud: { id: 'cloud', label: 'Cloud', hint: 'Runs on a cloud machine' },
 }
 
-export const placementOf = (location) => PLACEMENTS[location?.placement]?.id ?? (location?.remote ? 'remote' : 'local')
+export const placementOf = (location) => location?.cloud || location?.target === 'cloud' ? 'cloud' : PLACEMENTS[location?.placement]?.id ?? (location?.remote ? 'remote' : 'local')

package/src/lib/resource-imports.js

@@ -0,0 +1,63 @@
+export const IMPORT_TYPES = [
+  { id: 'groups', label: 'Groups', description: 'Definitions and policy relationships' },
+  { id: 'network', label: 'Network', description: 'Egress rules with destination targets' },
+  { id: 'setups', label: 'MCPs & Skills', description: 'Saved setups and skill files' },
+  { id: 'templates', label: 'Templates', description: 'Portable image recipes' },
+  { id: 'activity', label: 'Activity history', description: 'Historical events, in batches of up to 500', optional: true },
+]
+export const DEFAULT_IMPORT_TYPES = IMPORT_TYPES.filter(type => !type.optional).map(type => type.id)
+export const IMPORT_PAGE_TYPE = { groups: 'groups', egress: 'network', ingress: 'network', setups: 'setups', templates: 'templates', activity: 'activity' }
+export const importRunning = job => ['running', 'cancelling'].includes(job?.status)
+export const importFinished = job => job && !['planned', 'running', 'cancelling'].includes(job.status)
+export function importSelection(resources, selected) {
+  const index = new Map(resources.map(item => [item.key, item]))
+  const result = new Set()
+  function include(key) {
+    if (result.has(key)) return
+    const item = index.get(key)
+    if (!item) throw new Error(`Missing import dependency: ${key}`)
+    result.add(key)
+    for (const dependency of item.dependencies ?? []) include(dependency)
+  }
+  selected.forEach(include)
+  // Organization restrictions travel with their groups. The backend records
+  // these reverse dependencies so a group cannot lose source blocks during a
+  // partial selection, even if the Network category was not selected.
+  for (let previous = -1; previous !== result.size;) {
+    previous = result.size
+    for (const item of resources) if (item.requiredForGroups?.some(id => result.has(`groups:${id}`))) include(item.key)
+  }
+  return [...result]
+}
+export const importSourceId = location => location?.id ?? JSON.stringify([location?.target, location?.context])
+export function activityImportQuery({ from = '', to = '', offset = 0, snapshot } = {}) {
+  const query = { offset }
+  for (const [key, value] of Object.entries({ from, to })) {
+    if (!value) continue
+    const date = new Date(value)
+    if (!Number.isFinite(date.getTime())) throw new Error('Choose a valid activity date range.')
+    query[key] = date.toISOString()
+  }
+  if (query.from && query.to && query.from > query.to) throw new Error('Activity start must be before its end.')
+  if (snapshot != null) query.snapshot = snapshot
+  return query
+}
+export function importPercent(job) {
+  if (!job?.items?.length) return 0
+  const done = job.items.filter(item => ['created', 'completed', 'reused', 'skipped', 'blocked', 'failed', 'cancelled'].includes(item.status)).length
+  return Math.round(done / job.items.length * 100)
+}
+
+// A saved setup is the import unit. Mixed setups stay together so their
+// dependencies and selection keys remain intact.
+export function groupImportResources(resources) {
+  const sections = [...IMPORT_TYPES, { id: 'policyTemplates', label: 'Base policies' }].map(type => ({ ...type, items: resources.filter(item => item.type === type.id) }))
+  const other = resources.filter(item => !sections.some(section => section.id === item.type))
+  if (other.length) sections.push({ id: 'other', label: 'Other resources', items: other })
+  return sections.filter(section => section.items.length).map(section => {
+    if (section.id !== 'setups') return section
+    const kinds = item => new Set((item.data?.items ?? []).map(value => value.kind))
+    const category = item => { const types = kinds(item); return types.has('mcp') && types.has('skill') ? 'mixed' : types.has('mcp') ? 'mcps' : types.has('skill') ? 'skills' : 'saved' }
+    return { ...section, groups: [{ id: 'mcps', label: 'MCPs' }, { id: 'skills', label: 'Skills' }, { id: 'mixed', label: 'MCPs & Skills together' }, { id: 'saved', label: 'Saved setups' }].map(group => ({ ...group, items: section.items.filter(item => category(item) === group.id) })).filter(group => group.items.length) }
+  })
+}

package/src/lib/resource-sources.js

@@ -0,0 +1,105 @@
+
+export function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical)
+  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().filter(key => value[key] !== undefined).map(key => [key, canonical(value[key])]))
+  return value
+}
+const omit = (value, keys) => Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)))
+const metadata = ['location', 'copies', 'sourceOrg', 'sourceSetups', 'id', 'createdAt', 'updatedAt', 'revision', 'importedAt', 'importSource', 'localSource', 'configurationCount']
+export function resourceConfiguration(type, record) {
+  if (type === 'network' && record.sourceOrg) {
+    // Group template IDs are source-local references to separate policies, not
+    // part of this network rule. Imports assign new IDs to those templates.
+    const groupRef = id => { const group=record.sourceOrg.groups.find(group=>group.id===id); return group ? omit(resourceConfiguration('groups',group), ['template']) : {missing:id,source:record.location?.id} }
+    const setupRef = id => { const setup=record.sourceSetups?.find(setup=>setup.id===id); return setup ? resourceConfiguration('setups',setup) : {missing:id,source:record.location?.id} }
+    const sort = values => values.map(value=>canonical(value)).sort((a,b)=>JSON.stringify(a).localeCompare(JSON.stringify(b)))
+    const value=omit(record,metadata)
+    return {...value,destinations:sort(value.destinations),appliesTo:{...value.appliesTo,groups:sort(value.appliesTo.groups.map(groupRef)),setups:sort((value.appliesTo.setups ?? []).map(setupRef)),sandboxes:sort(value.appliesTo.sandboxes)},...(value.setup?{setup:{...value.setup,id:setupRef(value.setup.id)}}:{})}
+  }
+  if (type === 'setups') return { name: record.name, items: record.items.map(item => ({ name: item.name, kind: item.kind, contentDigest: item.contentDigest ?? record.revision })).sort((a,b) => JSON.stringify(a).localeCompare(JSON.stringify(b))) }
+  if (type === 'templates') return { name: record.name, recipe: record.recipe, managed: record.managed, status: record.status, exists: record.exists }
+  return omit(record, metadata)
+}
+export const configurationKey = (type, record) => JSON.stringify(canonical(resourceConfiguration(type, record)))
+export function consolidateResources(type, records) {
+  const rows = []
+  for (const record of records) {
+    // Network rows describe one configuration. Same-named copies split when
+    // edited independently and merge again when their configurations match.
+    const key = type !== 'network' && record.name
+      ? JSON.stringify([type, record.name])
+      : configurationKey(type, record)
+    const row = rows.find(row => row.key === key && !row.copies.some(copy => copy.location?.id === record.location?.id))
+    if (row) row.copies.push(record)
+    else rows.push({key, copies:[record]})
+  }
+  return rows.map(({copies}) => ({...(copies.find(copy => copy.location?.connected !== false) ?? copies[0]), copies, configurationCount: new Set(copies.map(copy => configurationKey(type, copy))).size}))
+}
+export const resourceCopies = record => record?.copies ?? (record ? [record] : [])
+export function matchingSources(record, records) {
+  // Offer only peers from the row as it existed when editing began. A separate
+  // same-named row is independent, even if this edit makes it identical again.
+  const copies = resourceCopies(record)
+  return records.filter(candidate => candidate.location?.id !== record.location?.id
+    && copies.some(copy => copy.location?.id === candidate.location?.id && (copy.id ?? copy.name) === (candidate.id ?? candidate.name))
+    && records.filter(other => other.location?.id === candidate.location?.id && (other.id ?? other.name) === (candidate.id ?? candidate.name)).length === 1)
+}
+function mergeChanged(before, after, destination) {
+  if (after && typeof after === 'object' && !Array.isArray(after)) {
+    const result={...destination}
+    for(const [key,value] of Object.entries(after)) {
+      if(JSON.stringify(canonical(before?.[key]))!==JSON.stringify(canonical(value))) result[key]=mergeChanged(before?.[key],value,destination?.[key])
+    }
+    return result
+  }
+  return after
+}
+export async function applySourceChange({ type, before, args, method }, target, api) {
+  if (!target.location?.connected) throw new Error('Reconnect this source before applying changes.')
+  const list = type === 'setups' ? await api.setups() : type === 'templates' ? await api.imageTemplates() : (await api.org())[type === 'network' ? 'policies' : 'groups']
+  const current = (Array.isArray(list) ? list : list.templates ?? []).find(item => (item.id ?? item.name) === (target.id ?? target.name))
+  if (!current || configurationKey(type, {...current,sourceOrg:undefined,sourceSetups:undefined}) !== configurationKey(type, {...target,sourceOrg:undefined,sourceSetups:undefined})) throw new Error('This source changed. Reopen it before applying the edit.')
+  if (method === 'deleteSetupItem') {
+    const removed = before.items.find(item => item.id === args[1])
+    const matches = current.items.filter(item => item.name === removed?.name && item.kind === removed?.kind && (removed.contentDigest ? item.contentDigest === removed.contentDigest : current.revision === before.revision))
+    if (matches.length !== 1) throw new Error('The matching item differs on this source. Edit it separately.')
+    return api.deleteSetupItem(current.id, matches[0].id, current.revision)
+  }
+  const patch = {}
+  const old = type === 'templates' ? before.recipe : before
+  for (const [key, value] of Object.entries(args[0])) {
+    // Template environment values can be credentials. As with imports, they
+    // are entered on each source and never copied to another one.
+    if (metadata.includes(key) || key === 'isNew' || (type === 'templates' && key === 'environment')) continue
+    if (JSON.stringify(canonical(old[key])) !== JSON.stringify(canonical(value))) patch[key] = mergeChanged(old[key],value,(type === 'templates' ? current.recipe : current)[key])
+  }
+  if (method === 'savePolicy') {
+    const org = await api.org()
+    const next = {...current, ...patch, id:current.id, isNew:false}
+    if (patch.appliesTo) {
+      next.appliesTo={...current.appliesTo}
+      for(const [key,value] of Object.entries(patch.appliesTo)) {
+        if(JSON.stringify(canonical(value))===JSON.stringify(canonical(before.appliesTo[key])))continue
+        if(key==='groups') next.appliesTo.groups=value.map(id=>{
+          const source=before.sourceOrg?.groups.find(group=>group.id===id)
+          const matches=source?org.groups.filter(group=>configurationKey('groups',group)===configurationKey('groups',source)):org.groups.filter(group=>group.id===id)
+          if(matches.length!==1)throw new Error('A changed group is missing or ambiguous here. Import or select it separately.')
+          return matches[0].id
+        })
+        else next.appliesTo[key]=value
+      }
+    }
+    if (next.appliesTo.groups.some(id => !org.groups.some(group => group.id === id))) throw new Error('A required group is missing here. Import it first.')
+    if (next.appliesTo.setups?.length) {
+      const setups = await api.setups()
+      if (next.appliesTo.setups.some(id => !setups.some(setup => setup.id === id))) throw new Error('A required setup is missing here. Import it first.')
+    }
+    return api.savePolicy(next)
+  }
+  if (method === 'saveGroup') return api.saveGroup({...current, ...patch, id:current.id, isNew:false})
+  if (method === 'buildImageTemplate') {
+    if (!Object.keys(patch).length) throw new Error('Only environment values changed. Enter them on this source separately.')
+    return api.buildImageTemplate({...current.recipe, ...patch, name:current.name}, true)
+  }
+  throw new Error('This change must be made separately on each source.')
+}

package/src/lib/sandbox-creations.js

@@ -2,13 +2,16 @@
 // Quick-setup environment can take minutes, so the dialog hands the work here
 // and closes; progress, build logs and the result follow the user around the
 // console as a notification.
-export function createSandboxCreations() {
+import { analytics, classifyAnalyticsError } from './analytics.js'
+export function createSandboxCreations({ telemetry = analytics } = {}) {
   let snapshot = []
   const listeners = new Set()
   const runs = new Map()
   const emit = () => listeners.forEach((listener) => listener())
   const update = (id, patch) => {
     snapshot = snapshot.map((job) => job.id === id ? { ...job, ...(typeof patch === "function" ? patch(job) : patch) } : job)
+    const job = snapshot.find(item => item.id === id)
+    if (job?.status === 'created' && job.phase === 'ready') telemetry.ready(job.analyticsFlow)
     emit()
   }
 
@@ -16,20 +19,22 @@ export function createSandboxCreations() {
     const job = snapshot.find((item) => item.id === id)
     const { task } = runs.get(id)
     const controller = new AbortController()
+    const tracked = telemetry.startFlow('sandbox_creation', job.analyticsProperties, job.analyticsFlow)
     runs.set(id, { task, controller })
-    update(id, { status: "preparing", message: "Preparing environment…", error: null, build: null })
+    update(id, { status: "preparing", message: "Preparing environment…", error: null, build: null, analyticsFlow: tracked })
     const report = {
       signal: controller.signal,
       progress: (message) => update(id, { message }),
-      build: (build) => update(id, (current) => ({ build: { ...build, logs: build.logs ?? current.build?.logs } })),
-      creating: () => update(id, { status: "creating", message: "Creating sandbox…" }),
+      build: (build) => { telemetry.step(tracked, 'building_image'); update(id, (current) => ({ build: { ...build, logs: build.logs ?? current.build?.logs } })) },
+      creating: () => { telemetry.step(tracked, 'creating'); update(id, { status: "creating", message: "Creating sandbox…" }) },
     }
     task(report).then((sandbox) => {
-      if (controller.signal.aborted) return update(id, { status: "cancelled", message: "Creation cancelled." })
+      if (controller.signal.aborted) { telemetry.finishFlow(tracked, 'cancelled'); return update(id, { status: "cancelled", message: "Creation cancelled." }) }
+      telemetry.finishFlow(tracked, 'created')
       update(id, { status: "created", sandbox: { ...sandbox, location: sandbox.location ?? job.location }, message: "" })
     }).catch((error) => {
-      if (controller.signal.aborted || error.name === "AbortError") update(id, { status: "cancelled", message: "Creation cancelled." })
-      else update(id, { status: "failed", error: error.message, code: error.code ?? null, fix: error.fix ?? null, message: "" })
+      if (controller.signal.aborted || error.name === "AbortError") { telemetry.finishFlow(tracked, 'cancelled'); update(id, { status: "cancelled", message: "Creation cancelled." }) }
+      else { telemetry.finishFlow(tracked, 'failed', snapshot.find(item => item.id === id)?.build?.status === 'failed' ? 'image_build' : classifyAnalyticsError(error)); update(id, { status: "failed", error: error.message, code: error.code ?? null, fix: error.fix ?? null, message: "" }) }
     })
   }
 
@@ -37,9 +42,9 @@ export function createSandboxCreations() {
     subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener) },
     getSnapshot: () => snapshot,
     // `task` receives { signal, progress, build, creating } and resolves to the created sandbox.
-    start({ name, location, task }) {
+    start({ name, location, task, analyticsProperties, analyticsFlow }) {
       const id = crypto.randomUUID()
-      snapshot = [...snapshot, { id, name, location, status: "preparing" }]
+      snapshot = [...snapshot, { id, name, location, status: "preparing", analyticsProperties, analyticsFlow }]
       runs.set(id, { task })
       run(id)
       return id

package/src/lib/sandboxes.js

@@ -59,7 +59,11 @@ export function destinationOf(chunk) {
 
 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"
+// Resolve only a matching authenticated account; keep stored ownership untouched.
+export function ownerOf(sandbox, user) {
+  const owner = sandbox.owner || sandbox.labels?.["openshell.console/owner"] || sandbox.labels?.owner
+  return (owner && owner === user?.uid && user.email) || owner || "Not reported"
+}
 export const creatorOf = (sandbox) => sandbox.createdBy || sandbox.labels?.["openshell.console/created-by"] || "Not reported"
 
 export function elapsedSince(value, now = Date.now()) {

package/src/lib/working-location.js

@@ -0,0 +1,10 @@
+export const locationIdentity = location => location ? JSON.stringify([location.target ?? 'local', location.context]) : null
+
+// A deep link owns its resources. Preserve that owner even if it goes offline;
+// only an unscoped page may pick a reachable default, preferring this computer.
+export function workingLocation(locations, requested, target = 'local') {
+  if (requested) return locations.find(location => locationIdentity(location) === locationIdentity(requested)) ?? { ...requested, connected: false }
+  return locations.find(location => location.target === target && !location.remote && location.connected)
+    ?? locations.find(location => location.target === target && location.connected)
+    ?? null
+}