@ossy/platform 0.0.1-alpha.1 → 1.13.0

package/package.json

@@ -1,39 +1,37 @@
 {
   "name": "@ossy/platform",
-  "version": "0.0.1-alpha.1",
+  "version": "1.13.0",
+  "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ossy-se/ossy.git",
-    "directory": "packages/platform"
+    "url": "git+https://github.com/ossy-se/packages.git"
   },
   "type": "module",
-  "description": "Platform module: deployment platform config resource template and home UI for Ossy websites",
+  "main": "./src/server.js",
   "exports": {
-    ".": "./src/index.js",
-    "./package.json": "./package.json"
+    ".": "./src/server.js",
+    "./server": "./src/server.js",
+    "./proxy-internal": "./src/proxy-internal.js",
+    "./worker": "./src/worker-entry.js",
+    "./worker-runtime": "./src/worker-runtime.js"
   },
-  "main": "./src/index.js",
-  "sideEffects": false,
   "scripts": {
-    "build": "echo \"@ossy/platform: no build step\" && exit 0",
-    "test": ""
+    "start": "PORT=3003 node ./src/server.js"
   },
+  "keywords": [],
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
+  "dependencies": {
+    "@ossy/router": "^1.14.0",
+    "@ossy/sdk": "^1.14.0",
+    "cookie-parser": "^1.4.7",
+    "express": ">=5.0.0 <6.0.0",
+    "morgan": ">=1.10.1 <2.0.0",
+    "react": ">=19.0.0 <20.0.0",
+    "react-dom": ">=19.0.0 <20.0.0"
+  },
   "files": [
-    "src",
-    "README.md",
-    "CHANGELOG.md"
+    "src"
   ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "peerDependencies": {
-    "@ossy/design-system": ">=0.14.0",
-    "@ossy/router-react": ">=0.14.0",
-    "@ossy/sdk-react": ">=0.14.0",
-    "react": ">=19.0.0"
-  },
-  "gitHead": "1da35d94f324f917d5ea790f838ce8e50214730e"
+  "gitHead": "c496b1f449dba609d65efac16aa100a02a5f0595"
 }

package/src/http.js

@@ -0,0 +1,85 @@
+import path from 'path';
+import url from 'url'
+import express from 'express'
+import morgan from 'morgan'
+import { Router as OssyRouter } from '@ossy/router'
+import cookieParser from 'cookie-parser'
+
+const app = express();
+
+const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
+
+function parsePortFromArgv(argv) {
+  // Supports: --port 4000, --port=4000, -p 4000
+  const idx = argv.findIndex(a => a === '--port' || a === '-p')
+  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1]
+
+  const eq = argv.find(a => a.startsWith('--port='))
+  if (eq) return eq.split('=')[1]
+
+  return undefined
+}
+
+function normalizePort(value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback
+  const n = Number.parseInt(String(value), 10)
+  if (!Number.isFinite(n) || n <= 0) return fallback
+  return n
+}
+
+const DEFAULT_PORT = 3000
+const port = normalizePort(parsePortFromArgv(process.argv) ?? process.env.PORT, DEFAULT_PORT)
+
+const middleware = [
+  morgan('tiny'),
+  express.json({ strict: false }),
+  cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'),
+]
+
+app.use(middleware)
+
+// const PageRegistry = OssyRouter.of({ pages: [] })
+// const ApiRegistry = OssyRouter.of({ api: [] })
+// const TaskRegistry = OssyRouter.of({ tasks: [] })
+// const StaticRegistry = OssyRouter.of({ static: [] })
+
+const Registry = OssyRouter.of({ pages: [
+    {
+        id: 'home',
+        type: '@ossy/platform/page',
+        path: '/',
+        content: '<h1>Hello World from page route</h1>'
+    },
+    {
+        id: 'home',
+        type: '@ossy/platform/api',
+        path: '/api',
+        handle: (req, res) => {
+            res.send({ message: 'Hello World from api route' })
+        }
+    }
+]})
+
+app.all('*all', (req, res) => {
+  const pathname = req.originalUrl
+
+  // Will be replaced with fetching the resource from ossy storage
+  const resource = Registry.getPageByUrl(pathname)
+
+  if (resource.type === '@ossy/platform/page') {
+    res.send(resource.content)
+  }
+
+  else if (resource.type === '@ossy/platform/api') {
+    resource.handle(req, res)
+  }
+
+  else {
+    res.status(404).send('Not found')
+  }
+  
+})
+
+app.listen(port, () => {
+  console.log(`[@ossy/app][server] Running on http://localhost:${port}`);
+});

package/src/proxy-internal.js

@@ -0,0 +1,112 @@
+/** Node/Express can join duplicate workspace headers as `id, id` — API expects a single id. */
+function normalizeWorkspaceIdHeader (value) {
+  if (!value || value === 'undefined') return undefined
+  const first = String(value).split(',')[0]?.trim()
+  return first || undefined
+}
+
+export function ProxyInternal () {
+  return (req, res, next) => {
+    if (!req.originalUrl.startsWith('/@ossy')) {
+      return next()
+    }
+
+    if (req.originalUrl.startsWith('/@ossy/users/me/app-settings') && req.method === 'PATCH') {
+      if (!req.body) {
+        res.status(400)
+        res.json('Invalid request body')
+        return
+      }
+
+      const requestedSettings = req.body
+      const expiresMaxAge = 2147483647
+      const userSettings = JSON.parse(req.signedCookies?.['x-ossy-user-settings'] || '{}')
+
+      const updatedSettings = {
+        ...userSettings,
+        ...requestedSettings,
+      }
+
+      res.cookie('x-ossy-user-settings', JSON.stringify(updatedSettings), {
+        httpOnly: true,
+        signed: true,
+        expires: new Date(Date.now() + expiresMaxAge),
+      })
+
+      res.status(201)
+      res.json('')
+      return
+    }
+
+    if (req.originalUrl.startsWith('/@ossy/users/me/app-settings') && req.method === 'GET') {
+      console.log('[@ossy/platform][proxy] GET /@ossy/users/me/app-settings')
+      const userSettings = JSON.parse(req.signedCookies?.['x-ossy-user-settings'] || '{}')
+      res.status(200)
+      res.json(userSettings)
+      return
+    }
+
+    console.log(`[@ossy/platform][proxy] ${req.method} ${req.originalUrl}`)
+
+    const domain = process.env.OSSY_API_URL || 'https://api.ossy.se'
+    const url = `${domain}${req.originalUrl?.replace('/@ossy', '/api/v0')}`
+    const forwardedHeaders = JSON.parse(JSON.stringify(req.headers))
+    const workspaceId = normalizeWorkspaceIdHeader(req.get('workspaceId'))
+
+    if (workspaceId) {
+      forwardedHeaders.workspaceid = workspaceId
+    }
+
+    const request = {
+      method: req.method,
+      headers: forwardedHeaders,
+    }
+
+    if (!['GET', 'HEAD'].includes(req.method)) {
+      request.body = JSON.stringify(req.body)
+    }
+
+    fetch(url, request)
+      .then((response) => {
+        response.headers.forEach((value, name) => {
+          res.setHeader(name, value)
+        })
+
+        if (response.headers.get('content-type')?.includes('application/json')) {
+          return response.text().then((text) => {
+            const trimmed = text?.trim() ?? ''
+            let data
+            try {
+              data = trimmed === '' ? null : JSON.parse(trimmed)
+            } catch (error) {
+              console.log('[@ossy/platform][proxy][error]', error)
+              res.removeHeader('content-length')
+              const st = response.status
+              if (st === 401 || st === 403 || st === 404) {
+                res.status(st)
+                res.json(null)
+                return
+              }
+              res.status(502)
+              res.json({ message: 'Upstream returned invalid JSON' })
+              return
+            }
+            res.removeHeader('content-length')
+            res.status(response.status)
+            res.json(data)
+          })
+        }
+
+        return response.arrayBuffer().then((buffer) => {
+          res.status(response.status)
+          res.send(Buffer.from(buffer))
+        })
+      })
+      .catch((error) => {
+        console.log('[@ossy/platform][proxy][error]', error)
+        const status = error.status
+        res.status(status || 500)
+        res.json({ message: error.message || 'Internal Server Error' })
+      })
+  }
+}

package/src/server.js

@@ -0,0 +1,142 @@
+import fs from 'node:fs'
+import path from 'path'
+import url from 'url'
+import { pathToFileURL } from 'node:url'
+import express from 'express'
+import morgan from 'morgan'
+import { Router as OssyRouter } from '@ossy/router'
+import cookieParser from 'cookie-parser'
+import { ProxyInternal } from './proxy-internal.js'
+
+import buildTimeConfig from './.ossy/server-config.runtime.mjs'
+import { BuildPage, buildPrerenderAppConfig } from './.ossy/render-page.task.js'
+import Middleware from './.ossy/middleware.runtime.js'
+
+const __ossyDir = path.dirname(url.fileURLToPath(import.meta.url)) + '/.ossy'
+
+function readOssyJson (name) {
+  return JSON.parse(fs.readFileSync(path.join(__ossyDir, name), 'utf8'))
+}
+
+const apiRouteList = readOssyJson('api.generated.json') ?? []
+const sitePageList = readOssyJson('pages.generated.json') ?? []
+
+function pageRouterLanguageOptions (config, pages) {
+  let supported = config?.supportedLanguages
+  let defaultLanguage = config?.defaultLanguage
+  if ((!supported || supported.length <= 1) && pages.length > 0) {
+    const p0 = pages[0]
+    if (p0 && typeof p0.path === 'object' && p0.path != null) {
+      supported = Object.keys(p0.path)
+      defaultLanguage = defaultLanguage || supported[0]
+    }
+  }
+  return {
+    supportedLanguages: Array.isArray(supported) ? supported : [],
+    defaultLanguage,
+  }
+}
+
+const app = express()
+
+const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
+const ROOT_PATH = path.resolve(currentDir, 'public')
+
+function parsePortFromArgv (argv) {
+  const idx = argv.findIndex((a) => a === '--port' || a === '-p')
+  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1]
+
+  const eq = argv.find((a) => a.startsWith('--port='))
+  if (eq) return eq.split('=')[1]
+
+  return undefined
+}
+
+function normalizePort (value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback
+  const n = Number.parseInt(String(value), 10)
+  if (!Number.isFinite(n) || n <= 0) return fallback
+  return n
+}
+
+const DEFAULT_PORT = 3000
+const port = normalizePort(parsePortFromArgv(process.argv) ?? process.env.PORT, DEFAULT_PORT)
+
+if (Middleware !== undefined) {
+  console.log(`[@ossy/platform][server] ${Middleware?.length || 0} custom middleware loaded`)
+}
+
+const middleware = [
+  morgan('tiny'),
+  express.json({ strict: false }),
+  cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'),
+  (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
+    }
+    const cookieHeader = req.headers.cookie
+    req.isAuthenticated = cookieHeader ? cookieHeader.includes('auth=') : false
+    next()
+  },
+  ...(Middleware || []),
+  express.static(ROOT_PATH),
+  ProxyInternal(),
+]
+
+app.use(middleware)
+
+const apiRouter = OssyRouter.of({
+  pages: apiRouteList,
+})
+
+const { supportedLanguages, defaultLanguage } = pageRouterLanguageOptions(
+  buildTimeConfig,
+  sitePageList
+)
+
+const pageRouter = OssyRouter.of({
+  pages: sitePageList,
+  defaultLanguage,
+  supportedLanguages,
+})
+
+app.all('*all', async (req, res) => {
+  const requestUrl = req.originalUrl || '/'
+  try {
+    const apiRoute = apiRouter.getPageByUrl(requestUrl)
+    if (apiRoute?.module) {
+      const mod = await import(pathToFileURL(path.resolve(__ossyDir, apiRoute.module)).href)
+      await mod.default(req, res)
+      return
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      res.status(404).send('Not found')
+      return
+    }
+    const pageRoute = pageRouter.getPageByUrl(requestUrl)
+    if (pageRoute) {
+      const appConfig = buildPrerenderAppConfig({
+        buildTimeConfig,
+        pageList: sitePageList,
+        activeRouteId: pageRoute.id,
+        urlPath: requestUrl,
+        isAuthenticated: !!req.isAuthenticated,
+      })
+      const html = await BuildPage.handle({ route: pageRoute, appConfig })
+      res.status(200).type('html').send(html)
+      return
+    }
+    res.status(404).send('Not found')
+  } catch (err) {
+    console.error('[@ossy/platform][server] Request handling failed:', err)
+    if (!res.headersSent) {
+      res.status(500).type('text').send('Internal Server Error')
+    }
+  }
+})
+
+app.listen(port, () => {
+  console.log(`[@ossy/platform][server] Running on http://localhost:${port}`)
+})

package/src/worker-entry.js

@@ -0,0 +1,10 @@
+import 'dotenv/config'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { runWorkerScheduler } from './worker-runtime.js'
+
+const __ossyDir = path.dirname(fileURLToPath(import.meta.url)) + '/.ossy'
+const tasks = JSON.parse(fs.readFileSync(path.join(__ossyDir, 'tasks.generated.json'), 'utf8')) ?? []
+
+runWorkerScheduler(tasks, __ossyDir)

package/src/worker-runtime.js

@@ -0,0 +1,115 @@
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { SDK } from '@ossy/sdk'
+
+/**
+ * @param {Array<{ type: string, module: string }>} tasks
+ * @param {string} ossyDir - absolute path to the .ossy directory
+ */
+export function runWorkerScheduler (tasks, ossyDir) {
+  const sdk = SDK.of({
+    workspaceId: process.env.OSSY_WORKSPACE_ID,
+    apiUrl: process.env.OSSY_API_URL,
+    authorization: process.env.OSSY_API_TOKEN,
+  })
+
+  const jobsClient = /** @type {{ getUnprocessed: () => Promise<unknown[]> }} */ (sdk.jobs)
+  let status = 'running'
+
+  console.log('Starting scheduler')
+  main()
+
+  setInterval(() => {
+    if (status === 'running') return
+    status = 'running'
+    try {
+      main()
+    } catch (error) {
+      console.log('Error running main')
+      console.error(error)
+      status = 'idle'
+    }
+  }, 3000)
+
+  function main () {
+    console.log('Looking for jobs')
+    jobsClient
+      .getUnprocessed()
+      .then(async (jobs) => {
+        if (!jobs || !jobs.length) {
+          console.log('No jobs found, going idle')
+          status = 'idle'
+          return
+        }
+
+        const jobsGroupedByResourceId = groupJobsByResourceId(jobs)
+        console.log(`Found ${jobs.length} jobs between ${jobsGroupedByResourceId.length} resources`)
+
+        const processedGroups = jobsGroupedByResourceId.map(([resourceId, groupJobs]) => {
+          console.log(`Processing group for resourceId ${resourceId}`)
+          return processJobsSequentially(groupJobs)
+            .then(() => console.log(`Completed group for resourceId ${resourceId}`))
+            .catch((err) => {
+              console.log(`Failed to process group for resourceId ${resourceId}`)
+              console.error(err)
+            })
+        })
+
+        try {
+          await Promise.allSettled(processedGroups)
+          console.log('Finished processing of groups...')
+          console.log('Going idle')
+          status = 'idle'
+          console.log('----------------------------------')
+          console.groupEnd()
+        } catch (error) {
+          console.log('Error processing groups')
+          console.error(error)
+          status = 'idle'
+        }
+      })
+      .catch((error) => {
+        console.log('Error getting jobs')
+        console.error(error)
+        status = 'idle'
+      })
+  }
+
+  function groupJobsByResourceId (jobList) {
+    return Object.entries(
+      jobList.reduce((acc, job) => {
+        const content = /** @type {{ resourceId?: string }} */ (job.content || {})
+        const rid = content.resourceId
+        return {
+          ...acc,
+          [rid]: [...(acc[rid] || []), job],
+        }
+      }, /** @type {Record<string, unknown[]>} */ ({}))
+    )
+  }
+
+  async function processJobsSequentially (jobList) {
+    console.log(`Processing ${jobList.length} jobs`)
+    for (const job of jobList) {
+      console.log(`Processing job ${job.id}`)
+      const task = tasks.find((t) => t.type === job.type)
+      if (!task) {
+        console.log('No handler found for job', job.id)
+        continue
+      }
+
+      console.log(`Handler found for ${task.type}`)
+      try {
+        const mod = await import(pathToFileURL(path.resolve(ossyDir, task.module)).href)
+        const jobSdk = SDK.of({
+          workspaceId: job.belongsTo,
+          authorization: process.env.OSSY_API_TOKEN,
+        })
+        await mod.default({ sdk: jobSdk, job }).catch(() => {})
+      } catch (error) {
+        console.error(error)
+        console.log('Failed to processing job')
+      }
+    }
+  }
+}

package/CHANGELOG.md

@@ -1,18 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-## 0.0.1-alpha.1 (2026-03-29)
-
-**Note:** Version bump only for package @ossy/platform
-
-
-
-
-
-# Changelog
-
-## 0.0.1-alpha.0
-
-- Initial extract from `website-ossy`: `Definition`, `PlatformResourceTemplates`, `PlatformHomeBody`, `platformHomeMetadata`.

package/README.md

@@ -1,30 +0,0 @@
-# @ossy/platform
-
-Ossy **Platform** module: resource template `@ossy/platform/config` (mirrors deployment-tools `platform-config.json`) and the platform home UI (`PlatformHomeBody`, metadata for routing).
-
-## Install
-
-```bash
-npm install @ossy/platform
-```
-
-Peer dependencies (your app should already include them):
-
-- `react`
-- `@ossy/design-system`
-- `@ossy/router-react`
-- `@ossy/sdk-react`
-
-## Use in a website
-
-1. Spread **`PlatformResourceTemplates`** into your app `resourceTemplates` (and sync to the API via publish / cms upload).
-2. Add a page that wraps **`PlatformHomeBody`** in your shell layout and export **`platformHomeMetadata`**.
-3. Register **`Definition`** in your navigation / module registry.
-
-## Publishing
-
-Released on its **own semver** from this monorepo (`lerna publish` with independent versions). Bump **`@ossy/platform`** when only this module changes.
-
-## Direction
-
-Long term, **which modules a workspace may enable** should be driven by the **CMS** and tied to **billing / entitlements**. Packages stay the **distributable implementation** of each module; access control lives in the product, not in npm scope alone.

package/src/Definition.js

@@ -1,13 +0,0 @@
-export const Definition = {
-  id: 'platform',
-  title: 'Platform',
-  description: 'Deployment platform configuration aligned with deployment-tools S3 platform-config.json.',
-  module: {
-    id: 'platform',
-    enabled: true,
-  },
-  statuses: ['beta'],
-  actions: ['resources.create', 'resources.update-content', 'resources.rename', 'resources.remove'],
-  views: ['home.page', 'resources.search', 'resources.get'],
-  tasks: [],
-}

package/src/PlatformHomeBody.jsx

@@ -1,88 +0,0 @@
-import React from 'react'
-import { useRouter } from '@ossy/router-react'
-import { useResources, AsyncStatus } from '@ossy/sdk-react'
-import { Title, Text, View, Tags, Button, Switch } from '@ossy/design-system'
-import { Definition } from './Definition.js'
-import { moduleStatusTags } from './moduleStatus.js'
-import { ResourceList } from './ResourceList.jsx'
-import { PLATFORM_CONFIG_TEMPLATE_ID, PLATFORM_RESOURCE_LOCATION } from './constants.js'
-
-/**
- * Platform module home content (no site chrome). Wrap with your app {@code Layout} in a *.page.jsx file.
- */
-export function PlatformHomeBody () {
-  const router = useRouter()
-  const { status, resources } = useResources(PLATFORM_RESOURCE_LOCATION)
-  const platformResources = (resources || []).filter(
-    (resource) => resource?.type === PLATFORM_CONFIG_TEMPLATE_ID
-  )
-
-  let listStatus = status
-
-  if (status === AsyncStatus.Success && platformResources.length === 0) {
-    listStatus = 'Empty'
-  }
-
-  return (
-    <View
-      gap="m"
-      surface="primary"
-      style={{ padding: 'var(--space-m) var(--space-l)', height: '100%', overflowY: 'auto' }}
-    >
-      <View inset="s" gap="s">
-        <View layout="row" justifyContent="space-between" alignItems="center">
-          <View layout="row" gap="s" alignItems="center">
-            <Title>{Definition.title}</Title>
-            {moduleStatusTags(Definition).length > 0 && (
-              <Tags tags={moduleStatusTags(Definition)} size="s" />
-            )}
-          </View>
-          <Button
-            variant="cta"
-            prefix="add"
-            href={router.getHref(
-              `@create-document?location=${encodeURIComponent(PLATFORM_RESOURCE_LOCATION)}&templateId=${encodeURIComponent(PLATFORM_CONFIG_TEMPLATE_ID)}`
-            )}
-          >
-            New platform config
-          </Button>
-        </View>
-
-        <Text style={{ maxWidth: '640px' }}>
-          {Definition.description} Field names match deployment-tools{' '}
-          <strong>platform-config.json</strong> on the S3 bucket (excluding <strong>awsRoleToAssume</strong>).
-        </Text>
-      </View>
-
-      <View gap="m" inset="s" style={{ overflowY: 'auto' }}>
-        <Switch on={listStatus}>
-          <Switch.Case match={[AsyncStatus.NotInitialized, AsyncStatus.Loading]}>
-            <Text>Loading…</Text>
-          </Switch.Case>
-
-          <Switch.Case match={[AsyncStatus.Error, AsyncStatus.AuthenticationError]}>
-            <Text>Could not load platform configs.</Text>
-          </Switch.Case>
-
-          <Switch.Case match={['Empty']}>
-            <Text>No platform configs yet. Create one to mirror a deployment-tools platform-config.json.</Text>
-          </Switch.Case>
-
-          <Switch.Case match={[AsyncStatus.Success]}>
-            <ResourceList
-              resources={platformResources.map((resource) => ({
-                ...resource,
-                name:
-                  resource?.content?.platformName ||
-                  resource?.content?.platformId ||
-                  resource?.name ||
-                  'Unnamed platform',
-                href: router.getHref({ id: '@resource', params: { resourceId: resource?.id } }),
-              }))}
-            />
-          </Switch.Case>
-        </Switch>
-      </View>
-    </View>
-  )
-}

package/src/ResourceList.jsx

@@ -1,138 +0,0 @@
-'use client'
-import React from 'react'
-import { useWorkspace } from '@ossy/sdk-react'
-import {
-  Dropdown,
-  DropZone,
-  Icon2,
-  Image,
-  View,
-  Text,
-  Button,
-  ContextMenu,
-} from '@ossy/design-system'
-import { formatBytes } from './utils/format-bytes.js'
-
-export const ResourceList = ({
-  resources = [],
-  onClick = () => {},
-}) => {
-  return resources
-    .map((resource) => (
-      <ResourceListItem
-        {...resource}
-        key={resource.id}
-        onClick={() => {
-          onClick(resource)
-          resource?.onClick?.(resource)
-        }}
-      />
-    ))
-}
-
-function ResourceListItem ({
-  onClick,
-  href,
-  onDrop,
-  dragData,
-  ...resource
-}) {
-  let Container = ({ children }) => <>{children}</>
-
-  if (onDrop) {
-    Container = DropZone
-  } else if (dragData) {
-    Container = DropZone.Dragable
-  }
-
-  return (
-    <Container onDrop={onDrop} dragData={dragData}>
-      <View
-        layout="row"
-        selectable
-        gap="m"
-        style={{
-          height: '56px',
-          flexShrink: 0,
-          borderBottom: '1px solid var(--separator-primary)',
-        }}
-      >
-        <View
-          as={href ? 'a' : undefined}
-          gap="m"
-          layout="row"
-          alignItems="center"
-          style={{ flexGrow: 1, padding: '12px 0 12px 20px' }}
-          href={href}
-          onClick={onClick}
-        >
-          <ResourceIcon {...resource} />
-          <Text>{typeof resource.name === 'string' && resource.name}</Text>
-          <View style={{ flexGrow: 1 }} />
-          <Size {...resource} />
-        </View>
-
-        <View style={{ padding: '12px 8px 12px 0' }}>
-          <RowActions {...resource} />
-        </View>
-      </View>
-    </Container>
-  )
-}
-
-function Size (resource) {
-  if (resource.content?.ContentLength) {
-    return (
-      <Text variant="small">
-        {formatBytes(resource.content.ContentLength)}
-      </Text>
-    )
-  }
-
-  return <></>
-}
-
-function ResourceIcon ({ ...resource }) {
-  const { workspace } = useWorkspace()
-
-  const resourceTemplates = (workspace.resourceTemplates || [])
-    .reduce((acc, curr) => ({ ...acc, [curr.id]: curr }), {})
-
-  if (resource?.type === 'directory') {
-    return (
-      <Icon2 size="s" name="folder" style={{ fill: 'hsl(0, 0%, 60%)' }} />
-    )
-  }
-
-  if (resource.type.startsWith('image')) {
-    return (
-      <Image
-        src={resource?.content?.sizes?.thumbnailSmall || resource?.content?.src}
-        placeholderSrc={resource?.content?.sizes?.['loader-square-blurred-after'] || resource?.content?.src}
-        style={{ width: '24px', height: '24px', borderRadius: '25%' }}
-      />
-    )
-  }
-
-  return (
-    <Icon2
-      size="s"
-      name={resourceTemplates[resource.type]?.icon || 'file'}
-      style={{ fill: 'hsl(0, 0%, 80%)' }}
-    />
-  )
-}
-
-function RowActions ({ actions }) {
-  if (!actions) return <></>
-
-  return (
-    <Dropdown trigger={<Button prefix="more-vertical-alt" variant="command" />}>
-      <View inset="xs" surface="primary" roundness="s">
-        <ContextMenu roundness="s" surface="primary">
-          {actions}
-        </ContextMenu>
-      </View>
-    </Dropdown>
-  )
-}

package/src/constants.js

@@ -1,2 +0,0 @@
-export const PLATFORM_RESOURCE_LOCATION = '/@ossy/platform/'
-export const PLATFORM_CONFIG_TEMPLATE_ID = '@ossy/platform/config'

package/src/index.js

@@ -1,6 +0,0 @@
-export { Definition } from './Definition.js'
-export { PlatformResourceTemplates } from './resourceTemplates.js'
-export { PLATFORM_RESOURCE_LOCATION, PLATFORM_CONFIG_TEMPLATE_ID } from './constants.js'
-export { platformHomeMetadata } from './platformHomeMetadata.js'
-export { PlatformHomeBody } from './PlatformHomeBody.jsx'
-export { moduleStatusTags, moduleStatuses, MODULE_STATUS } from './moduleStatus.js'

package/src/moduleStatus.js

@@ -1,34 +0,0 @@
-/**
- * Minimal subset of website module status helpers for {@link Definition} tags.
- */
-
-export const MODULE_STATUS = {
-  beta: 'beta',
-  comingSoon: 'coming-soon',
-  stable: 'stable',
-  hidden: 'hidden',
-}
-
-const STATUS_TO_TAG_LABEL = {
-  [MODULE_STATUS.beta]: 'Beta',
-  [MODULE_STATUS.comingSoon]: 'Coming Soon',
-  [MODULE_STATUS.stable]: null,
-  [MODULE_STATUS.hidden]: null,
-}
-
-export function moduleStatuses (definition) {
-  const fromArray = Array.isArray(definition?.statuses) ? definition.statuses : []
-  const fromLegacy = definition?.status && typeof definition.status === 'string' ? [definition.status] : []
-  if (fromArray.length) return [...new Set(fromArray)]
-  if (fromLegacy.length) return [...new Set(fromLegacy)]
-  return []
-}
-
-export function moduleStatusTags (definition) {
-  const labels = []
-  for (const s of moduleStatuses(definition)) {
-    const label = STATUS_TO_TAG_LABEL[s]
-    if (label) labels.push(label)
-  }
-  return [...new Set(labels)]
-}

package/src/platformHomeMetadata.js

@@ -1,11 +0,0 @@
-import { Definition } from './Definition.js'
-
-export const platformHomeMetadata = {
-  id: 'platform/home',
-  title: Definition.title,
-  description: Definition.description,
-  path: {
-    sv: '/plattform',
-    en: '/platform',
-  },
-}

package/src/resourceTemplates.js

@@ -1,84 +0,0 @@
-/**
- * Matches the shape written to S3 as `platform-config.json` by deployment-tools
- * (`BucketDeployment` → `Source.jsonData('platform-config.json', { ...config, awsRoleToAssume: undefined })`).
- *
- * @see ossy/packages/deployment-tools/src/config/platform-config.js (PlatformConfig typedef)
- * @see ossy/packages/deployment-tools/src/infrastructure/container-deployment-target/container-deployment-target.js
- *
- * Note: `awsRoleToAssume` is intentionally omitted from the uploaded file (secret); do not store it here.
- * Optional `sesDomains` / `dnsRecords` are JSON text fields for arrays/objects.
- */
-export const PlatformResourceTemplates = [
-  {
-    name: 'Platform config',
-    id: '@ossy/platform/config',
-    icon: 'controller',
-    fields: [
-      {
-        name: 'platformId',
-        label: 'Platform ID (Ossy reference)',
-        type: 'text',
-      },
-      {
-        name: 'platformName',
-        label: 'platformName',
-        type: 'text',
-      },
-      {
-        name: 'awsAccountId',
-        label: 'awsAccountId',
-        type: 'text',
-      },
-      {
-        name: 'awsRegion',
-        label: 'awsRegion',
-        type: 'text',
-      },
-      {
-        name: 'awsKeyPairName',
-        label: 'awsKeyPairName',
-        type: 'text',
-      },
-      {
-        name: 'awsStaticBucketName',
-        label: 'awsStaticBucketName',
-        type: 'text',
-      },
-      {
-        name: 'awsDeploymentSqsName',
-        label: 'awsDeploymentSqsName',
-        type: 'text',
-      },
-      {
-        name: 'awsDeploymentSqsArn',
-        label: 'awsDeploymentSqsArn',
-        type: 'text',
-      },
-      {
-        name: 'ciGithubActionsRepo',
-        label: 'ciGithubActionsRepo (org/repo)',
-        type: 'text',
-      },
-      {
-        name: 'ciDockerNetworkName',
-        label: 'ciDockerNetworkName',
-        type: 'text',
-      },
-      {
-        name: 'sesDomains',
-        label: 'sesDomains (JSON array of strings, optional)',
-        type: 'textarea',
-      },
-      {
-        name: 'dnsRecords',
-        label: 'dnsRecords (JSON object, optional)',
-        type: 'textarea',
-      },
-      {
-        name: 'Notes',
-        label: 'Notes',
-        type: 'textarea',
-      },
-    ],
-  },
-]

package/src/utils/format-bytes.js

@@ -1,14 +0,0 @@
-/**
- * Converts bytes to a human-readable format.
- * @param {number} bytes - The number of bytes.
- * @param {number} decimals - The number of decimal places to include (default is 2).
- * @returns {string} - The human-readable format.
- */
-export function formatBytes (bytes, decimals = 2) {
-  if (!bytes) return
-  const k = 1024
-  const dm = decimals < 0 ? 0 : decimals
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`
-}