@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/agents/definition.d.ts

@@ -1,3 +1,4 @@
+import { type ModelParameter } from "@capybara-hq/plugin-sdk";
 import { z } from "zod";
 /** 模型引用：供应商插件名 + 模型 id。 */
 export declare const ModelRef: z.ZodObject<{
@@ -196,3 +197,10 @@ export type AgentDefinition = z.infer<typeof AgentDefinitionSchema>;
  * connector 形（C27）。其余字段原样保留；没有旧形引用时返回原对象。
  */
 export declare function normalizeStoredDefinition(def: unknown): AgentDefinition;
+/** 按模型声明严格校验一组参数，返回 `{ path: "<field>.<key>", message }[]`（评测候选也用它）。 */
+export declare function paramIssues(field: string, decl: ModelParameter[], params: Record<string, unknown>): {
+    path: string;
+    message: string;
+}[];
+/** Roster entries an agent may list (spec §4.3), general-purpose included. */
+export declare const SUBAGENT_ROSTER_MAX = 20;

package/dist/agents/definition.js

@@ -1,3 +1,4 @@
+import { validateParams } from "@capybara-hq/plugin-sdk";
 import { z } from "zod";
 /** 模型引用：供应商插件名 + 模型 id。 */
 export const ModelRef = z.object({ provider: z.string(), model: z.string() });
@@ -150,3 +151,10 @@ export function normalizeStoredDefinition(def) {
     }
     return { ...d, tools: tools.map(normalizeToolRef) };
 }
+/** 按模型声明严格校验一组参数，返回 `{ path: "<field>.<key>", message }[]`（评测候选也用它）。 */
+export function paramIssues(field, decl, params) {
+    const r = validateParams(decl, params);
+    return r.ok ? [] : r.issues.map((i) => ({ path: `${field}.${i.key}`, message: i.message }));
+}
+/** Roster entries an agent may list (spec §4.3), general-purpose included. */
+export const SUBAGENT_ROSTER_MAX = 20;

package/dist/agents/models.controller.d.ts

@@ -1,5 +1,5 @@
 import type { ModelInfo } from "@capybara-hq/plugin-sdk";
-import type { ProviderRegistry } from "../runtime/providers.js";
+import { ProviderRegistry } from "../runtime/providers.js";
 /** 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。 */
 export declare class ModelsController {
     private readonly registry;

package/dist/agents/models.controller.js

@@ -8,8 +8,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, Inject } from "@nestjs/common";
-import { PROVIDER_REGISTRY } from "../http/tokens.js";
 import { OrgAction } from "../orgs/org.guard.js";
+import { ProviderRegistry } from "../runtime/providers.js";
 /** 可选模型（`/api/v1/orgs/:orgId/models`）：已安装的模型供应商及其模型，列表缓存在 Redis。 */
 let ModelsController = class ModelsController {
     registry;
@@ -26,6 +26,6 @@ __decorate([
 ], ModelsController.prototype, "list", null);
 ModelsController = __decorate([
     Controller("api/v1/orgs/:orgId/models"),
-    __param(0, Inject(PROVIDER_REGISTRY))
+    __param(0, Inject(ProviderRegistry))
 ], ModelsController);
 export { ModelsController };

package/dist/agents/templates.controller.d.ts

@@ -1,5 +1,5 @@
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { AgentTemplatesService, AgentTemplateView } from "./templates.js";
+import { AgentTemplatesService, type AgentTemplateView } from "./templates.js";
 /**
  * The org's agent templates installed from plugins (`/api/v1/orgs/:orgId/agent-templates`, phase C
  * spec §17): the agent page lists them to select as sub-agents. Read with `agents.create`, the

package/dist/agents/templates.controller.js

@@ -8,8 +8,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, Inject } from "@nestjs/common";
-import { AGENT_TEMPLATES } from "../http/tokens.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { AgentTemplatesService } from "./templates.js";
 /**
  * The org's agent templates installed from plugins (`/api/v1/orgs/:orgId/agent-templates`, phase C
  * spec §17): the agent page lists them to select as sub-agents. Read with `agents.create`, the
@@ -32,6 +32,6 @@ __decorate([
 ], AgentTemplatesController.prototype, "list", null);
 AgentTemplatesController = __decorate([
     Controller("api/v1/orgs/:orgId/agent-templates"),
-    __param(0, Inject(AGENT_TEMPLATES))
+    __param(0, Inject(AgentTemplatesService))
 ], AgentTemplatesController);
 export { AgentTemplatesController };

package/dist/agents/templates.d.ts

@@ -1,7 +1,6 @@
 import type { AgentTemplate, AgentTemplateTier } from "@capybara-hq/plugin-sdk";
-import type { Transaction } from "kysely";
-import type { KernelDatabase, KernelDb, SourceFormat } from "../db/kernel-schema.js";
-type Trx = Transaction<KernelDatabase>;
+import type { KernelSchemaDb, SourceFormat } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
 /**
  * Agent templates installed in an org from plugins (sub-agents spec §16): `agent_templates` (one
  * live row per org, plugin and name) and `agent_template_versions` (the parsed template). Plugin
@@ -35,7 +34,7 @@ export interface TemplateRow {
     catalogVersion: string | null;
 }
 /** The live templates of `ids` in the org (deleted and foreign ids are left out), by id. */
-export declare function loadTemplates(db: KernelDb | Trx, orgId: string, ids: readonly string[]): Promise<Map<string, TemplateRow>>;
+export declare function loadTemplates(db: KernelSchemaDb, orgId: string, ids: readonly string[]): Promise<Map<string, TemplateRow>>;
 /** Reads the org's agent templates (consumed by the roster, the agent page and Task 19's API). */
 export declare class AgentTemplatesService {
     private readonly db;
@@ -63,7 +62,7 @@ export interface TemplateSource {
  * caller holds the org row lock): a new template (version 1, `created`), a new version of the live
  * one when its definition differs (`changed`, the version added), or nothing when it is equal.
  */
-export declare function putTemplateVersionIn(t: Trx, s: TemplateSource, template: AgentTemplate): Promise<{
+export declare function putTemplateVersionIn(t: KernelSchemaDb, s: TemplateSource, template: AgentTemplate): Promise<{
     id: string;
     version: number;
     created: boolean;
@@ -74,10 +73,9 @@ export declare function putTemplateVersionIn(t: Trx, s: TemplateSource, template
  * rolled back): the version row goes and the template is back at the version before. Returns
  * whether anything changed.
  */
-export declare function revertTemplateVersionIn(t: Trx, orgId: string, id: string, version: number): Promise<boolean>;
+export declare function revertTemplateVersionIn(t: KernelSchemaDb, orgId: string, id: string, version: number): Promise<boolean>;
 /**
  * Removes a template (soft delete: sub-agents already started keep their frozen definition, and
  * the roster skips it). Returns whether it was live.
  */
-export declare function softDeleteTemplateIn(t: Trx, orgId: string, id: string): Promise<boolean>;
-export {};
+export declare function softDeleteTemplateIn(t: KernelSchemaDb, orgId: string, id: string): Promise<boolean>;

package/dist/agents/templates.js

@@ -1,4 +1,15 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 import { randomUUID } from "node:crypto";
+import { Inject, Injectable } from "@nestjs/common";
+import { KernelDb } from "../infra/database/kernel-db.js";
 import { canonicalJson } from "../tools/registry.js";
 const baseQuery = (db, orgId) => db
     .selectFrom("agent_templates as t")
@@ -35,14 +46,14 @@ export async function loadTemplates(db, orgId, ids) {
     return new Map(rows.map((r) => [r.id, rowOf(r)]));
 }
 /** Reads the org's agent templates (consumed by the roster, the agent page and Task 19's API). */
-export class AgentTemplatesService {
+let AgentTemplatesService = class AgentTemplatesService {
     db;
     constructor(db) {
         this.db = db;
     }
     /** Every live template of the org, by plugin then name. */
     async listForOrg(orgId) {
-        const rows = await baseQuery(this.db, orgId)
+        const rows = await baseQuery(this.db.db, orgId)
             .orderBy("t.plugin_name")
             .orderBy("t.name")
             .execute();
@@ -65,7 +76,7 @@ export class AgentTemplatesService {
     /** A live template by id or by `<plugin>:<name>`; null when there is none. */
     async resolve(orgId, ref) {
         const i = ref.indexOf(":");
-        let q = baseQuery(this.db, orgId);
+        let q = baseQuery(this.db.db, orgId);
         q =
             i < 0
                 ? q.where("t.id", "=", ref)
@@ -76,7 +87,12 @@ export class AgentTemplatesService {
         const t = rowOf(r);
         return { id: t.id, version: t.version, plugin: t.plugin, template: t.template };
     }
-}
+};
+AgentTemplatesService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb))
+], AgentTemplatesService);
+export { AgentTemplatesService };
 /**
  * Writes `template` as the org's live template `<plugin>:<name>` in the caller's transaction (the
  * caller holds the org row lock): a new template (version 1, `created`), a new version of the live

package/dist/app.d.ts

@@ -0,0 +1,93 @@
+import "reflect-metadata";
+import type { BootstrapManifest } from "@capybara-hq/plugin-sdk";
+import type { INestApplicationContext } from "@nestjs/common";
+import type { NestFastifyApplication } from "@nestjs/platform-fastify";
+import type { ConfigSource } from "./config/load.js";
+import type { KernelConfig } from "./config/schema.js";
+import type { ConfigSourceKind } from "./config/sources.js";
+import { type KernelHttp } from "./http/app.js";
+import { type ShutdownSignalOptions } from "./infra/lifecycle/shutdown-signals.js";
+import type { KernelLogger } from "./log.js";
+import type { KernelOverride } from "./overrides.js";
+/** What {@link createKernelApp} takes besides the config. */
+export interface KernelAppOptions {
+    /** 配置来源；提供 `watch` 时启用热更新。 */
+    source?: ConfigSource;
+    /** 解析插件裸包名的目录，默认 `process.cwd()`；相对路径按当前 cwd 解析。 */
+    resolveFrom?: string;
+    /** Defaults to a logger built from `config.log` and `config.roles` (createConfiguredLogger). */
+    logger?: KernelLogger;
+    /** 热更新时与来源原始值合并的环境变量，默认 `process.env`。 */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * The bootstrap step (package ecosystem spec §7, startup bootstrap spec). When given, the start
+     * runs it (see `extensions/bootstrap.ts`) before loading extensions unless it is already done for
+     * the manifest, and refuses to start when it cannot complete a required entry. `dir`: the
+     * optional offline directory whose `*.tgz` files are matched to the entries by sha512 (a missing
+     * directory is an empty one); entries without a matching file are downloaded from
+     * `packages.npmRegistry`. Omitted: no bootstrap step (tests, unless they ask for it).
+     */
+    bootstrap?: {
+        dir?: string;
+    };
+    /** The bootstrap manifest; default the `bootstrap.json` shipped with the kernel package. */
+    bootstrapManifest?: BootstrapManifest;
+    /**
+     * Where each extension deployment config field of the startup config comes from (the
+     * `extensionConfigSources` returned by `loadConfigWithSources`); these fields are read-only in the
+     * admin console (D8). When omitted it is derived from `config.extensionConfig`: fields present in
+     * the environment are `env`, the rest take the `CAPYBARA_CONFIG_SOURCE` kind (file / nacos).
+     */
+    extensionConfigSources?: Record<string, Record<string, ConfigSourceKind>>;
+    /**
+     * The kernel's own tests' seams: values for the named seam tokens ({@link KernelOverride} lists
+     * every one), registered in a global module so the domain modules that resolve these optional
+     * tokens get them. Any other token is refused when the application is built.
+     */
+    overrides?: readonly KernelOverride[];
+}
+/**
+ * Builds the kernel application (one Nest application, root module {@link KernelModule}) and sets
+ * up its HTTP side, without initializing it: nothing connects and nothing starts. A failure
+ * releases what was created (Redis connections, the pool) before it is thrown. Internal (not
+ * exported from the package): {@link startKernelApp} and the kernel's own tests that need the
+ * application before its start; everything else uses {@link createKernelApp}.
+ */
+export declare function buildKernelApp(config: KernelConfig, options?: KernelAppOptions): Promise<NestFastifyApplication>;
+/**
+ * Closes a kernel application once (later calls get the same promise): the stop phases begin at
+ * once (`KernelLifecycle.stop`: readiness 503, the start aborted at its next checkpoint), next to
+ * `app.close()`, which runs the shutdown hooks (the stop phases are the same promise, then Redis
+ * and the pool). Use it to stop an application from {@link createKernelApp} /
+ * {@link startKernelApp} (tests, `@capybara-hq/testing`), so the stop begins before Nest's
+ * `onModuleDestroy` hooks run.
+ */
+export declare function closeKernelApp(app: NestFastifyApplication): Promise<void>;
+/**
+ * Creates the kernel application and runs its start sequence (nest kernel spec §4): Redis,
+ * migrations, the official marketplace, the bootstrap step, the extension load, the role parts,
+ * extension routes, the lifecycle reconcile and the config watch. Does not listen and installs no
+ * process-wide handler.
+ */
+export declare function createKernelApp(config: KernelConfig, options?: KernelAppOptions): Promise<NestFastifyApplication>;
+/**
+ * Builds the kernel application, installs the SIGTERM / SIGINT handlers
+ * ({@link handleShutdownSignals}), runs the start sequence and listens on `config.http.port`:
+ * nothing is served before the start sequence finished. The handlers are installed before the
+ * start, so a signal during it aborts the start at its next checkpoint and closes the application
+ * cleanly; this function then rejects once the signal path has exited (with 0). A second signal
+ * exits with 1 at once. A failed build or start is logged (`kernel start failed`) before it is
+ * thrown.
+ */
+export declare function startKernelApp(config: KernelConfig, options?: KernelAppOptions, signalOptions?: ShutdownSignalOptions): Promise<NestFastifyApplication>;
+/**
+ * The start half of {@link startKernelApp} for an application from {@link buildKernelApp}: installs
+ * the signal handlers, runs the start sequence and listens on `config.http.port`. Internal (not
+ * exported from the package): {@link startKernelApp} and the kernel's own tests that need the
+ * application before its start.
+ */
+export declare function startBuiltKernelApp(app: NestFastifyApplication, config: KernelConfig, signalOptions?: ShutdownSignalOptions): Promise<void>;
+/** The in-process HTTP of a kernel application (`inject`, the route list). */
+export declare function kernelAppHttp(app: INestApplicationContext): KernelHttp;
+/** The port a kernel application listens on; undefined before it listens and after the stop. */
+export declare function kernelAppPort(app: INestApplicationContext): number | undefined;

package/dist/app.js

@@ -0,0 +1,150 @@
+import "reflect-metadata";
+import { NestFactory } from "@nestjs/core";
+import { createKernelAdapter } from "./http/adapter.js";
+import { createHttpApp } from "./http/app.js";
+import { NestLogAdapter } from "./http/nest-logger.js";
+import { GracefulShutdown } from "./infra/lifecycle/graceful-shutdown.service.js";
+import { handleShutdownSignals, } from "./infra/lifecycle/shutdown-signals.js";
+import { setupSwagger } from "./infra/swagger/swagger.js";
+import { KernelModule } from "./kernel.module.js";
+import { KernelLifecycle } from "./lifecycle/kernel-lifecycle.js";
+import { createConfiguredLogger } from "./log-config.js";
+/**
+ * Builds the kernel application (one Nest application, root module {@link KernelModule}) and sets
+ * up its HTTP side, without initializing it: nothing connects and nothing starts. A failure
+ * releases what was created (Redis connections, the pool) before it is thrown. Internal (not
+ * exported from the package): {@link startKernelApp} and the kernel's own tests that need the
+ * application before its start; everything else uses {@link createKernelApp}.
+ */
+export async function buildKernelApp(config, options = {}) {
+    const logger = options.logger ?? createConfiguredLogger(config);
+    const app = await NestFactory.create(KernelModule.forRoot(config, { ...options, logger }), createKernelAdapter(config.http.trustProxy), { logger: new NestLogAdapter(logger), abortOnError: false });
+    const lifecycle = app.get(KernelLifecycle);
+    const gateway = lifecycle.gatewayRoutes();
+    try {
+        lifecycle.attachHttp(await createHttpApp({
+            log: logger,
+            servePlugins: config.roles.includes("api") || config.roles.includes("gateway"),
+            ...(gateway !== undefined && { gateway }),
+            replicaId: config.http.replicaId === undefined ? undefined : String(config.http.replicaId),
+            packageMaxBytes: config.packages.maxBytes,
+        }, app));
+        setupSwagger(app, config.http.swagger);
+    }
+    catch (e) {
+        // Nothing started: only release the connections (the stop phases are skipped)
+        lifecycle.releaseOnly();
+        await app.close();
+        throw e;
+    }
+    return app;
+}
+const closing = new WeakMap();
+/**
+ * Closes a kernel application once (later calls get the same promise): the stop phases begin at
+ * once (`KernelLifecycle.stop`: readiness 503, the start aborted at its next checkpoint), next to
+ * `app.close()`, which runs the shutdown hooks (the stop phases are the same promise, then Redis
+ * and the pool). Use it to stop an application from {@link createKernelApp} /
+ * {@link startKernelApp} (tests, `@capybara-hq/testing`), so the stop begins before Nest's
+ * `onModuleDestroy` hooks run.
+ */
+export function closeKernelApp(app) {
+    let p = closing.get(app);
+    if (p === undefined) {
+        p = Promise.all([app.get(KernelLifecycle).stop(), app.close()]).then(() => { });
+        closing.set(app, p);
+    }
+    return p;
+}
+/**
+ * Initializes a built kernel application: `init()` runs the start sequence
+ * (`KernelLifecycle.onApplicationBootstrap`). A failure (unless the shutdown began meanwhile) is
+ * logged; either way the application is closed (the stop phases, then Redis and the pool) before
+ * the error is thrown.
+ */
+async function initKernelApp(app) {
+    try {
+        await app.init();
+    }
+    catch (e) {
+        if (!app.get(GracefulShutdown).isShuttingDown()) {
+            app.get(KernelLifecycle).log.error("kernel start failed", { err: e });
+        }
+        await closeKernelApp(app);
+        throw e;
+    }
+}
+/**
+ * Creates the kernel application and runs its start sequence (nest kernel spec §4): Redis,
+ * migrations, the official marketplace, the bootstrap step, the extension load, the role parts,
+ * extension routes, the lifecycle reconcile and the config watch. Does not listen and installs no
+ * process-wide handler.
+ */
+export async function createKernelApp(config, options = {}) {
+    const app = await buildKernelApp(config, options);
+    await initKernelApp(app);
+    return app;
+}
+/**
+ * Builds the kernel application, installs the SIGTERM / SIGINT handlers
+ * ({@link handleShutdownSignals}), runs the start sequence and listens on `config.http.port`:
+ * nothing is served before the start sequence finished. The handlers are installed before the
+ * start, so a signal during it aborts the start at its next checkpoint and closes the application
+ * cleanly; this function then rejects once the signal path has exited (with 0). A second signal
+ * exits with 1 at once. A failed build or start is logged (`kernel start failed`) before it is
+ * thrown.
+ */
+export async function startKernelApp(config, options = {}, signalOptions = {}) {
+    const logger = options.logger ?? createConfiguredLogger(config);
+    let app;
+    try {
+        app = await buildKernelApp(config, { ...options, logger });
+    }
+    catch (e) {
+        // Nothing to stop (the build released what it created); the process entry only sees the error
+        logger.error("kernel start failed", { err: e });
+        throw e;
+    }
+    await startBuiltKernelApp(app, config, signalOptions);
+    return app;
+}
+/**
+ * The start half of {@link startKernelApp} for an application from {@link buildKernelApp}: installs
+ * the signal handlers, runs the start sequence and listens on `config.http.port`. Internal (not
+ * exported from the package): {@link startKernelApp} and the kernel's own tests that need the
+ * application before its start.
+ */
+export async function startBuiltKernelApp(app, config, signalOptions = {}) {
+    const lifecycle = app.get(KernelLifecycle);
+    const signals = handleShutdownSignals(() => closeKernelApp(app), lifecycle.log, signalOptions);
+    try {
+        await initKernelApp(app);
+        try {
+            await lifecycle.listen(config.http.port);
+        }
+        catch (e) {
+            if (!app.get(GracefulShutdown).isShuttingDown()) {
+                lifecycle.log.error("kernel start failed", { err: e });
+            }
+            await closeKernelApp(app);
+            throw e;
+        }
+    }
+    catch (e) {
+        // Stopped by a signal: the signal path closes and exits; otherwise nothing is left to stop
+        const exiting = signals.exiting();
+        if (exiting)
+            await exiting;
+        else
+            signals.dispose();
+        throw e;
+    }
+}
+/** The in-process HTTP of a kernel application (`inject`, the route list). */
+export function kernelAppHttp(app) {
+    return app.get(KernelLifecycle).http;
+}
+/** The port a kernel application listens on; undefined before it listens and after the stop. */
+export function kernelAppPort(app) {
+    return app.get(KernelLifecycle).port;
+}

package/dist/catalog/admin-catalog.controller.d.ts

@@ -2,9 +2,9 @@ import type { FastifyReply } from "fastify";
 import { z } from "zod";
 import type { AdminExtensionView } from "../extensions/permission-view.js";
 import { type Principal } from "../identity/principal.js";
-import { type CatalogItemDetail, type CatalogItemView, type CatalogService, type PermissionsMismatch } from "./catalog.service.js";
-import type { OrgCatalogService } from "./org-catalog.service.js";
-import type { PluginConfirmResult, PluginImport, PluginReview } from "./plugin-import.js";
+import { type CatalogItemDetail, type CatalogItemView, CatalogService, type PermissionsMismatch } from "./catalog.service.js";
+import { OrgCatalogService } from "./org-catalog.service.js";
+import { type PluginConfirmResult, PluginImport, type PluginReview } from "./plugin-import.js";
 declare const NpmBody: z.ZodObject<{
     package: z.ZodString;
     version: z.ZodOptional<z.ZodString>;

package/dist/catalog/admin-catalog.controller.js

@@ -7,14 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Body, Controller, Delete, Get, HttpCode, Inject, Param, Post, Put, Query, Req, Res, } from "@nestjs/common";
+import { Controller, Delete, Get, HttpCode, Inject, Param, Post, Put, Req, Res, } from "@nestjs/common";
 import { z } from "zod";
 import { ApiError } from "../errors.js";
-import { CATALOG, ORG_CATALOG, PLUGIN_IMPORT } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
 import { CurrentPrincipal, EnterpriseAdmin, patTokenId, requireUser, } from "../identity/principal.js";
-import { CATALOG_LIST_MAX_LIMIT, } from "./catalog.service.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZBody, ZQuery } from "../infra/validation/zod-params.js";
+import { CATALOG_LIST_MAX_LIMIT, CatalogService, } from "./catalog.service.js";
 import { sendCatalogIcon } from "./org-catalog.controller.js";
+import { OrgCatalogService } from "./org-catalog.service.js";
+import { PluginImport } from "./plugin-import.js";
 const NpmBody = z.object({
     package: z.string().min(1).max(214),
     version: z.string().min(1).max(256).optional(),
@@ -43,6 +45,18 @@ const actorOpts = (actor) => {
     const tokenId = patTokenId(actor);
     return tokenId !== undefined ? { actorTokenId: tokenId } : {};
 };
+class CatalogImportConfirmBody extends createZodDto(ConfirmBody, "CatalogImportConfirmBody") {
+}
+class CatalogGitImportBody extends createZodDto(GitBody, "CatalogGitImportBody") {
+}
+class CatalogDeploymentInstallBody extends createZodDto(InstallBody, "CatalogDeploymentInstallBody") {
+}
+class CatalogItemsQuery extends createZodDto(ListQuery, "CatalogItemsQuery") {
+}
+class CatalogNpmImportBody extends createZodDto(NpmBody, "CatalogNpmImportBody") {
+}
+class CatalogPolicyBody extends createZodDto(PolicyBody, "CatalogPolicyBody") {
+}
 /**
  * The enterprise catalog (`/api/v1/admin/catalog/*`, enterprise admins): plugin import (upload / npm
  * prepare, then confirm), the item list and detail, policy, delete, and installing an item's
@@ -184,13 +198,13 @@ __decorate([
     Post("import/npm"),
     HttpCode(200),
     __param(0, CurrentPrincipal()),
-    __param(1, Body(new ZodPipe(NpmBody)))
+    __param(1, ZBody(CatalogNpmImportBody))
 ], AdminCatalogController.prototype, "importNpm", null);
 __decorate([
     Post("import/git"),
     HttpCode(200),
     __param(0, CurrentPrincipal()),
-    __param(1, Body(new ZodPipe(GitBody)))
+    __param(1, ZBody(CatalogGitImportBody))
 ], AdminCatalogController.prototype, "importGit", null);
 __decorate([
     Get("imports/:stagingId"),
@@ -201,11 +215,11 @@ __decorate([
     HttpCode(201),
     __param(0, CurrentPrincipal()),
     __param(1, Param("stagingId")),
-    __param(2, Body(new ZodPipe(ConfirmBody)))
+    __param(2, ZBody(CatalogImportConfirmBody))
 ], AdminCatalogController.prototype, "confirm", null);
 __decorate([
     Get("items"),
-    __param(0, Query(new ZodPipe(ListQuery)))
+    __param(0, ZQuery(CatalogItemsQuery))
 ], AdminCatalogController.prototype, "list", null);
 __decorate([
     Get("items/:id"),
@@ -220,7 +234,7 @@ __decorate([
     Put("items/:id/policy"),
     __param(0, CurrentPrincipal()),
     __param(1, Param("id")),
-    __param(2, Body(new ZodPipe(PolicyBody)))
+    __param(2, ZBody(CatalogPolicyBody))
 ], AdminCatalogController.prototype, "setPolicy", null);
 __decorate([
     Delete("items/:id"),
@@ -233,13 +247,13 @@ __decorate([
     HttpCode(200),
     __param(0, CurrentPrincipal()),
     __param(1, Param("id")),
-    __param(2, Body(new ZodPipe(InstallBody)))
+    __param(2, ZBody(CatalogDeploymentInstallBody))
 ], AdminCatalogController.prototype, "installToDeployment", null);
 AdminCatalogController = __decorate([
     Controller("api/v1/admin/catalog"),
     EnterpriseAdmin(),
-    __param(0, Inject(CATALOG)),
-    __param(1, Inject(PLUGIN_IMPORT)),
-    __param(2, Inject(ORG_CATALOG))
+    __param(0, Inject(CatalogService)),
+    __param(1, Inject(PluginImport)),
+    __param(2, Inject(OrgCatalogService))
 ], AdminCatalogController);
 export { AdminCatalogController };