@homeflare/alchemy 0.52.0 → 0.53.0

package/dist/litellm/marketplace-form.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 type { MarketplacePluginAttributes, MarketplacePluginProps } from './marketplace-types.ts';
+/** The first reason a declaration is refused, or `undefined`. Runs before any request. */
+export declare const firstProblem: (props: MarketplacePluginProps) => string | undefined;
+/** One list item. `undefined` is "not a plugin row": the caller refuses the whole answer. */
+export declare const toAttributes: (value: unknown) => MarketplacePluginAttributes | undefined;
+/** Wire names where live and declared disagree. Optional fields count only when declared. */
+export declare const differing: (live: MarketplacePluginAttributes, props: MarketplacePluginProps) => readonly string[];
+export declare const registerBody: (props: MarketplacePluginProps) => cc.RegisterPluginClaudeCodePluginsPostRequest;
+export declare const updateBody: (props: MarketplacePluginProps, live: MarketplacePluginAttributes) => Omit<cc.UpdatePluginClaudeCodePluginsPluginNamePutRequest, 'plugin_name'>;
+//# sourceMappingURL=marketplace-form.d.ts.map

package/dist/litellm/marketplace-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-form.d.ts","sourceRoot":"","sources":["../../src/litellm/marketplace-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,EAAE,MAAM,kDAAkD,CAAC;AAW5E,OAAO,KAAK,EAAE,2BAA2B,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAMlG,0FAA0F;AAC1F,eAAO,MAAM,YAAY,UAAW,sBAAsB,KAAG,MAAM,GAAG,SAyBrE,CAAC;AASF,6FAA6F;AAC7F,eAAO,MAAM,YAAY,UAAW,OAAO,KAAG,2BAA2B,GAAG,SAwB3E,CAAC;AAWF,6FAA6F;AAC7F,eAAO,MAAM,SAAS,SACd,2BAA2B,SAC1B,sBAAsB,KAC5B,SAAS,MAAM,EAiBjB,CAAC;AA6BF,eAAO,MAAM,YAAY,UAChB,sBAAsB,KAC5B,EAAE,CAAC,0CAGJ,CAAC;AAEH,eAAO,MAAM,UAAU,UACd,sBAAsB,QACvB,2BAA2B,KAChC,IAAI,CAAC,EAAE,CAAC,iDAAiD,EAAE,aAAa,CACpD,CAAC"}

package/dist/litellm/marketplace-operations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 } from './operations.ts';
+import { LitellmRegistryUnreadableError } from './registry-errors.ts';
+import type { MarketplacePluginAttributes } from './marketplace-types.ts';
+/** Every plugin, enabled or not (`enabled_only` unset). */
+export declare const listPlugins: () => Effect.Effect<readonly MarketplacePluginAttributes[], cc.ListPluginsClaudeCodePluginsGetError | LitellmRegistryUnreadableError, LitellmOpContext>;
+export declare const registerPlugin: (body: cc.RegisterPluginClaudeCodePluginsPostRequest) => Effect.Effect<void, cc.RegisterPluginClaudeCodePluginsPostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const updatePlugin: (name: string, body: Omit<cc.UpdatePluginClaudeCodePluginsPluginNamePutRequest, 'plugin_name'>) => Effect.Effect<void, cc.UpdatePluginClaudeCodePluginsPluginNamePutError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const setEnabled: (name: string, enabled: boolean) => Effect.Effect<void, cc.DisablePluginClaudeCodePluginsPluginNameDisablePostError, import("@distilled.cloud/litellm/Credentials").Credentials>;
+export declare const deletePlugin: (name: string) => Effect.Effect<void, cc.DeletePluginClaudeCodePluginsPluginNameDeleteError, LitellmOpContext>;
+//# sourceMappingURL=marketplace-operations.d.ts.map

package/dist/litellm/marketplace-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-operations.d.ts","sourceRoot":"","sources":["../../src/litellm/marketplace-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,MAAM,kDAAkD,CAAC;AACvE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAK1E,2DAA2D;AAC3D,eAAO,MAAM,WAAW,QAAO,MAAM,CAAC,MAAM,CAC1C,SAAS,2BAA2B,EAAE,EACtC,EAAE,CAAC,oCAAoC,GAAG,8BAA8B,EACxE,gBAAgB,CAef,CAAC;AAEJ,eAAO,MAAM,cAAc,SAAU,EAAE,CAAC,0CAA0C,iIACF,CAAC;AAEjF,eAAO,MAAM,YAAY,SACjB,MAAM,QACN,IAAI,CAAC,EAAE,CAAC,iDAAiD,EAAE,aAAa,CAAC,wIAI9E,CAAC;AAEJ,eAAO,MAAM,UAAU,SAAU,MAAM,WAAW,OAAO,iJAKlC,CAAC;AAExB,eAAO,MAAM,YAAY,SAAU,MAAM,iGAWtC,CAAC"}

package/dist/litellm/marketplace-plugin.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `LiteLLM.ClaudeCodeMarketplacePlugin` — one plugin registered in LiteLLM's Claude Code marketplace
+ * (`/claude-code/plugins`), which LiteLLM serves as `/claude-code/marketplace.json`. Types and what
+ * is left out: marketplace-types.ts.
+ *
+ * ★ ADOPT BY NAME. `name` is unique, so `pluginName` finds the one live row. A live row with no
+ *   state is `Unowned`, so it needs `--adopt`.
+ * ★ `defaultRemovalPolicy: 'retain'`: deleting a plugin removes the install source every Claude Code
+ *   client has pointed at. Opt in with `.pipe(RemovalPolicy.destroy())`.
+ * ★ A NEW NAME IS A REPLACE: the name is the path key of every call, so there is no rename. Under
+ *   the default `retain` the old plugin stays registered and listed until it is removed by hand or
+ *   the stack opts in with `.pipe(RemovalPolicy.destroy())`.
+ * ★ THE PROOF IS THE MARKETPLACE FILE: after a deploy, `GET /claude-code/marketplace.json` lists the
+ *   plugin only while it is enabled, which is why `enabled` is part of the declaration.
+ * ⛔ NO LITELLM CREDENTIAL IS A PROP; `litellmProviders`' layer supplies `Credentials`.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import type { MarketplacePluginAttributes, MarketplacePluginProps } from './marketplace-types.ts';
+import { LitellmRegistryAbsentAfterWriteError, LitellmRegistryNotConvergedError } from './registry-errors.ts';
+export type { MarketplacePluginAttributes, MarketplacePluginProps };
+export type { RegistryError as MarketplacePluginError } from './registry-errors.ts';
+export interface LiteLLMClaudeCodeMarketplacePlugin extends Resource<'LiteLLM.ClaudeCodeMarketplacePlugin', MarketplacePluginProps, MarketplacePluginAttributes> {
+}
+export declare const LiteLLMClaudeCodeMarketplacePlugin: import("alchemy").ResourceClass<LiteLLMClaudeCodeMarketplacePlugin>;
+export declare const isLiteLLMClaudeCodeMarketplacePlugin: (value: unknown) => value is LiteLLMClaudeCodeMarketplacePlugin;
+/** ⛔ TEST-ONLY EXPORT. Not on index.ts's barrel. */
+export declare const marketplacePluginHandlers: {
+    /** ⛔ With no `output` this is the adoption probe, so the refusals run here too. */
+    read: ({ olds, output, }: {
+        olds: MarketplacePluginProps;
+        output: MarketplacePluginAttributes | undefined;
+    }) => Effect.Effect<MarketplacePluginAttributes | undefined, import("./registry-errors.ts").LitellmRegistryUnreadableError | import("@distilled.cloud/litellm/claude_code_marketplace").ListPluginsClaudeCodePluginsGetError, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    diff: ({ news, output, }: {
+        news: Input<MarketplacePluginProps>;
+        output: MarketplacePluginAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'replace';
+    } | {
+        readonly action: 'noop';
+    } | {
+        readonly action: 'update';
+    } | undefined, import("./registry-errors.ts").LitellmRegistryInvalidError, never>;
+    reconcile: ({ news, output, }: {
+        news: MarketplacePluginProps;
+        output: MarketplacePluginAttributes | undefined;
+    }) => Effect.Effect<MarketplacePluginAttributes, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/litellm/Errors").LitellmParseError | LitellmRegistryAbsentAfterWriteError | import("./registry-errors.ts").LitellmRegistryInvalidError | LitellmRegistryNotConvergedError | import("./registry-errors.ts").LitellmRegistryUnreadableError | import("@distilled.cloud/caddy").ServiceUnavailable | import("@distilled.cloud/caddy").TooManyRequests | import("@distilled.cloud/caddy").Unauthorized | import("@distilled.cloud/litellm/Errors").UnknownLitellmError | import("@distilled.cloud/litellm/claude_code_marketplace").UnprocessableEntity, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    delete: ({ output }: {
+        output: MarketplacePluginAttributes;
+    }) => Effect.Effect<void, import("@distilled.cloud/litellm/claude_code_marketplace").DeletePluginClaudeCodePluginsPluginNameDeleteError, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+    /** ⛔ EMPTY: adoption is an explicit act (`--adopt`), and no ownership mark exists to filter by. */
+    list: () => Effect.Effect<never[], never, never>;
+};
+export declare const LiteLLMClaudeCodeMarketplacePluginProvider: () => import("effect/Layer").Layer<Provider.Provider<LiteLLMClaudeCodeMarketplacePlugin>, never, import("@distilled.cloud/litellm/Protocol").LitellmOpContext>;
+//# sourceMappingURL=marketplace-plugin.d.ts.map

package/dist/litellm/marketplace-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-plugin.d.ts","sourceRoot":"","sources":["../../src/litellm/marketplace-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAUxC,OAAO,KAAK,EAAE,2BAA2B,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EACL,oCAAoC,EACpC,gCAAgC,EACjC,MAAM,sBAAsB,CAAC;AAG9B,YAAY,EAAE,2BAA2B,EAAE,sBAAsB,EAAE,CAAC;AACpE,YAAY,EAAE,aAAa,IAAI,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAIpF,MAAM,WAAW,kCAAmC,SAAQ,QAAQ,CAClE,qCAAqC,EACrC,sBAAsB,EACtB,2BAA2B,CAC5B;CAAG;AAEJ,eAAO,MAAM,kCAAkC,qEAG9C,CAAC;AAEF,eAAO,MAAM,oCAAoC,UACxC,OAAO,KACb,KAAK,IAAI,kCACkF,CAAC;AAY/F,oDAAoD;AACpD,eAAO,MAAM,yBAAyB;IACpC,mFAAmF;IACnF,IAAI,sBAGD;QACD,IAAI,EAAE,sBAAsB,CAAC;QAC7B,MAAM,EAAE,2BAA2B,GAAG,SAAS,CAAC;KACjD;IAUD,IAAI,sBAGD;QACD,IAAI,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;QACpC,MAAM,EAAE,2BAA2B,GAAG,SAAS,CAAC;KACjD;yBAK+D,SAAS;;yBAEtD,MAAM;;yBACN,QAAQ;;IAG3B,SAAS,sBAGN;QACD,IAAI,EAAE,sBAAsB,CAAC;QAC7B,MAAM,EAAE,2BAA2B,GAAG,SAAS,CAAC;KACjD;IAkCD,MAAM,eAAe;QAAE,MAAM,EAAE,2BAA2B,CAAA;KAAE;IAE5D,mGAAmG;IACnG,IAAI;CACL,CAAC;AAEF,eAAO,MAAM,0CAA0C,gKAIpD,CAAC"}

package/dist/litellm/marketplace-types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What a `LiteLLM.ClaudeCodeMarketplacePlugin` declares (props) and remembers (attributes).
+ *
+ * ★ A PLUGIN IS A MARKETPLACE ENTRY, NOT A SKILL. LiteLLM serves `/claude-code/marketplace.json`
+ *   from the plugins registered under `/claude-code/plugins`; Claude Code installs from that
+ *   marketplace. The plugin folders a seat loads stay what they are (Tim, 2026-10-01); this entry
+ *   points the marketplace at the same folder through `source`.
+ * ★ THE NAME IS THE IDENTITY. `name` is the path key of every read, update and delete, so it cannot
+ *   be renamed in place: changing `pluginName` is a replace, never an update.
+ * ⚠️ `enabled` DEFAULTS TO `true`. A registered but disabled plugin is absent from the marketplace
+ *   file, so a declaration that means "listed" must also mean "enabled".
+ */
+export interface PluginAuthor {
+    readonly name: string;
+    readonly email?: string;
+}
+export interface MarketplacePluginProps {
+    /** kebab-case plugin name, e.g. `homeflare-workflows`. Also the way an existing row is adopted. */
+    readonly pluginName: string;
+    /**
+     * Where Claude Code fetches the plugin from, as LiteLLM takes it: `{ source: 'github', repo }`,
+     * `{ source: 'url', url }`, `{ source: 'git-subdir', url, path }` or `{ source: 'archive', url, sha256? }`.
+     * Always compared.
+     */
+    readonly source: Readonly<Record<string, string>>;
+    /** Compared only when declared: adopting never clears text a person wrote. */
+    readonly description?: string;
+    readonly version?: string;
+    readonly domain?: string;
+    readonly namespace?: string;
+    readonly category?: string;
+    readonly homepage?: string;
+    readonly keywords?: readonly string[];
+    readonly author?: PluginAuthor;
+    /** Whether the marketplace lists it. Default `true`. */
+    readonly enabled?: boolean;
+}
+export interface MarketplacePluginAttributes {
+    readonly pluginId: string;
+    readonly pluginName: string;
+    readonly source: Readonly<Record<string, string>>;
+    readonly enabled: boolean;
+    readonly description: string | null;
+    readonly version: string | null;
+    readonly domain: string | null;
+    readonly namespace: string | null;
+    readonly category: string | null;
+    readonly homepage: string | null;
+    readonly keywords: readonly string[];
+    readonly author: {
+        readonly name: string;
+        readonly email: string | null;
+    } | null;
+}
+//# sourceMappingURL=marketplace-types.d.ts.map

package/dist/litellm/marketplace-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-types.d.ts","sourceRoot":"","sources":["../../src/litellm/marketplace-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,mGAAmG;IACnG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CAClF"}

package/dist/litellm/providers.d.ts

@@ -20,5 +20,5 @@
  */
 import { type Credentials } from '@distilled.cloud/litellm/Credentials';
 import * as Layer from 'effect/Layer';
-export declare const litellmProviders: (creds?: Layer.Layer<Credentials>) => Layer.Layer<Credentials | import("alchemy").Provider<import("./access-group.ts").LiteLLMAccessGroup> | import("alchemy").Provider<import("./budget.ts").LiteLLMBudget> | import("alchemy").Provider<import("./credential.ts").LiteLLMCredential> | import("alchemy").Provider<import("./key.ts").LiteLLMKey> | import("alchemy").Provider<import("./mcp-server.ts").LiteLLMMCPServer> | import("alchemy").Provider<import("./model.ts").LiteLLMModel> | import("alchemy").Provider<import("./pass-through-endpoint.ts").LiteLLMPassThroughEndpoint> | import("alchemy").Provider<import("./policy.ts").LiteLLMPolicy> | import("alchemy").Provider<import("./policy-attachment.ts").LiteLLMPolicyAttachment> | import("alchemy").Provider<import("./team.ts").LiteLLMTeam> | import("alchemy").Provider<import("./tool-policy.ts").LiteLLMToolPolicy> | import("alchemy").Provider<import("./toolset.ts").LiteLLMToolset>, never, import("effect/http/HttpClient").HttpClient | import("alchemy").Stack | import("alchemy").Stage>;
+export declare const litellmProviders: (creds?: Layer.Layer<Credentials>) => Layer.Layer<Credentials | import("alchemy").Provider<import("./access-group.ts").LiteLLMAccessGroup> | import("alchemy").Provider<import("./budget.ts").LiteLLMBudget> | import("alchemy").Provider<import("./marketplace-plugin.ts").LiteLLMClaudeCodeMarketplacePlugin> | import("alchemy").Provider<import("./credential.ts").LiteLLMCredential> | import("alchemy").Provider<import("./key.ts").LiteLLMKey> | import("alchemy").Provider<import("./mcp-server.ts").LiteLLMMCPServer> | import("alchemy").Provider<import("./model.ts").LiteLLMModel> | import("alchemy").Provider<import("./pass-through-endpoint.ts").LiteLLMPassThroughEndpoint> | import("alchemy").Provider<import("./policy.ts").LiteLLMPolicy> | import("alchemy").Provider<import("./policy-attachment.ts").LiteLLMPolicyAttachment> | import("alchemy").Provider<import("./team.ts").LiteLLMTeam> | import("alchemy").Provider<import("./tool-policy.ts").LiteLLMToolPolicy> | import("alchemy").Provider<import("./toolset.ts").LiteLLMToolset>, never, import("effect/http/HttpClient").HttpClient | import("alchemy").Stack | import("alchemy").Stage>;
 //# sourceMappingURL=providers.d.ts.map

package/dist/litellm/providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/litellm/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,KAAK,WAAW,EAAsB,MAAM,sCAAsC,CAAC;AAC5F,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AActC,eAAO,MAAM,gBAAgB,WAAW,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,u+BAc7B,CAAC"}
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/litellm/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,KAAK,WAAW,EAAsB,MAAM,sCAAsC,CAAC;AAC5F,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAetC,eAAO,MAAM,gBAAgB,WAAW,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,0kCAe7B,CAAC"}

package/docs/litellm-marketplace.md

@@ -0,0 +1,59 @@
+# LiteLLM.ClaudeCodeMarketplacePlugin
+
+`LiteLLM.ClaudeCodeMarketplacePlugin` registers one plugin in LiteLLM's Claude Code
+marketplace. Plugins live under `/claude-code/plugins` and are served as
+`/claude-code/marketplace.json`; Claude Code installs from that marketplace, but the
+plugin folders a seat loads stay what they are (Tim, 2026-10-01). This entry points the
+marketplace at the same folder through `source`.
+
+Walked against LiteLLM **1.103.0** via `@homeflare/distilled-litellm@0.4.1`
+(`packages/distilled-litellm/src/services/claude_code_marketplace.ts`).
+
+## Identity
+
+`name` is the resource identity. It is the path key of every read, update and delete, so
+changing `pluginName` is a **replace**, not an update. Under the default `retain`, the
+old name stays registered and listed until it is removed by hand or the stack opts in
+with `.pipe(RemovalPolicy.destroy())`.
+
+## Source kinds
+
+`source.source` must be one of:
+
+- `github` — `repo: owner/name`
+- `url` — `url: <plugin.json URL>`
+- `git-subdir` — `url: <git URL>`, `path: <subdir>`
+- `archive` — `url: <archive URL>`, optional `sha256`
+
+## Behaviour
+
+- **Register** (`POST /claude-code/plugins`) is create-only and returns 409 if the name
+  already exists. The resource registers only after a list shows the name absent.
+- **Update** (`PUT /claude-code/plugins/{name}`) is a full replace, not a merge: any
+  optional field the declaration leaves out is reset. The provider re-sends the live
+  value of omitted optional fields so a person-written description, keywords, etc. are
+  never wiped.
+- **Enable/disable** is a separate route. The marketplace lists only enabled plugins,
+  so `enabled: true` (the default) is required for the plugin to be visible.
+- **Adoption** is by name. A live row with no recorded state is `Unowned`; pass
+  `--adopt` to take it without writing anything.
+- **Default removal policy is `retain`**. Deleting a plugin removes an install source
+  every Claude Code client has pointed at.
+
+## Example
+
+```ts
+import { LiteLLMClaudeCodeMarketplacePlugin, litellmProviders } from '@homeflare/alchemy/litellm';
+
+export class HomeflareWorkflows extends LiteLLMClaudeCodeMarketplacePlugin('HomeflareWorkflows', {
+  pluginName: 'homeflare-workflows',
+  source: { source: 'github', repo: 'homeflare/remote-claude-code' },
+  version: '0.1.0',
+  description: 'Homeflare workflows for Claude Code',
+  keywords: ['homeflare', 'workflows'],
+  author: { name: 'Homeflare', email: 'hello@homeflare.io' },
+  enabled: true,
+}) {}
+```
+
+Then provide `litellmProviders()` alongside the stack's other providers.

package/docs/litellm.md

@@ -19,6 +19,7 @@ Measured at 1.100.0 (`schema.prisma`, `pass_through_endpoints.py`, and the mini'
 | Family                                                                                                  | Managed by this resource?                                                                        |
 | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
 | Pass-through endpoints                                                                                  | Yes — this package                                                                               |
+| Claude Code marketplace plugins (`/claude-code/plugins`)                                                | Yes — `LiteLLM.ClaudeCodeMarketplacePlugin`, [litellm-marketplace.md](./litellm-marketplace.md)  |
 | Budgets (`/budget/*`)                                                                                   | Yes — `LiteLLM.Budget`, [litellm-budget.md](./litellm-budget.md)                                 |
 | MCP servers (`/v1/mcp/server`)                                                                          | Yes — `LiteLLM.MCPServer`, [litellm-mcp.md](./litellm-mcp.md)                                    |
 | Teams (`/team/*`)                                                                                       | Yes — `LiteLLM.Team`, [litellm-team.md](./litellm-team.md)                                       |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homeflare/alchemy",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "Custom Alchemy providers for Cloudflare, Proxmox, OpenBao, Forgejo, Talos, launchd and Caddy, and a verifier that proves adoptions are no-ops.",
   "homepage": "https://github.com/taslabs-net/homeflare-kit/tree/main/packages/alchemy#readme",
   "bugs": "https://github.com/taslabs-net/homeflare-kit/issues",

package/src/grafana/folder-permission.test.ts

@@ -0,0 +1,107 @@
+/**
+ * `Grafana.FolderPermission` against a fake Grafana: only DIRECT team entries count, writes go through
+ * the per-team endpoint (never the whole-list replace), missing team fails loudly, delete sets "".
+ */
+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 { spec } from './folder-permission.ts';
+import { grafanaOperations } from './resource.ts';
+
+const TEAMS = '/api/teams/search';
+const PERMS = '/api/access-control/folders/village-grafana';
+const SET = '/api/access-control/folders/village-grafana/teams/7';
+const teamRow = {
+  id: 7,
+  uid: 'aex7',
+  name: 'village-grafana',
+  isProvisioned: false,
+  memberCount: 0,
+  orgId: 1,
+};
+const props = {
+  folderUid: 'village-grafana',
+  teamName: 'village-grafana',
+  permission: 'Edit' as const,
+};
+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 grafanaWith = (entries: () => unknown[], teams = [teamRow]) =>
+  fakeGrafana((m, url) => {
+    if (m === 'GET' && url.pathname === TEAMS)
+      return Response.json({ teams, totalCount: teams.length });
+    if (m === 'GET' && url.pathname === PERMS) return Response.json(entries());
+    if (m === 'POST' && url.pathname === SET)
+      return Response.json({ message: 'Permission updated' });
+    return fakeFailure(404, `unexpected ${m} ${url.pathname}`);
+  });
+
+describe('Grafana.FolderPermission', () => {
+  test('an inherited entry for the team does not count as live', async () => {
+    const fake = grafanaWith(() => [
+      { teamId: 7, permission: 'Edit', isInherited: true },
+      { builtInRole: 'Admin', permission: 'Admin' },
+    ]);
+    expect(await run(fake, spec.fetchLive(props))).toBeUndefined();
+  });
+
+  test('a matching direct entry adopts with no write', async () => {
+    const fake = grafanaWith(() => [
+      { builtInRole: 'Viewer', permission: 'View', isInherited: true },
+      { teamId: 7, team: 'village-grafana', permission: 'Edit', isInherited: false },
+    ]);
+    const out = await run(fake, grafanaOperations(spec).reconcile(props));
+    expect(out).toEqual({
+      folderUid: 'village-grafana',
+      teamId: 7,
+      teamName: 'village-grafana',
+      permission: 'Edit',
+    });
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+
+  test('create writes only through the per-team endpoint', async () => {
+    const state = { set: false };
+    const fake = fakeGrafana((m, url) => {
+      if (m === 'GET' && url.pathname === TEAMS)
+        return Response.json({ teams: [teamRow], totalCount: 1 });
+      if (m === 'GET' && url.pathname === PERMS)
+        return Response.json(
+          state.set ? [{ teamId: 7, permission: 'Edit', isInherited: false }] : [],
+        );
+      if (m === 'POST' && url.pathname === SET) {
+        state.set = true;
+        return Response.json({ message: 'Permission updated' });
+      }
+      return fakeFailure(404, `unexpected ${m} ${url.pathname}`);
+    });
+    await run(fake, grafanaOperations(spec).reconcile(props));
+    expect(fake.seen.filter((s) => s.method === 'POST')).toEqual([{ method: 'POST', path: SET }]);
+    expect(fake.bodies.filter((b) => b !== undefined)).toEqual([{ permission: 'Edit' }]);
+  });
+
+  test('a permission drift (View live, Edit declared) updates', async () => {
+    const fake = grafanaWith(() => [{ teamId: 7, permission: 'View', isInherited: false }]);
+    await run(fake, Effect.flip(grafanaOperations(spec).reconcile(props))).catch(() => undefined);
+    expect(fake.seen.some((s) => s.method === 'POST' && s.path === SET)).toBe(true);
+  });
+
+  test('a missing team fails loudly, never folds to absent', async () => {
+    const fake = grafanaWith(() => [], []);
+    const failure = await run(fake, Effect.flip(spec.fetchLive(props)));
+    expect((failure as { _tag: string })._tag).toBe('GrafanaTeamNotFoundError');
+  });
+
+  test('delete sets the empty permission, and is a no-op when already absent', async () => {
+    const live = grafanaWith(() => [{ teamId: 7, permission: 'Edit', isInherited: false }]);
+    await run(live, grafanaOperations(spec).destroy(props));
+    expect(live.bodies.filter((b) => b !== undefined)).toEqual([{ permission: '' }]);
+    const gone = grafanaWith(() => []);
+    await run(gone, grafanaOperations(spec).destroy(props));
+    expect(gone.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+});

package/src/grafana/folder-permission.ts

@@ -0,0 +1,128 @@
+/**
+ * `Grafana.FolderPermission` — ONE team's DIRECT permission on ONE folder.
+ *
+ * Walked against `@distilled.cloud/grafana` 0.2.1 (`@homeflare/distilled-grafana`):
+ * `getResourcePermissions` (`GET /access-control/folders/{uid}`) and `setResourcePermissionsForTeam`
+ * (`POST /access-control/folders/{uid}/teams/{teamId}`).
+ *
+ * ★ ADDITIVE BY CONSTRUCTION. The per-team endpoint touches only that team's managed entry; the
+ *   folder's other entries (built-in roles, admin users, other teams, anything inherited from a parent
+ *   folder) are never read into a write and never changed. The whole-list `setResourcePermissions`
+ *   would replace them all — deliberately not used.
+ * ★ ONLY DIRECT ENTRIES COUNT. An entry inherited from a parent folder (`isInherited`) is not this
+ *   resource's object: it can't be changed here, so it never satisfies a declaration either.
+ * ★ The team is named, not numbered. Team ids differ per instance, so `teamName` is resolved through
+ *   `findTeamByName` on every read and write; a missing team fails loudly with
+ *   `GrafanaTeamNotFoundError` (declare the `Grafana.Team` first) instead of folding to "absent".
+ * ★ delete = set the team's permission to "" (Grafana's documented way to remove a managed entry),
+ *   idempotent: an already-absent entry is a no-op (S11).
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as grafana from '@distilled.cloud/grafana';
+import * as Data from 'effect/Data';
+import * as Effect from 'effect/Effect';
+import { type GrafanaSpec, grafanaHandlers } from './resource.ts';
+import { findTeamByName } from './team.ts';
+
+export type FolderPermissionLevel = 'View' | 'Edit' | 'Admin';
+
+export interface FolderPermissionProps {
+  folderUid: string;
+  teamName: string;
+  permission: FolderPermissionLevel;
+}
+
+export interface FolderPermissionAttributes {
+  folderUid: string;
+  teamId: number;
+  teamName: string;
+  permission: string;
+}
+
+export interface GrafanaFolderPermission extends Resource<
+  'Grafana.FolderPermission',
+  FolderPermissionProps,
+  FolderPermissionAttributes,
+  never
+> {}
+
+export const GrafanaFolderPermission = Resource<GrafanaFolderPermission>(
+  'Grafana.FolderPermission',
+);
+
+export class GrafanaTeamNotFoundError extends Data.TaggedError('GrafanaTeamNotFoundError')<{
+  readonly message: string;
+}> {}
+
+interface LivePermission {
+  readonly teamId: number;
+  readonly permission: string;
+}
+
+const resolveTeamId = (teamName: string) =>
+  findTeamByName(teamName).pipe(
+    Effect.flatMap((team) =>
+      team === undefined
+        ? Effect.fail(
+            new GrafanaTeamNotFoundError({
+              message: `Grafana.FolderPermission: team '${teamName}' does not exist. Declare it with Grafana.Team first.`,
+            }),
+          )
+        : Effect.succeed(team.id),
+    ),
+  );
+
+const setTeam = (folderUid: string, teamId: number, permission: string) =>
+  grafana.setResourcePermissionsForTeam({
+    resource: 'folders',
+    resourceID: folderUid,
+    teamID: teamId,
+    permission,
+  });
+
+export const spec: GrafanaSpec<
+  FolderPermissionProps,
+  LivePermission,
+  FolderPermissionAttributes,
+  | grafana.SearchTeamsError
+  | grafana.GetResourcePermissionsError
+  | grafana.SetResourcePermissionsForTeamError
+  | GrafanaTeamNotFoundError
+> = {
+  attributes: (live, props) => ({
+    folderUid: props.folderUid,
+    permission: live.permission,
+    teamId: live.teamId,
+    teamName: props.teamName,
+  }),
+  create: (props) =>
+    resolveTeamId(props.teamName).pipe(
+      Effect.flatMap((teamId) => setTeam(props.folderUid, teamId, props.permission)),
+    ),
+  destroy: (props, live) => setTeam(props.folderUid, live.teamId, ''),
+  fetchLive: (props) =>
+    Effect.gen(function* () {
+      const teamId = yield* resolveTeamId(props.teamName);
+      const entries = yield* grafana.getResourcePermissions({
+        resource: 'folders',
+        resourceID: props.folderUid,
+      });
+      const direct = (entries ?? []).find(
+        (entry) => entry.teamId === teamId && entry.isInherited !== true,
+      );
+      return direct === undefined
+        ? undefined
+        : { permission: direct.permission ?? '', teamId: teamId };
+    }),
+  matches: (attributes, props) => attributes.permission === props.permission,
+  update: (props, live) => setTeam(props.folderUid, live.teamId, props.permission),
+};
+
+export const handlers = grafanaHandlers(spec);
+
+export const GrafanaFolderPermissionProvider = () =>
+  Provider.effect(
+    GrafanaFolderPermission,
+    Effect.succeed(GrafanaFolderPermission.Provider.of(handlers)),
+  );

package/src/grafana/index.ts

@@ -8,7 +8,7 @@
  *
  * `Grafana.Datasource`, `Grafana.Folder`, `Grafana.Dashboard`, `Grafana.ContactPoint`,
  * `Grafana.MuteTiming`, `Grafana.MessageTemplate`, `Grafana.AlertRuleGroup` and
- * `Grafana.NotificationPolicy` all ship here — see docs/grafana.md, docs/grafana-folder-dashboard.md,
+ * `Grafana.NotificationPolicy`, `Grafana.Team` and `Grafana.FolderPermission` all ship here — see docs/grafana.md, docs/grafana-folder-dashboard.md,
  * docs/grafana-alerting.md, docs/grafana-alerting-rules.md and
  * docs/grafana-notification-policy.md for what shipped.
  */
@@ -46,6 +46,15 @@ export {
   GrafanaFolderProvider,
   GrafanaFolderReparentError,
 } from './folder.ts';
+export { type TeamAttributes, type TeamProps, GrafanaTeam, GrafanaTeamProvider } from './team.ts';
+export {
+  type FolderPermissionAttributes,
+  type FolderPermissionLevel,
+  type FolderPermissionProps,
+  GrafanaFolderPermission,
+  GrafanaFolderPermissionProvider,
+  GrafanaTeamNotFoundError,
+} from './folder-permission.ts';
 export {
   type ContactPointAttributes,
   type ContactPointProps,

package/src/grafana/providers.ts

@@ -18,6 +18,8 @@ import { type GrafanaTarget, grafanaCredentials } from './credentials.ts';
 import { GrafanaDashboardProvider } from './dashboard.ts';
 import { GrafanaDatasourceProvider } from './datasource.ts';
 import { GrafanaFolderProvider } from './folder.ts';
+import { GrafanaFolderPermissionProvider } from './folder-permission.ts';
+import { GrafanaTeamProvider } from './team.ts';
 import { GrafanaMessageTemplateProvider } from './message-template.ts';
 import { GrafanaMuteTimingProvider } from './mute-timing.ts';
 import { GrafanaNotificationPolicyProvider } from './notification-policy.ts';
@@ -26,6 +28,8 @@ export const grafanaProviders = (target: GrafanaTarget) =>
   Layer.mergeAll(
     GrafanaDatasourceProvider(),
     GrafanaFolderProvider(),
+    GrafanaTeamProvider(),
+    GrafanaFolderPermissionProvider(),
     GrafanaDashboardProvider(),
     GrafanaContactPointProvider(),
     GrafanaMuteTimingProvider(),

package/src/grafana/provisioned.ts

@@ -29,7 +29,7 @@ export class GrafanaProvisionedObjectError extends Data.TaggedError(
 }> {}
 
 export const refuseIfProvisioned = (
-  kind: 'Grafana.Folder' | 'Grafana.Dashboard',
+  kind: 'Grafana.Folder' | 'Grafana.Dashboard' | 'Grafana.Team',
   uid: string,
   owner: string | undefined,
 ): Effect.Effect<never, GrafanaProvisionedObjectError> => {