@ossy/platform 1.31.2 → 1.32.0

package/README.md

@@ -0,0 +1,95 @@
+# @ossy/platform
+
+Ossy application server runtime — Express-based server that loads the build manifest produced by `@ossy/app` and serves pages, APIs, tasks, and integrations.
+
+---
+
+## `*.integration.js` — third-party integration primitive
+
+An integration file declares a named third-party client (e.g. a database, email provider, or payment SDK) that the platform connects to once at startup and makes available to every task.
+
+### File naming
+
+Name the file `<slug>.integration.js` (or `.mjs` / `.cjs`) and place it anywhere inside `src/`. The build pipeline discovers it automatically using the `*.integration.js` pattern, just like `*.task.js` and `*.page.jsx`.
+
+### Required exports
+
+| Export | Type | Description |
+|---|---|---|
+| `id` | `string` | Unique slug used to retrieve the client — e.g. `'email'`, `'stripe'`. |
+| `credentials` | `string[]` | Names of environment variables that must be present. If any are missing the integration is skipped at startup with a warning. |
+| `connect` | `async ({ env }) => client` | Called once at startup with the full `process.env`. Returns the client object stored by `id`. If it throws, the integration is skipped (non-fatal). |
+
+### Minimal example
+
+```js
+// src/stripe.integration.js
+import Stripe from 'stripe'
+
+export const id = 'stripe'
+
+export const credentials = ['STRIPE_SECRET_KEY']
+
+export async function connect ({ env }) {
+  return new Stripe(env.STRIPE_SECRET_KEY)
+}
+```
+
+### Consuming integrations inside a task
+
+The platform injects `integrations` into every task's `run()` call alongside `sdk`:
+
+```js
+// src/send-invoice.task.js
+export const metadata = {
+  id: 'send-invoice',
+  triggers: [{ aggregateType: 'Invoice', event: 'InvoiceCreated' }],
+}
+
+export async function run ({ event, sdk, integrations }) {
+  const stripe = integrations.get('stripe')   // null if credentials are missing
+  if (!stripe) return
+
+  await stripe.invoices.send(event.payload.stripeInvoiceId)
+}
+```
+
+`integrations.get(id)` returns `null` when the integration was not loaded (missing credentials, failed `connect()`, or not declared anywhere).
+
+### Manifest output
+
+After `app build` the manifest contains an `integrations` array:
+
+```json
+{
+  "integrations": [
+    {
+      "id": "stripe",
+      "entry": "/static/stripe.integration-7f2a.js",
+      "credentials": ["STRIPE_SECRET_KEY"]
+    }
+  ]
+}
+```
+
+### Built-in integrations
+
+`@ossy/platform` ships with the following integration that is auto-discovered for every app using the package:
+
+| id | Credentials | Client |
+|---|---|---|
+| `email` | `SES_REGION`, `SES_ACCESS_KEY_ID`, `SES_SECRET_ACCESS_KEY` | `SESClient` from `@aws-sdk/client-ses` |
+
+If the SES env vars are not set the `email` integration is silently skipped and `integrations.get('email')` returns `null`.
+
+### `IntegrationService` API
+
+```js
+import { IntegrationService } from '@ossy/platform/integrations'
+
+// Load a list of already-imported integration modules (done automatically by the server).
+await IntegrationService.load(modules, process.env)
+
+// Retrieve a connected client by id.
+const client = IntegrationService.get('email')  // SESClient | null
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.31.2",
+  "version": "1.32.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -19,7 +19,8 @@
     "./site-loader": "./src/site-loader.js",
     "./tasks": "./src/index.js",
     "./resources": "./src/resources/index.js",
-    "./definition": "./src/Definition.js"
+    "./definition": "./src/Definition.js",
+    "./integrations": "./src/integration.service.js"
   },
   "scripts": {
     "start": "PORT=3003 node -e \"import('./src/server.js').then(m => m.startServer())\""
@@ -28,8 +29,11 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.32.2",
-    "@ossy/sdk": "^1.32.2",
+    "@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",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -40,5 +44,5 @@
     "src",
     "Dockerfile"
   ],
-  "gitHead": "5c17e379298f7027f1dbdcf064a4aff69d1497d5"
+  "gitHead": "9a8a1bb0466d35001425d241d77c2c9ab31e11d3"
 }

package/src/email.integration.js

@@ -0,0 +1,26 @@
+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,
+    },
+  })
+}

package/src/index.js

@@ -4,3 +4,4 @@ export { ChangeStream } from './tasks/change-stream.js'
 export { registerResourceTemplate, getSystemResourceTemplates } from './resources/resource-template.registry.js'
 export { normalizeAndValidateDocumentContent, validateResourceTemplatesForImport, ALLOWED_FIELD_TYPES } from './resources/resource-template.validation.js'
 export { Definition } from './Definition.js'
+export { IntegrationService } from './integration.service.js'

package/src/integration.service.js

@@ -0,0 +1,63 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
+
+/** @type {Record<string, unknown>} */
+const _clients = {}
+
+/**
+ * Manages third-party integration clients declared via `*.integration.js` files.
+ *
+ * Integrations are loaded once at server startup. If a required env var is
+ * missing, or if `connect()` throws, the integration is skipped with a warning
+ * so the server can still boot without every optional credential being present.
+ */
+export const IntegrationService = {
+  /**
+   * Connect all integration modules, storing each resulting client by id.
+   * Pass the array of already-imported integration modules (each exporting
+   * `id`, `credentials`, and `connect`).
+   *
+   * @param {Array<{ id: string, credentials: string[], connect: (opts: { env: NodeJS.ProcessEnv }) => Promise<unknown> | unknown }>} modules
+   * @param {NodeJS.ProcessEnv} env  Usually `process.env`.
+   */
+  async load (modules, env) {
+    for (const mod of modules) {
+      const { id, credentials = [], connect } = mod
+
+      if (typeof id !== 'string' || id.trim() === '') {
+        log.warn('[IntegrationService] Skipping integration with missing or invalid "id"')
+        continue
+      }
+
+      const missing = credentials.filter((key) => !env[key])
+      if (missing.length > 0) {
+        log.warn(
+          `[IntegrationService] Skipping integration "${id}" — missing env var(s): ${missing.join(', ')}`,
+        )
+        continue
+      }
+
+      try {
+        _clients[id] = await connect({ env })
+        log.info(`[IntegrationService] Connected integration "${id}"`)
+      } catch (err) {
+        log.warn(
+          `[IntegrationService] Integration "${id}" connect() failed — skipping: ${err && err.message ? err.message : err}`,
+        )
+      }
+    }
+  },
+
+  /**
+   * Retrieve a connected client by integration id.
+   * Returns `null` when the integration was not loaded (missing credentials,
+   * connect failure, or not declared in the manifest).
+   *
+   * @param {string} id
+   * @returns {unknown | null}
+   */
+  get (id) {
+    return _clients[id] ?? null
+  },
+}

package/src/proxy-internal.js

@@ -1,3 +1,7 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
+
 /** Node/Express can join duplicate workspace headers as `id, id` — API expects a single id. */
 function normalizeWorkspaceIdHeader (value) {
   if (!value || value === 'undefined') return undefined
@@ -39,14 +43,14 @@ export function ProxyInternal () {
     }
 
     if (req.originalUrl.startsWith('/@ossy/users/me/app-settings') && req.method === 'GET') {
-      console.log('[@ossy/platform][proxy] GET /@ossy/users/me/app-settings')
+      log.info('[@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}`)
+    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')}`
@@ -79,7 +83,7 @@ export function ProxyInternal () {
             try {
               data = trimmed === '' ? null : JSON.parse(trimmed)
             } catch (error) {
-              console.log('[@ossy/platform][proxy][error]', error)
+              log.error('[@ossy/platform][proxy][error]', undefined, error)
               res.removeHeader('content-length')
               const st = response.status
               if (st === 401 || st === 403 || st === 404) {
@@ -103,7 +107,7 @@ export function ProxyInternal () {
         })
       })
       .catch((error) => {
-        console.log('[@ossy/platform][proxy][error]', error)
+        log.error('[@ossy/platform][proxy][error]', undefined, error)
         const status = error.status
         res.status(status || 500)
         res.json({ message: error.message || 'Internal Server Error' })

package/src/resources/resource-template.registry.js

@@ -1,3 +1,7 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
+
 /** @type {object[]} */
 const systemTemplates = []
 
@@ -12,7 +16,7 @@ export function registerResourceTemplate(template) {
   if (typeof template.id !== 'string' || template.id.trim() === '') return
   if (systemTemplates.find(t => t.id === template.id)) return
   systemTemplates.push(template)
-  console.log(`[INFO][ResourceTemplateRegistry] Registered system template: ${template.id}`)
+  log.info(`[ResourceTemplateRegistry] Registered system template: ${template.id}`)
 }
 
 /**

package/src/runtime.js

@@ -7,6 +7,9 @@ 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'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
 
 const DEFAULT_PORT = 3000
 
@@ -119,7 +122,7 @@ export async function startRuntime ({ port } = {}) {
     try {
       context = await getSiteContext(domain)
     } catch (err) {
-      console.error(`[@ossy/platform] Failed to load site for ${domain}:`, err.message)
+      log.error(`[@ossy/platform] Failed to load site for ${domain}`, undefined, err)
       res.status(503).type('text').send(`Site not available: ${domain}`)
       return
     }
@@ -177,7 +180,7 @@ export async function startRuntime ({ port } = {}) {
       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)
+      log.error(`[@ossy/platform] Request error for ${domain}${requestUrl}`, undefined, err)
       if (!res.headersSent) res.status(500).type('text').send('Internal Server Error')
     }
   })
@@ -188,8 +191,8 @@ export async function startRuntime ({ port } = {}) {
     httpServer.once('error', reject)
   })
 
-  console.log(`[@ossy/platform] Runtime running on http://localhost:${resolvedPort}`)
-  console.log('[@ossy/platform] Press Ctrl+C to stop.')
+  log.info(`[@ossy/platform] Runtime running on http://localhost:${resolvedPort}`)
+  log.info('[@ossy/platform] Press Ctrl+C to stop.')
 
   const closeServer = () => new Promise((resolve) => server.close(() => resolve()))
 
@@ -197,7 +200,7 @@ export async function startRuntime ({ port } = {}) {
   const handleShutdown = async (signal) => {
     if (shuttingDown) return
     shuttingDown = true
-    console.log(`\n[@ossy/platform] Received ${signal}, shutting down…`)
+    log.info(`[@ossy/platform] Received ${signal}, shutting down…`)
     try { await closeServer() } finally { process.exit(0) }
   }
   process.on('SIGINT', () => handleShutdown('SIGINT'))
@@ -208,6 +211,6 @@ export async function startRuntime ({ port } = {}) {
 
 // Run directly: node src/runtime.js
 startRuntime().catch((err) => {
-  console.error('[@ossy/platform] Runtime failed to start:', err)
+  log.error('[@ossy/platform] Runtime failed to start', undefined, err)
   process.exit(1)
 })

package/src/server.js

@@ -7,9 +7,14 @@ import { Router as OssyRouter } from '@ossy/router'
 import cookieParser from 'cookie-parser'
 import { ProxyInternal } from './proxy-internal.js'
 import { SDK } from '@ossy/sdk'
+import { AggregateRebuild } from '@ossy/event-store'
 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 { createLogger } from '@ossy/observability'
+
+const log = createLogger('@ossy/platform')
 
 const DEFAULT_PORT = 3000
 const MANIFEST_FILE = 'manifest.json'
@@ -49,9 +54,11 @@ export function loadManifest (buildDir) {
   const components = Array.isArray(manifest.components) ? manifest.components : []
   const resourceTemplates = Array.isArray(manifest.resourceTemplates) ? manifest.resourceTemplates : []
   const aggregates = Array.isArray(manifest.aggregates) ? manifest.aggregates : []
+  const integrations = Array.isArray(manifest.integrations) ? manifest.integrations : []
+  const startups = Array.isArray(manifest.startups) ? manifest.startups : []
   for (const e of entries) {
     if ((e.type === 'page' || e.type === 'api') && !validRoutable(e)) {
-      console.warn(`[@ossy/platform][server] Skipping ${e.type} "${e.id}" — manifest entry has no path.`)
+      log.warn(`Skipping ${e.type} "${e.id}" — manifest entry has no path.`)
     }
   }
   return {
@@ -62,6 +69,8 @@ export function loadManifest (buildDir) {
     components,
     resourceTemplates,
     aggregates,
+    integrations,
+    startups,
     config: manifest.config || {},
   }
 }
@@ -100,7 +109,7 @@ export async function startServer (options = {}) {
         TaskService.registerTask(mod)
       }
     } catch (err) {
-      console.error(`[@ossy/platform][server] Failed to load task "${task.id}":`, err.message)
+      log.error(`Failed to load task "${task.id}"`, undefined, err)
     }
   }
 
@@ -108,28 +117,46 @@ export async function startServer (options = {}) {
     registerResourceTemplate(template)
   }
 
-  // Aggregate registration — mirrors task and resource-template registration above.
-  // AggregateRebuild lives in the co-located api package. The relative path resolves
-  // correctly both in the monorepo layout (ossy/packages/platform/src/ → api/) and
-  // when the published package is installed inside api/node_modules/@ossy/platform/src/.
-  // A try/catch ensures the server starts cleanly even when the api source is absent.
-  let AggregateRebuild = null
-  try {
-    const rebuildMod = await import(new URL('../../../../api/src/aggregate/aggregate.rebuild.js', import.meta.url).href)
-    AggregateRebuild = rebuildMod.AggregateRebuild
-  } catch {
-    // AggregateRebuild not reachable from this installation — aggregate registration skipped.
+  // Integration loading — import each bundled integration module, check its
+  // declared credentials, and call connect({ env }) to obtain a client.
+  // Missing credentials or a failing connect() are non-fatal: the integration
+  // is skipped with a warning so the server still starts.
+  const integrationModules = []
+  for (const intEntry of manifest.integrations ?? []) {
+    try {
+      integrationModules.push(await import(resolveEntryUrl(intEntry.entry, buildDir)))
+    } catch (err) {
+      log.warn(`Failed to import integration "${intEntry.id}"`, undefined, err)
+    }
   }
+  await IntegrationService.load(integrationModules, process.env)
 
+  // Aggregate registration — mirrors task and resource-template registration above.
+  // AggregateRebuild is provided by @ossy/event-store.
   if (AggregateRebuild) {
     for (const agg of manifest.aggregates ?? []) {
       try {
         const mod = await import(resolveEntryUrl(agg.entry, buildDir))
         AggregateRebuild.registerAggregate(mod)
       } catch (err) {
-        console.error(`[@ossy/platform][server] Failed to load aggregate "${agg.id}":`, err.message)
+        log.error(`Failed to load aggregate "${agg.id}"`, undefined, err)
       }
     }
+
+    AggregateRebuild.BuildAndSaveAll().catch((error) => {
+      log.error('BuildAndSaveAll failed — is MongoDB reachable?', undefined, error)
+    })
+  }
+
+  for (const startup of manifest.startups ?? []) {
+    try {
+      const mod = await import(resolveEntryUrl(startup.entry, buildDir))
+      if (typeof mod.run === 'function') {
+        await mod.run({ env: process.env })
+      }
+    } catch (err) {
+      log.error(`Failed to run startup "${startup.id}"`, undefined, err)
+    }
   }
 
   // Register the SDK so all tasks receive it as `sdk`.
@@ -234,7 +261,7 @@ export async function startServer (options = {}) {
 
       res.status(404).send('Not found')
     } catch (err) {
-      console.error('[@ossy/platform][server] Request handling failed:', err)
+      log.error('Request handling failed', undefined, err)
       if (!res.headersSent) {
         res.status(500).type('text').send('Internal Server Error')
       }
@@ -247,8 +274,8 @@ export async function startServer (options = {}) {
     httpServer.once('error', reject)
   })
 
-  console.log(`[@ossy/platform][server] Running on http://localhost:${port}`)
-  console.log('[@ossy/platform][server] Press Ctrl+C to stop.')
+  log.info(`Running on http://localhost:${port}`)
+  log.info('Press Ctrl+C to stop.')
 
   const closeServer = () => new Promise((resolve) => server.close(() => resolve()))
 
@@ -256,7 +283,7 @@ export async function startServer (options = {}) {
   const handleShutdown = async (signal) => {
     if (shuttingDown) return
     shuttingDown = true
-    console.log(`\n[@ossy/platform][server] Received ${signal}, shutting down...`)
+    log.info(`Received ${signal}, shutting down...`)
     try {
       await closeServer()
     } finally {

package/src/site-loader.js

@@ -2,6 +2,9 @@ import path from 'path'
 import os from 'os'
 import { mkdir, writeFile } from 'fs/promises'
 import { SDK, ResourcesList } from '@ossy/sdk'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
 
 const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
 const DOWNLOAD_CONCURRENCY = 10
@@ -125,7 +128,7 @@ export async function loadSite (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}…`)
+  log.info(`[@ossy/platform] Loading site for ${domain} (workspace ${workspaceId}) from CMS ${cmsLocation}…`)
 
   const sdk = SDK.of({
     apiUrl: API_URL,
@@ -146,7 +149,7 @@ export async function loadSite (domain) {
 
   await runWithConcurrency(tasks, DOWNLOAD_CONCURRENCY)
 
-  console.log(`[@ossy/platform] Site ${domain} ready — ${files.length} file(s) in ${buildDir}`)
+  log.info(`[@ossy/platform] Site ${domain} ready — ${files.length} file(s) in ${buildDir}`)
 
   cache.set(domain, { buildDir, workspaceId, loadedAt: Date.now() })
   return buildDir
@@ -158,5 +161,5 @@ export async function loadSite (domain) {
  */
 export function invalidateSite (domain) {
   cache.delete(domain)
-  console.log(`[@ossy/platform] Cache invalidated for ${domain}`)
+  log.info(`[@ossy/platform] Cache invalidated for ${domain}`)
 }

package/src/tasks/change-stream.js

@@ -1,4 +1,7 @@
 import { TaskService } from './task-service.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
 
 function isMongoTopologyClosedError(error) {
   if (!error || typeof error !== 'object') return false
@@ -24,7 +27,7 @@ export class ChangeStream {
     ChangeStream._reconnectAttempts = 0
     ChangeStream._dbUrl = dbUrl
     ChangeStream._open().catch((error) => {
-      console.error('[ChangeStream] Change stream could not be opened', error)
+      log.error('[ChangeStream] Change stream could not be opened', undefined, error)
       ChangeStream._scheduleReconnect()
     })
   }
@@ -61,7 +64,7 @@ export class ChangeStream {
     if (prev) {
       prev.close().catch(() => {})
     }
-    console.log('[ChangeStream] New MongoClient instance created')
+    log.info('[ChangeStream] New MongoClient instance created')
   }
 
   static _scheduleReconnect() {
@@ -70,19 +73,19 @@ export class ChangeStream {
     const delaySecs = Math.min(Math.pow(2, ChangeStream._reconnectAttempts), 30)
     ChangeStream._reconnectAttempts++
 
-    console.log(`[ChangeStream] Reconnecting in ${delaySecs}s...`)
+    log.info(`[ChangeStream] Reconnecting in ${delaySecs}s...`)
 
     setTimeout(() => {
       if (ChangeStream._stopped) return
       ChangeStream._open().catch((error) => {
-        console.error('[ChangeStream] Change stream could not be opened', error)
+        log.error('[ChangeStream] Change stream could not be opened', undefined, error)
         ChangeStream._scheduleReconnect()
       })
     }, delaySecs * 1000)
   }
 
   static async _open() {
-    console.log('[ChangeStream] Watching for changes')
+    log.info('[ChangeStream] Watching for changes')
 
     const dbName = process.env.DB_NAME || 'test'
     const client = await ChangeStream._getClient()
@@ -95,7 +98,7 @@ export class ChangeStream {
     const wasReconnecting = ChangeStream._reconnectAttempts > 0
     ChangeStream._reconnectAttempts = 0
     if (wasReconnecting) {
-      console.log('[ChangeStream] Reconnected.')
+      log.info('[ChangeStream] Reconnected.')
     }
 
     // Ensures only one reconnect is scheduled if both 'error' and 'close' fire for the same failure.
@@ -108,7 +111,7 @@ export class ChangeStream {
     }
 
     changeStream.on('error', (error) => {
-      console.error('[ChangeStream] Change stream error (server keeps running)', error)
+      log.error('[ChangeStream] Change stream error (server keeps running)', undefined, error)
       if (isMongoTopologyClosedError(error)) {
         ChangeStream._resetClient().catch(() => {})
       }
@@ -116,17 +119,17 @@ export class ChangeStream {
     })
 
     changeStream.on('change', (change) => {
-      console.log('[ChangeStream] Change detected')
+      log.info('[ChangeStream] Change detected')
       TaskService.dispatch(change.fullDocument)
     })
 
     changeStream.on('close', () => {
-      console.log('[ChangeStream] close detected')
+      log.info('[ChangeStream] close detected')
       scheduleOnce()
     })
 
     changeStream.on('end', () => {
-      console.log('[ChangeStream] end detected')
+      log.info('[ChangeStream] end detected')
       scheduleOnce()
     })
   }

package/src/tasks/task-registry.js

@@ -1,5 +1,8 @@
 import { discoverTaskFiles } from './task-loader.js'
 import { TaskService } from './task-service.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
 
 export async function loadAndRegisterTasks({ cwd }) {
   const taskFiles = await discoverTaskFiles({ cwd })
@@ -11,7 +14,7 @@ export async function loadAndRegisterTasks({ cwd }) {
         TaskService.registerTask(taskModule)
       }
     } catch (err) {
-      console.error(`[TaskService] Failed to load task ${fileUrl}:`, err.message)
+      log.error(`[TaskService] Failed to load task ${fileUrl}`, { message: err.message }, err)
     }
   }
 }

package/src/tasks/task-service.js

@@ -1,7 +1,10 @@
 import { matchesGlob } from './glob.js'
 import { matchesCron } from './cron.js'
+import { IntegrationService } from '../integration.service.js'
+import { createLogger, metrics } from '@ossy/observability'
 
 const SCHEDULER_INTERVAL_MS = 60_000
+const _serviceLog = createLogger('TaskService')
 
 export class TaskService {
 
@@ -40,17 +43,17 @@ export class TaskService {
     const metadata = taskModule.metadata
 
     if (typeof handler !== 'function') {
-      console.error(`[TaskService] Task "${metadata?.id}" has no exported "run" function — skipping`)
+      _serviceLog.error(`Task "${metadata?.id}" has no exported "run" function — skipping`)
       return
     }
     if (!metadata?.id) {
-      console.error('[TaskService] Task has no metadata.id — skipping')
+      _serviceLog.error('Task has no metadata.id — skipping')
       return
     }
 
     TaskService._tasks.push({ metadata, handler })
-    console.log(
-      `[TaskService] Registered task "${metadata.id}" with ${metadata.triggers?.length ?? 0} trigger(s)` +
+    _serviceLog.info(
+      `Registered task "${metadata.id}" with ${metadata.triggers?.length ?? 0} trigger(s)` +
       (metadata.schedule ? ` and schedule "${metadata.schedule}"` : ''),
     )
   }
@@ -71,13 +74,19 @@ export class TaskService {
 
       if (!matched) continue
 
-      console.log(`[TaskService] Dispatching task "${metadata.id}"`)
+      _serviceLog.info(`Dispatching task "${metadata.id}"`)
 
+      const _taskId = metadata.id
+      const _start = Date.now()
       Promise.resolve()
-        .then(() => handler({ event, sdk: effectiveSdk }))
+        .then(() => handler({ event, sdk: effectiveSdk, integrations: IntegrationService, log: createLogger(metadata.id) }))
         .catch(error =>
-          console.error(`[TaskService] Task "${metadata.id}" failed`, error),
+          _serviceLog.error(`Task "${metadata.id}" failed`, undefined, error),
         )
+        .finally(() => {
+          try { metrics.timing('task.duration', Date.now() - _start, { task: _taskId }) } catch {}
+          try { metrics.increment('task.run', { task: _taskId }) } catch {}
+        })
     }
   }
 
@@ -90,7 +99,7 @@ export class TaskService {
     const scheduledTasks = TaskService._tasks.filter(t => !!t.metadata.schedule)
     if (scheduledTasks.length === 0) return
 
-    console.log(`[TaskService] Scheduler started for ${scheduledTasks.length} task(s)`)
+    _serviceLog.info(`Scheduler started for ${scheduledTasks.length} task(s)`)
 
     TaskService._stopped = false
     TaskService._schedulerInterval = setInterval(() => {
@@ -101,13 +110,19 @@ export class TaskService {
       for (const { metadata, handler } of scheduledTasks) {
         if (!matchesCron(metadata.schedule, now)) continue
 
-        console.log(`[TaskService] Schedule fired for task "${metadata.id}"`)
+        _serviceLog.info(`Schedule fired for task "${metadata.id}"`)
 
+        const _taskId = metadata.id
+        const _start = Date.now()
         Promise.resolve()
-          .then(() => handler({ event: { type: 'scheduled', taskId: metadata.id }, sdk: TaskService._sdk }))
+          .then(() => handler({ event: { type: 'scheduled', taskId: metadata.id }, sdk: TaskService._sdk, integrations: IntegrationService, log: createLogger(metadata.id) }))
           .catch(error =>
-            console.error(`[TaskService] Scheduled task "${metadata.id}" failed`, error),
+            _serviceLog.error(`Scheduled task "${metadata.id}" failed`, undefined, error),
           )
+          .finally(() => {
+            try { metrics.timing('task.duration', Date.now() - _start, { task: _taskId }) } catch {}
+            try { metrics.increment('task.run', { task: _taskId }) } catch {}
+          })
       }
     }, SCHEDULER_INTERVAL_MS)
   }