@ossy/platform 1.16.5 → 1.16.7

package/Dockerfile

@@ -0,0 +1,23 @@
+# Build context: ossy/packages/platform directory.
+# From repo root: docker build -f ossy/packages/platform/Dockerfile ossy/packages/platform
+# In CI, this image is built and pushed to ghcr.io/ossy-se/runtime:latest by the Publish workflow.
+FROM node:24-bookworm-slim
+
+WORKDIR /app
+
+COPY package.json ./
+
+# Install production deps only.
+# @ossy/router and @ossy/sdk must be resolvable — in production these are
+# published npm packages; in monorepo CI use npm pack + install.
+RUN npm install --omit=dev --no-audit --no-fund --loglevel=error
+
+COPY src ./src
+
+EXPOSE 3000
+
+# Required env vars at runtime:
+#   OSSY_API_KEY   — Ossy API JWT for CMS reads
+#   OSSY_API_URL   — (optional) override API base, default https://api.ossy.se/api/v0
+#   PORT           — (optional) override listen port, default 3000
+CMD ["node", "src/runtime.js"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.16.5",
+  "version": "1.16.7",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -12,6 +12,8 @@
     ".": "./src/server.js",
     "./server": "./src/server.js",
     "./proxy-internal": "./src/proxy-internal.js",
+    "./runtime": "./src/runtime.js",
+    "./site-loader": "./src/site-loader.js",
     "./worker": "./src/worker-entry.js",
     "./worker-runtime": "./src/worker-runtime.js"
   },
@@ -22,15 +24,16 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.17.5",
-    "@ossy/sdk": "^1.17.5",
+    "@ossy/router": "^1.17.7",
+    "@ossy/sdk": "^1.17.7",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <17.0.0",
     "express": ">=5.0.0 <6.0.0",
     "morgan": ">=1.10.1 <2.0.0"
   },
   "files": [
-    "src"
+    "src",
+    "Dockerfile"
   ],
-  "gitHead": "81baa12dad845ec3f48438d2c4ba139a3a271770"
+  "gitHead": "09617a4222cd31cc0e8cf867d42310fa5c73d6cc"
 }

package/src/runtime.js

@@ -0,0 +1,213 @@
+import path from 'path'
+import fs from 'node:fs'
+import express from 'express'
+import cookieParser from 'cookie-parser'
+import morgan from 'morgan'
+import { Router as OssyRouter } from '@ossy/router'
+import { loadManifest, resolveEntryUrl } from './server.js'
+import { ProxyInternal } from './proxy-internal.js'
+import { loadSite, invalidateSite } from './site-loader.js'
+
+const DEFAULT_PORT = 3000
+
+function resolvePort () {
+  const raw = process.env.PORT
+  const parsed = Number.parseInt(String(raw ?? ''), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT
+}
+
+function cloneSerializable (value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value))
+}
+
+/**
+ * Per-domain SSR context, cached after first successful site load.
+ * @type {Map<string, { pageRouter: any, apiRouter: any, manifest: any, loadEntry: (url: string) => Promise<any> }>}
+ */
+const siteContextCache = new Map()
+
+function buildSiteContext (manifest, buildDir) {
+  const config = manifest.config
+  const supportedLanguages = Array.isArray(config.supportedLanguages) ? config.supportedLanguages : []
+
+  const pageRouter = OssyRouter.of({
+    pages: manifest.pages,
+    supportedLanguages,
+    defaultLanguage: config.defaultLanguage,
+  })
+  const apiRouter = OssyRouter.of({ pages: manifest.apis })
+
+  const moduleCache = new Map()
+  function loadEntry (entryUrl) {
+    if (moduleCache.has(entryUrl)) return moduleCache.get(entryUrl)
+    const promise = import(resolveEntryUrl(entryUrl, buildDir))
+    moduleCache.set(entryUrl, promise)
+    return promise
+  }
+
+  return { pageRouter, apiRouter, manifest, loadEntry }
+}
+
+async function getSiteContext (domain) {
+  if (siteContextCache.has(domain)) return siteContextCache.get(domain)
+  const buildDir = await loadSite(domain)
+  const manifest = loadManifest(buildDir)
+  const context = buildSiteContext(manifest, buildDir)
+  siteContextCache.set(domain, context)
+  return context
+}
+
+/**
+ * Start the multi-tenant SSR runtime. Serves any published Ossy app by hostname,
+ * loading build artifacts from the CMS on first request per domain.
+ *
+ * Environment variables:
+ *   OSSY_API_KEY  — API JWT for CMS reads (required)
+ *   OSSY_API_URL  — Override API base URL (default: https://api.ossy.se/api/v0)
+ *   PORT          — Override listen port (default: 3000)
+ */
+export async function startRuntime ({ port } = {}) {
+  const resolvedPort = port ?? resolvePort()
+
+  const app = express()
+  app.use(morgan('tiny'))
+  app.use(express.json({ strict: false }))
+  app.use(cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'))
+
+  app.use((req, _res, next) => {
+    const userSettings = JSON.parse(req.signedCookies?.['x-ossy-user-settings'] || '{}')
+    req.userAppSettings = userSettings
+    if (userSettings.workspaceId && !req.get('workspaceId')) {
+      req.headers.workspaceid = userSettings.workspaceId
+    }
+    req.isAuthenticated = req.headers.cookie ? req.headers.cookie.includes('auth=') : false
+    next()
+  })
+
+  // Proxy /@ossy/* to the upstream Ossy API
+  app.use(ProxyInternal())
+
+  // Force a fresh site download without waiting for the TTL to expire
+  app.post('/_ossy/reload', (req, res) => {
+    const domain = req.query.domain || req.hostname
+    invalidateSite(String(domain))
+    siteContextCache.delete(String(domain))
+    res.json({ ok: true, domain })
+  })
+
+  // Static file serving — download site on first request, then serve from local /tmp
+  app.use(async (req, res, next) => {
+    if (req.method !== 'GET' && req.method !== 'HEAD') return next()
+    const domain = req.hostname
+    let buildDir
+    try {
+      buildDir = await loadSite(domain)
+    } catch {
+      return next()
+    }
+    const publicDir = path.join(buildDir, 'public')
+    if (!fs.existsSync(publicDir)) return next()
+    express.static(publicDir)(req, res, next)
+  })
+
+  // SSR + API route handler
+  app.all('*all', async (req, res) => {
+    const domain = req.hostname
+    const requestUrl = req.originalUrl || '/'
+
+    let context
+    try {
+      context = await getSiteContext(domain)
+    } catch (err) {
+      console.error(`[@ossy/platform] Failed to load site for ${domain}:`, err.message)
+      res.status(503).type('text').send(`Site not available: ${domain}`)
+      return
+    }
+
+    const { pageRouter, apiRouter, manifest, loadEntry } = context
+
+    try {
+      const apiRoute = apiRouter.getPageByUrl(requestUrl)
+      if (apiRoute) {
+        const apiEntry = manifest.apis.find((a) => a.id === apiRoute.id)
+        if (apiEntry) {
+          const mod = await loadEntry(apiEntry.entry)
+          if (typeof mod.handle === 'function') {
+            await mod.handle(req, res)
+            return
+          }
+        }
+      }
+
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.status(404).send('Not found')
+        return
+      }
+
+      const pageRoute = pageRouter.getPageByUrl(requestUrl)
+      if (!pageRoute) {
+        res.status(404).send('Not found')
+        return
+      }
+
+      const pageEntry = manifest.pages.find((p) => p.id === pageRoute.id)
+      if (!pageEntry) {
+        res.status(404).send('Not found')
+        return
+      }
+
+      const mod = await loadEntry(pageEntry.entry)
+      if (typeof mod.render !== 'function') {
+        res.status(503).type('text').send('SSR runtime unavailable')
+        return
+      }
+
+      const config = manifest.config
+      const props = {
+        ...config,
+        ...(req.userAppSettings || {}),
+        theme: req.userAppSettings?.theme || cloneSerializable(config?.theme),
+        themes: cloneSerializable(config?.themes),
+        resourceTemplates: cloneSerializable(config?.resourceTemplates),
+        url: requestUrl,
+        isAuthenticated: !!req.isAuthenticated,
+        pages: manifest.pages.map((page) => ({ id: page.id, path: page.path })),
+        pageId: pageRoute.id,
+      }
+      const html = await mod.render(props)
+      res.status(200).type('html').send(html)
+    } catch (err) {
+      console.error(`[@ossy/platform] Request error for ${domain}${requestUrl}:`, err)
+      if (!res.headersSent) res.status(500).type('text').send('Internal Server Error')
+    }
+  })
+
+  const server = await new Promise((resolve, reject) => {
+    const httpServer = app.listen(resolvedPort)
+    httpServer.once('listening', () => resolve(httpServer))
+    httpServer.once('error', reject)
+  })
+
+  console.log(`[@ossy/platform] Runtime running on http://localhost:${resolvedPort}`)
+  console.log('[@ossy/platform] Press Ctrl+C to stop.')
+
+  const closeServer = () => new Promise((resolve) => server.close(() => resolve()))
+
+  let shuttingDown = false
+  const handleShutdown = async (signal) => {
+    if (shuttingDown) return
+    shuttingDown = true
+    console.log(`\n[@ossy/platform] Received ${signal}, shutting down…`)
+    try { await closeServer() } finally { process.exit(0) }
+  }
+  process.on('SIGINT', () => handleShutdown('SIGINT'))
+  process.on('SIGTERM', () => handleShutdown('SIGTERM'))
+
+  return { app, server, port: resolvedPort, close: closeServer }
+}
+
+// Run directly: node src/runtime.js
+startRuntime().catch((err) => {
+  console.error('[@ossy/platform] Runtime failed to start:', err)
+  process.exit(1)
+})

package/src/site-loader.js

@@ -0,0 +1,162 @@
+import path from 'path'
+import os from 'os'
+import { mkdir, writeFile } from 'fs/promises'
+import { SDK, ResourcesList } from '@ossy/sdk'
+
+const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+const DOWNLOAD_CONCURRENCY = 10
+const BASE_DIR = path.join(os.tmpdir(), 'ossy-rt')
+
+const API_URL = process.env.OSSY_API_URL || 'https://api.ossy.se/api/v0'
+const API_KEY = process.env.OSSY_API_KEY
+
+/** @type {Map<string, { buildDir: string, workspaceId: string, loadedAt: number }>} */
+const cache = new Map()
+
+/**
+ * Resolve workspaceId for a domain by calling the /apps/ask endpoint.
+ * Result is cached inside the site cache entry — this function is always
+ * called as part of loadSite(), which manages its own TTL.
+ *
+ * @param {string} domain  e.g. `ossy.se`
+ * @returns {Promise<string>}  workspaceId
+ */
+async function resolveWorkspaceId (domain) {
+  const url = `${API_URL}/apps/ask?domain=${encodeURIComponent(domain)}`
+  const res = await fetch(url)
+  if (res.status === 404) {
+    throw new Error(`[@ossy/platform] Domain not registered: ${domain}`)
+  }
+  if (!res.ok) {
+    throw new Error(`[@ossy/platform] /apps/ask failed for ${domain}: HTTP ${res.status}`)
+  }
+  const body = await res.json()
+  if (!body?.workspaceId) {
+    throw new Error(`[@ossy/platform] /apps/ask returned no workspaceId for ${domain}`)
+  }
+  return body.workspaceId
+}
+
+/**
+ * BFS walk of CMS resources under `location`, collecting all file resources recursively.
+ * Directories have `type === 'directory'`; files have `content.src`.
+ *
+ * @param {ReturnType<typeof SDK.of>} sdk
+ * @param {string} location  e.g. `/@ossy/apps/ossy.se`
+ * @returns {Promise<Array<{ resource: object, relPath: string }>>}
+ */
+async function collectFiles (sdk, location) {
+  const results = []
+  const queue = [{ location, prefix: '' }]
+
+  while (queue.length > 0) {
+    const { location: loc, prefix } = queue.shift()
+    const resources = await sdk.makeRequest(ResourcesList)({
+      search: new URLSearchParams({ location: loc }).toString(),
+    })
+
+    if (!Array.isArray(resources)) continue
+
+    for (const r of resources) {
+      const relPath = prefix ? `${prefix}/${r.name}` : r.name
+      if (r.type === 'directory') {
+        queue.push({ location: `${loc}/${r.name}`, prefix: relPath })
+      } else if (r.content?.src) {
+        results.push({ resource: r, relPath })
+      }
+    }
+  }
+
+  return results
+}
+
+/**
+ * Run async tasks with a concurrency limit.
+ * @param {Array<() => Promise<void>>} tasks
+ * @param {number} concurrency
+ */
+async function runWithConcurrency (tasks, concurrency) {
+  const queue = [...tasks]
+  const workers = Array.from(
+    { length: Math.min(concurrency, tasks.length) },
+    async () => {
+      while (queue.length > 0) {
+        const task = queue.shift()
+        if (task) await task()
+      }
+    }
+  )
+  await Promise.all(workers)
+}
+
+/**
+ * Download a file from a presigned URL to an absolute local path.
+ * @param {string} src  presigned S3 URL
+ * @param {string} absPath  local destination
+ */
+async function downloadFile (src, absPath) {
+  await mkdir(path.dirname(absPath), { recursive: true })
+  const res = await fetch(src)
+  if (!res.ok) {
+    throw new Error(`[@ossy/platform] Download failed for ${path.basename(absPath)}: HTTP ${res.status}`)
+  }
+  const buf = await res.arrayBuffer()
+  await writeFile(absPath, Buffer.from(buf))
+}
+
+/**
+ * Load (and cache) a site's build artifacts from the CMS into `/tmp/ossy-rt/{domain}/`.
+ * Returns the local `buildDir` path once all files are downloaded.
+ *
+ * The workspaceId is resolved dynamically via GET /api/v0/apps/ask?domain=X so
+ * the runtime can host apps from any workspace without a global OSSY_WORKSPACE_ID.
+ *
+ * @param {string} domain  e.g. `ossy.se`
+ * @returns {Promise<string>}  absolute path to the local buildDir
+ */
+export async function loadSite (domain) {
+  const cached = cache.get(domain)
+  if (cached && Date.now() - cached.loadedAt < CACHE_TTL_MS) {
+    return cached.buildDir
+  }
+
+  const workspaceId = await resolveWorkspaceId(domain)
+
+  const buildDir = path.join(BASE_DIR, domain)
+  const cmsLocation = `/@ossy/apps/${domain}`
+
+  console.log(`[@ossy/platform] Loading site for ${domain} (workspace ${workspaceId}) from CMS ${cmsLocation}…`)
+
+  const sdk = SDK.of({
+    apiUrl: API_URL,
+    workspaceId,
+    authorization: API_KEY,
+  })
+
+  const files = await collectFiles(sdk, cmsLocation)
+
+  if (files.length === 0) {
+    throw new Error(`[@ossy/platform] No published build found for ${domain} at ${cmsLocation}`)
+  }
+
+  const tasks = files.map(({ resource, relPath }) => async () => {
+    const absPath = path.join(buildDir, relPath)
+    await downloadFile(resource.content.src, absPath)
+  })
+
+  await runWithConcurrency(tasks, DOWNLOAD_CONCURRENCY)
+
+  console.log(`[@ossy/platform] Site ${domain} ready — ${files.length} file(s) in ${buildDir}`)
+
+  cache.set(domain, { buildDir, workspaceId, loadedAt: Date.now() })
+  return buildDir
+}
+
+/**
+ * Invalidate the in-memory cache for a domain, forcing a fresh download on next request.
+ * @param {string} domain
+ */
+export function invalidateSite (domain) {
+  cache.delete(domain)
+  console.log(`[@ossy/platform] Cache invalidated for ${domain}`)
+}