@frockbot/plugin-settings 0.0.0 → 0.1.0

package/src/client/package-surfaces.ts

@@ -0,0 +1,93 @@
+import type { PackageInstallationView } from "@frockbot/configuration-core";
+import type { PluginCatalogItem } from "@frockbot/plugin-shell/shared";
+
+/**
+ * Where a Package's configuration lives.
+ *
+ * Enablement and configuration are separate surfaces: Plugins turns a Package
+ * on and off, and whatever the Package declares — provider accounts, external
+ * accounts, plain settings — is edited on the surface that owns what it
+ * configures. This function is the whole routing table, so a Package that adds
+ * a Connection Type or a setting lands somewhere without an edit to a surface.
+ */
+export type PackageConfigurationHome =
+  "models" | "connections" | "user-settings" | "none";
+
+/** A Package that provides a model, whose accounts and catalogs are Models'. */
+export function isModelProviderPackage(item: PluginCatalogItem): boolean {
+  return item.capabilities.some((capability) => capability.kind === "model");
+}
+
+/** A Package a User authorizes an external account against. */
+export function declaresConnections(item: PluginCatalogItem): boolean {
+  return item.connectionTypes.length > 0;
+}
+
+export function packageConfigurationHome(
+  item: PluginCatalogItem,
+): PackageConfigurationHome {
+  if (isModelProviderPackage(item)) return "models";
+  if (declaresConnections(item)) return "connections";
+  if ((item.settings ?? []).length > 0) return "user-settings";
+  return "none";
+}
+
+/** The catalog entries one configuration surface is responsible for. */
+export function packagesForHome(
+  catalog: readonly PluginCatalogItem[],
+  home: PackageConfigurationHome,
+): PluginCatalogItem[] {
+  return catalog.filter((item) => packageConfigurationHome(item) === home);
+}
+
+/**
+ * The installation row of one Package, whatever state it is in. Absent means
+ * the Package is available to this deployment but not installed for the User.
+ */
+export function packageInstallation(
+  packages: readonly PackageInstallationView[],
+  packageId: string,
+): PackageInstallationView | undefined {
+  return packages.find((candidate) => candidate.packageId === packageId);
+}
+
+/** Installed and not disabled: the only state in which a Bot may be given it. */
+export function isPackageEnabled(
+  packages: readonly PackageInstallationView[],
+  packageId: string,
+): boolean {
+  return packageInstallation(packages, packageId)?.state === "installed";
+}
+
+/** Installed at all, in any state — including `disabled` and `failed`. */
+export function isPackageInstalled(
+  packages: readonly PackageInstallationView[],
+  packageId: string,
+): boolean {
+  return packageInstallation(packages, packageId) !== undefined;
+}
+
+/**
+ * What a configuration surface shows: the Packages it owns that the User has
+ * installed and enabled. A disabled Package configures nothing — its knobs are
+ * kept, and reappear when it is enabled again in Plugins.
+ */
+export function configurablePackages(input: {
+  catalog: readonly PluginCatalogItem[];
+  packages: readonly PackageInstallationView[];
+  home: PackageConfigurationHome;
+}): PluginCatalogItem[] {
+  return packagesForHome(input.catalog, input.home).filter((item) =>
+    isPackageEnabled(input.packages, item.packageId),
+  );
+}
+
+/** The surface name a Plugins row points at, or nothing to configure. */
+export function configurationHomeLabel(
+  home: PackageConfigurationHome,
+): string | undefined {
+  if (home === "models") return "Models";
+  if (home === "connections") return "Connections";
+  if (home === "user-settings") return "Application settings";
+  return undefined;
+}

package/src/client/user-display-name.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { resolveUserDisplayName } from "./user-display-name.js";
+
+describe("resolveUserDisplayName", () => {
+  test("prefers a saved name over the authenticated session", () => {
+    expect(
+      resolveUserDisplayName({
+        savedName: "Tim",
+        sessionName: "Local developer",
+        sessionEmail: "developer@example.com",
+      }),
+    ).toBe("Tim");
+  });
+
+  test("uses the session name when the saved name is the placeholder", () => {
+    expect(
+      resolveUserDisplayName({
+        savedName: "FrockBot user",
+        sessionName: "Local developer",
+        sessionEmail: "developer@example.com",
+      }),
+    ).toBe("Local developer");
+  });
+
+  test("uses the session email when its name is the placeholder", () => {
+    expect(
+      resolveUserDisplayName({
+        savedName: "FrockBot user",
+        sessionName: "FrockBot user",
+        sessionEmail: "  developer@example.com  ",
+      }),
+    ).toBe("developer@example.com");
+  });
+
+  test("uses the placeholder when every candidate is blank", () => {
+    expect(
+      resolveUserDisplayName({
+        savedName: "  ",
+        sessionName: "",
+        sessionEmail: "  ",
+      }),
+    ).toBe("FrockBot user");
+  });
+});

package/src/client/user-display-name.ts

@@ -0,0 +1,16 @@
+import {
+  isChosenUserName,
+  USER_PROFILE_PLACEHOLDER_NAME_V1,
+} from "@frockbot/configuration-core";
+
+export function resolveUserDisplayName(input: {
+  savedName?: string;
+  sessionName?: string;
+  sessionEmail?: string;
+}): string {
+  if (isChosenUserName(input.savedName)) return input.savedName.trim();
+  if (isChosenUserName(input.sessionName)) return input.sessionName.trim();
+
+  const sessionEmail = input.sessionEmail?.trim();
+  return sessionEmail || USER_PROFILE_PLACEHOLDER_NAME_V1;
+}

package/src/env.d.ts

@@ -0,0 +1,6 @@
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+
+  const component: DefineComponent;
+  export default component;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default, default as manifest } from "./manifest.js";

package/src/manifest.ts

@@ -0,0 +1,3 @@
+import manifest from "../frockbot.json" with { type: "json" };
+
+export default manifest;