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

package/dist/platform/ops/requests.ops.js

@@ -0,0 +1,191 @@
+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 { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { CatalogItemPathParams, CatalogMarketplaceRequestBody, CatalogRequestBody, CatalogRequestsListQuery, } from "../../catalog/org-catalog.schemas.js";
+import { CatalogRequestsService } from "../../catalog/requests.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { viaAgent } from "./errors.js";
+import { Cursor, pageOf, startOf } from "./paging.js";
+/** A request as the requester reads it (no org name: it is this org's). */
+const view = (r) => ({
+    id: r.id,
+    kind: r.kind,
+    status: r.status,
+    item: r.item,
+    entry: r.entry,
+    agent: r.agent,
+    note: r.note,
+    reason: r.reason,
+    decidedAt: r.decidedAt,
+    createdAt: r.createdAt,
+});
+/** A platform request as the super admin's list shows it: a compact row (the inbox's summary). */
+const platformRow = (r) => ({
+    id: r.id,
+    name: r.item?.name ?? r.entry?.name ?? r.kind,
+    state: r.status,
+    kind: r.kind,
+    org: r.orgName,
+    createdAt: r.createdAt,
+});
+/** A member's pending request as the org admins' list shows it: a compact row (the inbox's). */
+const pendingRow = (r) => ({
+    id: r.id,
+    name: r.item?.name ?? r.entry?.name ?? r.agent?.name ?? r.kind,
+    state: r.status,
+    kind: r.kind,
+    requestedBy: r.requestedByName,
+    note: r.note,
+    next: "Decide it on the web, in the inbox; agents never decide requests.",
+});
+/**
+ * Request operations of the `Platform` tool (spec §7): a member asks the org admins to switch a
+ * plugin on, an org admin asks the super admin for access to a plugin or for an import from a
+ * marketplace. Deciding a request is human-only (spec §6.4) and not offered.
+ */
+let RequestsOperations = class RequestsOperations {
+    registry;
+    requests;
+    constructor(registry, requests) {
+        this.registry = registry;
+        this.requests = requests;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "requests.list-mine",
+                description: "List the requests you made in this org, pending and decided, newest first: what was asked (a plugin, a marketplace entry, an agent's connectors), the status and a rejection's reason. Pages by 50: pass the returned next as params.cursor.",
+                input: z.object({ cursor: Cursor.optional() }).strict(),
+                example: {},
+                authz: { orgAction: "catalog.request" },
+                mirrors: [],
+                confirm: "read",
+                run: async (input, ctx) => {
+                    const mine = await this.requests.listForRequester(ctx.orgId, ctx.actorAccountId);
+                    return pageOf(mine.map(view), startOf(input.cursor), 50);
+                },
+            }),
+            defineOperation({
+                id: "requests.create",
+                description: 'Ask for a plugin: kind "enable" asks the org admins to switch on a plugin that is off in this org (members and up); kind "access" asks the super admin to offer this org a plugin it sees as not_offered (org admins). Take the plugin id and state from plugins.list. An optional note says why.',
+                input: z
+                    .object({ itemId: CatalogItemPathParams.shape.itemId.max(100) })
+                    .extend(CatalogRequestBody.shape)
+                    .strict(),
+                example: {
+                    itemId: "3f1c2a9e-5b7d-4e21-9c0a-1d2e3f4a5b6c",
+                    kind: "enable",
+                    note: "Our team needs it for the weekly report.",
+                },
+                authz: { orgAction: "catalog.request" },
+                mirrors: ["POST /api/v1/orgs/:orgId/catalog/:itemId/requests"],
+                confirm: "personal",
+                errors: [
+                    {
+                        code: "catalog.request_pending",
+                        next: "The org already has a pending request of this kind for the plugin; nothing to do but wait.",
+                    },
+                    {
+                        code: "catalog.request_invalid",
+                        next: 'The plugin\'s state does not fit the kind: "enable" needs state off, "access" needs not_offered. Check plugins.list.',
+                    },
+                    {
+                        code: "forbidden",
+                        next: 'Only org admins can ask for access; ask an org admin, or use kind "enable".',
+                    },
+                ],
+                summary: (i) => i.kind === "enable"
+                    ? {
+                        zh: `申请在本组织启用插件 ${i.itemId}`,
+                        en: `Request that plugin ${i.itemId} be enabled in the org`,
+                    }
+                    : {
+                        zh: `向超级管理员申请插件 ${i.itemId} 的使用权`,
+                        en: `Request access to plugin ${i.itemId} from the super admin`,
+                    },
+                run: async (input, ctx) => ({
+                    request: view(await this.requests.requestItem(ctx.orgId, ctx.actorAccountId, input.itemId, { kind: input.kind, ...(input.note !== undefined && { note: input.note }) }, { auditDetail: viaAgent("requests.create", ctx) })),
+                }),
+            }),
+            defineOperation({
+                id: "requests.create-import",
+                description: "Ask the super admin to import a plugin from a marketplace into the platform catalog (org admins, when the platform lets orgs browse): the marketplaceId, name and version from marketplaces.entries, and an optional note.",
+                input: CatalogMarketplaceRequestBody,
+                example: { marketplaceId: "official", name: "github", version: "1.4.0" },
+                authz: { orgAction: "catalog.decide" },
+                mirrors: ["POST /api/v1/orgs/:orgId/marketplace-requests"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "catalog.marketplace_browse_disabled",
+                        next: "The platform does not let orgs request imports; ask the super admin directly.",
+                    },
+                    {
+                        code: "catalog.request_invalid",
+                        next: 'The plugin is in the catalog already: use requests.create with kind "access" or "enable".',
+                    },
+                    {
+                        code: "catalog.request_pending",
+                        next: "A request for this entry is pending already; wait for the super admin.",
+                    },
+                ],
+                summary: (i) => ({
+                    zh: `申请从市场导入插件 ${i.name} ${i.version}`,
+                    en: `Request the import of plugin ${i.name} ${i.version} from a marketplace`,
+                }),
+                run: async (input, ctx) => ({
+                    request: view(await this.requests.requestImport(ctx.orgId, ctx.actorAccountId, {
+                        marketplaceId: input.marketplaceId,
+                        name: input.name,
+                        version: input.version,
+                        ...(input.note !== undefined && { note: input.note }),
+                    }, { auditDetail: viaAgent("requests.create-import", ctx) })),
+                }),
+            }),
+            defineOperation({
+                id: "requests.pending",
+                description: "List the requests members sent this org's admins that wait for a decision (org admins), as the inbox shows them, newest first: kind enable (switch a plugin on) or connector_setup (set up an agent's connectors), what it is about (the plugin or the agent), who asked and their note. Deciding them is done on the web. Pages by 50: pass the returned next as params.cursor.",
+                input: z.object({ cursor: Cursor.optional() }).strict(),
+                example: {},
+                authz: { orgAction: "catalog.decide" },
+                mirrors: [],
+                confirm: "read",
+                run: async (input, ctx) => {
+                    const all = await this.requests.listForOrgAdmin(ctx.orgId, ctx.actorAccountId);
+                    return pageOf(all.map(pendingRow), startOf(input.cursor), 50);
+                },
+            }),
+            defineOperation({
+                id: "requests.platform-list",
+                description: "List the requests orgs sent the super admin (super admin): access to a plugin and imports from a marketplace, one compact row each (what, status, kind, the requesting org, when), newest first; pending by default, or filter by status. Deciding them is done on the web. Pages by 50: pass the returned next as params.cursor.",
+                input: z
+                    .object({ status: CatalogRequestsListQuery.shape.status, cursor: Cursor.optional() })
+                    .strict(),
+                example: {},
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/catalog/requests"],
+                extras: ["cursor"],
+                confirm: "read",
+                run: async (input) => {
+                    const all = await this.requests.listDeployment(input.status !== undefined ? { status: input.status } : {});
+                    return pageOf(all.map(platformRow), startOf(input.cursor), 50);
+                },
+            }),
+        ]);
+    }
+};
+RequestsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(CatalogRequestsService))
+], RequestsOperations);
+export { RequestsOperations };

package/dist/platform/ops/role.d.ts

@@ -0,0 +1,4 @@
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+import type { OrgRole } from "../../orgs/roles.js";
+/** The account's role in the org, read now; null when it is not a member. */
+export declare function roleOf(db: KernelSchemaDb, orgId: string, accountId: string): Promise<OrgRole | null>;

package/dist/platform/ops/role.js

@@ -0,0 +1,10 @@
+/** The account's role in the org, read now; null when it is not a member. */
+export async function roleOf(db, orgId, accountId) {
+    const m = await db
+        .selectFrom("memberships")
+        .select("role")
+        .where("org_id", "=", orgId)
+        .where("account_id", "=", accountId)
+        .executeTakeFirst();
+    return m?.role ?? null;
+}

package/dist/platform/ops/skills.ops.d.ts

@@ -0,0 +1,17 @@
+import { type OnModuleInit } from "@nestjs/common";
+import { OwnedItems } from "../../catalog/owned-items.js";
+import { SkillsService } from "../../skills/skills.service.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Skill library operations of the `Platform` tool (spec §7). The skill body can be long; `get`
+ * returns it whole because reading it is the point of the call.
+ */
+export declare class SkillsOperations implements OnModuleInit {
+    private readonly registry;
+    private readonly skills;
+    private readonly owned;
+    constructor(registry: PlatformOperations, skills: SkillsService, owned: OwnedItems);
+    /** The skill's name for a card summary; its id when it cannot be read. */
+    private skillName;
+    onModuleInit(): void;
+}

package/dist/platform/ops/skills.ops.js

@@ -0,0 +1,216 @@
+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 { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { OwnedItems } from "../../catalog/owned-items.js";
+import { SkillCreateFields, SkillIdParams, SkillPathParams, SkillShareableSchema, } from "../../skills/skills.schemas.js";
+import { SkillsService } from "../../skills/skills.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { precheckBy, viaAgent } from "./errors.js";
+import { named, orElse } from "./summary.js";
+const NoInput = z.object({}).strict();
+const SkillId = z.object({ skillId: SkillPathParams.shape.id.max(100) }).strict();
+const Create = SkillCreateFields.shape;
+const OwnedSkillId = z.object({ skillId: SkillIdParams.shape.id }).strict();
+/**
+ * Skill library operations of the `Platform` tool (spec §7). The skill body can be long; `get`
+ * returns it whole because reading it is the point of the call.
+ */
+let SkillsOperations = class SkillsOperations {
+    registry;
+    skills;
+    owned;
+    constructor(registry, skills, owned) {
+        this.registry = registry;
+        this.skills = skills;
+        this.owned = owned;
+    }
+    /** The skill's name for a card summary; its id when it cannot be read. */
+    skillName(orgId, skillId) {
+        return orElse(async () => named((await this.skills.get(orgId, skillId)).name), skillId);
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "skills.list",
+                description: "List the skills the org can use, org skills and platform skills switched on in it. Each entry has an id, name, description, current version and where it came from.",
+                input: NoInput,
+                example: {},
+                authz: { orgAction: "skills.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/skills"],
+                confirm: "read",
+                run: async (_input, ctx) => ({ skills: await this.skills.list(ctx.orgId) }),
+            }),
+            defineOperation({
+                id: "skills.get",
+                description: "Read one skill: its description, versions, file list and the current SKILL.md body. Takes the skill id from skills.list.",
+                input: SkillId,
+                example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11" },
+                authz: { orgAction: "skills.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/skills/:id"],
+                renames: { skillId: "id" },
+                confirm: "read",
+                run: async (input, ctx) => this.skills.get(ctx.orgId, input.skillId),
+            }),
+            defineOperation({
+                id: "skills.create",
+                description: "Create an org skill from text: a name, a one-line description of when to use it, and the SKILL.md body. A skill of that name must not exist yet. Uploads of packages are done on the web.",
+                // the route's text form, its bounds tightened for the model (a SKILL.md up to 100k chars)
+                input: z
+                    .object({
+                    name: Create.name.unwrap().max(64),
+                    description: Create.description.unwrap(),
+                    body: Create.body.unwrap().min(1).max(100_000),
+                    shareable: Create.shareable,
+                })
+                    .strict(),
+                example: {
+                    name: "weekly-report",
+                    description: "Use when asked to write the weekly status report.",
+                    body: "# Steps\n\n1. Collect this week's updates.\n2. Write the report.",
+                },
+                authz: { orgAction: "skills.manage" },
+                mirrors: ["POST /api/v1/orgs/:orgId/skills"],
+                // packages are uploaded on the web
+                omits: ["uploadId"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "skill.name_exists",
+                        next: "A skill of that name exists: pick another name, or read the existing one with skills.get.",
+                    },
+                    {
+                        code: "validation_failed",
+                        next: "Fix the SKILL.md as the message says (name, description, body), then call again.",
+                    },
+                    {
+                        code: "catalog.custom_disabled",
+                        next: {
+                            superAdmin: "The platform does not allow custom skills: allow them in the admin console under Settings, then call again.",
+                            orgAdmin: "The platform does not allow custom skills; ask the super admin, or use a platform skill from skills.list.",
+                            member: "The platform does not allow custom skills; use a platform skill from skills.list, or ask an org admin.",
+                        },
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.skills.checkCreateFromText(ctx.orgId, i)),
+                summary: (i) => i.shareable === true
+                    ? {
+                        zh: `新建组织技能「${i.name}」（可共享给其他组织）`,
+                        en: `Create org skill "${i.name}" (shared with other orgs)`,
+                    }
+                    : { zh: `新建组织技能「${i.name}」`, en: `Create org skill "${i.name}"` },
+                run: async (input, ctx) => this.skills.createFromText(ctx.orgId, ctx.actorAccountId, {
+                    name: input.name,
+                    description: input.description,
+                    body: input.body,
+                    ...(input.shareable !== undefined && { shareable: input.shareable }),
+                    auditDetail: viaAgent("skills.create", ctx),
+                }),
+            }),
+            defineOperation({
+                id: "skills.set-shareable",
+                description: "Set whether an org skill may be shared with other orgs. Only the org's own skills can be changed; a skill that came from a platform plugin cannot.",
+                input: OwnedSkillId.extend({ shareable: SkillShareableSchema.shape.shareable }).strict(),
+                example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11", shareable: true },
+                authz: { orgAction: "skills.manage" },
+                mirrors: ["PUT /api/v1/orgs/:orgId/skills/:id/shareable"],
+                renames: { skillId: "id" },
+                confirm: "org",
+                errors: [
+                    {
+                        code: "skill.not_found",
+                        next: "Check the skill id with skills.list; only the org's own skills can be changed or deleted here.",
+                    },
+                    {
+                        code: "catalog.not_owned",
+                        next: "Only a skill the org created can be shared; a platform skill or a copy of another owner's is not the org's to share.",
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.owned.previewSkillDelete(ctx.orgId, i.skillId)),
+                summary: async (i, ctx) => {
+                    const n = await this.skillName(ctx.orgId, i.skillId);
+                    return i.shareable
+                        ? {
+                            zh: `允许把组织技能「${n}」共享给其他组织`,
+                            en: `Allow org skill "${n}" to be shared with other orgs`,
+                        }
+                        : {
+                            zh: `不再把组织技能「${n}」共享给其他组织`,
+                            en: `Stop sharing org skill "${n}" with other orgs`,
+                        };
+                },
+                run: async (input, ctx) => {
+                    await this.owned.setShareable(ctx.orgId, ctx.actorAccountId, { kind: "skill", id: input.skillId }, input.shareable, { auditDetail: viaAgent("skills.set-shareable", ctx) });
+                    return { id: input.skillId, shareable: input.shareable };
+                },
+            }),
+            defineOperation({
+                id: "skills.delete-preview",
+                description: "Preview deleting an org skill (org admins): whether it is removed or handed to the platform because another org uses it, and which of the org's agents lose it. Show it to the person before skills.delete.",
+                input: OwnedSkillId,
+                example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11" },
+                authz: { orgAction: "skills.manage" },
+                mirrors: ["GET /api/v1/orgs/:orgId/skills/:id/delete-preview"],
+                renames: { skillId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "skill.not_found",
+                        next: "Check the skill id with skills.list; only the org's own skills can be changed or deleted here.",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    preview: await this.owned.previewSkillDelete(ctx.orgId, input.skillId),
+                }),
+            }),
+            defineOperation({
+                id: "skills.delete",
+                description: "Delete an org skill. Agents of the org that use it lose it; a skill another org uses is handed to the platform instead of removed. Read skills.delete-preview first and show it to the person.",
+                input: OwnedSkillId,
+                example: { skillId: "0b9f2c4e-1d3a-4c55-9e0a-7a2f6d1c8b11" },
+                authz: { orgAction: "skills.manage" },
+                mirrors: ["DELETE /api/v1/orgs/:orgId/skills/:id"],
+                renames: { skillId: "id" },
+                confirm: "org",
+                errors: [
+                    {
+                        code: "skill.not_found",
+                        next: "Check the skill id with skills.list; only the org's own skills can be changed or deleted here.",
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.owned.previewSkillDelete(ctx.orgId, i.skillId)),
+                summary: async (i, ctx) => {
+                    const n = await this.skillName(ctx.orgId, i.skillId);
+                    const p = await orElse(() => this.owned.previewSkillDelete(ctx.orgId, i.skillId), null);
+                    const agents = p?.agents.length ?? 0;
+                    const handed = p?.outcome === "transferred";
+                    return {
+                        zh: `删除组织技能「${n}」：${agents} 个智能体将失去它${handed ? "；其他组织在用，将转为平台技能" : ""}`,
+                        en: `Delete org skill "${n}": ${agents} agents lose it${handed ? "; another org uses it, so it becomes a platform skill" : ""}`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    id: input.skillId,
+                    outcome: await this.owned.deleteSkill(ctx.orgId, ctx.actorAccountId, input.skillId, {
+                        auditDetail: viaAgent("skills.delete", ctx),
+                    }),
+                }),
+            }),
+        ]);
+    }
+};
+SkillsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(SkillsService)),
+    __param(2, Inject(OwnedItems))
+], SkillsOperations);
+export { SkillsOperations };

package/dist/platform/ops/summary.d.ts

@@ -0,0 +1,10 @@
+import type { LocalizedName } from "@capybara-hq/plugin-sdk";
+/** A name as a card summary quotes it: clipped to {@link NAME_MAX}. */
+export declare const named: (s: string) => string;
+/** A display name in both languages, clipped; `fallback` (the plain name) for a missing one. */
+export declare const localized: (n: LocalizedName | null | undefined, fallback: string) => {
+    zh: string;
+    en: string;
+};
+/** The value of `read`, or `fallback` when the read throws (a summary never fails on a name). */
+export declare function orElse<T>(read: () => Promise<T>, fallback: T): Promise<T>;

package/dist/platform/ops/summary.js

@@ -0,0 +1,18 @@
+/** Longest name quoted in a card summary (a name is set by people, and by agents through tools). */
+const NAME_MAX = 80;
+/** A name as a card summary quotes it: clipped to {@link NAME_MAX}. */
+export const named = (s) => (s.length > NAME_MAX ? `${s.slice(0, NAME_MAX)}…` : s);
+/** A display name in both languages, clipped; `fallback` (the plain name) for a missing one. */
+export const localized = (n, fallback) => ({
+    zh: named(n?.zh ?? fallback),
+    en: named(n?.en ?? fallback),
+});
+/** The value of `read`, or `fallback` when the read throws (a summary never fails on a name). */
+export async function orElse(read, fallback) {
+    try {
+        return await read();
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/platform/ops/themes.ops.d.ts

@@ -0,0 +1,14 @@
+import { type OnModuleInit } from "@nestjs/common";
+import { ThemesService } from "../../themes/themes.service.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Theme operations of the `Platform` tool (themes spec §9): the org's theme listing. Setting a
+ * theme goes through the settings operations (`platform.set-preferences`, `org-settings.update`,
+ * `admin.update-settings`).
+ */
+export declare class ThemesOperations implements OnModuleInit {
+    private readonly registry;
+    private readonly themes;
+    constructor(registry: PlatformOperations, themes: ThemesService);
+    onModuleInit(): void;
+}

package/dist/platform/ops/themes.ops.js

@@ -0,0 +1,47 @@
+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 { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { ThemesService } from "../../themes/themes.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Theme operations of the `Platform` tool (themes spec §9): the org's theme listing. Setting a
+ * theme goes through the settings operations (`platform.set-preferences`, `org-settings.update`,
+ * `admin.update-settings`).
+ */
+let ThemesOperations = class ThemesOperations {
+    registry;
+    themes;
+    constructor(registry, themes) {
+        this.registry = registry;
+        this.themes = themes;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "themes.list",
+                description: "List the themes on in this org (id, version, name, schemes, logo and the bg / panel / ink / accent swatches per scheme), the theme in effect for you here (resolved; null is the built-in theme) and the org's setting (its default theme id, null following the platform, and whether personal picks are allowed or locked). Use a theme id with platform.set-preferences to change your own theme, or with org-settings.update to change the org's default.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { orgAction: "org.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/themes"],
+                confirm: "read",
+                run: async (_input, ctx) => this.themes.forOrg(ctx.orgId, ctx.actorAccountId),
+            }),
+        ]);
+    }
+};
+ThemesOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(ThemesService))
+], ThemesOperations);
+export { ThemesOperations };

package/dist/platform/ops/unavailable.d.ts

@@ -0,0 +1,23 @@
+import type { PluginUnavailableReason } from "../../catalog/catalog-content.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+import { type ErrorRole } from "../errors.js";
+import type { OperationContext, OperationErrorNext } from "../operation.js";
+/** The next step for an unavailable plugin or extension, keyed by role. */
+export declare function unavailableNext(reason: PluginUnavailableReason, name: string): OperationErrorNext;
+/** Why it cannot be used: "The extension of plugin "X" is not running on the platform: … (reason)." */
+export declare function unavailableMessage(reason: PluginUnavailableReason, name: string): string;
+/** The fields an unavailable list row or detail adds: the reason and the role's next step. */
+export declare function unavailableFields(reason: PluginUnavailableReason | undefined, name: string, role: ErrorRole): {
+    reason?: PluginUnavailableReason;
+    next?: string;
+};
+/**
+ * The actor's role for next steps: the one the tool derived from this call's actor facts
+ * (`ctx.errorRole`), else read now with {@link errorRoleFor} (a context no tool call is behind).
+ */
+export declare function roleFor(db: KernelSchemaDb, ctx: OperationContext): Promise<ErrorRole>;
+/**
+ * The actor's role for next steps, read now (the super admin first, then an org admin): the
+ * fallback of {@link roleFor}, the same rule as `errorRoleOf` over `PlatformActor` facts.
+ */
+export declare function errorRoleFor(db: KernelSchemaDb, orgId: string, accountId: string): Promise<ErrorRole>;