@ossy/app 1.40.2 → 3.0.1

package/src/manifest/build-capabilities.js

@@ -0,0 +1,190 @@
+import { actionIdToToolName, humanizeActionId } from './action-id-to-tool-name.js'
+import { buildActionInputSchema } from './build-action-input-schema.js'
+import { taskIdFromActionId } from '@ossy/schema'
+
+const MCP_ACCESS = new Set(['workspace', 'public'])
+
+/** MCP resource URI for read-only task topology (tasks + graph edges). */
+export const TASK_TOPOLOGY_RESOURCE_URI = 'ossy://capabilities/task-topology'
+
+/**
+ * @param {object} task
+ */
+export function projectTaskForCapabilities (task) {
+  return {
+    id: task.id,
+    package: task.package ?? null,
+    moduleId: task.moduleId ?? null,
+    triggers: task.triggers ?? [],
+    schedule: task.schedule ?? null,
+    inputSchemaIds: task.inputSchemaIds ?? [],
+    actionIds: task.actionIds ?? [],
+    primaryActionId: task.primaryActionId ?? null,
+    outputs: task.outputs ?? [],
+  }
+}
+
+/**
+ * Structured trigger → task edges for agent planning (ADR 0011).
+ *
+ * @param {object[]} taskCatalog
+ */
+export function buildCapabilitiesGraph (taskCatalog = []) {
+  /** @type {Array<{ kind: string, from: object, to: { taskId: string }, label?: string }>} */
+  const edges = []
+
+  for (const task of taskCatalog) {
+    for (const trigger of task.triggers ?? []) {
+      if (trigger.kind === 'on_action' && trigger.action) {
+        edges.push({
+          kind: 'on_action',
+          from: { kind: 'action', actionId: trigger.action },
+          to: { taskId: task.id },
+          label: trigger.action,
+        })
+      }
+      if (trigger.kind === 'on_event' && trigger.type) {
+        edges.push({
+          kind: 'on_event',
+          from: {
+            kind: 'trigger',
+            type: trigger.type,
+            ...(trigger.event ? { event: trigger.event } : {}),
+          },
+          to: { taskId: task.id },
+          label: [trigger.type, trigger.event].filter(Boolean).join(' · '),
+        })
+      }
+      if (trigger.kind === 'on_schedule' && trigger.schedule) {
+        edges.push({
+          kind: 'on_schedule',
+          from: { kind: 'schedule', schedule: trigger.schedule },
+          to: { taskId: task.id },
+          label: trigger.schedule,
+        })
+      }
+    }
+    if (task.primaryActionId) {
+      edges.push({
+        kind: 'primary',
+        from: { kind: 'action', actionId: task.primaryActionId },
+        to: { taskId: task.id },
+        label: 'invoke',
+      })
+    }
+  }
+
+  return { edges }
+}
+
+/**
+ * Build agent capabilities (MCP tools + resource template catalog) from manifest data.
+ *
+ * @param {{
+ *   actions?: Array<{ id: string, access?: string, package?: string }>,
+ *   tasks?: Array<{ id: string }>,
+ *   schemas?: Array<object>,
+ *   taskCatalog?: object[],
+ *   taskGraphEdges?: object[],
+ * }} manifest
+ * @param {{ generatedAt?: string }} [options]
+ */
+export function buildCapabilities (manifest, options = {}) {
+  const actions = manifest.actions || []
+  const tasks = manifest.tasks || []
+  const schemas = manifest.schemas || []
+  const taskCatalog = manifest.taskCatalog || []
+  const taskIds = new Set(tasks.map(t => t.id))
+
+  const tools = actions
+    .filter(action => {
+      try {
+        return taskIds.has(taskIdFromActionId(action.id))
+      } catch {
+        return false
+      }
+    })
+    .filter(action => MCP_ACCESS.has(action.access || 'authenticated'))
+    .map(action => ({
+      actionId: action.id,
+      name: actionIdToToolName(action.id),
+      title: humanizeActionId(action.id),
+      description: `Invoke ${action.id}`,
+      access: action.access || 'authenticated',
+      package: action.package,
+      channels: ['sdk', 'api', 'mcp'],
+      inputSchema: buildActionInputSchema(action.id, { schemas }),
+    }))
+    .sort((a, b) => a.actionId.localeCompare(b.actionId))
+
+  const projectedTasks = taskCatalog.map(projectTaskForCapabilities)
+
+  return {
+    version: 2,
+    generatedAt: options.generatedAt || new Date().toISOString(),
+    tools,
+    schemas: schemas.map(t => ({
+      id: t.id,
+      name: t.name,
+      package: t.package,
+      fields: t.fields,
+    })),
+    tasks: projectedTasks,
+    graph: buildCapabilitiesGraph(taskCatalog),
+    /** Legacy string-edge projection kept for UI parity — prefer `graph.edges`. */
+    taskGraphEdges: manifest.taskGraphEdges ?? [],
+  }
+}
+
+/**
+ * Payload exposed via MCP resource {@link TASK_TOPOLOGY_RESOURCE_URI}.
+ *
+ * @param {ReturnType<typeof buildCapabilities>} capabilities
+ */
+export function capabilitiesTaskTopologyResource (capabilities) {
+  return {
+    version: capabilities.version,
+    generatedAt: capabilities.generatedAt,
+    tasks: capabilities.tasks ?? [],
+    graph: capabilities.graph ?? { edges: [] },
+  }
+}
+
+/**
+ * Legacy actions.schema.json shape for package detail / docs.
+ *
+ * @param {ReturnType<typeof buildCapabilities>} capabilities
+ * @param {Array<{ id: string, access?: string, package?: string }>} [allActions]
+ */
+export function capabilitiesToActionsSchema (capabilities, allActions) {
+  const toolById = Object.fromEntries(capabilities.tools.map(t => [t.actionId, t]))
+  const actions = (allActions || capabilities.tools.map(t => ({
+    id: t.actionId,
+    access: t.access,
+    package: t.package,
+  })))
+
+  return {
+    version: capabilities.version,
+    generatedAt: capabilities.generatedAt,
+    actions: actions.map(action => {
+      const tool = toolById[action.id]
+      const inputSchema = tool?.inputSchema
+        ?? buildActionInputSchema(action.id, {
+          schemas: capabilities.schemas,
+        })
+      const hasKnownEnvelope = inputSchema?.properties && !inputSchema.properties.payload
+
+      return {
+        id: action.id,
+        access: action.access ?? 'authenticated',
+        package: action.package,
+        channels: tool ? tool.channels : ['sdk', 'api'],
+        ...(tool?.title ? { title: tool.title } : {}),
+        ...(tool?.description ? { description: tool.description } : {}),
+        ...(tool?.name ? { mcpTool: tool.name } : {}),
+        ...(hasKnownEnvelope ? { inputSchema } : {}),
+      }
+    }).sort((a, b) => a.id.localeCompare(b.id)),
+  }
+}

package/src/manifest/build-manifest-summary.js

@@ -32,7 +32,7 @@ export function buildManifestSummary (manifest) {
         apis: [],
         actions: [],
         components: [],
-        resourceTemplates: [],
+        schemas: [],
         tasks: [],
         integrations: [],
         emails: [],
@@ -69,15 +69,21 @@ export function buildManifestSummary (manifest) {
     add(component.package, 'components', { id: component.id })
   }
 
-  for (const template of manifest.resourceTemplates || []) {
-    add(template.package, 'resourceTemplates', {
+  for (const template of manifest.schemas || []) {
+    add(template.package, 'schemas', {
       id: template.id,
       ...(template.title ? { title: template.title } : {}),
     })
   }
 
-  for (const task of manifest.tasks || []) {
-    add(task.package, 'tasks', { id: task.id })
+  for (const task of manifest.taskCatalog || manifest.tasks || []) {
+    add(task.package, 'tasks', {
+      id: task.id,
+      ...(task.moduleId ? { moduleId: task.moduleId } : {}),
+      ...(task.triggers ? { triggers: task.triggers } : {}),
+      ...(task.inputSchemaIds ? { inputSchemaIds: task.inputSchemaIds } : {}),
+      ...(task.primaryActionId ? { primaryActionId: task.primaryActionId } : {}),
+    })
   }
 
   for (const integration of manifest.integrations || []) {

package/src/manifest/extract-task-catalog.js

@@ -0,0 +1 @@
+export { extractTaskCatalogEntry, buildTaskCatalogEdges } from '@ossy/schema'

package/src/manifest/resolve-page-layout.js

@@ -0,0 +1,51 @@
+import { mergeShellSlots } from '../../runtime/merge-shell-slots.js'
+
+const LAYOUT_ID_PATTERN = /^@([^/]+)\/([^/]+)\/layout\/([^/]+)$/
+
+/**
+ * @param {string} layoutId
+ * @returns {boolean}
+ */
+export function isCanonicalLayoutId (layoutId) {
+  return typeof layoutId === 'string' && LAYOUT_ID_PATTERN.test(layoutId.trim())
+}
+
+/**
+ * Resolve layout id for a page at build time (ADR 0012).
+ *
+ * @param {{
+ *   pageMetadata?: { layout?: string },
+ *   appConfig?: { layout?: string },
+ * }} options
+ * @returns {string}
+ */
+export function resolvePageLayoutId ({
+  pageMetadata = {},
+  appConfig = {},
+} = {}) {
+  const pageLayout = pageMetadata?.layout
+  if (typeof pageLayout === 'string' && pageLayout.trim()) return pageLayout.trim()
+
+  const appLayout = appConfig?.layout
+  if (typeof appLayout === 'string' && appLayout.trim()) return appLayout.trim()
+
+  return '@ossy/app/layout/default'
+}
+
+/**
+ * Merge layout, app, and page slot maps for a single page render.
+ *
+ * @param {{
+ *   layoutSlots?: Record<string, string>,
+ *   appSlots?: Record<string, string | null>,
+ *   pageSlots?: Record<string, string | null>,
+ * }} options
+ * @returns {Record<string, import('../../runtime/merge-shell-slots.js').ShellSlotSpec>}
+ */
+export function resolvePageShellSlots ({
+  layoutSlots,
+  appSlots,
+  pageSlots,
+} = {}) {
+  return mergeShellSlots(layoutSlots, appSlots, pageSlots)
+}

package/src/manifest/serialize-package-definition.js

@@ -21,9 +21,8 @@ export function serializePackageDefinition (definition) {
     out.navOrder = definition.navOrder
   }
   if (definition.entitlementRequired === false) out.entitlementRequired = false
-  if (typeof definition.status === 'string' && definition.status.trim()) out.status = definition.status.trim()
-  if (Array.isArray(definition.statuses) && definition.statuses.length) {
-    out.statuses = definition.statuses.filter((s) => typeof s === 'string' && s.trim()).map((s) => s.trim())
+  if (Array.isArray(definition.status) && definition.status.length) {
+    out.status = definition.status.filter((s) => typeof s === 'string' && s.trim()).map((s) => s.trim())
   }
 
   return Object.keys(out).length ? out : null

package/src/manifest/template-to-json-schema.js

@@ -0,0 +1,103 @@
+/**
+ * Map resource template field types to JSON Schema (draft-07 subset).
+ *
+ * @param {{ name: string, type: string, options?: string[] }} field
+ * @returns {object}
+ */
+export function fieldToJsonSchema (field) {
+  const type = field?.type?.trim?.() || 'text'
+
+  switch (type) {
+    case 'number':
+    case 'timestamp':
+      return { type: 'number', description: `${field.name} (Unix ms for timestamp)` }
+    case 'boolean':
+      return { type: 'boolean' }
+    case 'select':
+      return {
+        type: 'string',
+        ...(Array.isArray(field.options) && field.options.length
+          ? { enum: field.options }
+          : {}),
+      }
+    case 'multiselect':
+      return {
+        type: 'array',
+        items: {
+          type: 'string',
+          ...(Array.isArray(field.options) && field.options.length
+            ? { enum: field.options }
+            : {}),
+        },
+      }
+    case 'file':
+    case 'image':
+      return {
+        type: 'object',
+        properties: { resourceId: { type: 'string' } },
+        required: ['resourceId'],
+        description: 'Reference to an uploaded binary resource',
+      }
+    case 'date-range':
+      return {
+        type: 'object',
+        properties: {
+          start: { type: 'number' },
+          end: { type: 'number' },
+        },
+        required: ['start', 'end'],
+      }
+    case 'date-ranges':
+      return {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            start: { type: 'number' },
+            end: { type: 'number' },
+          },
+          required: ['start', 'end'],
+        },
+      }
+    case 'email':
+      return { type: 'string', format: 'email' }
+    case 'textarea':
+    case 'richtext':
+    case 'text':
+    case 'date':
+    default:
+      return { type: 'string' }
+  }
+}
+
+/**
+ * @param {{ id: string, name?: string, fields?: Array<object> }} template
+ * @returns {object}
+ */
+export function templateToJsonSchema (template) {
+  const properties = {}
+  for (const field of template.fields || []) {
+    if (!field?.name) continue
+    properties[field.name] = fieldToJsonSchema(field)
+  }
+
+  return {
+    title: template.id,
+    type: 'object',
+    properties,
+  }
+}
+
+/**
+ * @param {Array<{ id: string, fields?: Array<object> }>} templates
+ * @returns {object | undefined}
+ */
+export function templatesContentOneOf (templates) {
+  const branches = (templates || [])
+    .filter(t => t?.id && Array.isArray(t.fields))
+    .map(templateToJsonSchema)
+
+  if (!branches.length) return undefined
+
+  return { oneOf: branches }
+}

package/src/shell/App.jsx

@@ -1,22 +1,26 @@
 import React from 'react'
 import { SDK } from '@ossy/sdk'
 import { WorkspaceProvider } from '@ossy/sdk-react'
-import { Theme, ComponentSlotsProvider, LocaleProvider } from '@ossy/design-system'
+import { Theme, ComponentSlotsProvider, LocaleProvider, DEFAULT_FORM_FIELD_SLOTS } from '@ossy/design-system'
+import { DEFAULT_SCHEMA_VIEW_SLOTS } from '@ossy/resources/schemaViewSlots.js'
+import { DEFAULT_SCHEMA_FORM_SLOTS } from '@ossy/resources/schemaFormSlots.js'
+import { SchemasReadBootstrap } from '@ossy/workspaces/SchemasReadBootstrap'
 import { ThemeEditor } from './ThemeEditor.jsx'
+import { WorkspaceAppSettingsSync } from './WorkspaceAppSettingsSync.jsx'
 import { defaultAppSettings } from './AppSettings.jsx'
 import { Router } from '@ossy/router-react'
 import { AppContext } from './AppContext.js'
 
-export const App = ({ children, language, messages, fallbackMessages, ..._appSettings }) => {
+export const App = ({ children, language, messages, fallbackMessages, sdk: sdkOverride, ..._appSettings }) => {
   const appSettings = { ...defaultAppSettings(), ..._appSettings }
 
-  // `components` holds resolved ComponentType values — not JSON-serializable,
-  // so we keep them out of AppContext and provide them via ComponentSlotsProvider.
-  const { components, ...contextSettings } = appSettings
+  // `components` and `sdk` are not JSON-serializable — keep them out of AppContext.
+  const { components, sdk: _sdkFromSettings, ...contextSettings } = appSettings
 
-  const sdk = SDK.of({
+  const sdk = sdkOverride ?? SDK.of({
     apiUrl: appSettings.apiUrl,
-    workspaceId: appSettings.workspaceId
+    workspaceId: appSettings.workspaceId,
+    actionRoutes: appSettings.actionRoutes,
   })
 
   return (
@@ -28,9 +32,14 @@ export const App = ({ children, language, messages, fallbackMessages, ..._appSet
       supportedLanguages={appSettings.supportedLanguages}
     >
       <AppContext.Provider value={contextSettings}>
-        <ComponentSlotsProvider slots={components || {}}>
+        <ComponentSlotsProvider slots={{ ...DEFAULT_FORM_FIELD_SLOTS, ...DEFAULT_SCHEMA_VIEW_SLOTS, ...DEFAULT_SCHEMA_FORM_SLOTS, ...(components || {}) }}>
           <Theme theme={appSettings.theme} themes={appSettings.themes}>
-            <WorkspaceProvider sdk={sdk}>
+            <WorkspaceProvider
+              sdk={sdk}
+              enablePushInvalidation={appSettings.enablePushInvalidation === true}
+            >
+              <SchemasReadBootstrap schemas={appSettings.schemas} />
+              <WorkspaceAppSettingsSync />
               <Router {...appSettings} pages={appSettings.pages || []}>
                 {children}
                 {appSettings.devMode && <ThemeEditor />}

package/src/shell/AppSettings.jsx

@@ -25,7 +25,24 @@ export function defaultAppSettings() {
       faviconHref: undefined,
       /** When true, main app sidebar is collapsed to icons (from server cookie / app-settings). */
       sidebarPrimaryCollapsed: false,
+      /** Cached workspace shell snapshot (from user-app-settings cookie; refreshed client-side). */
+      workspaceName: undefined,
+      workspaceServices: undefined,
+      workspaces: undefined,
       /** Grouped manifest entries by npm package — for dev tooling. */
       manifestSummary: undefined,
+      /** Merged system + workspace schemas (SSR bootstrap for client validation). */
+      schemas: undefined,
+      /** Task catalog from `app build` (ADR 0011) — for automation topology UI. */
+      taskCatalog: undefined,
+      taskGraphEdges: undefined,
+      /** Action id → HTTP route map for sdk.invoke transport routing. */
+      actionRoutes: undefined,
+      /**
+       * When true, the app shell opens SSE push invalidation for every page.
+       * Default false — mount `PushInvalidationSubscriber` only on pages that
+       * need live cross-tab cache updates (see @ossy/sdk-react README).
+       */
+      enablePushInvalidation: false,
     }
   }

package/src/shell/DevPagesPanel.jsx

@@ -57,36 +57,40 @@ export const DevPagesPanel = () => {
 
   return (
     <View gap="m">
-      <Text variant="title-tertiary">Dev</Text>
+      <Text variant="heading-tertiary" text="design-system.dev.pagesPanel.title" />
 
       <View gap="xs" style={currentPageStyles}>
-        <Text variant="title-tertiary" style={{ marginBottom: 'var(--space-xs)' }}>
-          Current page
-        </Text>
+        <Text
+          variant="heading-tertiary"
+          text="design-system.dev.pagesPanel.currentPage"
+          style={{ marginBottom: 'var(--space-xs)' }}
+        />
         <Text style={monoStyle}>
-          <strong>id:</strong> {app?.pageId || '—'}
+          <strong><Text as="span" text="design-system.dev.pagesPanel.id" />:</strong> {app?.pageId || '—'}
         </Text>
         <Text style={monoStyle}>
-          <strong>path:</strong> {currentPathLabel}
+          <strong><Text as="span" text="design-system.dev.pagesPanel.path" />:</strong> {currentPathLabel}
         </Text>
         <Text style={monoStyle}>
-          <strong>url:</strong> {currentUrl}
+          <strong><Text as="span" text="design-system.dev.pagesPanel.url" />:</strong> {currentUrl}
         </Text>
         {packageDetailHref && currentPage?.package && (
           <Button
             variant="link"
             href={packageDetailHref}
+            label="design-system.dev.pagesPanel.viewPackage"
+            params={{ package: currentPage.package }}
             style={{ alignSelf: 'flex-start', padding: 0, height: 'auto' }}
-          >
-            View package ({currentPage.package})
-          </Button>
+          />
         )}
       </View>
 
       <View gap="s">
-        <Text variant="title-tertiary">
-          Pages ({pages.length})
-        </Text>
+        <Text
+          variant="heading-tertiary"
+          text="design-system.dev.pagesPanel.pages"
+          params={{ count: pages.length }}
+        />
 
         {groups.map(({ key, label, pages: groupPages }) => (
           <View key={key} gap="xs">

package/src/shell/HeaderAuthActions.jsx

@@ -0,0 +1,49 @@
+import React from 'react'
+import { Button, useLocale } from '@ossy/design-system'
+import { useRouter } from '@ossy/router-react'
+import { OpenSignIn, OpenSignUp } from '@ossy/authentication'
+import { useApp } from './AppContext.js'
+
+/**
+ * Profile link when authenticated; sign-in / sign-up when not.
+ */
+export function HeaderAuthActions ({ compact = false }) {
+  const app = useApp()
+  const router = useRouter()
+  const { t } = useLocale()
+
+  if (app?.isAuthenticated) {
+    return (
+      <Button
+        variant="link"
+        suffix="profile"
+        href={router.getHref('@profile')}
+        aria-label={t('app.shell.header.profile') || 'Profile'}
+        style={{ flexShrink: 0 }}
+      >
+        {compact ? null : (t('app.shell.header.profile') || 'Profile')}
+      </Button>
+    )
+  }
+
+  return (
+    <>
+      <Button
+        variant="link"
+        suffix={OpenSignIn.suffix}
+        href={router.getHref('@sign-in')}
+        label={compact ? undefined : OpenSignIn.label}
+        aria-label={t(OpenSignIn.label)}
+        style={{ flexShrink: 0 }}
+      />
+      <Button
+        variant="cta"
+        suffix={OpenSignUp.suffix}
+        href={router.getHref('@sign-up')}
+        label={compact ? undefined : OpenSignUp.label}
+        aria-label={t(OpenSignUp.label)}
+        style={{ flexShrink: 0 }}
+      />
+    </>
+  )
+}

package/src/shell/LanguageList.jsx

@@ -0,0 +1,83 @@
+import React, { useMemo } from 'react'
+import { Text, View, useLocale } from '@ossy/design-system'
+import { useRouter } from '@ossy/router-react'
+import { languageDisplayName } from './languageCode.js'
+
+const listItemStyle = {
+  display: 'block',
+  width: '100%',
+  textAlign: 'left',
+}
+
+/**
+ * Footer language column when multiple locales are configured.
+ */
+export function LanguageList () {
+  const router = useRouter()
+  const { t } = useLocale()
+  const { language, supportedLanguages, getHref } = router
+
+  const displayNames = useMemo(
+    () => new Intl.DisplayNames([language], { type: 'language' }),
+    [language],
+  )
+
+  if (!supportedLanguages?.length || supportedLanguages.length <= 1) {
+    return null
+  }
+
+  const listLabel = t('app.shell.footer.languages') || 'Languages'
+
+  return (
+    <View layout="column" gap="s" alignItems="flex-start" style={{ minWidth: 0 }}>
+      <Text variant="heading-tertiary" as="h2" style={listItemStyle}>
+        {listLabel}
+      </Text>
+      <View
+        as="nav"
+        aria-label={listLabel}
+        style={{ width: '100%' }}
+      >
+        <View
+          as="ul"
+          layout="column"
+          gap="xs"
+          alignItems="flex-start"
+          style={{ listStyle: 'none', margin: 0, padding: 0, width: '100%' }}
+        >
+          {supportedLanguages.map((lang) => {
+            const isActive = lang === language
+            const label = displayNames.of(lang) ?? languageDisplayName(lang, language)
+
+            if (isActive) {
+              return (
+                <View as="li" key={lang} style={{ width: '100%' }}>
+                  <Text variant="small" as="span" aria-current="true" style={listItemStyle}>
+                    {label}
+                  </Text>
+                </View>
+              )
+            }
+
+            return (
+              <View as="li" key={lang} style={{ width: '100%' }}>
+                <Text
+                  variant="small"
+                  as="a"
+                  href={getHref({ language: lang })}
+                  style={{
+                    ...listItemStyle,
+                    textDecoration: 'underline',
+                    cursor: 'pointer',
+                  }}
+                >
+                  {label}
+                </Text>
+              </View>
+            )
+          })}
+        </View>
+      </View>
+    </View>
+  )
+}