@ossy/platform 1.39.2 → 1.39.3

package/src/mcp/mount-ossy-mcp.js

@@ -0,0 +1,72 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
+import { createOssyMcpServer } from './create-ossy-mcp-server.js'
+
+/**
+ * @param {import('express').Express} app
+ * @param {{
+ *   capabilities: object,
+ *   invokeAction: (actionId: string, payload: object, req: import('express').Request) => Promise<unknown>,
+ *   requireAuth?: (req: import('express').Request, res: import('express').Response) => boolean,
+ *   customTools?: Array<object>,
+ *   path?: string,
+ *   capabilitiesPath?: string,
+ * }} options
+ */
+export function mountOssyMcp ({ app, capabilities, invokeAction, requireAuth, customTools, path = '/mcp', capabilitiesPath = '/capabilities.json' }) {
+  app.get(capabilitiesPath, (req, res) => {
+    if (requireAuth && !requireAuth(req, res)) return
+    res.json(capabilities)
+  })
+
+  const handleMcpPost = async (req, res) => {
+    if (requireAuth && !requireAuth(req, res)) return
+
+    const server = createOssyMcpServer({
+      capabilities,
+      customTools: customTools?.map((tool) => ({
+        ...tool,
+        handler: (args, extra) => tool.handler(args, req, extra),
+      })),
+      invokeAction: (actionId, payload) => invokeAction(actionId, payload, req),
+    })
+
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+    })
+
+    try {
+      await server.connect(transport)
+      await transport.handleRequest(req, res, req.body)
+      res.on('close', () => {
+        transport.close()
+        server.close()
+      })
+    } catch (err) {
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: '2.0',
+          error: { code: -32603, message: err?.message || 'Internal error' },
+          id: null,
+        })
+      }
+    }
+  }
+
+  app.post(path, handleMcpPost)
+
+  app.get(path, (_req, res) => {
+    res.status(405).json({
+      jsonrpc: '2.0',
+      error: { code: -32000, message: 'Method not allowed.' },
+      id: null,
+    })
+  })
+
+  app.delete(path, (_req, res) => {
+    res.status(405).json({
+      jsonrpc: '2.0',
+      error: { code: -32000, message: 'Method not allowed.' },
+      id: null,
+    })
+  })
+}

package/src/mcp/mount-platform-mcp.js

@@ -0,0 +1,101 @@
+import { buildCapabilities } from '@ossy/app/manifest/build-capabilities'
+import { mountOssyMcp } from './mount-ossy-mcp.js'
+import { uploadFileToolHandler, UPLOAD_FILE_TOOL } from './upload-file-tool.js'
+import { ActionService } from '../actions/action.service.js'
+import { TaskService } from '../tasks/task-service.js'
+import { IntegrationService } from '../integration.service.js'
+import { createLogger } from '@ossy/observability'
+import { assertActionEntitled } from '../entitlements/action-entitlement.js'
+
+/**
+ * @param {import('express').Express} app
+ * @param {{
+ *   manifest: object,
+ *   capabilities?: object,
+ *   log?: import('@ossy/observability').Logger,
+ *   actionEntitlementIndex?: Map<string, { packageName: string, entitlementRequired: boolean }>,
+ *   loadWorkspaceForEntitlements?: (workspaceId: string) => Promise<{ services?: Record<string, unknown> } | null>,
+ * }} options
+ */
+export function mountPlatformMcp (app, {
+  manifest,
+  capabilities,
+  log = createLogger('platform/mcp'),
+  actionEntitlementIndex,
+  loadWorkspaceForEntitlements,
+}) {
+  const resolvedCapabilities = capabilities ?? buildCapabilities({
+    actions: manifest.actions,
+    tasks: manifest.tasks,
+    schemas: manifest.schemas,
+    taskCatalog: manifest.taskCatalog,
+    taskGraphEdges: manifest.taskGraphEdges,
+  })
+
+  const requireAuth = (req, res) => {
+    if (!req.userId || req.userId === 'anonymous') {
+      res.status(401).json({ error: 'Unauthorized — MCP requires API token or session auth' })
+      return false
+    }
+    return true
+  }
+
+  const invokePlatformAction = async (actionId, payload, req) => {
+    const action = ActionService.get(actionId)
+    if (!action) {
+      throw Object.assign(new Error(`Action not found: ${actionId}`), { status: 404 })
+    }
+
+    if (action.access === 'authenticated' && (!req?.userId || req.userId === 'anonymous')) {
+      throw Object.assign(new Error('Unauthorized'), { status: 401 })
+    }
+    if (action.access === 'workspace' && !req?.workspaceId) {
+      throw Object.assign(new Error('Forbidden — workspaceId header required'), { status: 403 })
+    }
+    if (!ActionService.hasHandler(actionId)) {
+      throw Object.assign(new Error(`Action has no server handler: ${actionId}`), { status: 405 })
+    }
+
+    if (actionEntitlementIndex && loadWorkspaceForEntitlements) {
+      await assertActionEntitled({
+        actionId,
+        access: action.access,
+        workspaceId: payload?.workspaceId ?? req?.workspaceId,
+        entitlementIndex: actionEntitlementIndex,
+        loadWorkspace: loadWorkspaceForEntitlements,
+      })
+    }
+
+    const actionLog = createLogger(actionId)
+    return ActionService.invoke(actionId, {
+      payload: {
+        workspaceId: payload?.workspaceId ?? req?.workspaceId,
+        user: req?.user,
+        userId: req?.userId,
+        ...payload,
+      },
+      sdk: req?.sdk ?? null,
+      log: actionLog,
+      integrations: IntegrationService,
+      req,
+    })
+  }
+
+  mountOssyMcp({
+    app,
+    capabilities: resolvedCapabilities,
+    requireAuth,
+    invokeAction: invokePlatformAction,
+    customTools: [
+      {
+        ...UPLOAD_FILE_TOOL,
+        handler: (args, req) => uploadFileToolHandler(invokePlatformAction, args, req),
+      },
+    ],
+  })
+
+  log.info(`MCP mounted at /mcp (${resolvedCapabilities.tools?.length ?? 0} action tools, ${resolvedCapabilities.tasks?.length ?? 0} tasks in topology resource)`)
+  return resolvedCapabilities
+}
+
+export { buildCapabilities }

package/src/mcp/upload-file-tool.js

@@ -0,0 +1,62 @@
+import { readFile, stat } from 'node:fs/promises'
+
+/**
+ * Composite upload: create binary resource + PUT file bytes.
+ *
+ * @param {(actionId: string, payload: object, req?: object) => Promise<unknown>} invokeAction
+ * @param {import('express').Request} [req]
+ */
+export async function uploadFileToolHandler (invokeAction, args, req) {
+  const filePath = args.filePath
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('filePath is required')
+  }
+
+  const fileStat = await stat(filePath)
+  const body = await readFile(filePath)
+  const type = args.type || 'application/octet-stream'
+
+  const resource = await invokeAction('@ossy/resources/actions/create', {
+    workspaceId: args.workspaceId,
+    location: args.location,
+    name: args.name,
+    type,
+    size: fileStat.size,
+  }, req)
+
+  const uploadUrl = resource?.content?.uploadUrl
+  if (!uploadUrl) {
+    throw new Error('Storage is not configured or create did not return uploadUrl')
+  }
+
+  const response = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': type },
+    body,
+  })
+
+  if (!response.ok) {
+    throw new Error(`Upload failed: HTTP ${response.status}`)
+  }
+
+  return invokeAction('@ossy/resources/actions/get', {
+    workspaceId: args.workspaceId,
+    resourceId: resource.id,
+  }, req)
+}
+
+export const UPLOAD_FILE_TOOL = {
+  name: 'ossy_storage_upload_file',
+  description: 'Create a binary file resource and upload bytes from a local file path.',
+  inputSchema: {
+    type: 'object',
+    required: ['location', 'name', 'type', 'filePath'],
+    properties: {
+      workspaceId: { type: 'string' },
+      location: { type: 'string', description: 'Parent folder path, e.g. /test/' },
+      name: { type: 'string', description: 'Filename with extension' },
+      type: { type: 'string', description: 'Mime type, e.g. image/png' },
+      filePath: { type: 'string', description: 'Absolute path to the file on disk' },
+    },
+  },
+}

package/src/metering/metering-service.js

@@ -0,0 +1,92 @@
+import { nanoid } from 'nanoid'
+import { EventStore } from '@ossy/event-store'
+import { createLogger, metrics } from '@ossy/observability'
+import { PlatformSchema } from '../schema-ids.js'
+import { moduleIdFromTaskId } from '../audit/audit-helpers.js'
+
+const log = createLogger('platform/metering')
+
+/**
+ * Append-only usage records for billing replay (Wave 3 — record only).
+ */
+export const MeteringService = {
+
+  /**
+   * @param {{
+   *   kind: 'action' | 'task',
+   *   actionId?: string | null,
+   *   taskId?: string | null,
+   *   channel?: string | null,
+   *   workspaceId?: string | null,
+   *   actorId?: string | null,
+   *   durationMs?: number | null,
+   *   success?: boolean,
+   *   actionInvocationId?: string | null,
+   *   taskRunId?: string | null,
+   *   trigger?: string | null,
+   * }} record
+   */
+  async record (record) {
+    const {
+      kind,
+      actionId = null,
+      taskId = null,
+      channel = null,
+      workspaceId = null,
+      actorId = null,
+      durationMs = null,
+      success = true,
+      actionInvocationId = null,
+      taskRunId = null,
+      trigger = null,
+    } = record
+
+    const moduleId = taskId
+      ? moduleIdFromTaskId(taskId)
+      : actionId
+        ? moduleIdFromTaskId(actionId)
+        : 'unknown'
+
+    const envelope = {
+      kind,
+      moduleId,
+      actionId,
+      taskId,
+      channel,
+      workspaceId,
+      actorId,
+      durationMs,
+      success,
+      actionInvocationId,
+      taskRunId,
+      trigger,
+      recordedAt: Date.now(),
+    }
+
+    try {
+      metrics.increment('meter.record', { kind, module: moduleId, success: String(success) })
+      if (durationMs != null) {
+        metrics.timing('meter.duration', durationMs, { kind, module: moduleId })
+      }
+    } catch {}
+
+    try {
+      await EventStore.AppendResourceEvent({
+        id: nanoid(),
+        type: PlatformSchema.meterEvent,
+        resourceId: nanoid(),
+        event: 'Recorded',
+        version: 1,
+        created: Date.now(),
+        createdBy: actorId ?? undefined,
+        payload: {
+          ...envelope,
+          belongsTo: workspaceId,
+          location: '/@ossy/metering/',
+        },
+      })
+    } catch (err) {
+      log.warn('[MeteringService] Failed to persist meter event', envelope, err)
+    }
+  },
+}

package/src/{platform-config.resource.js → platform-config.schema.js}

@@ -10,7 +10,7 @@
  */
 export default {
   name: 'Platform config',
-  id: '@ossy/platform/config',
+  id: '@ossy/platform/schema/config',
   icon: 'controller',
   fields: [
     {

package/src/proxy-internal.js

@@ -1,4 +1,8 @@
 import { createLogger } from '@ossy/observability'
+import {
+  mergeUserAppSettingsCookie,
+  readUserAppSettings,
+} from './user-app-settings.js'
 
 const log = createLogger('platform')
 
@@ -23,19 +27,7 @@ export function ProxyInternal () {
       }
 
       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),
-      })
+      mergeUserAppSettingsCookie(req, res, requestedSettings)
 
       res.status(201)
       res.json('')
@@ -44,7 +36,7 @@ export function ProxyInternal () {
 
     if (req.originalUrl.startsWith('/@ossy/users/me/app-settings') && req.method === 'GET') {
       log.info('[@ossy/platform][proxy] GET /@ossy/users/me/app-settings')
-      const userSettings = JSON.parse(req.signedCookies?.['x-ossy-user-settings'] || '{}')
+      const userSettings = readUserAppSettings(req)
       res.status(200)
       res.json(userSettings)
       return
@@ -52,8 +44,13 @@ export function ProxyInternal () {
 
     log.info(`[@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 domain = (process.env.OSSY_API_URL || 'https://api.ossy.se')
+      .replace(/\/api\/v0\/?$/, '')
+      .replace(/\/$/, '')
+    const pathAfterOssy = req.originalUrl.replace(/^\/@ossy/, '') || '/'
+    // POST /actions lives on the app server root — not under /api/v0.
+    const upstreamPath = pathAfterOssy === '/actions' ? '/actions' : `/api/v0${pathAfterOssy}`
+    const url = `${domain}${upstreamPath}`
     const forwardedHeaders = JSON.parse(JSON.stringify(req.headers))
     const workspaceId = normalizeWorkspaceIdHeader(req.get('workspaceId'))
 

package/src/push/mount-push-sse.js

@@ -0,0 +1,43 @@
+import { PushInvalidation } from '@ossy/event-store'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('@ossy/platform')
+
+const HEARTBEAT_MS = 25_000
+
+/**
+ * ADR 0008 §9 — workspace-scoped SSE invalidation bus.
+ *
+ * @param {import('express').Express} app
+ */
+export function mountPushSse (app) {
+  app.get('/events', (req, res) => {
+    const workspaceId = req.workspaceId
+    if (!workspaceId) {
+      res.status(403).json({ error: 'Forbidden' })
+      return
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8')
+    res.setHeader('Cache-Control', 'no-cache, no-transform')
+    res.setHeader('Connection', 'keep-alive')
+    res.flushHeaders?.()
+
+    const send = (message) => {
+      res.write(`data: ${JSON.stringify(message)}\n\n`)
+    }
+
+    send({ kind: 'connected', scope: { workspaceId } })
+
+    const unsubscribe = PushInvalidation.subscribe(workspaceId, send)
+    const heartbeat = setInterval(() => {
+      res.write(': heartbeat\n\n')
+    }, HEARTBEAT_MS)
+
+    req.on('close', () => {
+      clearInterval(heartbeat)
+      unsubscribe()
+      log.debug(`[push] SSE closed for workspace ${workspaceId}`)
+    })
+  })
+}

package/src/resources/index.js

@@ -1,2 +1,3 @@
-export { registerResourceTemplate, getSystemResourceTemplates } from './resource-template.registry.js'
-export { normalizeAndValidateDocumentContent, validateResourceTemplatesForImport, ALLOWED_FIELD_TYPES } from './resource-template.validation.js'
+export { registerSchema, getSystemSchemas } from './schema.registry.js'
+export { getPlatformSchema, initPlatformSchema, createSchemaEngine, schemaForWorkspace } from './schema.service.js'
+export { validateSchemasForImport, ALLOWED_FIELD_TYPES, normalizeFieldType, resolveFieldDef } from './schema.validation.js'

package/src/resources/schema.registry.js

@@ -0,0 +1,26 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
+
+/** @type {object[]} */
+const systemSchemas = []
+
+/**
+ * Register a single schema POJO (as inlined in `build/manifest.json`).
+ *
+ * @param {object} schema
+ */
+export function registerSchema (schema) {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return
+  if (typeof schema.id !== 'string' || schema.id.trim() === '') return
+  if (systemSchemas.find(s => s.id === schema.id)) return
+  systemSchemas.push(schema)
+  log.info(`[SchemaRegistry] Registered system schema: ${schema.id}`)
+}
+
+/**
+ * @returns {object[]}
+ */
+export function getSystemSchemas () {
+  return systemSchemas
+}

package/src/resources/schema.service.js

@@ -0,0 +1,54 @@
+import { Schema } from '@ossy/schema'
+
+/** @type {Schema | null} */
+let platformSchema = null
+
+/**
+ * Platform-wide schema engine from build manifest (no workspace overlays).
+ *
+ * @param {{ schemas?: object[], actions?: { id: string }[], tasks?: { id: string }[] }} manifest
+ */
+export function initPlatformSchema (manifest) {
+  platformSchema = Schema.of(manifest, {
+    actionIds: (manifest.actions ?? []).map((a) => a.id),
+    taskIds: (manifest.tasks ?? []).map((t) => t.id),
+    strictRefs: false,
+  })
+  return platformSchema
+}
+
+/**
+ * @returns {Schema}
+ */
+export function getPlatformSchema () {
+  if (!platformSchema) {
+    throw new Error('[@ossy/platform] Platform Schema not initialized — call initPlatformSchema after loadManifest')
+  }
+  return platformSchema
+}
+
+/**
+ * Build-time or per-request engine with optional strict ref checks.
+ *
+ * @param {{ schemas?: object[], actions?: { id: string }[], tasks?: { id: string }[] }} manifest
+ * @param {{ strictRefs?: boolean, actionIds?: string[], taskIds?: string[] }} [options]
+ */
+export function createSchemaEngine (manifest, options = {}) {
+  return Schema.of(manifest, {
+    actionIds: options.actionIds ?? (manifest.actions ?? []).map((a) => a.id),
+    taskIds: options.taskIds ?? (manifest.tasks ?? []).map((t) => t.id),
+    strictRefs: options.strictRefs ?? false,
+  })
+}
+
+/**
+ * Platform schema engine with optional workspace schema overlays.
+ *
+ * @param {object[]} [workspaceSchemas]
+ */
+export function schemaForWorkspace (workspaceSchemas = []) {
+  const platform = getPlatformSchema()
+  const extra = (workspaceSchemas ?? []).filter((s) => s?.id && !platform.has(s.id))
+  if (!extra.length) return platform
+  return platform.withWorkspaceSchemas(extra)
+}

package/src/resources/schema.validation.js

@@ -0,0 +1,90 @@
+import { Schema } from '@ossy/schema'
+
+/** Field input types accepted in schema definitions (UI + API contract). */
+export const ALLOWED_FIELD_TYPES = new Set([
+  'text',
+  'email',
+  'textarea',
+  'richtext',
+  'number',
+  'select',
+  'multiselect',
+  'file',
+  'image',
+  'boolean',
+  'date',
+  'timestamp',
+  'date-range',
+  'date-ranges',
+  'id',
+  'path',
+])
+
+/**
+ * Normalize template field `type` to the canonical editor type.
+ * `image` is an alias for `file` with default `accept: 'image/*'` when accept is omitted.
+ *
+ * @param {string | undefined} type
+ * @returns {{ type: string, defaultAccept?: string }}
+ */
+export function normalizeFieldType (type) {
+  const raw = typeof type === 'string' ? type.trim() : ''
+  if (raw === 'image') return { type: 'file', defaultAccept: 'image/*' }
+  return { type: raw }
+}
+
+/**
+ * @param {{ type?: string, accept?: string, min?: number, max?: number } & Record<string, unknown>} field
+ */
+export function resolveFieldDef (field) {
+  const { type: canonical, defaultAccept } = normalizeFieldType(field?.type)
+  return {
+    ...field,
+    type: canonical,
+    accept: field?.accept ?? defaultAccept,
+    max: field?.max ?? 1,
+  }
+}
+
+/**
+ * Validates a batch import of workspace schemas.
+ *
+ * @param {unknown} templates
+ * @param {Set<string>} reservedIds - System schema ids that must not be redefined
+ * @returns {{ ok: true } | { ok: false, code: string, message: string }}
+ */
+export function validateSchemasForImport (templates, reservedIds) {
+  if (!Array.isArray(templates)) {
+    return { ok: false, code: 'INVALID_PAYLOAD', message: 'Body must be a JSON array of schemas' }
+  }
+
+  const engine = Schema.of({ schemas: templates })
+  const seenIds = new Set()
+
+  for (const template of templates) {
+    if (reservedIds?.has(template?.id)) {
+      return {
+        ok: false,
+        code: 'RESERVED_SCHEMA_ID',
+        message: `Template id "${template.id}" is reserved by a system template`,
+      }
+    }
+
+    const result = engine.validate(template)
+    if (!result.ok) {
+      const first = result.errors[0]
+      return { ok: false, code: first.code, message: first.message }
+    }
+
+    if (seenIds.has(template.id)) {
+      return {
+        ok: false,
+        code: 'DUPLICATE_SCHEMA_ID',
+        message: `Duplicate schema id "${template.id}" in import payload`,
+      }
+    }
+    seenIds.add(template.id)
+  }
+
+  return { ok: true }
+}

package/src/runtime.js

@@ -174,8 +174,11 @@ export async function startRuntime ({ port } = {}) {
         ...(req.userAppSettings || {}),
         theme: req.userAppSettings?.theme || cloneSerializable(config?.theme),
         themes: cloneSerializable(config?.themes),
-        resourceTemplates: cloneSerializable(manifest.resourceTemplates),
+        schemas: cloneSerializable(manifest.schemas),
         manifestSummary: cloneSerializable(manifestSummary),
+        actionRoutes: cloneSerializable(manifest.actionRoutes || {}),
+        taskCatalog: cloneSerializable(manifest.taskCatalog || []),
+        taskGraphEdges: cloneSerializable(manifest.taskGraphEdges || []),
         url: requestUrl,
         isAuthenticated: !!req.isAuthenticated,
         language,

package/src/schema-ids.js

@@ -0,0 +1,9 @@
+/** Platform envelope schemas (ADR 0008). */
+export const PlatformSchema = Object.freeze({
+  config: '@ossy/platform/schema/config',
+  directory: '@ossy/platform/schema/directory',
+  file: '@ossy/platform/schema/file',
+  taskRun: '@ossy/platform/schema/task-run',
+  actionInvocation: '@ossy/platform/schema/action-invocation',
+  meterEvent: '@ossy/platform/schema/meter-event',
+})