@kennofizet/apphub-frontend 0.1.0

package/src/utils/originSafety.js

@@ -0,0 +1,267 @@
+export const ORIGIN_UNSAFE_SAME_ORIGIN_EMBED = 'same_origin_embed'
+export const ORIGIN_UNSAFE_NOT_CONFIGURED = 'hub_origin_not_configured'
+export const ORIGIN_UNSAFE_WRONG_ORIGIN = 'hub_origin_mismatch'
+export const ORIGIN_UNSAFE_RUNTIME_NOT_CONFIGURED = 'runtime_public_url_not_configured'
+export const ORIGIN_UNSAFE_RUNTIME_SAME_ORIGIN = 'runtime_same_origin_as_hub'
+
+function parseOrigin(value) {
+  const trimmed = String(value ?? '').trim()
+  if (!trimmed) return null
+  try {
+    return new URL(trimmed).origin
+  } catch {
+    return null
+  }
+}
+
+/** localhost / 127.0.0.1 — same gate as evaluateOriginSafety devFriendly bypass. */
+export function isLocalDevOrigin(origin) {
+  try {
+    const host = new URL(origin).hostname
+    return host === 'localhost' || host === '127.0.0.1'
+  } catch {
+    return false
+  }
+}
+
+/** True on page when devFriendly origin rules may apply (matches originSafety.js). */
+export function isLocalDevHostPage() {
+  if (typeof window === 'undefined') return false
+  return isLocalDevOrigin(window.location.origin)
+}
+
+export function parseDevUserFromBootstrap(resp) {
+  const data = resp?.data?.data ?? resp?.data ?? {}
+  return data.is_dev_user === true
+}
+
+/**
+ * @param {import('axios').AxiosResponse|{ data?: unknown }} resp
+ */
+export function parseOriginsFromBootstrap(resp) {
+  const data = resp?.data?.data ?? resp?.data ?? {}
+  const origins = data.origins ?? {}
+  return {
+    hubPublicUrl: String(origins.hub_public_url ?? '').trim(),
+    frontendOrigin: String(origins.frontend_origin ?? '').trim(),
+    runtimePublicUrl: String(origins.runtime_public_url ?? '').trim(),
+    originsAuto: origins.auto_derived === true,
+  }
+}
+
+/**
+ * @param {{ runtimePublicUrl?: string, backendUrl?: string }} options
+ */
+export function resolveRuntimeApiBase(options = {}) {
+  const configured = String(options.runtimePublicUrl ?? '').trim().replace(/\/$/, '')
+  if (configured) return configured
+  return String(options.backendUrl ?? '').trim().replace(/\/$/, '')
+}
+
+/**
+ * Merge client install options with server bootstrap origins.
+ *
+ * @param {{
+ *   hubOrigin?: string,
+ *   runtimePublicUrl?: string,
+ *   backendUrl?: string,
+ *   serverHubPublicUrl?: string,
+ *   serverFrontendOrigin?: string,
+ *   serverRuntimePublicUrl?: string,
+ *   serverOriginsAuto?: boolean,
+ *   enforceDevFriendlyOrigins?: boolean,
+ *   isDevUser?: boolean,
+ * }} [options]
+ */
+export function resolveEffectiveOrigins(options = {}) {
+  const currentOrigin = typeof window !== 'undefined' ? window.location.origin : ''
+  const localDev = isLocalDevOrigin(currentOrigin)
+  const isDevUser = options.isDevUser === true
+  const devFriendlyToggleOn = options.enforceDevFriendlyOrigins !== false
+
+  const clientHub = String(options.hubOrigin ?? '').trim()
+  const clientRuntime = String(options.runtimePublicUrl ?? '').trim()
+  const serverHub = String(options.serverHubPublicUrl ?? '').trim()
+  const serverFrontend = String(options.serverFrontendOrigin ?? '').trim()
+  const serverRuntime = String(options.serverRuntimePublicUrl ?? '').trim()
+  const originsAuto = options.serverOriginsAuto === true
+
+  let hubOrigin = clientHub || serverHub
+  let runtimePublicUrl = clientRuntime || serverRuntime
+
+  let devFriendly = false
+
+  // Relaxed localhost bypass — dev users only (toggle in DEV bar).
+  if (localDev && isDevUser && devFriendlyToggleOn) {
+    if (!clientHub) hubOrigin = currentOrigin
+    if (!clientRuntime && options.backendUrl) {
+      runtimePublicUrl = resolveRuntimeApiBase({ backendUrl: options.backendUrl })
+    }
+    devFriendly = true
+  } else if (localDev && originsAuto && serverHub) {
+    // Strict localhost — non-dev, or dev with strict toggle: enforce APP_URL hub host.
+    hubOrigin = serverHub
+  } else if (!localDev && (serverFrontend || serverHub)) {
+    hubOrigin = clientHub || serverFrontend || serverHub
+  }
+
+  return {
+    hubOrigin,
+    runtimePublicUrl,
+    devFriendly,
+    localDev,
+    originsAuto,
+    currentOrigin,
+  }
+}
+
+function safeResult(extra = {}) {
+  return {
+    safe: true,
+    pending: false,
+    loading: false,
+    reason: null,
+    parentOrigin: null,
+    expectedHubOrigin: null,
+    expectedRuntimeOrigin: null,
+    devFriendly: false,
+    ...extra,
+  }
+}
+
+function unsafe(reason, extra = {}) {
+  return {
+    safe: false,
+    pending: false,
+    loading: false,
+    reason,
+    parentOrigin: extra.parentOrigin ?? null,
+    expectedHubOrigin: extra.expectedHubOrigin ?? null,
+    expectedRuntimeOrigin: extra.expectedRuntimeOrigin ?? null,
+    devFriendly: false,
+  }
+}
+
+function loadingResult(extra = {}) {
+  return {
+    safe: false,
+    pending: true,
+    loading: true,
+    reason: null,
+    parentOrigin: null,
+    expectedHubOrigin: null,
+    expectedRuntimeOrigin: null,
+    devFriendly: false,
+    ...extra,
+  }
+}
+
+function checkSameOriginEmbed(expectedHubOrigin, expectedRuntimeOrigin) {
+  if (typeof window === 'undefined' || window.self === window.top) {
+    return null
+  }
+
+  try {
+    const parentOrigin = window.parent.location.origin
+    if (parentOrigin === window.location.origin) {
+      return unsafe(ORIGIN_UNSAFE_SAME_ORIGIN_EMBED, {
+        parentOrigin,
+        expectedHubOrigin,
+        expectedRuntimeOrigin,
+      })
+    }
+  } catch {
+    // Cross-origin parent — isolation OK.
+  }
+
+  return null
+}
+
+/**
+ * App Hub must run on a dedicated origin; hosted bundles on another public runtime origin.
+ * Local dev relaxed mode — dev users only (APPHUB_DEV_USER_IDS). Non-dev gets strict checks.
+ *
+ * @param {{
+ *   allowSameOriginEmbed?: boolean,
+ *   allowUnsafeOrigin?: boolean,
+ *   allowSameOriginHostedRuntime?: boolean,
+ *   hubOrigin?: string,
+ *   runtimePublicUrl?: string,
+ *   backendUrl?: string,
+ *   serverHubPublicUrl?: string,
+ *   serverRuntimePublicUrl?: string,
+ *   serverOriginsResolved?: boolean,
+ *   hasToken?: boolean,
+ *   enforceDedicatedHubOrigin?: boolean,
+ *   enforceIsolatedHostedRuntime?: boolean,
+ *   enforceDevFriendlyOrigins?: boolean,
+ *   isDevUser?: boolean,
+ * }} [options]
+ */
+export function evaluateOriginSafety(options = {}) {
+  if (
+    options.allowUnsafeOrigin === true
+    || options.allowSameOriginEmbed === true
+    || options.allowSameOriginHostedRuntime === true
+  ) {
+    return safeResult()
+  }
+
+  if (typeof window === 'undefined') {
+    return safeResult()
+  }
+
+  const effective = resolveEffectiveOrigins(options)
+  const expectedHubOrigin = parseOrigin(effective.hubOrigin)
+  const expectedRuntimeOrigin = parseOrigin(effective.runtimePublicUrl)
+  const enforceDedicated = options.enforceDedicatedHubOrigin !== false
+  const enforceRuntime = options.enforceIsolatedHostedRuntime !== false
+  const canBootstrap = options.hasToken === true && Boolean(options.backendUrl)
+  const serverResolved = options.serverOriginsResolved === true
+
+  if (effective.devFriendly) {
+    const embedBlock = checkSameOriginEmbed(expectedHubOrigin, expectedRuntimeOrigin)
+    if (embedBlock) return embedBlock
+    return safeResult({
+      devFriendly: true,
+      expectedHubOrigin,
+      expectedRuntimeOrigin,
+    })
+  }
+
+  const embedBlock = checkSameOriginEmbed(expectedHubOrigin, expectedRuntimeOrigin)
+  if (embedBlock) return embedBlock
+
+  if (enforceDedicated) {
+    if (!expectedHubOrigin) {
+      if (!serverResolved && canBootstrap) {
+        return loadingResult({ expectedRuntimeOrigin })
+      }
+      return unsafe(ORIGIN_UNSAFE_NOT_CONFIGURED, { expectedHubOrigin: null, expectedRuntimeOrigin })
+    }
+
+    if (expectedHubOrigin !== effective.currentOrigin) {
+      return unsafe(ORIGIN_UNSAFE_WRONG_ORIGIN, { expectedHubOrigin, expectedRuntimeOrigin })
+    }
+  }
+
+  if (enforceRuntime && !effective.originsAuto && !effective.localDev) {
+    if (!expectedRuntimeOrigin) {
+      if (!serverResolved && canBootstrap) {
+        return loadingResult({ expectedHubOrigin, expectedRuntimeOrigin: null })
+      }
+      return unsafe(ORIGIN_UNSAFE_RUNTIME_NOT_CONFIGURED, { expectedHubOrigin, expectedRuntimeOrigin: null })
+    }
+
+    if (expectedRuntimeOrigin === effective.currentOrigin) {
+      return unsafe(ORIGIN_UNSAFE_RUNTIME_SAME_ORIGIN, { expectedHubOrigin, expectedRuntimeOrigin })
+    }
+  }
+
+  return safeResult({ expectedHubOrigin, expectedRuntimeOrigin })
+}
+
+export function isEmbeddedFrame() {
+  if (typeof window === 'undefined') return false
+  return window.self !== window.top
+}

package/src/utils/safeStorage.js

@@ -0,0 +1,191 @@
+const SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/
+const MAX_STRING = 200
+const MAX_HINT = 500
+const MAX_ICON = 32
+const MAX_LIST = 200
+
+export function isValidSlug(slug) {
+  return typeof slug === 'string' && SLUG_RE.test(slug)
+}
+
+export function clampString(value, max = MAX_STRING) {
+  if (typeof value !== 'string') return ''
+  return value.slice(0, max)
+}
+
+export function safeParseJson(raw, maxBytes = 512 * 1024) {
+  if (!raw || typeof raw !== 'string' || raw.length > maxBytes) return null
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return null
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  if (hasDangerousOwnKey(parsed)) return null
+  return parsed
+}
+
+function hasDangerousOwnKey(obj) {
+  const dangerous = ['__proto__', 'constructor', 'prototype']
+  return dangerous.some((key) => Object.prototype.hasOwnProperty.call(obj, key))
+}
+
+export function sanitizeGroupNames(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const out = {}
+  let count = 0
+  for (const [key, name] of Object.entries(value)) {
+    if (count >= MAX_LIST) break
+    const id = clampString(key, 64)
+    if (!id) continue
+    out[id] = clampString(name, MAX_STRING)
+    count += 1
+  }
+  return out
+}
+
+export function sanitizeDesktopSettings(parsed) {
+  if (!parsed || typeof parsed !== 'object') return null
+  const theme = parsed.theme
+  return {
+    snapToGrid: typeof parsed.snapToGrid === 'boolean' ? parsed.snapToGrid : undefined,
+    theme: theme === 'dark' || theme === 'light' || theme === 'auto' ? theme : undefined,
+    groupNames: sanitizeGroupNames(parsed.groupNames),
+    builtinPositions: sanitizeBuiltinPlacements(parsed.builtinPositions),
+  }
+}
+
+function sanitizeBuiltinPlacements(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const out = {}
+  let count = 0
+  for (const [key, pos] of Object.entries(value)) {
+    if (count >= MAX_LIST) break
+    const id = clampString(key, 64)
+    if (!id || !pos || typeof pos !== 'object') continue
+    const x = Number(pos.x)
+    const y = Number(pos.y)
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+    out[id] = { x: Math.round(x), y: Math.round(y) }
+    count += 1
+  }
+  return Object.keys(out).length ? out : undefined
+}
+
+export function sanitizeUserApp(app) {
+  if (!app || typeof app !== 'object') return null
+  const slug = isValidSlug(app.slug)
+    ? app.slug
+    : (isValidSlug(app.id?.replace(/^user-/, '')) ? app.id.replace(/^user-/, '') : null)
+  if (!slug) return null
+
+  const installMethod = app.installMethod === 'local' || app.installMethod === 'appstore' || app.installMethod === 'publish'
+    ? app.installMethod
+    : (app.local ? 'local' : 'appstore')
+
+  const status = app.status === 'draft' || app.status === 'active' || app.status === 'disabled'
+    ? app.status
+    : 'active'
+
+  const desktopX = Number(app.desktopX)
+  const desktopY = Number(app.desktopY)
+
+  return {
+    id: `user-${slug}`,
+    slug,
+    installedVersion: typeof app.installedVersion === 'string'
+      ? clampString(app.installedVersion, 64) || null
+      : (typeof app.version === 'string' ? clampString(app.version, 64) || null : null),
+    version: typeof app.installedVersion === 'string'
+      ? clampString(app.installedVersion, 64) || null
+      : (typeof app.version === 'string' ? clampString(app.version, 64) || null : null),
+    name: clampString(app.name) || slug,
+    icon: clampString(app.icon, MAX_ICON) || '📦',
+    hint: clampString(app.hint ?? app.description, MAX_HINT),
+    status,
+    runtime_type: app.runtime_type === 'iframe' || app.runtime_type === 'hosted' || app.runtime_type === 'connected' || app.runtime_type === 'native'
+      ? app.runtime_type
+      : 'iframe',
+    entry_url: typeof app.entry_url === 'string' ? clampString(app.entry_url, 2048) || null : null,
+    healthcheck_url: typeof app.healthcheck_url === 'string' ? clampString(app.healthcheck_url, 2048) || null : null,
+    builtin: false,
+    local: installMethod === 'local',
+    installMethod,
+    createdAt: clampString(app.createdAt, 40) || new Date().toISOString(),
+    windowTitle: clampString(app.windowTitle ?? app.name) || slug,
+    width: clampNumber(app.width, 320, 4096, 640),
+    height: clampNumber(app.height, 240, 4096, 420),
+    desktopX: Number.isFinite(desktopX) ? Math.round(desktopX) : null,
+    desktopY: Number.isFinite(desktopY) ? Math.round(desktopY) : null,
+  }
+}
+
+function clampNumber(value, min, max, fallback) {
+  const n = Number(value)
+  if (!Number.isFinite(n)) return fallback
+  return Math.min(max, Math.max(min, Math.round(n)))
+}
+
+export function sanitizeWindowState(win) {
+  if (!win || typeof win !== 'object') return null
+  const appId = clampString(win.appId, 80)
+  if (!appId) return null
+  const display = win.display === 'mini' || win.display === 'fullscreen' ? win.display : 'mini'
+  return {
+    appId,
+    minimized: !!win.minimized,
+    display,
+    x: clampNumber(win.x, 0, 100000, 0),
+    y: clampNumber(win.y, 0, 100000, 0),
+    width: clampNumber(win.width, 200, 10000, 720),
+    height: clampNumber(win.height, 200, 10000, 480),
+    zIndex: clampNumber(win.zIndex, 0, 100000, 1),
+  }
+}
+
+export function sanitizeDesktopSession(parsed) {
+  if (!parsed || typeof parsed !== 'object') return null
+
+  const userApps = Array.isArray(parsed.userApps)
+    ? parsed.userApps.slice(0, MAX_LIST).map(sanitizeUserApp).filter(Boolean)
+    : []
+
+  const installedSlugs = Array.isArray(parsed.installedSlugs)
+    ? [...new Set(parsed.installedSlugs.filter(isValidSlug))].slice(0, MAX_LIST)
+    : []
+
+  const windows = Array.isArray(parsed.windows)
+    ? parsed.windows.slice(0, MAX_LIST).map(sanitizeWindowState).filter(Boolean)
+    : []
+
+  const settings = sanitizeDesktopSettings(parsed.settings)
+  const activeId = typeof parsed.activeId === 'string' ? clampString(parsed.activeId, 80) : null
+
+  return {
+    userApps,
+    installedSlugs,
+    windows,
+    activeId: activeId || null,
+    settings: settings ?? undefined,
+  }
+}
+
+export function sanitizeWindowLayout(parsed) {
+  if (!parsed || typeof parsed !== 'object') return null
+  const display = parsed.display === 'mini' || parsed.display === 'fullscreen' ? parsed.display : null
+  if (!display) return null
+
+  const mini = parsed.mini ?? parsed
+  if (!mini || typeof mini !== 'object') return { display }
+
+  return {
+    display,
+    mini: {
+      x: mini.x == null ? null : clampNumber(mini.x, 0, 100000, 0),
+      y: mini.y == null ? null : clampNumber(mini.y, 0, 100000, 0),
+      width: clampNumber(mini.width, 200, 10000, 720),
+      height: clampNumber(mini.height, 200, 10000, 480),
+    },
+  }
+}

package/src/utils/semver.js

@@ -0,0 +1,30 @@
+/**
+ * @param {string|null|undefined} version
+ * @returns {number[]}
+ */
+function parseParts(version) {
+  if (!version || typeof version !== 'string') return [0, 0, 0]
+  return version.trim().split('.').map((part) => {
+    const n = Number.parseInt(part, 10)
+    return Number.isFinite(n) ? n : 0
+  })
+}
+
+/**
+ * @param {string|null|undefined} next
+ * @param {string|null|undefined} current
+ */
+export function isSemverGreaterThan(next, current) {
+  const a = parseParts(next)
+  const b = parseParts(current)
+  const len = Math.max(a.length, b.length, 3)
+
+  for (let i = 0; i < len; i += 1) {
+    const da = a[i] ?? 0
+    const db = b[i] ?? 0
+    if (da > db) return true
+    if (da < db) return false
+  }
+
+  return false
+}

package/src/utils/zoneContext.js

@@ -0,0 +1,38 @@
+/** Shared with other KNF packages on the same host (e.g. workpoint). */
+export const ZONE_STORAGE_KEY = 'selected_zone'
+
+export function parseZonesFromResponse(resp) {
+  const data = resp?.data?.datas ?? resp?.data?.data ?? resp?.data ?? {}
+  if (Array.isArray(data.zones)) return data.zones
+  if (Array.isArray(data)) return data
+  return []
+}
+
+export function parseZonesMeta(resp) {
+  const data = resp?.data?.datas ?? resp?.data?.data ?? resp?.data ?? {}
+  return {
+    timezone: data.timezone ?? null,
+    isManager: !!data.is_manager,
+  }
+}
+
+export function loadStoredZone() {
+  try {
+    const raw = localStorage.getItem(ZONE_STORAGE_KEY)
+    if (!raw) return null
+    const zone = JSON.parse(raw)
+    if (zone && zone.id != null) return zone
+  } catch {
+    /* ignore */
+  }
+  return null
+}
+
+export function saveStoredZone(zone) {
+  if (!zone?.id) return
+  try {
+    localStorage.setItem(ZONE_STORAGE_KEY, JSON.stringify({ id: zone.id, name: zone.name ?? '' }))
+  } catch {
+    /* ignore */
+  }
+}