@capybara-hq/kernel 0.1.0-rc.6 → 0.1.0-rc.8

package/dist/catalog/component-scope.schemas.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { COMPONENT_KINDS } from "./component-state.js";
+export const ComponentKindSchema = z.enum(COMPONENT_KINDS);
+export const OrgComponentListQuery = z
+    .object({ kind: ComponentKindSchema.optional(), itemId: z.string().uuid().optional() })
+    .strict();
+/** `?kind=` of the admin component list. */
+export const ComponentListQuery = z.object({ kind: ComponentKindSchema }).strict();
+export const ComponentParams = z.object({
+    kind: ComponentKindSchema,
+    id: z.string().min(1).max(128),
+});
+/** `{ enabled, confirm? }` of the org's switch of a platform component. */
+export const ComponentSwitchBody = z
+    .object({
+    enabled: z.boolean(),
+    confirm: z
+        .string()
+        .regex(/^[0-9a-f]{64}$/)
+        .optional(),
+})
+    .strict();
+const Scope = z.enum(["all", "optional", "named"]);
+const Orgs = z.array(z.string().min(1).max(128)).max(1000);
+const Hash = z.string().min(1).max(128);
+const exactlyOnePreviewTarget = (b) => [b.scope !== undefined, b.disabled === true, b.follow === true].filter(Boolean).length === 1;
+const orgsNeedScope = (b) => b.scope !== undefined || b.orgs === undefined;
+const scopeXorFollow = (b) => (b.scope !== undefined) !== (b.follow === true);
+/** The fields of the scope preview body, before its refinements (zod 4 cannot `extend` a refined object). */
+export const ComponentScopePreviewFields = z
+    .object({
+    scope: Scope.optional(),
+    orgs: Orgs.optional(),
+    disabled: z.literal(true).optional(),
+    follow: z.literal(true).optional(),
+})
+    .strict();
+/** `{ scope, orgs? }`, `{ disabled: true }` or `{ follow: true }`: exactly one. */
+export const ComponentScopePreviewSchema = ComponentScopePreviewFields.refine(exactlyOnePreviewTarget, { message: "send exactly one of scope (with orgs for named), disabled: true or follow: true" }).refine(orgsNeedScope, { message: "orgs: only allowed with scope named", path: ["orgs"] });
+/** The fields of the scope body, before its refinements. */
+export const ComponentScopeFields = z
+    .object({
+    scope: Scope.optional(),
+    orgs: Orgs.optional(),
+    follow: z.literal(true).optional(),
+    scopeHash: Hash,
+})
+    .strict();
+/** `{ scope, orgs?, scopeHash }` or `{ follow: true, scopeHash }`. */
+export const ComponentScopeSchema = ComponentScopeFields.refine(scopeXorFollow, {
+    message: "send either scope (with orgs for named) or follow: true",
+}).refine(orgsNeedScope, { message: "orgs: only allowed with scope named", path: ["orgs"] });
+export const ComponentDisabledSchema = z
+    .object({ disabled: z.boolean(), scopeHash: Hash.optional() })
+    .strict();
+export const ComponentShownSchema = z.object({ shownToOthers: z.boolean() }).strict();
+export const ComponentIdSchema = z.object({ id: z.string().min(1).max(128) });
+export const ComponentTemplateVersionSchema = z
+    .object({ content: z.string().min(1).max(400_000) })
+    .strict();
+/** The refinements of the two scope bodies, for operations that rebuild them from the fields. */
+export const componentScopeRules = { exactlyOnePreviewTarget, orgsNeedScope, scopeXorFollow };
+export const COMPONENT_SCOPE_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/components", query: OrgComponentListQuery },
+    { route: "GET /api/v1/admin/components", query: ComponentListQuery },
+    { route: "GET /api/v1/admin/components/:kind/:id/versions", params: ComponentParams },
+    {
+        route: "POST /api/v1/admin/components/:kind/:id/scope/preview",
+        params: ComponentParams,
+        body: ComponentScopePreviewSchema,
+    },
+    {
+        route: "PUT /api/v1/admin/components/:kind/:id/scope",
+        params: ComponentParams,
+        body: ComponentScopeSchema,
+    },
+    {
+        route: "PUT /api/v1/admin/components/:kind/:id/disabled",
+        params: ComponentParams,
+        body: ComponentDisabledSchema,
+    },
+    {
+        route: "PUT /api/v1/admin/components/:kind/:id/shown",
+        params: ComponentParams,
+        body: ComponentShownSchema,
+    },
+    {
+        route: "POST /api/v1/admin/components/agent_template/:id/versions",
+        params: ComponentIdSchema,
+        body: ComponentTemplateVersionSchema,
+    },
+    {
+        route: "PUT /api/v1/orgs/:orgId/components/:kind/:id/switch",
+        params: ComponentParams,
+        body: ComponentSwitchBody,
+    },
+];

package/dist/catalog/component-scope.service.d.ts

@@ -160,6 +160,10 @@ export type ComponentSwitchResult = {
     };
     confirm: string;
 };
+/** Actor facts of a write: the token, and detail the caller adds to the audit row. */
+type AuditOpts = ActorOpts & {
+    auditDetail?: Record<string, unknown>;
+};
 /**
  * 409 `plugin.skill_conflict` listing the orgs whose own skills use a component's name (rule 10);
  * for an agent template 409 `agent_template.name_taken` listing the orgs that already use its
@@ -238,7 +242,7 @@ export declare class ComponentScopeService {
         follow: true;
     }) & {
         scopeHash: string;
-    }, opts?: ActorOpts): Promise<ComponentView>;
+    }, opts?: AuditOpts): Promise<ComponentView>;
     /**
      * Disables the component on the whole deployment (after its preview, `scopeHash` required) or
      * enables it again (no hash; refused while an org it would be offered to has a skill of its name).
@@ -246,9 +250,9 @@ export declare class ComponentScopeService {
     setDisabled(actor: string, kind: ComponentKind, id: string, body: {
         disabled: boolean;
         scopeHash?: string;
-    }, opts?: ActorOpts): Promise<ComponentView>;
+    }, opts?: AuditOpts): Promise<ComponentView>;
     /** Shows or hides the component to orgs outside its `named` list (never makes it usable). */
-    setShown(actor: string, kind: ComponentKind, id: string, shown: boolean, opts?: ActorOpts): Promise<ComponentView>;
+    setShown(actor: string, kind: ComponentKind, id: string, shown: boolean, opts?: AuditOpts): Promise<ComponentView>;
     /**
      * The org admin's switch of one component (`PUT orgs/:orgId/components/:kind/:id/switch`): only
      * this component (rule 5). A component not offered to the org -> 404. On: refused while the
@@ -260,7 +264,26 @@ export declare class ComponentScopeService {
     setSwitch(orgId: string, actor: string, kind: ComponentKind, id: string, body: {
         enabled: boolean;
         confirm?: string;
-    }, actorTokenId?: string): Promise<ComponentSwitchResult>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<ComponentSwitchResult>;
+    /**
+     * What {@link setSwitch} would do to the org's switch, read-only (the Platform tool's preview):
+     * the component as the org sees it, whether it is `stopped` on the deployment, and for one that
+     * is on and can be switched off the preview of the agents that lose it with the `confirm` hash
+     * the switch-off needs (both null otherwise). Unknown or not offered -> 404 `component.not_found`.
+     */
+    switchPreview(orgId: string, kind: ComponentKind, id: string): Promise<{
+        component: OrgComponentView;
+        stopped: boolean;
+        preview: {
+            agents: {
+                id: string;
+                name: string;
+                refs: string[];
+            }[];
+            connectorsKept: number;
+        } | null;
+        confirm: string | null;
+    }>;
     /**
      * `x.hashId`: the id the preview was asked for (an org row's id before its promotion);
      * `x.promote`: the org row to promote first, in this transaction. Returns the id written.
@@ -301,3 +324,4 @@ export declare class ComponentScopeService {
      */
     private compute;
 }
+export {};

package/dist/catalog/component-scope.service.js

@@ -432,7 +432,7 @@ let ComponentScopeService = class ComponentScopeService {
      * is on, without `confirm` the preview (agents that use it) and its hash are returned, with the
      * current hash the switch is written (a changed preview -> `plugin.switch_stale`).
      */
-    async setSwitch(orgId, actor, kind, id, body, actorTokenId) {
+    async setSwitch(orgId, actor, kind, id, body, actorTokenId, auditDetail) {
         await this.orgLock.lockAndAuthorize(orgId, actor, ACTION[kind]);
         // The rows an unshare narrows (ruling P3-25) are locked before the scope is read, in its order
         // (plugin, then component): a switch-on never commits against a scope narrowed meanwhile
@@ -509,7 +509,14 @@ let ComponentScopeService = class ComponentScopeService {
                 orgId,
                 action: "component.org_switched",
                 target: c.id,
-                detail: { kind, name: c.name, plugin: c.plugin, from: sw, to: body.enabled },
+                detail: {
+                    kind,
+                    name: c.name,
+                    plugin: c.plugin,
+                    from: sw,
+                    to: body.enabled,
+                    ...auditDetail,
+                },
             });
         }
         return {
@@ -525,6 +532,42 @@ let ComponentScopeService = class ComponentScopeService {
             },
         };
     }
+    /**
+     * What {@link setSwitch} would do to the org's switch, read-only (the Platform tool's preview):
+     * the component as the org sees it, whether it is `stopped` on the deployment, and for one that
+     * is on and can be switched off the preview of the agents that lose it with the `confirm` hash
+     * the switch-off needs (both null otherwise). Unknown or not offered -> 404 `component.not_found`.
+     */
+    async switchPreview(orgId, kind, id) {
+        const [c] = await loadComponents(this.db, kind, { ids: [id] });
+        if (!c)
+            throw notFound();
+        const st = await loadScopeState(this.db, kind, [c]);
+        const p = pluginFactsOf(st, c.itemId, orgId);
+        const listed = listedIn(st, c.id, orgId);
+        const sw = switchOf(st, c.id, orgId);
+        const on = componentOn(c, p, listed, sw);
+        const stopped = c.disabled || (p?.live === true && p.disabled);
+        const offered = componentOffered({ ...c, disabled: false }, p && { ...p, disabled: false }, listed);
+        if (!on && !offered)
+            throw notFound();
+        const locked = componentLocked(c, p);
+        let preview = null;
+        let confirm = null;
+        if (on && !locked) {
+            preview = {
+                agents: await agentsUsing(this.db, orgId, kind, [c.id]),
+                connectorsKept: kind === "connector_template" ? await connectorsMadeFrom(this.db, orgId, c.id) : 0,
+            };
+            confirm = switchHash(orgId, c, preview);
+        }
+        return {
+            component: { kind, id: c.id, name: c.name, plugin: c.plugin, switch: sw, on, locked },
+            stopped,
+            preview,
+            confirm,
+        };
+    }
     /**
      * `x.hashId`: the id the preview was asked for (an org row's id before its promotion);
      * `x.promote`: the org row to promote first, in this transaction. Returns the id written.
@@ -590,6 +633,7 @@ let ComponentScopeService = class ComponentScopeService {
                 plugin: c.plugin,
                 from: { scopeMode: c.scopeMode, scope: c.scope, orgs: from },
                 to: { scopeMode: t.scopeMode, scope: t.scope, orgs: t.orgs },
+                ...opts.auditDetail,
             },
         });
         return id;
@@ -623,6 +667,7 @@ let ComponentScopeService = class ComponentScopeService {
                 name: c.name,
                 plugin: c.plugin,
                 disabled: { from: c.disabled, to: disabled },
+                ...opts.auditDetail,
             },
         });
     }
@@ -649,7 +694,14 @@ let ComponentScopeService = class ComponentScopeService {
             ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
             action: "component.shown_changed",
             target: id,
-            detail: { kind, name: c.name, plugin: c.plugin, from: c.shownToOthers, to: shown },
+            detail: {
+                kind,
+                name: c.name,
+                plugin: c.plugin,
+                from: c.shownToOthers,
+                to: shown,
+                ...opts.auditDetail,
+            },
         });
         return id;
     }

package/dist/catalog/component-state.d.ts

@@ -101,14 +101,21 @@ export declare const switchOf: (st: ScopeState, id: string, orgId: string) => bo
 export declare const listedIn: (st: ScopeState, id: string, orgId: string) => boolean;
 /** The connectors, skills and agent templates an agent definition references. */
 export interface DefinitionRefs {
+    /**
+     * The connectors the agent uses: tools are on by default (tools default-on spec §6), so every
+     * one of `orgConnectors` it does not turn off as a whole.
+     */
     connectors: Set<string>;
     /** `skills.orgSkills`, `skills.pinned` and the inline sub-agent templates' `skills`. */
     skills: Set<string>;
     /** `subagents.templates`. */
     templates: Set<string>;
 }
-/** The ids an agent definition references (see {@link DefinitionRefs}). */
-export declare function definitionRefs(definition: unknown): DefinitionRefs;
+/**
+ * The ids an agent definition references (see {@link DefinitionRefs}); `orgConnectors` are the
+ * ids of the org's live connectors.
+ */
+export declare function definitionRefs(definition: unknown, orgConnectors?: readonly string[]): DefinitionRefs;
 /** The org's live agents with their current definitions' references, sorted by id. */
 export declare function agentDefinitionRefs(db: KernelSchemaDb, orgId: string): Promise<({
     id: string;

package/dist/catalog/component-state.js

@@ -1,9 +1,3 @@
-// Component scope (plugin scope phase 2, Task 6; spec §5 rules 2, 5, 8, 10, 11, §13.5): when a platform
-// component (skill, agent template, connector template) is on in an org, offered to it, or locked on,
-// and which agents of an org use one. Pure predicates plus the reads they need; the usable sets
-// (skills/usable.ts, agents/templates.ts), the component scope service and the plugin scope preview
-// all decide with the same predicates.
-import { normalizeToolRef } from "../agents/definition.js";
 import { visibleTo, wantedOn } from "./scope.js";
 export const COMPONENT_KINDS = [
     "skill",
@@ -244,17 +238,25 @@ export function pluginFactsOf(st, itemId, orgId) {
 export const switchOf = (st, id, orgId) => st.switches.get(id)?.get(orgId) ?? null;
 /** Whether the org is on a component's own `named` list in a {@link ScopeState}. */
 export const listedIn = (st, id, orgId) => st.listed.get(id)?.has(orgId) ?? false;
-/** The ids an agent definition references (see {@link DefinitionRefs}). */
-export function definitionRefs(definition) {
+/**
+ * The ids an agent definition references (see {@link DefinitionRefs}); `orgConnectors` are the
+ * ids of the org's live connectors.
+ */
+export function definitionRefs(definition, orgConnectors = []) {
     const def = definition;
     const connectors = new Set();
     const skills = new Set();
     const templates = new Set();
-    for (const ref of Array.isArray(def?.tools) ? def.tools : []) {
-        const n = normalizeToolRef(ref);
-        if (n?.kind === "connector" && typeof n.connectorId === "string")
-            connectors.add(n.connectorId);
+    const off = new Set();
+    for (const ref of Array.isArray(def?.disabledTools) ? def.disabledTools : []) {
+        const n = ref;
+        if (n?.kind === "connector" && typeof n.connectorId === "string" && n.tools === "all") {
+            off.add(n.connectorId);
+        }
     }
+    for (const id of orgConnectors)
+        if (!off.has(id))
+            connectors.add(id);
     const strings = (xs, into) => {
         if (Array.isArray(xs))
             for (const x of xs)
@@ -280,12 +282,19 @@ export async function agentDefinitionRefs(db, orgId) {
         .where("a.deleted_at", "is", null)
         .orderBy("a.id")
         .execute();
+    const connectors = (await db
+        .selectFrom("connectors")
+        .select("id")
+        .where("org_id", "=", orgId)
+        .where("deleted_at", "is", null)
+        .orderBy("id")
+        .execute()).map((c) => c.id);
     return rows.map((r) => {
         const name = r.definition?.name;
         return {
             id: r.id,
             name: typeof name === "string" ? name : r.id,
-            ...definitionRefs(r.definition),
+            ...definitionRefs(r.definition, connectors),
         };
     });
 }

package/dist/catalog/marketplaces.controller.d.ts

@@ -1,40 +1,11 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { type OrgContext } from "../orgs/org.guard.js";
 import { CatalogService, type MarketplaceImportResult } from "./catalog.service.js";
+import { MarketplaceImportBody as ImportBody, MarketplaceAddBody, MarketplaceEntriesQuery, MarketplacePatchBody as PatchBody } from "./marketplaces.schemas.js";
 import { type MarketplaceEntryView, MarketplacesService, type MarketplaceView } from "./marketplaces.service.js";
-declare const AddBody: z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodString;
-    form: z.ZodOptional<z.ZodEnum<{
-        git: "git";
-        http: "http";
-    }>>;
-    ref: z.ZodOptional<z.ZodString>;
-    mirrors: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    token: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const PatchBody: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    form: z.ZodOptional<z.ZodEnum<{
-        git: "git";
-        http: "http";
-    }>>;
-    ref: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    mirrors: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-declare const EntriesQuery: z.ZodObject<{
-    sourceId: z.ZodOptional<z.ZodString>;
-    q: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const ImportBody: z.ZodObject<{
-    version: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
 /**
  * Marketplaces (`/api/v1/admin/marketplaces/*`, super admins): create, update, delete and
  * refresh the official and custom marketplaces, browse entries, import from a marketplace.
@@ -55,7 +26,7 @@ export declare class MarketplacesController {
      * to the URL's origin). A git URL (`…/*.git`, `owner/repo`, or any URL with `form: "git"`) is a
      * git marketplace with an optional `ref`; anything else is a marketplace.json URL.
      */
-    add(principal: Principal, body: z.infer<typeof AddBody>): Promise<MarketplaceView>;
+    add(principal: Principal, body: z.infer<typeof MarketplaceAddBody>): Promise<MarketplaceView>;
     /**
      * Browses entries (enabled marketplaces only, `sourceId` filters by marketplace; at most
      * `MARKETPLACE_ENTRIES_MAX`, `truncated` true means there are more). An entry that cannot be
@@ -63,7 +34,7 @@ export declare class MarketplacesController {
      * outside `marketplaces.allowedHosts`) or `path_needs_git_marketplace` (a path entry of an http
      * marketplace).
      */
-    entries(q: z.infer<typeof EntriesQuery>): Promise<{
+    entries(q: z.infer<typeof MarketplaceEntriesQuery>): Promise<{
         items: MarketplaceEntryView[];
         truncated: boolean;
     }>;
@@ -106,9 +77,8 @@ export declare class OrgMarketplacesController {
     private readonly marketplaces;
     private readonly kdb;
     constructor(marketplaces: MarketplacesService, kdb: KernelDb);
-    entries(org: OrgContext, q: z.infer<typeof EntriesQuery>): Promise<{
+    entries(org: OrgContext, q: z.infer<typeof MarketplaceEntriesQuery>): Promise<{
         items: MarketplaceEntryView[];
         truncated: boolean;
     }>;
 }
-export {};

package/dist/catalog/marketplaces.controller.js

@@ -8,8 +8,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Delete, Get, HttpCode, Inject, Param, Patch, Post } from "@nestjs/common";
-import { z } from "zod";
-import { MARKETPLACE_MAX_MIRRORS } from "../config/schema.js";
 import { ApiError } from "../errors.js";
 import { CurrentPrincipal, patTokenId, requireUser, SuperAdmin, } from "../identity/principal.js";
 import { readOrgMarketplaceBrowse } from "../identity/settings.js";
@@ -19,44 +17,18 @@ import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZBody, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { CatalogService } from "./catalog.service.js";
+import { MarketplaceImportBody as ImportBody, MarketplaceAddBody, MarketplaceEntriesQuery, MarketplacePatchBody as PatchBody, } from "./marketplaces.schemas.js";
 import { MarketplacesService, } from "./marketplaces.service.js";
 import { itemsSeenBy } from "./scope-state.js";
-const Url = z.string().min(1).max(2000);
-const Form = z.enum(["http", "git"]);
-const Ref = z.string().min(1).max(256);
-const AddBody = z.object({
-    name: z.string().min(1).max(100),
-    url: Url,
-    form: Form.optional(),
-    ref: Ref.optional(),
-    mirrors: z.array(Url).max(MARKETPLACE_MAX_MIRRORS).optional(),
-    token: z.string().min(1).max(4096).optional(),
-});
-const PatchBody = z
-    .object({
-    name: z.string().min(1).max(100).optional(),
-    url: Url.optional(),
-    form: Form.optional(),
-    ref: Ref.nullable().optional(),
-    mirrors: z.array(Url).max(MARKETPLACE_MAX_MIRRORS).optional(),
-    enabled: z.boolean().optional(),
-    token: z.string().min(1).max(4096).nullable().optional(),
-})
-    .strict();
-const EntriesQuery = z.object({
-    sourceId: z.string().min(1).max(100).optional(),
-    q: z.string().max(200).optional(),
-});
-const ImportBody = z.object({ version: z.string().min(1).max(256).optional() });
 /** 手动刷新的总时限（每个地址另有 30 秒超时）。 */
 const REFRESH_DEADLINE_MS = 300_000;
 const actorOpts = (actor) => {
     const tokenId = patTokenId(actor);
     return tokenId !== undefined ? { actorTokenId: tokenId } : {};
 };
-class MarketplaceAddBody extends createZodDto(AddBody, "MarketplaceAddBody") {
+class MarketplaceAddBodyDto extends createZodDto(MarketplaceAddBody, "MarketplaceAddBody") {
 }
-class MarketplaceEntriesQuery extends createZodDto(EntriesQuery, "MarketplaceEntriesQuery") {
+class MarketplaceEntriesQueryDto extends createZodDto(MarketplaceEntriesQuery, "MarketplaceEntriesQuery") {
 }
 class MarketplaceImportBody extends createZodDto(ImportBody, "MarketplaceImportBody") {
 }
@@ -171,11 +143,11 @@ __decorate([
     Post(),
     HttpCode(201),
     __param(0, CurrentPrincipal()),
-    __param(1, ZBody(MarketplaceAddBody))
+    __param(1, ZBody(MarketplaceAddBodyDto))
 ], MarketplacesController.prototype, "add", null);
 __decorate([
     Get("entries"),
-    __param(0, ZQuery(MarketplaceEntriesQuery))
+    __param(0, ZQuery(MarketplaceEntriesQueryDto))
 ], MarketplacesController.prototype, "entries", null);
 __decorate([
     Patch(":id"),
@@ -247,7 +219,7 @@ __decorate([
     Get("entries"),
     OrgAction("catalog.decide"),
     __param(0, CurrentOrg()),
-    __param(1, ZQuery(MarketplaceEntriesQuery))
+    __param(1, ZQuery(MarketplaceEntriesQueryDto))
 ], OrgMarketplacesController.prototype, "entries", null);
 OrgMarketplacesController = __decorate([
     Controller("api/v1/orgs/:orgId/marketplaces"),

package/dist/catalog/marketplaces.schemas.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+export declare const MarketplaceUrl: z.ZodString;
+export declare const MarketplaceForm: z.ZodEnum<{
+    git: "git";
+    http: "http";
+}>;
+export declare const MarketplaceRef: z.ZodString;
+export declare const MarketplaceAddBody: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    form: z.ZodOptional<z.ZodEnum<{
+        git: "git";
+        http: "http";
+    }>>;
+    ref: z.ZodOptional<z.ZodString>;
+    mirrors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MarketplaceEntriesQuery: z.ZodObject<{
+    sourceId: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MarketplacePatchBody: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    form: z.ZodOptional<z.ZodEnum<{
+        git: "git";
+        http: "http";
+    }>>;
+    ref: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mirrors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const MarketplaceImportBody: z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** `:id` of a marketplace as the routes take it (`@Param`). */
+export declare const MarketplaceIdPathParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+/** `:id` and the entry `:name` of the import route (`@Param`). */
+export declare const MarketplaceEntryPathParams: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const MARKETPLACE_ROUTES: readonly RouteSchemas[];

package/dist/catalog/marketplaces.schemas.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { MARKETPLACE_MAX_MIRRORS } from "../config/schema.js";
+export const MarketplaceUrl = z.string().min(1).max(2000);
+export const MarketplaceForm = z.enum(["http", "git"]);
+export const MarketplaceRef = z.string().min(1).max(256);
+export const MarketplaceAddBody = z.object({
+    name: z.string().min(1).max(100),
+    url: MarketplaceUrl,
+    form: MarketplaceForm.optional(),
+    ref: MarketplaceRef.optional(),
+    mirrors: z.array(MarketplaceUrl).max(MARKETPLACE_MAX_MIRRORS).optional(),
+    token: z.string().min(1).max(4096).optional(),
+});
+export const MarketplaceEntriesQuery = z.object({
+    sourceId: z.string().min(1).max(100).optional(),
+    q: z.string().max(200).optional(),
+});
+export const MarketplacePatchBody = z
+    .object({
+    name: z.string().min(1).max(100).optional(),
+    url: MarketplaceUrl.optional(),
+    form: MarketplaceForm.optional(),
+    ref: MarketplaceRef.nullable().optional(),
+    mirrors: z.array(MarketplaceUrl).max(MARKETPLACE_MAX_MIRRORS).optional(),
+    enabled: z.boolean().optional(),
+    token: z.string().min(1).max(4096).nullable().optional(),
+})
+    .strict();
+export const MarketplaceImportBody = z.object({ version: z.string().min(1).max(256).optional() });
+/** `:id` of a marketplace as the routes take it (`@Param`). */
+export const MarketplaceIdPathParams = z.object({ id: z.string().min(1) });
+/** `:id` and the entry `:name` of the import route (`@Param`). */
+export const MarketplaceEntryPathParams = MarketplaceIdPathParams.extend({
+    name: z.string().min(1),
+});
+export const MARKETPLACE_ROUTES = [
+    { route: "GET /api/v1/admin/marketplaces" },
+    { route: "POST /api/v1/admin/marketplaces", body: MarketplaceAddBody },
+    { route: "GET /api/v1/orgs/:orgId/marketplaces/entries", query: MarketplaceEntriesQuery },
+    { route: "GET /api/v1/admin/marketplaces/entries", query: MarketplaceEntriesQuery },
+    {
+        route: "PATCH /api/v1/admin/marketplaces/:id",
+        params: MarketplaceIdPathParams,
+        body: MarketplacePatchBody,
+    },
+    { route: "DELETE /api/v1/admin/marketplaces/:id", params: MarketplaceIdPathParams },
+    { route: "POST /api/v1/admin/marketplaces/:id/refresh", params: MarketplaceIdPathParams },
+    {
+        route: "POST /api/v1/admin/marketplaces/:id/entries/:name/import",
+        params: MarketplaceEntryPathParams,
+        body: MarketplaceImportBody,
+    },
+];

package/dist/catalog/marketplaces.service.d.ts

@@ -181,7 +181,7 @@ export declare function headsToResolve(entries: readonly MarketplaceEntry[], imp
 /** The host versions (an entry's `minKernel` is judged against them). */
 export declare const HOST_VERSIONS: {
     readonly kernel: string;
-    readonly sdk: "0.1.0-rc.4";
+    readonly sdk: "0.1.0-rc.5";
 };
 /** Whether this deployment satisfies the entry's `minKernel`. */
 export declare const entryCompatible: (e: Pick<MarketplaceEntry, "minKernel">) => boolean;
@@ -297,6 +297,20 @@ export declare class MarketplacesService {
         mirrors?: string[];
         token?: string;
     }, opts?: ActorOpts): Promise<MarketplaceView>;
+    /**
+     * The read-only checks of {@link add}, for the `Platform` tool's precheck (before the card): the
+     * name, URL and git fields as `add` checks them (throws `validation_failed`), then the source
+     * that has the same URL and ref already, if any (adding a duplicate is allowed; the tool points
+     * the agent at the existing source instead).
+     */
+    checkAdd(input: {
+        name: string;
+        url: string;
+        ref?: string;
+    }): Promise<{
+        id: string;
+        name: string;
+    } | null>;
     private writeAdd;
     /**
      * Updates a custom marketplace (audit `marketplace.updated`, listing the changed fields, the