@ossy/platform 1.32.0 → 1.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.32.0",
+  "version": "1.34.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -29,11 +29,15 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1057.0",
     "@aws-sdk/client-ses": "^3.0.0",
-    "@ossy/event-store": "^1.1.0",
-    "@ossy/observability": "^1.1.0",
-    "@ossy/router": "^1.33.0",
-    "@ossy/sdk": "^1.33.0",
+    "@aws-sdk/s3-request-presigner": "^3.1057.0",
+    "@aws-sdk/util-create-request": "^3.972.26",
+    "@aws-sdk/util-format-url": "^3.972.17",
+    "@ossy/event-store": "^1.3.0",
+    "@ossy/observability": "^1.3.0",
+    "@ossy/router": "^1.35.0",
+    "@ossy/sdk": "^1.35.0",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -44,5 +48,5 @@
     "src",
     "Dockerfile"
   ],
-  "gitHead": "9a8a1bb0466d35001425d241d77c2c9ab31e11d3"
+  "gitHead": "c6697078268867d88553ca0bac08faad5cea1546"
 }

package/src/actions/action.service.js

@@ -0,0 +1,73 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform/actions')
+
+/** @type {Map<string, { id: string, access: string, run: Function }>} */
+const _actions = new Map()
+
+/**
+ * Registry and invoker for `*.action.js` command handlers.
+ *
+ * Actions are named, discoverable functions exposed at `POST /actions/:id`.
+ * Each action exports:
+ *   - `id`     {string}   — unique slug, e.g. `'authentication/request-sign-in'`
+ *   - `access` {string}   — `'public'` | `'authenticated'` | `'workspace'` (default `'authenticated'`)
+ *   - `run`    {Function} — async handler receiving `{ payload, sdk, log, integrations, req }`
+ */
+export const ActionService = {
+  /**
+   * Register an action module (as imported from a bundled entry).
+   * Validates that `id` is a non-empty string and `run` is a function.
+   *
+   * @param {{ id: string, access?: string, run: Function }} mod
+   */
+  register (mod) {
+    const { id, run, access = 'authenticated' } = mod ?? {}
+
+    if (typeof id !== 'string' || id.trim() === '') {
+      throw new Error(`[ActionService] Action module must export a non-empty string "id" (got ${JSON.stringify(id)})`)
+    }
+    if (typeof run !== 'function') {
+      throw new Error(`[ActionService] Action "${id}" must export a "run" function`)
+    }
+
+    if (_actions.has(id)) {
+      log.warn(`[ActionService] Action "${id}" already registered — overwriting`)
+    }
+
+    _actions.set(id, { id, access, run })
+    log.info(`[ActionService] Registered action "${id}" (access: ${access})`)
+  },
+
+  /**
+   * Look up a registered action by id. Returns `null` when not found.
+   *
+   * @param {string} id
+   * @returns {{ id: string, access: string, run: Function } | null}
+   */
+  get (id) {
+    return _actions.get(id) ?? null
+  },
+
+  /**
+   * Returns all registered actions.
+   *
+   * @returns {{ id: string, access: string, run: Function }[]}
+   */
+  all () {
+    return [..._actions.values()]
+  },
+
+  /**
+   * Invoke an action by id, forwarding the provided context.
+   *
+   * @param {string} id
+   * @param {{ payload?: unknown, sdk?: unknown, log?: unknown, integrations?: unknown, req?: unknown }} context
+   * @returns {Promise<unknown>}
+   */
+  async invoke (id, context = {}) {
+    const action = _actions.get(id)
+    if (!action) throw new Error(`[ActionService] Action not found: "${id}"`)
+    return action.run(context)
+  },
+}

package/src/config.service.js

@@ -0,0 +1,48 @@
+/**
+ * API Configuration
+ * @class
+ */
+export class ConfigService {
+
+  static Port = process.env.BE_PORT || 3000
+  static Domain = process.env.DOMAIN || `localhost:${ConfigService.Port}`
+  static WebClientDomain = process.env.WEB_CLIENT_DOMAIN || `http://localhost:3000`
+  static MongoUrl = process.env.DB_URL || 'mongodb://mongodb:27017/'
+  static DbName = process.env.DB_NAME || 'test'
+  static TokenSecret = process.env.TOKEN_SECRET || 'testsecret2'
+  static TokenValidity = process.env.TOKEN_VALIDITY || 60 * 60 * 24 * 14
+  static LimitedAccessCode = process.env.LIMITED_ACCESS_CODE || 'test'
+  static BuildEnvironment = process.env.BUILD_ENVIRONMENT
+  static BotUserEmail = process.env.BOT_USER_EMAIL || 'ossybot@ossy.se'
+  static BotUserId = process.env.BOT_USER_ID || 'Mil5qAL7jDFCTyuKD_BKb'
+  /** Set on `req.userId` when there is no valid session; role checks can treat this as unauthenticated. */
+  static AnonymousUserId = process.env.ANONYMOUS_USER_ID || 'anonymous'
+  static MediaRepository = process.env.MEDIA_REPOSITORY
+  static MediaCdnDomainName = process.env.MEDIA_CDN_DOMAIN_NAME
+  static awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID
+  static awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
+  static SesRegion = process.env.SES_REGION || 'eu-north-1'
+  static Debug = process.env.DEBUG
+
+  /**
+   * Derives the web client base URL from the incoming request's Origin or Referer
+   * header so that email links point back to whichever domain the user came from
+   * (e.g. http://ossy.local, http://localhost:3002).  Falls back to the
+   * WEB_CLIENT_DOMAIN env var / default when no header is present.
+   */
+  static getWebClientBaseUrl(req) {
+    const origin = req?.headers?.origin
+    if (origin && origin !== 'null') return origin
+
+    const referer = req?.headers?.referer
+    if (referer) {
+      try {
+        const { origin: refOrigin } = new URL(referer)
+        if (refOrigin && refOrigin !== 'null') return refOrigin
+      } catch {}
+    }
+
+    return ConfigService.WebClientDomain
+  }
+
+}

package/src/index.js

@@ -5,3 +5,5 @@ export { registerResourceTemplate, getSystemResourceTemplates } from './resource
 export { normalizeAndValidateDocumentContent, validateResourceTemplatesForImport, ALLOWED_FIELD_TYPES } from './resources/resource-template.validation.js'
 export { Definition } from './Definition.js'
 export { IntegrationService } from './integration.service.js'
+export { ConfigService } from './config.service.js'
+export { ActionService } from './actions/action.service.js'

package/src/server.js

@@ -12,6 +12,7 @@ import { TaskService } from './tasks/task-service.js'
 import { ChangeStream } from './tasks/change-stream.js'
 import { registerResourceTemplate } from './resources/resource-template.registry.js'
 import { IntegrationService } from './integration.service.js'
+import { ActionService } from './actions/action.service.js'
 import { createLogger } from '@ossy/observability'
 
 const log = createLogger('@ossy/platform')
@@ -56,6 +57,7 @@ export function loadManifest (buildDir) {
   const aggregates = Array.isArray(manifest.aggregates) ? manifest.aggregates : []
   const integrations = Array.isArray(manifest.integrations) ? manifest.integrations : []
   const startups = Array.isArray(manifest.startups) ? manifest.startups : []
+  const actions = Array.isArray(manifest.actions) ? manifest.actions : []
   for (const e of entries) {
     if ((e.type === 'page' || e.type === 'api') && !validRoutable(e)) {
       log.warn(`Skipping ${e.type} "${e.id}" — manifest entry has no path.`)
@@ -71,6 +73,7 @@ export function loadManifest (buildDir) {
     aggregates,
     integrations,
     startups,
+    actions,
     config: manifest.config || {},
   }
 }
@@ -159,6 +162,17 @@ export async function startServer (options = {}) {
     }
   }
 
+  // Action registration — import each bundled action module and register it
+  // with ActionService so it can be looked up and invoked at runtime.
+  for (const actionEntry of manifest.actions ?? []) {
+    try {
+      const mod = await import(resolveEntryUrl(actionEntry.entry, buildDir))
+      ActionService.register(mod)
+    } catch (err) {
+      log.error(`Failed to load action "${actionEntry.id}"`, undefined, err)
+    }
+  }
+
   // Register the SDK so all tasks receive it as `sdk`.
   // Priority: explicit options.sdk → SDK.of() from env vars → null (direct-DB fallback in tasks).
   const botSdk = (process.env.API_URL && process.env.OSSY_API_KEY)
@@ -210,6 +224,36 @@ export async function startServer (options = {}) {
   if (fs.existsSync(publicDir)) app.use(express.static(publicDir))
   app.use(ProxyInternal())
 
+  // Actions endpoint — auto-exposes every registered `*.action.js` handler.
+  // Access rules are enforced here; business logic lives in the action's `run`.
+  app.post('/actions/:id', async (req, res) => {
+    const actionId = req.params.id
+    const action = ActionService.get(actionId)
+    if (!action) return res.status(404).json({ error: 'Action not found' })
+
+    if (action.access === 'authenticated' && (!req.userId || req.userId === 'anonymous')) {
+      return res.status(401).json({ error: 'Unauthorized' })
+    }
+    if (action.access === 'workspace' && !req.workspaceId) {
+      return res.status(403).json({ error: 'Forbidden' })
+    }
+
+    const actionLog = createLogger(actionId)
+    try {
+      const result = await ActionService.invoke(actionId, {
+        payload: req.body,
+        sdk: req.sdk ?? null,
+        log: actionLog,
+        integrations: IntegrationService,
+        req,
+      })
+      res.json(result ?? { ok: true })
+    } catch (err) {
+      actionLog.error('Action failed', { id: actionId }, err)
+      res.status(500).json({ error: err && err.message ? err.message : 'Internal error' })
+    }
+  })
+
   app.all('*all', async (req, res) => {
     const requestUrl = req.originalUrl || '/'
     try {
@@ -314,3 +358,8 @@ async function loadMiddleware (buildDir) {
 }
 
 export default startServer
+export { ConfigService } from './config.service.js'
+export { ActionService } from './actions/action.service.js'
+export { StorageClient } from './storage/storage.client.js'
+export { S3Client } from './storage/s3.client.js'
+export { LocalStorageClient } from './storage/local-storage.client.js'

package/src/storage/local-storage.client.js

@@ -0,0 +1,65 @@
+import path from 'path'
+import os from 'os'
+import { mkdir, writeFile, readFile, stat } from 'fs/promises'
+import { existsSync } from 'fs'
+
+const LOCAL_STORAGE_DIR = path.join(os.tmpdir(), 'ossy-local-media')
+
+function normalizeKey(keyOrShape) {
+  const Key = typeof keyOrShape === 'string' ? keyOrShape : keyOrShape?.Key
+  if (!Key || typeof Key !== 'string') {
+    throw new Error('[LocalStorageClient] missing Key')
+  }
+  return Key
+}
+
+function keyToLocalPath(key) {
+  const resolved = path.resolve(LOCAL_STORAGE_DIR, key)
+  if (!resolved.startsWith(LOCAL_STORAGE_DIR)) {
+    throw new Error('[LocalStorageClient] invalid key: path traversal detected')
+  }
+  return resolved
+}
+
+function buildUrl(key) {
+  const base = (process.env.LOCAL_API_URL || 'http://localhost:3001').replace(/\/$/, '')
+  return `${base}/local-storage?key=${encodeURIComponent(key)}`
+}
+
+export class LocalStorageClient {
+
+  static createUploadUrl({ Key }) {
+    return Promise.resolve(buildUrl(Key))
+  }
+
+  static createPresignedDownloadUrl(keyOrShape) {
+    const Key = normalizeKey(keyOrShape)
+    return Promise.resolve(buildUrl(Key))
+  }
+
+  static createDownloadUrl(keyOrShape) {
+    const Key = normalizeKey(keyOrShape)
+    return buildUrl(Key)
+  }
+
+  static async save(key, body) {
+    const localPath = keyToLocalPath(key)
+    await mkdir(path.dirname(localPath), { recursive: true })
+    await writeFile(localPath, body)
+  }
+
+  static async load(key) {
+    const localPath = keyToLocalPath(key)
+    if (!existsSync(localPath)) return { buffer: null, exists: false }
+    const buffer = await readFile(localPath)
+    return { buffer, exists: true }
+  }
+
+  static async headObject({ Key }) {
+    const localPath = keyToLocalPath(Key)
+    const s = await stat(localPath).catch(() => null)
+    if (!s) throw Object.assign(new Error('Not Found'), { $metadata: { httpStatusCode: 404 } })
+    return { ContentLength: s.size }
+  }
+
+}

package/src/storage/s3.client.js

@@ -0,0 +1,100 @@
+import { S3, PutObjectCommand, GetObjectCommand, HeadObjectCommand } from '@aws-sdk/client-s3'
+import { S3RequestPresigner } from '@aws-sdk/s3-request-presigner'
+import { createRequest } from '@aws-sdk/util-create-request'
+import { formatUrl } from '@aws-sdk/util-format-url'
+import { ConfigService } from '../config.service.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('storage')
+
+const REGION = 'eu-north-1'
+
+function createS3Client() {
+  return new S3({
+    region: REGION,
+    credentials: {
+      accessKeyId: ConfigService.awsAccessKeyId,
+      secretAccessKey: ConfigService.awsSecretAccessKey
+    }
+  })
+}
+
+function normalizeKey(keyOrShape) {
+  const Key = typeof keyOrShape === 'string' ? keyOrShape : keyOrShape?.Key
+  if (!Key || typeof Key !== 'string') {
+    throw new Error('[S3Client] missing Key')
+  }
+  return Key
+}
+
+export class S3Client {
+
+  /**
+   * Public CDN URL (CloudFront) for objects under `media/` — use only when `access === 'public'`.
+   */
+  static createDownloadUrl(keyOrShape) {
+    const Key = normalizeKey(keyOrShape)
+    const pathAfterMedia = Key.includes('media/') ? Key.split('media/')[1] : Key
+    const base = ConfigService.MediaCdnDomainName || ''
+    return `${base.replace(/\/$/, '')}/${pathAfterMedia}`
+  }
+
+  /**
+   * Short-lived presigned GET for private bucket reads (restricted resources, workspace members).
+   */
+  static createPresignedDownloadUrl(keyOrShape, { expiresIn = 15 * 60 } = {}) {
+    const Key = normalizeKey(keyOrShape)
+    const Bucket = ConfigService.MediaRepository
+    if (!Bucket) {
+      return Promise.reject(new Error('[S3Client] MEDIA_REPOSITORY is not configured'))
+    }
+
+    const s3Client = createS3Client()
+    const signedRequest = new S3RequestPresigner(s3Client.config)
+
+    return createRequest(s3Client, new GetObjectCommand({ Bucket, Key }))
+      .then(request => signedRequest.presign(request, { expiresIn }))
+      .then(formatUrl)
+      .catch(error => {
+        log.error('S3Client.createPresignedDownloadUrl error', undefined, error)
+        return Promise.reject(error)
+      })
+  }
+
+  static createUploadUrl({ ContentType, ContentLength, Key, Bucket, expiresIn = 60 * 60 * 24 }) {
+    log.info('[S3Client][createUploadUrl()] Creating upload URL')
+
+    const bucket = Bucket ?? ConfigService.MediaRepository
+    if (!bucket) {
+      return Promise.reject(new Error('[S3Client] Bucket is not configured'))
+    }
+
+    const clientParams = {
+      Bucket: bucket,
+      Key,
+      ContentType,
+      ContentLength
+    }
+
+    const s3Client = createS3Client()
+    const signedRequest = new S3RequestPresigner(s3Client.config)
+
+    return createRequest(s3Client, new PutObjectCommand(clientParams))
+      .then(request => signedRequest.presign(request, { expiresIn }))
+      .then(formatUrl)
+      .catch(error => {
+        log.error('S3Client.createUploadUrl error', undefined, error)
+        return Promise.reject(error)
+      })
+  }
+
+  static headObject({ Key, Bucket }) {
+    const bucket = Bucket ?? ConfigService.MediaRepository
+    if (!bucket) {
+      return Promise.reject(new Error('[S3Client] Bucket is not configured'))
+    }
+    const s3Client = createS3Client()
+    return s3Client.send(new HeadObjectCommand({ Bucket: bucket, Key }))
+  }
+
+}

package/src/storage/storage.client.js

@@ -0,0 +1,12 @@
+import { S3Client } from './s3.client.js'
+import { LocalStorageClient } from './local-storage.client.js'
+import { ConfigService } from '../config.service.js'
+
+/**
+ * Active storage backend.
+ *
+ * - When `MEDIA_REPOSITORY` is set (production): delegates to S3.
+ * - When `MEDIA_REPOSITORY` is unset (local dev): delegates to LocalStorageClient,
+ *   which stores files in /tmp/ossy-local-media/ and serves them via GET /local-storage.
+ */
+export const StorageClient = ConfigService.MediaRepository ? S3Client : LocalStorageClient

package/src/email.integration.js

@@ -1,26 +0,0 @@
-import { SESClient } from '@aws-sdk/client-ses'
-
-export const id = 'email'
-
-export const credentials = [
-  'SES_REGION',
-  'SES_ACCESS_KEY_ID',
-  'SES_SECRET_ACCESS_KEY',
-]
-
-/**
- * Returns an AWS SES client configured from env vars.
- * Tasks receive this via `integrations.get('email')`.
- *
- * @param {{ env: NodeJS.ProcessEnv }} opts
- * @returns {SESClient}
- */
-export async function connect ({ env }) {
-  return new SESClient({
-    region: env.SES_REGION,
-    credentials: {
-      accessKeyId: env.SES_ACCESS_KEY_ID,
-      secretAccessKey: env.SES_SECRET_ACCESS_KEY,
-    },
-  })
-}