@ossy/app 1.40.2 → 1.40.3

package/src/manifest/build-action-input-schema.js

@@ -0,0 +1,220 @@
+import { templatesContentOneOf } from './template-to-json-schema.js'
+
+const workspaceIdProp = {
+  workspaceId: {
+    type: 'string',
+    description: 'Workspace id (defaults to request workspace header)',
+  },
+}
+
+/** @type {Record<string, (ctx: { schemas: object[] }) => object>} */
+const ENVELOPES = {
+  '@ossy/resources/actions/list': () => ({
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      location: { type: 'string', description: 'Folder path, e.g. /test/' },
+      query: { type: 'object', description: 'Optional query filters merged with location' },
+    },
+  }),
+
+  '@ossy/resources/actions/get': () => ({
+    type: 'object',
+    required: ['resourceId'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/search': () => ({
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      location: { type: 'string' },
+      name: { type: 'string' },
+      type: { type: 'string', description: 'Resource template id or mime type' },
+    },
+  }),
+
+  '@ossy/resources/actions/create': ({ schemas }) => {
+    const contentSchema = templatesContentOneOf(schemas)
+    return {
+      type: 'object',
+      required: ['location', 'name', 'type'],
+      properties: {
+        ...workspaceIdProp,
+        location: { type: 'string', description: 'Parent folder path, e.g. /test/' },
+        name: { type: 'string' },
+        type: {
+          type: 'string',
+          description: 'directory | mime type (binary) | registered resource template id',
+        },
+        size: {
+          type: 'number',
+          description: 'Byte size — required when type is a mime type (binary upload)',
+        },
+        ...(contentSchema
+          ? {
+              content: {
+                description: 'Document payload when type is a resource template id',
+                ...contentSchema,
+              },
+            }
+          : {}),
+      },
+    }
+  },
+
+  '@ossy/resources/actions/update-content': ({ schemas }) => {
+    const contentSchema = templatesContentOneOf(schemas)
+    return {
+      type: 'object',
+      required: ['resourceId', 'content'],
+      properties: {
+        ...workspaceIdProp,
+        resourceId: { type: 'string' },
+        ...(contentSchema
+          ? { content: contentSchema }
+          : { content: { type: 'object' } }),
+      },
+    }
+  },
+
+  '@ossy/resources/actions/delete': () => ({
+    type: 'object',
+    required: ['resourceId'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/upload-named-version': () => ({
+    type: 'object',
+    required: ['resourceId', 'namedVersion', 'type', 'size'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      namedVersion: { type: 'string', description: 'Version label, e.g. thumbnail' },
+      type: { type: 'string', description: 'Mime type' },
+      size: { type: 'number' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-name': () => ({
+    type: 'object',
+    required: ['resourceId', 'name'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      name: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-location': () => ({
+    type: 'object',
+    required: ['resourceId', 'target'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      target: { type: 'string', description: 'Destination folder path' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-access': () => ({
+    type: 'object',
+    required: ['resourceId', 'access'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      access: { type: 'string', enum: ['public', 'workspace', 'restricted'] },
+    },
+  }),
+
+  '@ossy/booking/actions/get-services': () => ({
+    type: 'object',
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      includeInactive: { type: 'boolean' },
+      includeContact: { type: 'boolean' },
+    },
+  }),
+
+  '@ossy/booking/actions/get-available-slots': () => ({
+    type: 'object',
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      serviceId: { type: 'string' },
+      duration: { type: 'number', description: 'Slot duration in minutes' },
+      from: { type: 'number', description: 'Range start (Unix ms)' },
+      to: { type: 'number', description: 'Range end (Unix ms)' },
+    },
+  }),
+
+  '@ossy/booking/actions/create': () => ({
+    type: 'object',
+    required: ['startAt', 'duration', 'clientName', 'clientEmail'],
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      serviceId: { type: 'string' },
+      startAt: { type: 'number', description: 'Slot start (Unix ms)' },
+      duration: { type: 'number', description: 'Duration in minutes' },
+      clientName: { type: 'string' },
+      clientEmail: { type: 'string', format: 'email' },
+      clientMessage: { type: 'string' },
+    },
+  }),
+
+  '@ossy/workspaces/actions/get-schemas': () => ({
+    type: 'object',
+    properties: { ...workspaceIdProp },
+  }),
+
+  '@ossy/workspaces/actions/import-schemas': () => ({
+    type: 'object',
+    required: ['schemas'],
+    properties: {
+      ...workspaceIdProp,
+      schemas: {
+        type: 'array',
+        items: { type: 'object' },
+        description: 'Workspace-imported schema definitions',
+      },
+    },
+  }),
+
+  '@ossy/users/actions/create-api-token': () => ({
+    type: 'object',
+    required: ['name', 'description'],
+    properties: {
+      name: { type: 'string' },
+      description: { type: 'string' },
+    },
+  }),
+}
+
+/**
+ * @param {string} actionId
+ * @param {{ schemas?: object[] }} [ctx]
+ * @returns {object}
+ */
+export function buildActionInputSchema (actionId, ctx = {}) {
+  const schemas = ctx.schemas || []
+  const builder = ENVELOPES[actionId]
+  if (builder) {
+    return builder({ schemas })
+  }
+
+  return {
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      payload: { type: 'object', description: 'Action-specific payload' },
+    },
+    additionalProperties: true,
+  }
+}

package/src/manifest/build-actions-schema.js

@@ -0,0 +1,36 @@
+import { buildCapabilities, capabilitiesToActionsSchema } from './build-capabilities.js'
+import { taskIdFromActionId } from '@ossy/schema'
+
+/**
+ * @param {Array<{ id: string, access?: string, package?: string }>} actions
+ * @param {{ schemas?: object[], tasks?: object[], taskCatalog?: object[], taskGraphEdges?: object[], generatedAt?: string }} [options]
+ * @returns {{ version: number, generatedAt: string, actions: Array<object> }}
+ */
+export function buildActionsSchema (actions = [], options = {}) {
+  const capabilities = buildCapabilities(
+    {
+      actions,
+      tasks: options.tasks || actions.flatMap(a => {
+        try {
+          return [{ id: taskIdFromActionId(a.id) }]
+        } catch {
+          return []
+        }
+      }),
+      schemas: options.schemas || [],
+      taskCatalog: options.taskCatalog || [],
+      taskGraphEdges: options.taskGraphEdges || [],
+    },
+    { generatedAt: options.generatedAt },
+  )
+  return capabilitiesToActionsSchema(capabilities, actions)
+}
+
+export {
+  buildCapabilities,
+  buildCapabilitiesGraph,
+  capabilitiesTaskTopologyResource,
+  capabilitiesToActionsSchema,
+  projectTaskForCapabilities,
+  TASK_TOPOLOGY_RESOURCE_URI,
+} from './build-capabilities.js'

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/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,7 +1,8 @@
 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 { SchemasReadBootstrap } from '@ossy/workspaces/SchemasReadBootstrap'
 import { ThemeEditor } from './ThemeEditor.jsx'
 import { defaultAppSettings } from './AppSettings.jsx'
 import { Router } from '@ossy/router-react'
@@ -16,7 +17,8 @@ export const App = ({ children, language, messages, fallbackMessages, ..._appSet
 
   const sdk = SDK.of({
     apiUrl: appSettings.apiUrl,
-    workspaceId: appSettings.workspaceId
+    workspaceId: appSettings.workspaceId,
+    actionRoutes: appSettings.actionRoutes,
   })
 
   return (
@@ -28,9 +30,10 @@ export const App = ({ children, language, messages, fallbackMessages, ..._appSet
       supportedLanguages={appSettings.supportedLanguages}
     >
       <AppContext.Provider value={contextSettings}>
-        <ComponentSlotsProvider slots={components || {}}>
+        <ComponentSlotsProvider slots={{ ...DEFAULT_FORM_FIELD_SLOTS, ...(components || {}) }}>
           <Theme theme={appSettings.theme} themes={appSettings.themes}>
             <WorkspaceProvider sdk={sdk}>
+              <SchemasReadBootstrap schemas={appSettings.schemas} />
               <Router {...appSettings} pages={appSettings.pages || []}>
                 {children}
                 {appSettings.devMode && <ThemeEditor />}

package/src/shell/AppSettings.jsx

@@ -25,7 +25,18 @@ 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,
     }
   }

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">