@ossy/app 3.0.1 → 3.0.2

package/cli/manifest-plugin.js

@@ -3,9 +3,9 @@ import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 
 import { metadataIdFromFile, defaultPageRoute } from './get-platform-files.task.js'
-import { discoverPackageDefinitions } from '../src/manifest/discover-package-definitions.js'
-import { buildActionsSchema } from '../src/manifest/build-actions-schema.js'
-import { buildCapabilities } from '../src/manifest/build-capabilities.js'
+import { discoverPackageDefinitions } from '@ossy/manifest/discover-package-definitions'
+import { buildActionsSchema } from '@ossy/manifest/build-actions-schema'
+import { buildCapabilities } from '@ossy/manifest/build-capabilities'
 import { extractTaskCatalogEntry, buildTaskCatalogEdges } from '../src/manifest/extract-task-catalog.js'
 import {
   Schema,
@@ -587,6 +587,14 @@ export function manifestPlugin ({ entriesByStub, srcDir, staticOutDir, configVal
           this.error(`[@ossy/app][build] ${entryInfo.kind} entry missing metadata.id: ${entryInfo.sourcePath}`)
         }
         if (seenIds[entryInfo.kind].has(id)) {
+          // App-local components are discovered first. Allow the app to shadow
+          // the same component id from an installed package (e.g. brand logos).
+          if (entryInfo.kind === 'component' && entryInfo.packageName) {
+            console.warn(
+              `[@ossy/app][build] Skipping package component "${id}" from ${entryInfo.packageName} — app already provides it`,
+            )
+            continue
+          }
           this.error(`[@ossy/app][build] Duplicate ${entryInfo.kind} id "${id}"`)
         }
         seenIds[entryInfo.kind].add(id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "",
   "source": "./src/index.js",
   "main": "./src/index.js",
@@ -49,20 +49,21 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-react": "^7.26.3",
     "@babel/register": "^7.25.9",
-    "@ossy/authentication": "^3.0.1",
-    "@ossy/design-system": "^3.0.1",
-    "@ossy/locale": "^3.0.1",
-    "@ossy/package-catalog": "^3.0.1",
-    "@ossy/pages": "^3.0.1",
-    "@ossy/platform": "^3.0.1",
-    "@ossy/resources": "^3.0.1",
-    "@ossy/router": "^3.0.1",
-    "@ossy/router-react": "^3.0.1",
-    "@ossy/schema": "^3.0.1",
-    "@ossy/sdk": "^3.0.1",
-    "@ossy/sdk-react": "^3.0.1",
-    "@ossy/themes": "^3.0.1",
-    "@ossy/workspaces": "^3.0.1",
+    "@ossy/authentication": "^3.0.2",
+    "@ossy/design-system": "^3.0.2",
+    "@ossy/locale": "^3.0.2",
+    "@ossy/manifest": "^3.0.2",
+    "@ossy/package-catalog": "^3.0.2",
+    "@ossy/pages": "^3.0.2",
+    "@ossy/platform": "^3.0.2",
+    "@ossy/resources": "^3.0.2",
+    "@ossy/router": "^3.0.2",
+    "@ossy/router-react": "^3.0.2",
+    "@ossy/schema": "^3.0.2",
+    "@ossy/sdk": "^3.0.2",
+    "@ossy/sdk-react": "^3.0.2",
+    "@ossy/themes": "^3.0.2",
+    "@ossy/workspaces": "^3.0.2",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "^7.0.0",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -96,5 +97,5 @@
     "README.md",
     "tsconfig.json"
   ],
-  "gitHead": "4a70ec216448680d2fddc57b2a8a0077489720ae"
+  "gitHead": "f0a8af3c370bbaffe4f7388c14f9345a5c6c56e5"
 }

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

@@ -1,36 +1 @@
-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'
+export * from '@ossy/manifest/build-actions-schema'

package/src/manifest/build-capabilities.js

@@ -1,190 +1 @@
-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)),
-  }
-}
+export * from '@ossy/manifest/build-capabilities'

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

@@ -1,121 +1 @@
-/**
- * @param {string} packageName npm package name (e.g. `@ossy/booking`).
- * @returns {string} URL slug (e.g. `booking`).
- */
-export function packageNameToSlug (packageName) {
-  const slash = packageName.indexOf('/')
-  return slash === -1 ? packageName : packageName.slice(slash + 1)
-}
-
-/**
- * @param {string} slug URL slug (e.g. `booking`).
- * @returns {string} Scoped package name (e.g. `@ossy/booking`).
- */
-export function slugToPackageName (slug) {
-  return `@ossy/${slug}`
-}
-
-/**
- * @param {object} manifest Loaded manifest from `@ossy/platform` `loadManifest`.
- * @returns {{ packages: Array<object> }} Grouped, JSON-serializable package summary.
- */
-export function buildManifestSummary (manifest) {
-  /** @type {Map<string, object>} */
-  const groups = new Map()
-
-  const ensure = (pkg) => {
-    if (!groups.has(pkg)) {
-      groups.set(pkg, {
-        package: pkg,
-        slug: packageNameToSlug(pkg),
-        pages: [],
-        apis: [],
-        actions: [],
-        components: [],
-        schemas: [],
-        tasks: [],
-        integrations: [],
-        emails: [],
-        aggregates: [],
-      })
-    }
-    return groups.get(pkg)
-  }
-
-  const add = (pkg, key, item) => {
-    ensure(pkg || '@ossy/app')[key].push(item)
-  }
-
-  for (const page of manifest.pages || []) {
-    add(page.package, 'pages', {
-      id: page.id,
-      path: page.path,
-      ...(page.title ? { title: page.title } : {}),
-    })
-  }
-
-  for (const api of manifest.apis || []) {
-    add(api.package, 'apis', { id: api.id, path: api.path })
-  }
-
-  for (const action of manifest.actions || []) {
-    add(action.package, 'actions', {
-      id: action.id,
-      ...(action.access ? { access: action.access } : {}),
-    })
-  }
-
-  for (const component of manifest.components || []) {
-    add(component.package, 'components', { id: component.id })
-  }
-
-  for (const template of manifest.schemas || []) {
-    add(template.package, 'schemas', {
-      id: template.id,
-      ...(template.title ? { title: template.title } : {}),
-    })
-  }
-
-  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 || []) {
-    add(integration.package, 'integrations', {
-      id: integration.id,
-      ...(integration.credentials?.length ? { credentials: integration.credentials } : {}),
-    })
-  }
-
-  for (const email of manifest.emails || []) {
-    add(email.package, 'emails', { id: email.id })
-  }
-
-  for (const aggregate of manifest.aggregates || []) {
-    add(aggregate.package, 'aggregates', { id: aggregate.id })
-  }
-
-  const packages = Array.from(groups.values())
-    .sort((a, b) => a.package.localeCompare(b.package))
-
-  for (const pkg of packages) {
-    for (const key of Object.keys(pkg)) {
-      if (Array.isArray(pkg[key])) {
-        pkg[key].sort((a, b) => a.id.localeCompare(b.id))
-      }
-    }
-  }
-
-  const definitions =
-    manifest.definitions && typeof manifest.definitions === 'object' && !Array.isArray(manifest.definitions)
-      ? manifest.definitions
-      : {}
-
-  return { packages, definitions }
-}
+export * from '@ossy/manifest/build-manifest-summary'

package/src/manifest/discover-package-definitions.js

@@ -1,100 +1 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-import { packageNameToSlug } from './build-manifest-summary.js'
-import { serializePackageDefinition } from './serialize-package-definition.js'
-
-/**
- * @param {string} projectRoot
- * @returns {string[]}
- */
-function collectNodeModulesDirs (projectRoot) {
-  const dirs = []
-  let current = projectRoot
-  while (true) {
-    const nm = path.join(current, 'node_modules')
-    if (fs.existsSync(nm) && fs.statSync(nm).isDirectory()) dirs.push(nm)
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return dirs
-}
-
-/**
- * Load `Definition.js` from disk only — never import the package main entry,
- * which may pull CLI side effects (e.g. `@ossy/cli` runs on import).
- *
- * @param {string} pkgDir
- * @param {object} pkg
- * @returns {Promise<object | null>}
- */
-async function loadPackageDefinition (pkgDir, pkg) {
-  if (!pkg.ossy?.src) return null
-
-  const defPath = path.join(pkgDir, pkg.ossy.src, 'Definition.js')
-  if (!fs.existsSync(defPath)) return null
-
-  try {
-    const mod = await import(pathToFileURL(defPath).href + `?t=${Date.now()}`)
-    if (mod?.Definition && typeof mod.Definition === 'object') {
-      return mod.Definition
-    }
-  } catch {
-    // skip packages without a readable Definition
-  }
-
-  return null
-}
-
-/**
- * Discover `Definition.js` from installed `@ossy/*` packages.
- *
- * @param {string} projectRoot Absolute path to the consuming app root.
- * @returns {Promise<Record<string, object>>} Map keyed by package slug.
- */
-export async function discoverPackageDefinitions (projectRoot) {
-  const nmDirs = collectNodeModulesDirs(projectRoot)
-  /** @type {Record<string, object>} */
-  const definitions = {}
-  const seen = new Set()
-
-  const tryPackageDir = async (pkgDir) => {
-    const real = fs.realpathSync(pkgDir)
-    if (seen.has(real)) return
-    seen.add(real)
-
-    const pkgJsonPath = path.join(pkgDir, 'package.json')
-    if (!fs.existsSync(pkgJsonPath)) return
-
-    let pkg
-    try {
-      pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'))
-    } catch {
-      return
-    }
-
-    const name = typeof pkg.name === 'string' ? pkg.name.trim() : ''
-    if (!name.startsWith('@ossy/')) return
-
-    const slug = packageNameToSlug(name)
-    if (!slug || definitions[slug]) return
-
-    const raw = await loadPackageDefinition(real, pkg)
-    const serialized = serializePackageDefinition(raw)
-    if (serialized) definitions[slug] = serialized
-  }
-
-  for (const nmDir of nmDirs) {
-    const scopeDir = path.join(nmDir, '@ossy')
-    if (!fs.existsSync(scopeDir) || !fs.statSync(scopeDir).isDirectory()) continue
-
-    for (const entry of fs.readdirSync(scopeDir, { withFileTypes: true })) {
-      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
-      await tryPackageDir(path.join(scopeDir, entry.name))
-    }
-  }
-
-  return definitions
-}
+export * from '@ossy/manifest/discover-package-definitions'

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

@@ -1,29 +1 @@
-/**
- * Pick JSON-serializable Definition fields for manifest / SSR bootstrap.
- * Definition holds module presentation metadata only — capabilities live in manifestSummary.
- *
- * @param {object | null | undefined} definition
- * @returns {object | null}
- */
-export function serializePackageDefinition (definition) {
-  if (!definition || typeof definition !== 'object' || Array.isArray(definition)) return null
-
-  /** @type {Record<string, unknown>} */
-  const out = {}
-
-  if (typeof definition.id === 'string' && definition.id.trim()) out.id = definition.id.trim()
-  if (typeof definition.title === 'string' && definition.title.trim()) out.title = definition.title.trim()
-  if (typeof definition.description === 'string' && definition.description.trim()) {
-    out.description = definition.description.trim()
-  }
-  if (typeof definition.icon === 'string' && definition.icon.trim()) out.icon = definition.icon.trim()
-  if (typeof definition.navOrder === 'number' && Number.isFinite(definition.navOrder)) {
-    out.navOrder = definition.navOrder
-  }
-  if (definition.entitlementRequired === false) out.entitlementRequired = false
-  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
-}
+export * from '@ossy/manifest/serialize-package-definition'

package/src/shell/DevPagesPanel.jsx

@@ -3,7 +3,7 @@ import { Button, Text, View } from '@ossy/design-system'
 import { useRouter } from '@ossy/router-react'
 import { useApp } from './AppContext.js'
 import { formatPagePaths, groupPagesByFeature } from './devPagesUtils.js'
-import { packageNameToSlug } from '../manifest/build-manifest-summary.js'
+import { packageNameToSlug } from '@ossy/manifest/build-manifest-summary'
 
 const monoStyle = {
   fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace',

package/src/shell/buildSidebarNav.js

@@ -1,6 +1,9 @@
 import { slugToDisplayName } from '@ossy/package-catalog'
 import { isServiceEntitled } from '@ossy/workspaces/entitlements'
 import { resolveWorkspaceServices } from './resolveWorkspaceServices.js'
+import { resolvePackageHomePageId } from './resolvePackageHomePageId.js'
+
+export { resolvePackageHomePageId }
 
 /**
  * @typedef {object} SidebarShellItem
@@ -19,38 +22,8 @@ import { resolveWorkspaceServices } from './resolveWorkspaceServices.js'
  */
 
 /**
- * Pick the package "home" page from manifest pages.
- * Convention: slug plus "/home", then any page id ending in "/home", then shortest route path.
- *
- * @param {Array<{ id?: string, path?: string | Record<string, string> }>} pages
- * @param {string} slug
- * @returns {string | null}
- */
-export function resolvePackageHomePageId (pages, slug) {
-  const list = (pages || []).filter((page) => page?.id)
-  if (!list.length) return null
-
-  const conventional = list.find((page) => page.id === `${slug}/home`)
-  if (conventional) return conventional.id
-
-  const anyHome = list.find((page) => page.id === 'home' || page.id.endsWith('/home'))
-  if (anyHome) return anyHome.id
-
-  const pathLength = (page) => {
-    const path = page.path
-    if (typeof path === 'string') return path.length
-    if (path && typeof path === 'object') {
-      return Math.min(...Object.values(path).map((p) => (typeof p === 'string' ? p.length : 999)))
-    }
-    return 999
-  }
-
-  const byPath = [...list].sort((a, b) => pathLength(a) - pathLength(b) || a.id.localeCompare(b.id))
-  return byPath[0].id
-}
-
-/**
- * Build entitlement-filtered sidebar navigation — one link per entitled package home.
+ * Build entitlement-filtered sidebar navigation — one link per entitled package
+ * that registers a `{slug}/home` page.
  *
  * @param {{
  *   manifestSummary?: { packages?: Array<{ slug?: string, package?: string, pages?: Array<{ id: string, title?: string, path?: string | Record<string, string> }> }> }

package/src/shell/index.js

@@ -8,7 +8,8 @@ export { WorkspaceAppSettingsSync } from './WorkspaceAppSettingsSync.jsx'
 export { resolveEndpoints } from './resolveEndpoints.js'
 export { resolveWorkspaceServices } from './resolveWorkspaceServices.js'
 export { useCompactShellLayout } from './useCompactShellLayout.js'
-export { buildSidebarNav, resolvePackageHomePageId } from './buildSidebarNav.js'
+export { buildSidebarNav } from './buildSidebarNav.js'
+export { resolvePackageHomePageId } from './resolvePackageHomePageId.js'
 export { shellSlotUnset, shellSlotViewId, coerceShellSlotSpec } from '../../runtime/merge-shell-slots.js'
 export { ThemeSelect } from './ThemeSelect.jsx'
 export { LanguageSelect } from './LanguageSelect.jsx'

package/src/shell/resolvePackageHomePageId.js

@@ -0,0 +1,14 @@
+/**
+ * Pick the package home page for sidebar nav.
+ * Only `{slug}/home` qualifies — no fallback to other pages.
+ *
+ * @param {Array<{ id?: string }> | undefined} pages
+ * @param {string} slug
+ * @returns {string | null}
+ */
+export function resolvePackageHomePageId (pages, slug) {
+  if (!slug) return null
+  const homeId = `${slug}/home`
+  const match = (pages || []).find((page) => page?.id === homeId)
+  return match ? homeId : null
+}

package/src/manifest/action-id-to-tool-name.js

@@ -1,29 +0,0 @@
-/**
- * Derive MCP tool name from platform action id.
- *
- * @example
- * actionIdToToolName('@ossy/resources/actions/list') // 'ossy_resources_list'
- *
- * @param {string} actionId
- * @returns {string}
- */
-export function actionIdToToolName (actionId) {
-  const parts = actionId.split('/')
-  if (parts.length >= 4 && parts[0].startsWith('@') && parts[2] === 'actions') {
-    const provider = parts[0].slice(1)
-    return `${provider}_${parts[1]}_${parts[3]}`.replace(/-/g, '_')
-  }
-  return `ossy_${actionId.replace(/^@/, '').replace(/\//g, '_').replace(/-/g, '_')}`
-}
-
-/**
- * @param {string} actionId
- * @returns {string}
- */
-export function humanizeActionId (actionId) {
-  const intent = actionId.split('/').pop() || actionId
-  return intent
-    .split('-')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(' ')
-}

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

@@ -1,220 +0,0 @@
-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/template-to-json-schema.js

@@ -1,103 +0,0 @@
-/**
- * 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 }
-}