Mount every external bundle layer as a cordis:contained-group entry `bundle/<package>` whose rows carry a `<package>/<id>` prefix, so one community bundle that no longer loads records a failure in the root `pluginFailures` registry instead of rejecting the whole Loader transaction, and two bundles may declare the same row id. Classify layers by origin (`builtin` for the template bundle and `dsh.profile.firstParty`, `external` for profile dependencies) and let `dsh.bundle.stage: boot` or `dsh.profile.stages` opt a bundle out of isolation when it provides a service built-in rows inject; a built-in row left pending beside an isolated bundle still fails boot and names the bundle. Keep `installFailLoud` for the boot transaction only and install runtime guards afterwards: an unhandled rejection is reported and contained, an uncaught exception is reported and exits. Report nested fiber failures under built-in entries as advisory lines. Provide `ctx.profileRuntime` from the launcher (layers with trust and stage, row origin, user-disabled rows, recomposition through the root include) and probe installed packages in a child process (`probePackage`, cached under `profiles/<name>/.dsh-plugins/`). Split installation from enablement in `reconcileInstalledBundles`; the CLI keeps install-means-enable. The plugin inventory now reports `trust`, `package`, `disabledBy`, and `failure` per row and lists rows only the failure registry knows.
135 lines
5.3 KiB
TypeScript
135 lines
5.3 KiB
TypeScript
/** Read-only projection of the current Cordis Loader plugin entries. */
|
|
|
|
import type { Context, FiberState } from '@deepseek-ai/cordis'
|
|
import type {} from '@deepseek-ai/cordis-plugin-loader'
|
|
// Type-only: the optional agent-preset roster resolved through `ctx.get`.
|
|
import type {} from '@deepseek-ai/dsh-agent-presets'
|
|
// Type-only: the optional profile runtime and contained-failure registry the
|
|
// boot glue provides, both resolved through `ctx.get`.
|
|
import type {} from '@deepseek-ai/dsh-app-boot'
|
|
import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol'
|
|
// Typert-generated ./typert and ./remote artifacts import Zod at runtime.
|
|
import type {} from 'zod'
|
|
import type {
|
|
AgentPresetPluginGroup,
|
|
PluginEntryId,
|
|
PluginFiberPhase,
|
|
PluginInventoryEntry,
|
|
PluginInventorySnapshot,
|
|
PluginPackageRef,
|
|
} from './types.ts'
|
|
|
|
export type * from './types.ts'
|
|
|
|
/** Brand an existing Loader-tree entry id at the owning boundary. */
|
|
function pluginEntryId(value: string): PluginEntryId {
|
|
return value as PluginEntryId
|
|
}
|
|
|
|
/** The wire view of a row's package origin. */
|
|
function packageRef(origin: { packageName: string; version?: string; originalId?: string }): PluginPackageRef {
|
|
return {
|
|
name: origin.packageName,
|
|
...origin.version === undefined ? {} : { version: origin.version },
|
|
...origin.originalId === undefined ? {} : { originalId: origin.originalId },
|
|
}
|
|
}
|
|
|
|
/** Runtime mirror: FiberState is a cross-package const enum. */
|
|
const FIBER_STATE = {
|
|
PENDING: 0 as FiberState.PENDING,
|
|
LOADING: 1 as FiberState.LOADING,
|
|
ACTIVE: 2 as FiberState.ACTIVE,
|
|
FAILED: 3 as FiberState.FAILED,
|
|
DISPOSED: 4 as FiberState.DISPOSED,
|
|
UNLOADING: 5 as FiberState.UNLOADING,
|
|
} as const
|
|
|
|
/** Complete public projection of Cordis Fiber states. */
|
|
const FIBER_PHASE = {
|
|
[FIBER_STATE.PENDING]: 'pending',
|
|
[FIBER_STATE.LOADING]: 'loading',
|
|
[FIBER_STATE.ACTIVE]: 'active',
|
|
[FIBER_STATE.FAILED]: 'failed',
|
|
[FIBER_STATE.DISPOSED]: null,
|
|
[FIBER_STATE.UNLOADING]: 'unloading',
|
|
} as const satisfies Record<FiberState, PluginFiberPhase>
|
|
|
|
/** Remote-only service exposing the Loader's current non-group entry state. */
|
|
export class PluginInventoryGateway extends TypertRemoteService {
|
|
static inject = ['loader']
|
|
|
|
constructor(ctx: Context) {
|
|
super(ctx, 'pluginInventory')
|
|
}
|
|
|
|
/**
|
|
* Read the Loader directly on every call. Cordis's internal plugin/status
|
|
* events already maintain Entry.fiber and Fiber.state, so a second cache
|
|
* would only add another lifecycle truth to keep synchronized.
|
|
*
|
|
* When an agent-preset roster is composed, the snapshot also carries each
|
|
* preset's composition rows, because those rows — not the Loader's own
|
|
* entries — are where a deployment that mounts the roster runs its
|
|
* model-facing plugins.
|
|
* @returns Current non-group Loader entries in Loader order, with per-preset
|
|
* compositions when a roster is composed.
|
|
*/
|
|
@Remote('list')
|
|
async list(): Promise<PluginInventorySnapshot> {
|
|
const entries: PluginInventoryEntry[] = []
|
|
const runtime = this.ctx.get('profileRuntime')
|
|
const failures = this.ctx.get('pluginFailures')
|
|
const userDisabled = runtime?.userDisabledRowIds() ?? new Set<string>()
|
|
const listed = new Set<string>()
|
|
for (const entry of this.ctx.loader.entries()) {
|
|
if (entry.options.group) continue
|
|
listed.add(entry.id)
|
|
// Provenance and user patches address rows by the id the composition
|
|
// declares; the tree-wide `entry.id` adds the owning include's prefix.
|
|
const origin = runtime?.originOf(entry.options.id)
|
|
const enabled = !entry.disabled
|
|
const failure = failures?.get(entry.id)
|
|
entries.push({
|
|
entryId: pluginEntryId(entry.id),
|
|
moduleName: entry.options.name,
|
|
enabled,
|
|
fiberPhase: entry.fiber === undefined ? null : FIBER_PHASE[entry.fiber.state],
|
|
trust: origin?.trust ?? 'builtin',
|
|
...origin === undefined ? {} : { package: packageRef(origin) },
|
|
...enabled ? {} : { disabledBy: userDisabled.has(entry.options.id) ? 'user' as const : 'composition' as const },
|
|
...failure === undefined ? {} : { failure: { stage: failure.stage, message: failure.message } },
|
|
})
|
|
}
|
|
// A row an isolated bundle failed to start is gone from the tree; the
|
|
// registry is its only record, and the list must still show it.
|
|
for (const failure of failures?.list() ?? []) {
|
|
if (listed.has(failure.entryId)) continue
|
|
const origin = runtime?.originOf(failure.rowId)
|
|
entries.push({
|
|
entryId: pluginEntryId(failure.entryId),
|
|
moduleName: failure.moduleName,
|
|
enabled: true,
|
|
fiberPhase: 'failed',
|
|
trust: origin?.trust ?? 'external',
|
|
...origin === undefined ? {} : { package: packageRef(origin) },
|
|
failure: { stage: failure.stage, message: failure.message },
|
|
})
|
|
}
|
|
const presets = this.ctx.get('agentPresets')
|
|
if (presets === undefined) return { entries }
|
|
const agentPresets: AgentPresetPluginGroup[] = (await presets.compositionInventory()).map(
|
|
composition => ({
|
|
...composition,
|
|
rows: composition.rows.map(({ fiberState, ...row }) => ({
|
|
...row,
|
|
fiberPhase: fiberState === undefined ? null : FIBER_PHASE[fiberState],
|
|
})),
|
|
}),
|
|
)
|
|
return { entries, agentPresets }
|
|
}
|
|
}
|
|
|
|
export default PluginInventoryGateway
|