@capybara-hq/kernel 0.1.0-rc.10 → 0.1.0-rc.11

package/dist/catalog/plugin-install.js

@@ -28,10 +28,11 @@ import { OrgLock } from "../orgs/org-lock.js";
 import { packagePath } from "../packages/tgz.js";
 import { SkillsService, skillConflictError, skillConflicts, } from "../skills/skills.service.js";
 import { StorageService } from "../storage/storage.service.js";
+import { assertNotPlatformDefault, themesPreview, } from "../themes/theme-usage.js";
 import { ConnectorsService } from "../tools/connectors.service.js";
 import { findConnectorIn, lockOrgForActions, readCatalogAgentTemplates, readCatalogFiles, readCatalogTemplates, requiredActions, templateConnectorInput, templatePluginProblem, } from "./catalog-content.js";
 import { versionUsable } from "./catalog-items.js";
-import { agentDefinitionRefs, componentOn, connectorTemplateState, connectorTemplatesOn, listedIn, loadComponents, loadScopeState, pluginFactsOf, referenceIds, switchOf, } from "./component-state.js";
+import { agentDefinitionRefs, componentOn, connectorTemplateState, connectorTemplatesOn, listedIn, loadComponents, loadScopeState, pluginFactsOf, referenceIds, switchOf, themeIdClashes, } from "./component-state.js";
 import { assertItemInstallable, disabledPluginItems, pluginItemDisabled, resolveRequestsByInstall, } from "./request-rules.js";
 import { visibleTo } from "./scope.js";
 import { ScopeNoLongerWanted, ScopeStillWanted, wantedByScope } from "./scope-state.js";
@@ -336,12 +337,14 @@ let PluginInstaller = class PluginInstaller {
     async preflight(orgId, actor, itemId, version) {
         const plan = await this.plan(orgId, actor, itemId, version, null, "", undefined);
         await this.assertNoSkillConflicts(orgId, plan);
+        await this.assertNoThemeClashes(orgId, itemId);
         return { actions: planActions(plan) };
     }
     async install(orgId, actor, itemId, version, input, opts = {}) {
         const { switchOn, via, ...actorOpts } = opts;
         const plan = await this.plan(orgId, actor, itemId, version, input, "", undefined);
         await this.assertNoSkillConflicts(orgId, plan);
+        await this.assertNoThemeClashes(orgId, itemId);
         let installId;
         try {
             installId = await this.execute(orgId, actor, plan, actorOpts, {
@@ -386,6 +389,39 @@ let PluginInstaller = class PluginInstaller {
         if (conflicts.length > 0)
             throw skillConflictError(conflicts);
     }
+    /**
+     * Refuses installing a plugin whose themes would come on in the org (they follow it) while
+     * another theme with the same id is on there (themes spec §6, rule 10): 409 `theme.id_taken`,
+     * details `[{ theme, orgId, themes, plugins }]`, before anything is written.
+     */
+    async assertNoThemeClashes(orgId, itemId) {
+        const themes = await loadComponents(this.db, "theme", { itemId });
+        if (themes.length === 0)
+            return;
+        const st = await loadScopeState(this.db, "theme", themes);
+        const conflicts = [];
+        for (const c of themes) {
+            const p = pluginFactsOf(st, c.itemId, orgId);
+            const listed = listedIn(st, c.id, orgId);
+            const sw = switchOf(st, c.id, orgId);
+            if (componentOn(c, p, listed, sw) ||
+                !componentOn(c, p && { ...p, installed: true }, listed, sw)) {
+                continue;
+            }
+            const clash = await themeIdClashes(this.db, orgId, c, c.name);
+            if (clash.length > 0) {
+                conflicts.push({
+                    theme: c.name,
+                    orgId,
+                    themes: clash.map((x) => x.id),
+                    plugins: clash.map((x) => x.plugin ?? "platform"),
+                });
+            }
+        }
+        if (conflicts.length > 0) {
+            throw new ApiError("theme.id_taken", `The plugin's themes would come on next to themes with the same id already on in this organization (${conflicts.map((c) => c.theme).join(", ")}); switch those themes off first`, conflicts);
+        }
+    }
     /** The connector checks of templates against what this replica loads right now. */
     templateDeps() {
         const versions = new Map(this.registry.manifests().map((m) => [m.name, m.version]));
@@ -1108,6 +1144,10 @@ let PluginInstaller = class PluginInstaller {
                 }
             }
         }
+        // An org's own uninstall never takes the platform default theme away from it (themes spec §7;
+        // a scope sync uninstall follows a scope change or disable that was guarded already)
+        if (via !== "scope")
+            await this.assertKeepsPlatformDefault(orgId, installId);
         const outcome = await this.uninstallIn(orgId, actor, installId, {
             report,
             removing: new Set(),
@@ -1131,6 +1171,24 @@ let PluginInstaller = class PluginInstaller {
         });
         return report;
     }
+    /**
+     * 409 `theme.platform_default` when uninstalling `installId` would switch the platform default
+     * theme off in the org (one of the plugin's `follow` themes on there through it, themes spec §7),
+     * in the caller's transaction before anything is written. A missing install passes (the
+     * uninstall reports it).
+     */
+    async assertKeepsPlatformDefault(orgId, installId) {
+        const found = await this.db
+            .selectFrom("plugin_installs")
+            .select("id")
+            .where("id", "=", installId)
+            .where("org_id", "=", orgId)
+            .executeTakeFirst();
+        if (!found)
+            return;
+        const p = await this.previewUninstall(orgId, installId);
+        await assertNotPlatformDefault(this.db, (p.themes ?? []).map((t) => t.id), () => "narrower");
+    }
     /**
      * The oldest other live install (not in `removing`) that has component `kind` / `ref`, or
      * undefined.
@@ -1883,8 +1941,19 @@ let PluginInstaller = class PluginInstaller {
                     }
                 }
             }
+            const themes = await loadComponents(t, "theme", { itemId });
+            const tst = await loadScopeState(t, "theme", themes);
+            for (const c of themes) {
+                if (c.scopeMode === "follow" &&
+                    componentOn(c, pluginFactsOf(tst, c.itemId, orgId), listedIn(tst, c.id, orgId), switchOf(tst, c.id, orgId))) {
+                    lostThemes.set(c.id, new Set([orgId]));
+                }
+            }
         };
+        /** The themes that go off in the org with the install (and the dependencies it removes). */
+        const lostThemes = new Map();
         await visit(row.item_id, comps, true, new Set([installId]));
+        const themes = await themesPreview(t, lostThemes);
         return {
             installId,
             name: row.name,
@@ -1894,6 +1963,7 @@ let PluginInstaller = class PluginInstaller {
             agents: [...used.values()]
                 .map((a) => ({ ...a, uses: a.uses.sort((x, y) => x.ref.localeCompare(y.ref)) }))
                 .sort((x, y) => x.id.localeCompare(y.id)),
+            ...(themes !== undefined && { themes }),
         };
     }
     /**

package/dist/catalog/plugin-package.d.ts

@@ -1,4 +1,5 @@
-import { type AgentTemplate, type ConnectorTemplateFile, type PluginManifest } from "@capybara-hq/plugin-sdk";
+import { type AgentTemplate, type ConnectorTemplateFile, type ParsedTheme, type PluginManifest } from "@capybara-hq/plugin-sdk";
+import { ApiError } from "../errors.js";
 import { LEGACY_FORMAT_MESSAGE, type PackageTgzLimits, packagePath } from "../packages/tgz.js";
 export { LEGACY_FORMAT_MESSAGE, packagePath };
 /**
@@ -13,13 +14,24 @@ export { LEGACY_FORMAT_MESSAGE, packagePath };
  * plugin.json) is rejected first, with {@link LEGACY_FORMAT_MESSAGE}: there is no reader for the
  * old formats.
  */
-/** Codes of {@link PluginPackageError}. */
-export type PluginPackageErrorCode = "catalog.invalid_manifest" | "catalog.legacy_format";
+/**
+ * Codes of {@link PluginPackageError}: `theme.invalid` / `theme.unreadable` when the package's only
+ * problems are in its themes (themes spec §5: a failing theme refuses the whole plugin).
+ */
+export type PluginPackageErrorCode = "catalog.invalid_manifest" | "catalog.legacy_format" | "theme.invalid" | "theme.unreadable";
+/** The problems of one theme of a refused plugin (English; `unreadable:` lines for readability). */
+export interface PluginThemeProblem {
+    /** The theme id (the file's base name). */
+    theme: string;
+    problems: string[];
+}
 /** The plugin package is invalid; `issues` lists the problems (English, shown to the admin). */
 export declare class PluginPackageError extends Error {
     readonly code: PluginPackageErrorCode;
     readonly issues: string[];
-    constructor(code: PluginPackageErrorCode, issues: string[]);
+    /** The failing themes of a `theme.*` code. */
+    readonly themes?: PluginThemeProblem[];
+    constructor(code: PluginPackageErrorCode, issues: string[], themes?: PluginThemeProblem[]);
 }
 /** A skill of the plugin. `dir` is relative to the package root; `files` are relative to `dir`. */
 export interface PluginPackageSkill {
@@ -42,6 +54,18 @@ export interface PluginPackageAgentTemplate {
     path: string;
     template: AgentTemplate;
 }
+/** A theme of the plugin (themes spec §4); `id` is the file's base name. */
+export interface PluginPackageTheme {
+    id: string;
+    /** Relative to the package root (no leading `./`). */
+    path: string;
+    theme: ParsedTheme;
+    /**
+     * The theme's fonts and logo files after `validateThemeAssets` (the SVGs sanitized, the rest
+     * unchanged), keyed by their path relative to the package root (no leading `./`).
+     */
+    assets: Map<string, Uint8Array>;
+}
 /** A validated plugin file tree. Paths are relative to the plugin root (no `package/`). */
 export interface PluginContents {
     /** `{}` when a git plugin has no package.json. */
@@ -52,6 +76,8 @@ export interface PluginContents {
     connectorTemplates: PluginPackageConnectorTemplate[];
     /** Agent templates (listed in plugin.json `agents`, else scanned from `agents/*.md`). */
     agentTemplates: PluginPackageAgentTemplate[];
+    /** Themes (listed in plugin.json `themes`, else scanned from `themes/*.json`). */
+    themes: PluginPackageTheme[];
     /** {@link contentDigest} of `files` (the same for a tgz and a git tree of the same files). */
     contentDigest: string;
 }
@@ -141,3 +167,14 @@ export interface ReadPluginFilesOptions {
  * {@link PluginPackageError} like {@link readPluginPackage}.
  */
 export declare function readPluginFiles(files: Map<string, Uint8Array>, opts: ReadPluginFilesOptions): PluginContents;
+/**
+ * The refusal of a plugin whose only problems are in its themes: `theme.invalid` when any theme
+ * has a problem other than readability (those themes listed), else `theme.unreadable` (every
+ * failing theme listed with its failing pairs).
+ */
+export declare function pluginThemeError(problems: PluginThemeProblem[]): PluginPackageError;
+/**
+ * The API error of a `theme.*` {@link PluginPackageError}: 400 `theme.invalid` with details
+ * `[{ theme, errors }]`, or 400 `theme.unreadable` with details `[{ theme, issues }]`.
+ */
+export declare function themeApiError(e: PluginPackageError): ApiError;

package/dist/catalog/plugin-package.js

@@ -1,18 +1,25 @@
 import { createHash } from "node:crypto";
-import { AGENT_TEMPLATE_LIMITS, CATALOG_ITEM_NAME_RE, CONNECTOR_TEMPLATE_LIMITS, hostSdkProblem, PLUGIN_MANIFEST_FILE, PLUGIN_MANIFEST_LIMITS, parseAgentTemplate, parseConnectorTemplateFile, parsePluginManifest, parseSkillMd, SKILL_ENTRY_FILE, setupGuideFileProblem, validatePluginPackageJsonFor, } from "@capybara-hq/plugin-sdk";
+import { AGENT_TEMPLATE_LIMITS, CATALOG_ITEM_NAME_RE, CONNECTOR_TEMPLATE_LIMITS, hostSdkProblem, PLUGIN_MANIFEST_FILE, PLUGIN_MANIFEST_LIMITS, parseAgentTemplate, parseConnectorTemplateFile, parsePluginManifest, parseSkillMd, parseThemeFile, SKILL_ENTRY_FILE, setupGuideFileProblem, THEME_LIMITS, themeIdOf, validatePluginPackageJsonFor, validateThemeAssets, } from "@capybara-hq/plugin-sdk";
+import { ApiError } from "../errors.js";
 import { HOST_ZOD_VERSION, LEGACY_FORMAT_MESSAGE, PackageTgzError, packagePath, parsePackageJsonFile, unpackPackageTgz, } from "../packages/tgz.js";
 export { LEGACY_FORMAT_MESSAGE, packagePath };
 /** The plugin package is invalid; `issues` lists the problems (English, shown to the admin). */
 export class PluginPackageError extends Error {
     code;
     issues;
-    constructor(code, issues) {
+    /** The failing themes of a `theme.*` code. */
+    themes;
+    constructor(code, issues, themes) {
         super(code === "catalog.legacy_format"
             ? (issues[0] ?? LEGACY_FORMAT_MESSAGE)
-            : `Invalid plugin package: ${issues[0] ?? "unknown problem"}`);
+            : code === "theme.invalid" || code === "theme.unreadable"
+                ? `Theme ${themes?.[0]?.theme ?? "?"} ${code === "theme.invalid" ? "is invalid" : "is not readable"}: ${issues[0] ?? "unknown problem"}`
+                : `Invalid plugin package: ${issues[0] ?? "unknown problem"}`);
         this.name = "PluginPackageError";
         this.code = code;
         this.issues = issues;
+        if (themes !== undefined)
+            this.themes = themes;
     }
 }
 /**
@@ -345,6 +352,7 @@ export function readPluginFiles(files, opts) {
         agentNames.set(r.template.name, path);
         agentTemplates.push({ name: r.template.name, path, template: r.template });
     }
+    const { themes, themePaths, themeProblems } = readThemes(files, manifest);
     if (manifest.icon !== undefined) {
         const icon = files.get(packagePath(manifest.icon));
         const problem = icon === undefined
@@ -378,11 +386,21 @@ export function readPluginFiles(files, opts) {
             }
         }
     }
-    else if (skillDirs.length === 0 && templatePaths.length === 0 && agentPaths.length === 0) {
-        issues.push("a plugin must contain an extension, a skill, a connector template or an agent template");
+    else if (skillDirs.length === 0 &&
+        templatePaths.length === 0 &&
+        agentPaths.length === 0 &&
+        themePaths.length === 0) {
+        issues.push("a plugin must contain an extension, a skill, a connector template, an agent template or a theme");
     }
-    if (issues.length > 0)
-        invalid(issues);
+    if (issues.length > 0) {
+        // Other problems first: the theme problems are listed with them as plain issues
+        invalid([
+            ...issues,
+            ...themeProblems.flatMap((t) => t.problems.map((p) => `themes/${t.theme}: ${p}`)),
+        ]);
+    }
+    if (themeProblems.length > 0)
+        throw pluginThemeError(themeProblems);
     return {
         packageJson: (packageJson ?? {}),
         manifest,
@@ -390,6 +408,108 @@ export function readPluginFiles(files, opts) {
         skills,
         connectorTemplates,
         agentTemplates,
+        themes,
         contentDigest: contentDigest(files),
     };
 }
+const UNREADABLE = "unreadable:";
+/**
+ * The refusal of a plugin whose only problems are in its themes: `theme.invalid` when any theme
+ * has a problem other than readability (those themes listed), else `theme.unreadable` (every
+ * failing theme listed with its failing pairs).
+ */
+export function pluginThemeError(problems) {
+    const invalidOnes = problems.filter((t) => t.problems.some((p) => !p.startsWith(UNREADABLE)));
+    const code = invalidOnes.length > 0 ? "theme.invalid" : "theme.unreadable";
+    const listed = invalidOnes.length > 0 ? invalidOnes : problems;
+    return new PluginPackageError(code, listed.flatMap((t) => t.problems), listed);
+}
+/**
+ * The API error of a `theme.*` {@link PluginPackageError}: 400 `theme.invalid` with details
+ * `[{ theme, errors }]`, or 400 `theme.unreadable` with details `[{ theme, issues }]`.
+ */
+export function themeApiError(e) {
+    const code = e.code === "theme.unreadable" ? "theme.unreadable" : "theme.invalid";
+    const key = code === "theme.invalid" ? "errors" : "issues";
+    return new ApiError(code, e.message, (e.themes ?? []).map((t) => ({ theme: t.theme, [key]: t.problems })));
+}
+/**
+ * The plugin's themes (themes spec §4-§5): listed in `manifest.themes`, else scanned from
+ * `themes/*.json` (at most {@link THEME_LIMITS}`.perPlugin`); each parsed by `parseThemeFile`
+ * (shape, token grammar, readability) and its assets checked by `validateThemeAssets`. The asset
+ * limit is per plugin, so the sizes of the distinct asset paths are also summed over all themes.
+ * Problems are returned per theme, never thrown.
+ */
+function readThemes(files, manifest) {
+    const themeProblems = [];
+    const problem = (theme, problems) => {
+        const t = themeProblems.find((x) => x.theme === theme);
+        if (t)
+            t.problems.push(...problems);
+        else
+            themeProblems.push({ theme, problems: [...problems] });
+    };
+    const themePaths = [];
+    if (manifest.themes !== undefined) {
+        for (const t of manifest.themes) {
+            const path = packagePath(t.path);
+            if (!files.has(path))
+                problem(themeIdOf(path), [`${t.path} not found in the package`]);
+            else if (!themePaths.includes(path))
+                themePaths.push(path);
+        }
+    }
+    else {
+        for (const p of [...files.keys()].sort()) {
+            if (/^themes\/[^/]+\.json$/.test(p))
+                themePaths.push(p);
+        }
+        if (themePaths.length > THEME_LIMITS.perPlugin) {
+            problem(themeIdOf(themePaths[THEME_LIMITS.perPlugin]), [
+                `themes/ holds ${themePaths.length} themes; a plugin may have at most ${THEME_LIMITS.perPlugin}`,
+            ]);
+        }
+    }
+    const themes = [];
+    const sizes = new Map();
+    for (const path of themePaths) {
+        const id = themeIdOf(path);
+        if (themes.some((t) => t.id === id)) {
+            problem(id, [`${path}: another theme of the plugin has the id "${id}"`]);
+            continue;
+        }
+        const bytes = files.get(path);
+        if (bytes.byteLength > THEME_LIMITS.fileBytes) {
+            problem(id, [`${path}: the theme file is larger than ${THEME_LIMITS.fileBytes} bytes`]);
+            continue;
+        }
+        const json = decode(bytes);
+        if (json === undefined) {
+            problem(id, [`${path}: not valid UTF-8 text`]);
+            continue;
+        }
+        const parsed = parseThemeFile(id, json);
+        if ("errors" in parsed) {
+            problem(id, parsed.errors);
+            continue;
+        }
+        const { assets, errors } = validateThemeAssets(parsed, files);
+        if (errors.length > 0) {
+            problem(id, errors);
+            continue;
+        }
+        let total = 0;
+        for (const p of assets.keys())
+            sizes.set(p, files.get(p).byteLength);
+        for (const n of sizes.values())
+            total += n;
+        if (total > THEME_LIMITS.assetsBytes) {
+            problem(id, [
+                `the plugin's theme assets are larger than ${THEME_LIMITS.assetsBytes} bytes in total (${total}); the limit covers all of the plugin's themes`,
+            ]);
+            continue;
+        }
+        themes.push({ id, path, theme: parsed, assets });
+    }
+    return { themes, themePaths, themeProblems };
+}

package/dist/catalog/plugin-upgrade.d.ts

@@ -11,6 +11,7 @@ import { LockService } from "../infra/lock/lock.service.js";
 import type { KernelLogger } from "../log.js";
 import { OrgLock } from "../orgs/org-lock.js";
 import { StorageService } from "../storage/storage.service.js";
+import { type ThemePreview } from "../themes/theme-usage.js";
 import { ConnectorsService } from "../tools/connectors.service.js";
 import { type CatalogVersionFiles } from "./catalog-content.js";
 import { type ComponentKind } from "./component-state.js";
@@ -25,7 +26,7 @@ export interface PlatformUpdateComponent {
     kind: ComponentKind;
     /** The platform component (null: added by the target). */
     id: string | null;
-    /** Skill or agent template name; a connector template's id. */
+    /** Skill or agent template name; a connector template's or a theme's id. */
     name: string;
     change: UpdateChange;
     /** The catalog version of the component's current version (null: added, or no catalog version). */
@@ -109,6 +110,11 @@ export interface PlatformUpdatePreview {
         needsApproval: boolean;
     } | null;
     connectorOrgs: PlatformUpdateConnectorOrg[];
+    /**
+     * The themes the update removes that are on in some org (themes spec §6): the orgs whose default
+     * each is and how many people picked it. Absent when no such theme is removed.
+     */
+    themes?: ThemePreview[];
     /**
      * An owner's update preview only ({@link PlatformPluginUpdater.previewForOwner}): the name of
      * every org the preview mentions, by id. An org admin cannot read other orgs, and these names
@@ -306,7 +312,10 @@ export declare class PlatformPluginUpdater {
      * extension removes it.
      */
     private diff;
-    /** The target's skill names, agent templates and connector templates, from object storage. */
+    /**
+     * The target's skill names, agent templates, connector templates and themes, from object storage
+     * (a theme failing its checks -> 400 `theme.invalid`, themes spec §6).
+     */
     private readContents;
     /**
      * Whether the target's extension package asks for permissions the approved snapshot does not
@@ -328,6 +337,8 @@ export declare class PlatformPluginUpdater {
     private checkDependents;
     /** The plugin's live platform components with their current versions. */
     private liveComponents;
+    /** The `themes` block of the preview: the orgs each of the removed themes `ids` is on in. */
+    private themesLost;
     /** The orgs where the plugin is on: a live install (builtin: every live org). */
     private pluginOrgs;
     private liveOrgs;

package/dist/catalog/plugin-upgrade.js

@@ -34,11 +34,12 @@ import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { OrgLock } from "../orgs/org-lock.js";
 import { packagePath } from "../packages/tgz.js";
 import { StorageService } from "../storage/storage.service.js";
+import { assertNotPlatformDefault, pickedByIn, themesPreview, } from "../themes/theme-usage.js";
 import { canonicalJson } from "../tools/canonical-json.js";
 import { ConnectorsService } from "../tools/connectors.service.js";
-import { dirDigest, getPath, readCatalogAgentTemplates, readCatalogTemplates, setPath, skillFilesDigest, templatePluginProblem, } from "./catalog-content.js";
+import { dirDigest, getPath, readCatalogAgentTemplates, readCatalogTemplates, readCatalogThemes, setPath, skillFilesDigest, templatePluginProblem, themeAssetsDigest, } from "./catalog-content.js";
 import { markVersionApplied, versionUsable } from "./catalog-items.js";
-import { agentsUsing, clashingOrgSkills, clashingPlatformSkills, componentOn, connectorsMadeFrom, connectorTemplatesOn, listedIn, loadScopeState, pluginFactsOf, switchOf, } from "./component-state.js";
+import { agentsUsing, clashingOrgSkills, clashingPlatformSkills, componentOn, connectorsMadeFrom, connectorTemplatesOn, listedIn, loadComponents, loadScopeState, pluginFactsOf, switchOf, themeIdClashes, } from "./component-state.js";
 import { CatalogItemLock } from "./locks.js";
 import { itemPendingError, itemRemovedError } from "./ownership.js";
 import { PlanStale, PlatformComponents } from "./platform-components.js";
@@ -58,6 +59,7 @@ const KIND_ORDER = {
     skill: 0,
     agent_template: 1,
     connector_template: 2,
+    theme: 3,
 };
 /** How long one update holds its item (renewed while it runs). */
 const UPDATE_LOCK_TTL_MS = 60_000;
@@ -188,7 +190,17 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
             owner: { orgId },
             ...(staged !== undefined && { target: staged }),
         }));
-        return { ...preview, orgNames: await this.orgNamesOf(preview) };
+        // The owner sees the names of the orgs whose default a removed theme is (named like the other
+        // orgs the preview mentions, P3-14 / P3-19), but people only of its own org: other orgs'
+        // member counts were never disclosed to it. Display only: `diffHash` covers the full preview.
+        const themes = preview.themes === undefined
+            ? undefined
+            : await Promise.all(preview.themes.map(async (t) => ({
+                ...t,
+                pickedBy: await pickedByIn(this.db, t.id, new Set([orgId])),
+            })));
+        const owned = { ...preview, ...(themes !== undefined && { themes }) };
+        return { ...owned, orgNames: await this.orgNamesOf(owned) };
     }
     /**
      * Locks, in sorted order and before the item (ruling P3-50), every live org the update may
@@ -234,6 +246,7 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
             ...(p.extension?.orgs ?? []),
             ...p.connectorOrgs.map((c) => c.orgId),
             ...p.components.flatMap((c) => [...c.pinnedOrgs, ...(c.kept ?? []).map((k) => k.orgId)]),
+            ...(p.themes ?? []).flatMap((t) => t.orgDefaults.map((o) => o.orgId)),
         ]);
         if (ids.size === 0)
             return {};
@@ -517,7 +530,9 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
                 ? "platform_skills"
                 : c.kind === "agent_template"
                     ? "platform_agent_templates"
-                    : "platform_connector_templates";
+                    : c.kind === "theme"
+                        ? "platform_themes"
+                        : "platform_connector_templates";
             await t
                 .updateTable(table)
                 .set({ deleted_at: now, updated_at: now })
@@ -984,6 +999,43 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
                 pinnedOrgs: [],
             });
         }
+        // Themes (by id, canonical definition and their assets' digest)
+        const toThemes = contents.themes;
+        for (const th of toThemes) {
+            const l = live.themes.find((x) => x.name === th.id);
+            if (!l) {
+                components.push(added("theme", th.id));
+                continue;
+            }
+            const same = canonicalJson(l.definition) === canonicalJson(th.theme) &&
+                l.assetsDigest === th.assetsDigest;
+            components.push({
+                kind: "theme",
+                id: l.id,
+                name: th.id,
+                change: same ? "same" : direction(l.catalogVersion),
+                from: l.catalogVersion,
+                to: to.version,
+                updatedOnOwn: false,
+                ownScope: l.ownScope,
+                pinnedOrgs: [],
+            });
+        }
+        for (const l of live.themes) {
+            if (toThemes.some((x) => x.id === l.name))
+                continue;
+            components.push({
+                kind: "theme",
+                id: l.id,
+                name: l.name,
+                change: "removed",
+                from: l.catalogVersion,
+                to: null,
+                updatedOnOwn: false,
+                ownScope: l.ownScope,
+                pinnedOrgs: [],
+            });
+        }
         // The orgs where the plugin is on (a live install; builtin: every org)
         const onOrgs = await this.pluginOrgs(itemId, item.builtin);
         if (extension)
@@ -1005,6 +1057,32 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
         if (conflicts.length > 0) {
             throw new ApiError("plugin.skill_conflict", `The update adds skills whose names organizations already use where the plugin is on (${[...new Set(conflicts.map((c) => c.skill))].join(", ")}); remove or rename those skills first`, conflicts);
         }
+        // Themes spec §7: an update never removes the platform default theme; rule 10 (§6): an added
+        // theme must not take an id already on where the plugin is on
+        const removedThemes = components
+            .filter((c) => c.kind === "theme" && c.change === "removed" && c.id !== null)
+            .map((c) => c.id);
+        await assertNotPlatformDefault(db, removedThemes, () => "gone");
+        const themeConflicts = [];
+        for (const c of components) {
+            if (c.kind !== "theme" || c.change !== "added")
+                continue;
+            for (const orgId of onOrgs) {
+                const clash = await themeIdClashes(db, orgId, null, c.name);
+                if (clash.length > 0) {
+                    themeConflicts.push({
+                        theme: c.name,
+                        orgId,
+                        themes: clash.map((x) => x.id),
+                        plugins: clash.map((x) => x.plugin ?? "platform"),
+                    });
+                }
+            }
+        }
+        if (themeConflicts.length > 0) {
+            throw new ApiError("theme.id_taken", `The update adds themes whose ids are already on in organizations where the plugin is on (${[...new Set(themeConflicts.map((c) => c.theme))].join(", ")}); switch those themes off there first`, themeConflicts);
+        }
+        const themes = await this.themesLost(removedThemes);
         // Pinned copies (in orgs where the component is on) and removed components agents use
         for (const kind of ["skill", "agent_template"]) {
             const mine = components.filter((c) => c.kind === kind && c.id !== null);
@@ -1145,6 +1223,8 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
                 reset: c.credentialsReset,
             })),
             connectorOrgs,
+            // only when present: a diff without themes keeps the hash it had before themes
+            ...(themes !== undefined && { themes }),
         }));
         return {
             itemId,
@@ -1155,18 +1235,23 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
             extension,
             connectors,
             connectorOrgs,
+            ...(themes !== undefined && { themes }),
             suggest,
             contents,
             dependencies,
             diffHash,
         };
     }
-    /** The target's skill names, agent templates and connector templates, from object storage. */
+    /**
+     * The target's skill names, agent templates, connector templates and themes, from object storage
+     * (a theme failing its checks -> 400 `theme.invalid`, themes spec §6).
+     */
     async readContents(to) {
         return {
             skillNames: await catalogSkillNames(this.storage, to, to.manifest),
             agents: await readCatalogAgentTemplates(this.storage, to),
             templates: await readCatalogTemplates(this.storage, to),
+            themes: await readCatalogThemes(this.storage, to),
         };
     }
     /**
@@ -1331,7 +1416,39 @@ let PlatformPluginUpdater = class PlatformPluginUpdater {
             file: r.file,
             ownScope: r.scope_mode === "own",
         }));
-        return { skills, agentTemplates, templates };
+        const themes = (await db
+            .selectFrom("platform_themes as p")
+            .innerJoin("platform_theme_versions as v", (j) => j.onRef("v.theme_id", "=", "p.id").onRef("v.version", "=", "p.current_version"))
+            .leftJoin("catalog_item_versions as cv", (j) => j
+            .onRef("cv.item_id", "=", "p.catalog_item_id")
+            .onRef("cv.version", "=", "v.catalog_version"))
+            .select(["p.id", "p.name", "p.scope_mode", "v.definition", "v.catalog_version", "cv.files"])
+            .where("p.catalog_item_id", "=", itemId)
+            .where("p.deleted_at", "is", null)
+            .execute()).map((r) => ({
+            id: r.id,
+            name: r.name,
+            definition: r.definition,
+            catalogVersion: r.catalog_version,
+            // no recorded files (should not happen): never equal, the update writes a new version
+            assetsDigest: r.files === null ? null : themeAssetsDigest(r.files, r.definition),
+            ownScope: r.scope_mode === "own",
+        }));
+        return { skills, agentTemplates, templates, themes };
+    }
+    /** The `themes` block of the preview: the orgs each of the removed themes `ids` is on in. */
+    async themesLost(ids) {
+        if (ids.length === 0)
+            return undefined;
+        const comps = await loadComponents(this.db, "theme", { ids });
+        const st = await loadScopeState(this.db, "theme", comps);
+        const orgs = await this.liveOrgs();
+        const lost = new Map();
+        for (const c of comps) {
+            const on = orgs.filter((orgId) => componentOn(c, pluginFactsOf(st, c.itemId, orgId), listedIn(st, c.id, orgId), switchOf(st, c.id, orgId)));
+            lost.set(c.id, new Set(on));
+        }
+        return themesPreview(this.db, lost);
     }
     /** The orgs where the plugin is on: a live install (builtin: every live org). */
     async pluginOrgs(itemId, builtin) {
@@ -1398,6 +1515,7 @@ function previewOf(d) {
         components: d.components,
         extension: extensionView(d.extension),
         connectorOrgs: d.connectorOrgs,
+        ...(d.themes !== undefined && { themes: d.themes }),
         diffHash: d.diffHash,
     };
 }

package/dist/catalog/unshare.js

@@ -115,4 +115,5 @@ const TABLE = {
     skill: "platform_skills",
     agent_template: "platform_agent_templates",
     connector_template: "platform_connector_templates",
+    theme: "platform_themes",
 };