refactor: fold definition-services into ctx.services.install()

install()'s resolveFrom now also accepts an npm package name (the
declaring plugin's packageName), expanded to that package's location so
its declared services resolve against the plugin's own dependencies —
adapters and the hub queue def.services with a plain loop, and the
installDefinitionServices helper (whose awaited form could deadlock
pre-barrier) is gone.

Author: antfubot

packages/devframe/src/adapters/build.ts

@@ -14,7 +14,6 @@ import {
   DEVFRAME_RPC_DUMP_MANIFEST_FILENAME,
 } from '../constants'
 import { createHostContext } from '../node/context'
-import { installDefinitionServices } from '../node/definition-services'
 import { diagnostics } from '../node/diagnostics'
 import { createH3DevframeHost } from '../node/host-h3'
 import { collectStaticRpcDump } from '../rpc/dump/static'
@@ -89,7 +88,8 @@ export async function createBuild(d: DevframeDefinition, options: CreateBuildOpt
     mode: 'build',
     host,
   })
-  await installDefinitionServices(ctx, d)
+  for (const input of d.services ?? [])
+    void ctx.services.install(input, { resolveFrom: d.packageName })
   await d.setup(ctx)
   await ctx.services.ready()
 

packages/devframe/src/adapters/embedded.ts

@@ -1,6 +1,5 @@
 import type { DevframeNodeContext } from '../types/context'
 import type { DevframeDefinition } from '../types/devframe'
-import { installDefinitionServices } from '../node/definition-services'
 
 export interface CreateEmbeddedOptions {
   /** Target context the devframe is registered into. Required. */
@@ -20,6 +19,7 @@ export async function createEmbedded(d: DevframeDefinition, options: CreateEmbed
   // Declarative services queue before setup; the owning host fires the
   // `ctx.services.ready()` barrier (post-barrier registration installs
   // immediately).
-  await installDefinitionServices(options.ctx, d)
+  for (const input of d.services ?? [])
+    void options.ctx.services.install(input, { resolveFrom: d.packageName })
   await d.setup(options.ctx)
 }

packages/devframe/src/adapters/initiate.ts

@@ -16,7 +16,6 @@ import { resolve } from 'pathe'
 import { joinURL } from 'ufo'
 import { DEVFRAME_CONNECTION_META_FILENAME } from '../constants'
 import { createHostContext } from '../node/context'
-import { installDefinitionServices } from '../node/definition-services'
 import { diagnostics } from '../node/diagnostics'
 import { createH3DevframeHost } from '../node/host-h3'
 import { createInstanceShell, resolveInstanceRegister } from '../node/instance-shell'
@@ -290,7 +289,10 @@ export function initDevframe(
         host: hostImpl,
       })
       const setupInfo: DevframeSetupInfo = { flags: options.flags ?? {} }
-      await installDefinitionServices(context, def)
+      // Declarative services queue ahead of setup (their promises resolve at
+      // the ready() barrier below), resolving against the plugin's own deps.
+      for (const input of def.services ?? [])
+        void context.services.install(input, { resolveFrom: def.packageName })
       await def.setup(context, setupInfo)
       await context.services.ready()
 

packages/devframe/src/adapters/mcp/build-server.ts

@@ -8,7 +8,6 @@ import { Server } from '@modelcontextprotocol/server'
 import { createHostContext } from 'devframe/node'
 import { toAgentToolName } from 'devframe/utils/agent-tool-name'
 import { join } from 'pathe'
-import { installDefinitionServices } from '../../node/definition-services'
 import { diagnostics } from '../../node/diagnostics'
 import { formatMcpError, stringifyForMcp } from './stringify'
 import { argsToJsonSchema, returnToJsonSchema } from './to-json-schema'
@@ -117,7 +116,8 @@ export async function createMcpServer(
     mode: 'dev',
     host,
   })
-  await installDefinitionServices(ctx, definition)
+  for (const input of definition.services ?? [])
+    void ctx.services.install(input, { resolveFrom: definition.packageName })
   await definition.setup(ctx)
   await ctx.services.ready()
 

packages/devframe/src/internal/index.ts

@@ -32,13 +32,9 @@
 // - `diagnostics` — devframe core's structured diagnostics instance
 //   (`DF00xx`), so a first-party integration built outside this package can
 //   report against the same registered codes instead of minting its own.
-// - `installDefinitionServices` — queues a definition's declarative wire
-//   services ahead of its `setup`; a host that installs devframes itself
-//   (the hub's `installDevframe`) calls it exactly like the adapters do.
 export { normalizeBasePath, resolveBasePath } from '../adapters/_shared'
 export { coerceAgentPositionalArgs } from '../node/agent-args'
 export type { AgentArgsFallback } from '../node/agent-args'
-export { installDefinitionServices } from '../node/definition-services'
 export { diagnostics } from '../node/diagnostics'
 export { DevframeAgentHost } from '../node/host-agent'
 export * from '../node/host-h3'

packages/devframe/src/node/__tests__/services.test.ts

@@ -208,6 +208,20 @@ describe('wire services (install / ready barrier)', () => {
     await expect(ctx.services.ready()).rejects.toThrowError(/Failed to import the required service package/)
   })
 
+  it('resolves a package-name resolveFrom through that package\'s own dependencies', async () => {
+    const { ctx, dir } = await createCtx()
+    // A "plugin" package whose own node_modules carries the service — the
+    // declarative flow passes the plugin's packageName as resolveFrom.
+    const pluginDir = join(dir, 'node_modules', '@test', 'plugin')
+    mkdirSync(pluginDir, { recursive: true })
+    writeFileSync(join(pluginDir, 'package.json'), JSON.stringify({ name: '@test/plugin', version: '0.0.0' }))
+    writeFakeServicePackage(pluginDir, '@test/nested-svc', '1.0.0')
+
+    const install = ctx.services.install({ package: '@test/nested-svc' }, { resolveFrom: '@test/plugin' })
+    await ctx.services.ready()
+    await expect(install).resolves.toEqual({ imported: true, options: undefined })
+  })
+
   it('imports a descriptor package relative to resolveFrom and installs its factory', async () => {
     const { ctx, dir } = await createCtx()
     writeFakeServicePackage(dir, '@test/imported-svc', '2.0.0')

packages/devframe/src/node/definition-services.ts

@@ -8,10 +8,11 @@ import type {
   DevframeServicesHost,
   DevframeServicesState,
 } from 'devframe/types'
+import process from 'node:process'
 import { DEVFRAME_SERVICES_STATE_KEY } from 'devframe/constants'
 import { createDebug } from 'obug'
 import { diagnostics } from './diagnostics'
-import { importServicePackage, satisfiesVersionRange, shallowMergeOptionSets } from './services-install'
+import { expandResolveFrom, importServicePackage, satisfiesVersionRange, shallowMergeOptionSets } from './services-install'
 
 const debug = createDebug('devframe:services')
 
@@ -184,10 +185,11 @@ export class DevframeServicesHostImpl implements DevframeServicesHost {
     if (!def) {
       const descriptors = entries.map(entry => entry.input as DevframeServiceDescriptor)
       const required = descriptors.some(descriptor => descriptor.required === true)
+      const cwd = this.context?.cwd ?? process.cwd()
       const resolveFroms = [
-        ...entries.map(entry => entry.resolveFrom),
+        ...entries.map(entry => entry.resolveFrom && expandResolveFrom(entry.resolveFrom, cwd)),
         this.context?.workspaceRoot,
-        this.context?.cwd,
+        cwd,
       ]
       let mod: unknown
       try {

packages/devframe/src/node/host-services.ts

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
-import { join } from 'pathe'
+import { isAbsolute, join } from 'pathe'
 
 /**
  * Turn a `resolveFrom` value (a file path, a file URL like `import.meta.url`,
@@ -18,6 +18,29 @@ function toRequireBase(resolveFrom: string): string {
   return join(resolveFrom, '_devframe_resolve.js')
 }
 
+/**
+ * Normalize an `install()` `resolveFrom` into a resolution base. Paths and
+ * file URLs pass through; a bare npm package name (the common case: the
+ * declaring plugin's `packageName`) resolves to that package's location from
+ * `cwd`, so a service it declares resolves against the plugin's own
+ * dependencies. An unresolvable package name reads as no base (the caller's
+ * workspace fallbacks apply).
+ */
+export function expandResolveFrom(resolveFrom: string, cwd: string): string | undefined {
+  if (resolveFrom.startsWith('file://') || resolveFrom.startsWith('.') || isAbsolute(resolveFrom))
+    return resolveFrom
+  const require = createRequire(join(cwd, '_devframe_resolve.js'))
+  try {
+    return require.resolve(`${resolveFrom}/package.json`)
+  }
+  catch {}
+  try {
+    return require.resolve(resolveFrom)
+  }
+  catch {}
+  return undefined
+}
+
 /**
  * Import a service package's module, trying each `resolveFrom` candidate in
  * order (so a plugin-declared service resolves against the plugin's own

packages/devframe/src/node/services-install.ts

@@ -220,10 +220,11 @@ export interface DevframeServicesHost {
    * already-installed package returns the existing API (a warning is
    * emitted when the late install carried options, since they're ignored).
    *
-   * `resolveFrom` is the path or file URL (e.g. `import.meta.url`) a
-   * descriptor's package resolves **from**, so a plugin-declared service
-   * resolves against the plugin's own dependencies; it falls back to the
-   * context's `workspaceRoot`.
+   * `resolveFrom` is where a descriptor's package resolves **from**: a path
+   * or file URL (e.g. `import.meta.url`), or an npm package name — typically
+   * the declaring plugin's `packageName`, so its declared services resolve
+   * against the plugin's own dependencies. Falls back to the context's
+   * `workspaceRoot`.
    */
   install: <API = unknown, Options = any>(
     input: DevframeServiceInput<API, Options>,