@homeflare/alchemy 0.52.0 → 0.53.0

package/src/grafana/team.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `Grafana.Team` against a fake Grafana through the real `@distilled.cloud/grafana` protocol:
+ * exact-name observe (adopt), create body, update only on drift, provisioned refusal, idempotent delete.
+ */
+import { describe, expect, test } from 'bun:test';
+import type { GrafanaOpContext } from '@distilled.cloud/grafana/Protocol';
+import * as Effect from 'effect/Effect';
+import { fakeFailure, fakeGrafana, fakeGrafanaLayer } from './fake-grafana.ts';
+import { grafanaOperations } from './resource.ts';
+import { spec } from './team.ts';
+
+const team = (over: Record<string, unknown> = {}) => ({
+  id: 7,
+  uid: 'aex7',
+  name: 'village-grafana',
+  email: '',
+  isProvisioned: false,
+  memberCount: 0,
+  orgId: 1,
+  ...over,
+});
+const search = (teams: unknown[]) =>
+  Response.json({ teams, totalCount: teams.length, page: 1, perPage: 100 });
+const run = <A, E>(
+  fake: ReturnType<typeof fakeGrafana>,
+  effect: Effect.Effect<A, E, GrafanaOpContext>,
+): Promise<A> => Effect.runPromise(effect.pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))));
+const props = { name: 'village-grafana' };
+
+describe('Grafana.Team', () => {
+  test('fetchLive keeps only an exact name match, GET without a body', async () => {
+    const fake = fakeGrafana((m, url) =>
+      m === 'GET' && url.pathname === '/api/teams/search'
+        ? search([team({ name: 'village-grafana-old', id: 9 }), team()])
+        : fakeFailure(404, 'x'),
+    );
+    const live = await run(fake, spec.fetchLive(props));
+    expect(live?.id).toBe(7);
+    expect(fake.bodies[0]).toBeUndefined();
+  });
+
+  test('absent team folds to undefined; 403 propagates', async () => {
+    expect(
+      await run(
+        fakeGrafana(() => search([])),
+        spec.fetchLive(props),
+      ),
+    ).toBeUndefined();
+    const failure = await run(
+      fakeGrafana(() => fakeFailure(403, 'forbidden')),
+      Effect.flip(spec.fetchLive(props)),
+    );
+    expect((failure as { _tag: string })._tag).toBe('Forbidden');
+  });
+
+  test('reconcile adopts a matching live team with no write', async () => {
+    const fake = fakeGrafana((m) =>
+      m === 'GET' ? search([team()]) : fakeFailure(500, 'no write expected'),
+    );
+    const out = await run(fake, grafanaOperations(spec).reconcile(props));
+    expect(out).toMatchObject({ id: 7, name: 'village-grafana' });
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+
+  test('reconcile creates when absent, sending only declared fields', async () => {
+    let created = false;
+    const fake = fakeGrafana((m) => {
+      if (m === 'POST') {
+        created = true;
+        return Response.json({ teamId: 7, uid: 'aex7', message: 'Team created' });
+      }
+      return search(created ? [team()] : []);
+    });
+    await run(fake, grafanaOperations(spec).reconcile(props));
+    expect(fake.bodies.filter((b) => b !== undefined)).toEqual([{ name: 'village-grafana' }]);
+  });
+
+  test('email drift updates by team id', async () => {
+    let updated = false;
+    const fake = fakeGrafana((m) => {
+      if (m === 'PUT') {
+        updated = true;
+        return Response.json({ message: 'Team updated' });
+      }
+      return search([team({ email: updated ? 'ops@example.com' : '' })]);
+    });
+    await run(fake, grafanaOperations(spec).reconcile({ ...props, email: 'ops@example.com' }));
+    expect(fake.seen.some((s) => s.method === 'PUT' && s.path === '/api/teams/7')).toBe(true);
+  });
+
+  test('a provisioned team refuses update and delete without writing', async () => {
+    const fake = fakeGrafana(() => search([team({ isProvisioned: true, email: 'a@b' })]));
+    const failure = await run(
+      fake,
+      Effect.flip(grafanaOperations(spec).reconcile({ ...props, email: 'ops@example.com' })),
+    );
+    expect((failure as { _tag: string })._tag).toBe('GrafanaProvisionedObjectError');
+    const del = await run(fake, Effect.flip(grafanaOperations(spec).destroy(props)));
+    expect((del as { _tag: string })._tag).toBe('GrafanaProvisionedObjectError');
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+
+  test('delete is idempotent when the team is already gone', async () => {
+    const fake = fakeGrafana(() => search([]));
+    await run(fake, grafanaOperations(spec).destroy(props));
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+});

package/src/grafana/team.ts

@@ -0,0 +1,105 @@
+/**
+ * `Grafana.Team` — a Grafana team, keyed by NAME.
+ *
+ * Walked against `@distilled.cloud/grafana` 0.2.1 (`@homeflare/distilled-grafana`): `searchTeams`,
+ * `createTeam`, `updateTeam`, `deleteTeam`. Upstream Alchemy ships no Grafana family (S1); distilled
+ * ships the SDK, so every call goes through it (S23).
+ *
+ * ★ NAME IS THE KEY, NOT `uid`. `CreateTeamRequest` takes only `name`/`email` — there is no way to
+ *   choose a team uid, and Grafana enforces unique team names per org. `fetchLive` therefore runs
+ *   `GET /teams/search?name=<name>` (an exact-name filter) and keeps only an exact match; adoption of a
+ *   team created by hand or by a script is a plain observe (S9/S10).
+ * ★ `email` is optional and compared only when declared ("undeclared means don't care", the kit's
+ *   convention for optional props).
+ * ⛔ A provisioned team (`isProvisioned`, e.g. synced from SCIM/LDAP) is refused for update and delete.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as grafana from '@distilled.cloud/grafana';
+import * as Effect from 'effect/Effect';
+import { type GrafanaProvisionedObjectError, refuseIfProvisioned } from './provisioned.ts';
+import { type GrafanaSpec, grafanaHandlers } from './resource.ts';
+
+export interface TeamProps {
+  /** Team name — unique per org, and this resource's identity. */
+  name: string;
+  /** Optional team email; compared only when declared. */
+  email?: string;
+}
+
+export interface TeamAttributes {
+  id: number;
+  uid: string;
+  name: string;
+  email: string;
+  isProvisioned: boolean;
+}
+
+export interface GrafanaTeam extends Resource<'Grafana.Team', TeamProps, TeamAttributes, never> {}
+
+export const GrafanaTeam = Resource<GrafanaTeam>('Grafana.Team');
+
+/** Exact-name lookup. `/teams/search?name=` is already exact in Grafana; the filter keeps that true. */
+export const findTeamByName = (name: string) =>
+  grafana
+    .searchTeams({ name, perpage: 100 })
+    .pipe(Effect.map((result) => (result.teams ?? []).find((team) => team.name === name)));
+
+export const spec: GrafanaSpec<
+  TeamProps,
+  grafana.TeamDTO,
+  TeamAttributes,
+  | grafana.SearchTeamsError
+  | grafana.CreateTeamError
+  | grafana.UpdateTeamError
+  | grafana.DeleteTeamError
+  | GrafanaProvisionedObjectError
+> = {
+  attributes: (live) => ({
+    email: live.email ?? '',
+    id: live.id,
+    isProvisioned: live.isProvisioned,
+    name: live.name,
+    uid: live.uid,
+  }),
+  create: (props) =>
+    grafana.createTeam({
+      name: props.name,
+      ...(props.email === undefined ? {} : { email: props.email }),
+    }),
+  destroy: (props, live) =>
+    Effect.gen(function* () {
+      if (live.isProvisioned) {
+        return yield* refuseIfProvisioned(
+          'Grafana.Team',
+          props.name,
+          'an external team sync (isProvisioned)',
+        );
+      }
+      yield* grafana.deleteTeam({ team_id: String(live.id) });
+    }),
+  fetchLive: (props) => findTeamByName(props.name),
+  matches: (attributes, props) =>
+    attributes.name === props.name &&
+    (props.email === undefined || attributes.email === props.email),
+  update: (props, live) =>
+    Effect.gen(function* () {
+      if (live.isProvisioned) {
+        return yield* refuseIfProvisioned(
+          'Grafana.Team',
+          props.name,
+          'an external team sync (isProvisioned)',
+        );
+      }
+      return yield* grafana.updateTeam({
+        team_id: String(live.id),
+        name: props.name,
+        ...(props.email === undefined ? {} : { email: props.email }),
+      });
+    }),
+};
+
+export const handlers = grafanaHandlers(spec);
+
+export const GrafanaTeamProvider = () =>
+  Provider.effect(GrafanaTeam, Effect.succeed(GrafanaTeam.Provider.of(handlers)));

package/src/litellm/fake-marketplace-litellm.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Fake-level assertions for `fake-marketplace-litellm.ts` against the distilled 1.103.0 route docs.
+ */
+import { expect, test } from 'bun:test';
+import { credentials } from '@distilled.cloud/litellm/Credentials';
+import * as Effect from 'effect/Effect';
+import * as FetchHttpClient from 'effect/http/FetchHttpClient';
+import * as Layer from 'effect/Layer';
+import { registerPlugin, updatePlugin } from './marketplace-operations.ts';
+import { FAKE_BASE } from './fake-litellm.ts';
+import { pluginRow, startFakeMarketplaceLitellm } from './fake-marketplace-litellm.ts';
+import { FAKE_KEY } from './fake-registry-base.ts';
+
+const run = <A, E>(fetchFn: typeof globalThis.fetch, effect: Effect.Effect<A, E, unknown>) =>
+  Effect.runPromise(
+    effect.pipe(
+      Effect.provide(FetchHttpClient.layer),
+      Effect.provide(Layer.succeed(FetchHttpClient.Fetch, fetchFn)),
+      Effect.provide(credentials({ apiKey: FAKE_KEY, baseUrl: FAKE_BASE })),
+    ) as Effect.Effect<A, E, never>,
+  );
+
+test('register is create-only: a second POST of the same name returns 409 and changes nothing', async () => {
+  const fake = startFakeMarketplaceLitellm();
+  await run(fake.fetch, registerPlugin({ name: 'fake-workflows', source: { source: 'github' } }));
+  const before = fake.plugins()[0];
+  await expect(
+    run(fake.fetch, registerPlugin({ name: 'fake-workflows', source: { source: 'github' } })),
+  ).rejects.toThrow();
+  expect(fake.plugins()).toHaveLength(1);
+  expect(fake.plugins()[0]).toEqual(before);
+});
+
+test('PUT is a full replace: an omitted description is reset to null', async () => {
+  const fake = startFakeMarketplaceLitellm({
+    seed: [
+      pluginRow({
+        description: 'FAKE workflows',
+        name: 'fake-workflows',
+        source: { source: 'github', repo: 'FAKE-org/FAKE-repo' },
+      }),
+    ],
+  });
+  await run(
+    fake.fetch,
+    updatePlugin('fake-workflows', {
+      source: { source: 'github', repo: 'FAKE-org/FAKE-repo' },
+    }),
+  );
+  expect(fake.plugins()[0]).toMatchObject({ description: null, name: 'fake-workflows' });
+});

package/src/litellm/fake-marketplace-litellm.ts

@@ -0,0 +1,134 @@
+/**
+ * A fake of LiteLLM's `/claude-code/*` routes for tests — TEST ONLY. Skeleton and the rules every
+ * fake follows: fake-registry-base.ts.
+ *
+ * ★ MEASURED AGAINST THE GENERATED 1.103.0 ROUTE DOCS:
+ *   - `POST /claude-code/plugins` is create-only and never overwrites; if `name` already exists it
+ *     returns 409 Conflict (`claude_code_marketplace.ts:546`).
+ *   - `PUT /claude-code/plugins/{name}` is a full replace, not a merge: any optional field left out
+ *     is reset to its default (`claude_code_marketplace.ts:563`).
+ *   - `PluginListItem` optional fields: author, category, description, domain, homepage, keywords,
+ *     namespace, version (`claude_code_marketplace.ts:211-226`).
+ *   - Enable/disable flip `enabled`; `GET /claude-code/marketplace.json` lists only enabled plugins.
+ *   - Writes need an admin key (`forbidWrites` models the 403).
+ *   - `registerDisabled` models a proxy whose register leaves the plugin disabled, which the resource
+ *     must not trust. `ignoreSource` models a PUT that drops the source field.
+ * ⚠️ EVERY OTHER ANSWER IS UNMEASURED; shapes come from the generated 1.103.0 schema.
+ */
+import { FAKE_KEY, type FakeRecord, json, recordingFetch } from './fake-registry-base.ts';
+import type { Row } from './registry-support.ts';
+
+export interface FakeMarketplaceLitellm extends FakeRecord {
+  readonly plugins: () => readonly Row[];
+  /** The names `GET /claude-code/marketplace.json` lists right now. */
+  readonly listed: () => Promise<readonly string[]>;
+}
+
+export interface FakeMarketplaceOptions {
+  readonly seed?: readonly Row[];
+  readonly forbidWrites?: boolean;
+  readonly registerDisabled?: boolean;
+  readonly ignoreSource?: boolean;
+}
+
+export const pluginRow = (fields: Row): Row => ({
+  created_at: '2026-10-12T00:00:00Z',
+  description: null,
+  enabled: true,
+  id: `FAKE-plugin-${String(fields['name'])}`,
+  source: { repo: 'FAKE-org/FAKE-repo', source: 'github' },
+  updated_at: '2026-10-12T00:00:00Z',
+  version: null,
+  ...fields,
+});
+
+const OPTIONAL_PUT_FIELDS = [
+  'author',
+  'category',
+  'description',
+  'domain',
+  'homepage',
+  'keywords',
+  'namespace',
+  'version',
+] as const;
+
+export const startFakeMarketplaceLitellm = (
+  options: FakeMarketplaceOptions = {},
+): FakeMarketplaceLitellm => {
+  let rows: Row[] = (options.seed ?? []).map((row) => ({ ...row }));
+
+  const record = recordingFetch(FAKE_KEY, ({ body, request, url }) => {
+    const byName = /^\/claude-code\/plugins\/([^/]+)(\/enable|\/disable)?$/.exec(url.pathname);
+    if (url.pathname === '/claude-code/plugins' && request.method === 'GET') {
+      return json(200, { count: rows.length, plugins: rows });
+    }
+    if (url.pathname === '/claude-code/marketplace.json' && request.method === 'GET') {
+      return json(200, {
+        name: 'FAKE-litellm',
+        plugins: rows
+          .filter((row) => row['enabled'] === true)
+          .map((row) => ({ name: row['name'] })),
+      });
+    }
+    if (request.method !== 'GET' && options.forbidWrites === true) {
+      return json(403, { detail: { error: 'not_allowed_access' } });
+    }
+    if (url.pathname === '/claude-code/plugins' && request.method === 'POST') {
+      const name = body['name'];
+      if (rows.some((row) => row['name'] === name)) {
+        return json(409, { detail: `Plugin '${name}' already exists` });
+      }
+      const next = pluginRow({
+        ...body,
+        enabled: options.registerDisabled !== true,
+      });
+      rows = [...rows, next];
+      return json(200, { action: 'created', plugin: next, status: 'success' });
+    }
+    if (byName !== null) {
+      const name = decodeURIComponent(byName[1] ?? '');
+      const at = rows.findIndex((row) => row['name'] === name);
+      if (at === -1) return json(404, { detail: `Plugin '${name}' not found` });
+      const row = rows[at];
+      if (row === undefined) return json(404, { detail: `Plugin '${name}' not found` });
+      if (request.method === 'PUT') {
+        const reset = Object.fromEntries(
+          OPTIONAL_PUT_FIELDS.map((field) => [field, body[field] ?? null]),
+        );
+        const source = options.ignoreSource === true ? row['source'] : body['source'];
+        const next = pluginRow({
+          ...row,
+          ...reset,
+          source,
+        });
+        rows = rows.map((each, i) => (i === at ? next : each));
+        return json(200, { action: 'updated', plugin: next, status: 'success' });
+      }
+      if (request.method === 'POST' && byName[2] !== undefined) {
+        rows = rows.map((each, i) =>
+          i === at ? { ...each, enabled: byName[2] === '/enable' } : each,
+        );
+        return json(200, { status: 'success' });
+      }
+      if (request.method === 'DELETE') {
+        rows = rows.filter((_, i) => i !== at);
+        return json(200, { status: 'success' });
+      }
+    }
+    return json(404, { detail: 'not found' });
+  });
+
+  return {
+    ...record,
+    listed: async () => {
+      const response = await record.fetch('http://fake.local/claude-code/marketplace.json', {
+        headers: { authorization: `Bearer ${FAKE_KEY}` },
+        method: 'GET',
+      });
+      const payload = (await response.json()) as { plugins?: readonly { name?: unknown }[] };
+      return (payload.plugins ?? []).map((each) => String(each.name));
+    },
+    plugins: () => rows.map((row) => ({ ...row })),
+  };
+};

package/src/litellm/index.ts

@@ -79,6 +79,14 @@ export {
   type AccessGroupError,
   type AccessGroupProps,
 } from './access-group.ts';
+export {
+  LiteLLMClaudeCodeMarketplacePlugin,
+  LiteLLMClaudeCodeMarketplacePluginProvider,
+  isLiteLLMClaudeCodeMarketplacePlugin,
+  type MarketplacePluginAttributes,
+  type MarketplacePluginError,
+  type MarketplacePluginProps,
+} from './marketplace-plugin.ts';
 export {
   LiteLLMPolicyAttachment,
   LiteLLMPolicyAttachmentProvider,

package/src/litellm/marketplace-form.ts

@@ -0,0 +1,160 @@
+/**
+ * Wire bodies, comparison and refusals for `LiteLLM.ClaudeCodeMarketplacePlugin`.
+ *
+ * ★ THE UPDATE IS A FULL PUT: `source` is required and `version` is "cleared if omitted"
+ *   (`claude_code_marketplace.ts:563`), so an update carries every optional field the plugin
+ *   already has; a field the declaration leaves out is re-sent as it is live, never wiped.
+ * ★ REGISTER IS CREATE-ONLY: `POST /claude-code/plugins` returns 409 if the name already exists
+ *   (`claude_code_marketplace.ts:546`), so `reconcile` registers only after a list shows the name
+ *   absent.
+ */
+import type * as cc from '@distilled.cloud/litellm/claude_code_marketplace';
+import {
+  asRow,
+  canonical,
+  firstBadEntry,
+  firstDuplicate,
+  isBlank,
+  sameSet,
+  stringOrNull,
+  stringsOf,
+} from './registry-support.ts';
+import type { MarketplacePluginAttributes, MarketplacePluginProps } from './marketplace-types.ts';
+
+const TEXT = ['description', 'version', 'domain', 'namespace', 'category', 'homepage'] as const;
+
+const SOURCE_KINDS = new Set(['github', 'url', 'git-subdir', 'archive']);
+
+/** The first reason a declaration is refused, or `undefined`. Runs before any request. */
+export const firstProblem = (props: MarketplacePluginProps): string | undefined => {
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(String(props.pluginName))) {
+    return '`pluginName` must be kebab-case (lowercase letters, digits and single hyphens)';
+  }
+  const source = props.source as Readonly<Record<string, unknown>> | undefined;
+  if (source === undefined || isBlank(source['source'])) {
+    return '`source` needs a `source` kind (github, url, git-subdir or archive)';
+  }
+  if (!SOURCE_KINDS.has(String(source['source']))) {
+    return `\`source.source\` must be github, url, git-subdir or archive`;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (isBlank(key) || isBlank(value)) return `\`source.${key}\` is blank`;
+  }
+  for (const field of TEXT) {
+    if (props[field] !== undefined && isBlank(props[field])) {
+      return `\`${field}\` is blank; leave it out to keep the live text`;
+    }
+  }
+  if (props.author !== undefined && isBlank(props.author.name)) return '`author.name` is blank';
+  const bad = firstBadEntry(props.keywords ?? []);
+  if (bad !== undefined) return `\`keywords\` has a blank or padded entry (${JSON.stringify(bad)})`;
+  const twice = firstDuplicate(props.keywords ?? []);
+  if (twice !== undefined) return `\`keywords\` lists ${JSON.stringify(twice)} twice`;
+  return undefined;
+};
+
+const sourceOf = (value: unknown): Readonly<Record<string, string>> =>
+  Object.fromEntries(
+    Object.entries(asRow(value) ?? {}).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  );
+
+/** One list item. `undefined` is "not a plugin row": the caller refuses the whole answer. */
+export const toAttributes = (value: unknown): MarketplacePluginAttributes | undefined => {
+  const row = asRow(value);
+  if (row === undefined) return undefined;
+  const pluginId = row['id'];
+  const pluginName = row['name'];
+  if (typeof pluginId !== 'string' || typeof pluginName !== 'string') return undefined;
+  const author = asRow(row['author']);
+  return {
+    author:
+      author !== undefined && typeof author['name'] === 'string'
+        ? { email: stringOrNull(author['email']), name: author['name'] }
+        : null,
+    category: stringOrNull(row['category']),
+    description: stringOrNull(row['description']),
+    domain: stringOrNull(row['domain']),
+    enabled: row['enabled'] === true,
+    homepage: stringOrNull(row['homepage']),
+    keywords: canonical(stringsOf(row['keywords'])),
+    namespace: stringOrNull(row['namespace']),
+    pluginId,
+    pluginName,
+    source: sourceOf(row['source']),
+    version: stringOrNull(row['version']),
+  };
+};
+
+const sameSource = (
+  left: Readonly<Record<string, string>>,
+  right: Readonly<Record<string, string>>,
+): boolean => {
+  const a = Object.entries(left).sort(([x], [y]) => x.localeCompare(y));
+  const b = Object.entries(right).sort(([x], [y]) => x.localeCompare(y));
+  return a.length === b.length && a.every(([k, v], i) => k === b[i]?.[0] && v === b[i]?.[1]);
+};
+
+/** Wire names where live and declared disagree. Optional fields count only when declared. */
+export const differing = (
+  live: MarketplacePluginAttributes,
+  props: MarketplacePluginProps,
+): readonly string[] => {
+  const fields: string[] = [];
+  if (!sameSource(live.source, props.source)) fields.push('source');
+  for (const field of TEXT) {
+    if (props[field] !== undefined && live[field] !== props[field]) fields.push(field);
+  }
+  if (props.keywords !== undefined && !sameSet(live.keywords, props.keywords)) {
+    fields.push('keywords');
+  }
+  if (props.author !== undefined) {
+    const same =
+      live.author?.name === props.author.name &&
+      (props.author.email === undefined || live.author.email === props.author.email);
+    if (!same) fields.push('author');
+  }
+  if (live.enabled !== (props.enabled ?? true)) fields.push('enabled');
+  return fields;
+};
+
+/** The metadata both writes share. `live` is the row an update must not wipe. */
+const metadata = (props: MarketplacePluginProps, live?: MarketplacePluginAttributes) => {
+  const author: { name: string; email?: string } | undefined = props.author
+    ? { name: props.author.name }
+    : live?.author
+      ? { name: live.author.name }
+      : undefined;
+  if (author !== undefined) {
+    const keep = props.author?.email ?? live?.author?.email;
+    if (keep !== undefined && keep !== null) {
+      author.email = keep;
+    }
+  }
+  const keywords = props.keywords ?? (live?.keywords.length ? live.keywords : undefined);
+  return {
+    ...(author === undefined ? {} : { author }),
+    ...Object.fromEntries(
+      TEXT.flatMap((field) => {
+        const value = props[field] ?? live?.[field] ?? undefined;
+        return value === undefined ? [] : [[field, value]];
+      }),
+    ),
+    ...(keywords === undefined ? {} : { keywords: [...keywords] }),
+    source: { ...props.source },
+  };
+};
+
+export const registerBody = (
+  props: MarketplacePluginProps,
+): cc.RegisterPluginClaudeCodePluginsPostRequest => ({
+  ...metadata(props),
+  name: props.pluginName,
+});
+
+export const updateBody = (
+  props: MarketplacePluginProps,
+  live: MarketplacePluginAttributes,
+): Omit<cc.UpdatePluginClaudeCodePluginsPluginNamePutRequest, 'plugin_name'> =>
+  metadata(props, live);

package/src/litellm/marketplace-operations.ts

@@ -0,0 +1,76 @@
+/**
+ * The LiteLLM `/claude-code/plugins*` calls `LiteLLM.ClaudeCodeMarketplacePlugin` uses, through
+ * `@distilled.cloud/litellm/claude_code_marketplace` (1.103.0):
+ *
+ *   list     `listPluginsClaudeCodePluginsGet`                      GET    /claude-code/plugins
+ *   register `registerPluginClaudeCodePluginsPost`                  POST   /claude-code/plugins
+ *   update   `updatePluginClaudeCodePluginsPluginNamePut`           PUT    /claude-code/plugins/{name}
+ *   enable   `enablePluginClaudeCodePluginsPluginNameEnablePost`    POST   …/{name}/enable
+ *   disable  `disablePluginClaudeCodePluginsPluginNameDisablePost`  POST   …/{name}/disable
+ *   delete   `deletePluginClaudeCodePluginsPluginNameDelete`        DELETE /claude-code/plugins/{name}
+ *
+ * ⛔ WRITES NEED A PROXY ADMIN KEY. ⛔ NO MESSAGE SNIFFING: the by-name GET is not used, the list
+ *   decides absence (registry-support.ts says why). ★ DELETE IS IDEMPOTENT BY A REAL READ: a failed
+ *   DELETE is swallowed only when the list no longer has the name; otherwise the ORIGINAL error rises.
+ */
+import * as cc from '@distilled.cloud/litellm/claude_code_marketplace';
+import * as Effect from 'effect/Effect';
+import { type LitellmOpContext, throughFetch } from './operations.ts';
+import { LitellmRegistryUnreadableError } from './registry-errors.ts';
+import { asRow, bodyOf } from './registry-support.ts';
+import type { MarketplacePluginAttributes } from './marketplace-types.ts';
+import { toAttributes } from './marketplace-form.ts';
+
+const RESOURCE = 'LiteLLM.ClaudeCodeMarketplacePlugin';
+
+/** Every plugin, enabled or not (`enabled_only` unset). */
+export const listPlugins = (): Effect.Effect<
+  readonly MarketplacePluginAttributes[],
+  cc.ListPluginsClaudeCodePluginsGetError | LitellmRegistryUnreadableError,
+  LitellmOpContext
+> =>
+  throughFetch(cc.listPluginsClaudeCodePluginsGet({})).pipe(
+    Effect.flatMap((response) => {
+      const items = asRow(bodyOf(response))?.['plugins'];
+      const parsed = Array.isArray(items) ? items.map(toAttributes) : undefined;
+      return parsed !== undefined && parsed.every((row) => row !== undefined)
+        ? Effect.succeed(parsed as readonly MarketplacePluginAttributes[])
+        : Effect.fail(
+            new LitellmRegistryUnreadableError({
+              reason: 'no plugins array of rows with an id and a name',
+              resource: RESOURCE,
+            }),
+          );
+    }),
+  );
+
+export const registerPlugin = (body: cc.RegisterPluginClaudeCodePluginsPostRequest) =>
+  throughFetch(cc.registerPluginClaudeCodePluginsPost(body)).pipe(Effect.asVoid);
+
+export const updatePlugin = (
+  name: string,
+  body: Omit<cc.UpdatePluginClaudeCodePluginsPluginNamePutRequest, 'plugin_name'>,
+) =>
+  throughFetch(cc.updatePluginClaudeCodePluginsPluginNamePut({ ...body, plugin_name: name })).pipe(
+    Effect.asVoid,
+  );
+
+export const setEnabled = (name: string, enabled: boolean) =>
+  throughFetch(
+    enabled
+      ? cc.enablePluginClaudeCodePluginsPluginNameEnablePost({ plugin_name: name })
+      : cc.disablePluginClaudeCodePluginsPluginNameDisablePost({ plugin_name: name }),
+  ).pipe(Effect.asVoid);
+
+export const deletePlugin = (name: string) =>
+  throughFetch(cc.deletePluginClaudeCodePluginsPluginNameDelete({ plugin_name: name })).pipe(
+    Effect.asVoid,
+    Effect.catch((original) =>
+      listPlugins().pipe(
+        Effect.catch(() => Effect.fail(original)),
+        Effect.flatMap((rows) =>
+          rows.some((row) => row.pluginName === name) ? Effect.fail(original) : Effect.void,
+        ),
+      ),
+    ),
+  );