@frockbot/plugin-settings 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-settings",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -21,14 +21,14 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/catalog-core": "0.2.2",
-    "@frockbot/client-core": "0.2.2",
-    "@frockbot/client-ui": "0.2.2",
-    "@frockbot/configuration-core": "0.2.2",
-    "@frockbot/connection-core": "0.2.2",
-    "@frockbot/kernel-composition": "0.2.2",
-    "@frockbot/plugin-auth": "0.2.2",
-    "@frockbot/plugin-shell": "0.2.2",
+    "@frockbot/catalog-core": "0.2.4",
+    "@frockbot/client-core": "0.2.4",
+    "@frockbot/client-ui": "0.2.4",
+    "@frockbot/configuration-core": "0.2.4",
+    "@frockbot/connection-core": "0.2.4",
+    "@frockbot/kernel-composition": "0.2.4",
+    "@frockbot/plugin-auth": "0.2.4",
+    "@frockbot/plugin-shell": "0.2.4",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },

package/src/user.test.ts

@@ -6,6 +6,7 @@ import {
 } from "@frockbot/configuration-core";
 import {
   createUserSettingsBackendContribution,
+  type AvailableUserPackage,
   type UserPackageCatalogHost,
   type UserSettingsStorage,
 } from "./user.js";
@@ -246,6 +247,166 @@ describe("User settings backend Contribution", () => {
     ).toEqual(first);
   });
 
+  test("repairs a pre-default-enablement account before Package enablement", async () => {
+    const storage = new MemoryStorage();
+    const availablePackages: AvailableUserPackage[] = [
+      {
+        packageId: "custom-models",
+        version: "0.0.1",
+        installByDefault: true,
+        defaultEnablement: "disabled",
+        dependencies: {
+          settings: ">=0.0.1",
+          shell: ">=0.0.1",
+          "ui-theme": ">=0.0.1",
+        },
+      },
+      {
+        packageId: "provider-ollama-cloud",
+        version: "0.0.1",
+        installByDefault: true,
+        defaultEnablement: "disabled",
+        dependencies: {
+          "custom-models": ">=0.0.1",
+          credentials: ">=0.0.1",
+          settings: ">=0.0.1",
+          web: ">=0.0.1",
+        },
+      },
+      { packageId: "credentials", version: "0.0.1", installByDefault: true },
+      { packageId: "settings", version: "0.0.1", installByDefault: true },
+      { packageId: "shell", version: "0.0.1", installByDefault: true },
+      { packageId: "ui-theme", version: "0.0.1", installByDefault: true },
+      { packageId: "web", version: "0.0.1", installByDefault: true },
+    ];
+    await storage.put("user-id", "legacy-user");
+    await storage.put("user-default-packages-bootstrap:v1", {
+      schemaVersion: 1,
+    });
+    await storage.put("user-configuration", {
+      schemaVersion: 1,
+      revision: 12,
+      profile: { name: "Legacy User" },
+      packages: [
+        {
+          packageId: "provider-workers-ai",
+          version: "0.0.1",
+          state: "installed",
+        },
+        {
+          packageId: "provider-ollama-cloud",
+          version: "0.0.1",
+          state: "installed",
+        },
+      ],
+      connections: [
+        {
+          connectionId: "workers-ai-ambient",
+          packageId: "provider-workers-ai",
+          connectionTypeId: "workers-ai-account",
+          displayName: "Cloudflare Workers AI",
+          state: "ready",
+          generation: "workers-ai-ambient-v1",
+          providerType: "workers-ai",
+          safeMetadata: { catalog: "static" },
+        },
+        {
+          connectionId: "ollama-legacy",
+          packageId: "provider-ollama-cloud",
+          connectionTypeId: "ollama-cloud-account",
+          displayName: "Ollama",
+          state: "ready",
+          generation: "ollama-generation-1",
+          providerType: "ollama-cloud",
+          safeMetadata: {
+            dependentAssignments: [
+              {
+                botId: "primary",
+                generation: "assignment-1",
+                packageId: "provider-ollama-cloud",
+                capabilityId: "ollama-cloud-models",
+                claimOrder: 1,
+                status: "acknowledged",
+              },
+            ],
+          },
+        },
+      ],
+      platformModel: {
+        connectionId: "workers-ai-ambient",
+        providerModelId: "@cf/deepseek-ai/deepseek-v4-flash-0731",
+      },
+      newBotModelTemplate: {
+        connectionId: "ollama-legacy",
+        providerModelId: "glm-5.3-flash:cloud",
+      },
+      newBotModelTemplateSource: "user",
+    });
+    const settings = createUserSettingsBackendContribution({
+      storage,
+      availablePackages,
+    });
+
+    const migrated = await settings.readConfiguration({
+      schemaVersion: 1,
+      userId: "legacy-user",
+    });
+    expect(migrated.packages).toEqual([
+      {
+        packageId: "provider-ollama-cloud",
+        version: "0.0.1",
+        state: "disabled",
+      },
+      {
+        packageId: "custom-models",
+        version: "0.0.1",
+        state: "disabled",
+        provenance: "first-party",
+      },
+      ...availablePackages.slice(2).map(({ packageId, version }) => ({
+        packageId,
+        version,
+        state: "installed" as const,
+        provenance: "first-party" as const,
+      })),
+    ]);
+    expect(migrated.connections).toEqual([
+      expect.objectContaining({
+        connectionId: "ollama-legacy",
+        safeMetadata: {},
+      }),
+    ]);
+    expect(migrated.platformModel).toBeUndefined();
+
+    const customModels = await settings.executeConfiguration({
+      schemaVersion: 1,
+      userId: "legacy-user",
+      command: {
+        schemaVersion: 1,
+        type: "user/set-package-enabled",
+        commandId: "enable-custom-models-after-migration",
+        expectedRevision: migrated.revision,
+        packageId: "custom-models",
+        enabled: true,
+      },
+    });
+    expect(customModels).toMatchObject({ status: "applied" });
+    await expect(
+      settings.executeConfiguration({
+        schemaVersion: 1,
+        userId: "legacy-user",
+        command: {
+          schemaVersion: 1,
+          type: "user/set-package-enabled",
+          commandId: "enable-ollama-after-migration",
+          expectedRevision: customModels.revision,
+          packageId: "provider-ollama-cloud",
+          enabled: true,
+        },
+      }),
+    ).resolves.toMatchObject({ status: "applied" });
+  });
+
   test("installs a Package disabled when explicitly requested", async () => {
     const settings = contribution();
     const receipt = await settings.executeConfiguration({
@@ -417,6 +578,32 @@ describe("User settings backend Contribution", () => {
     const storage = new MemoryStorage();
     const settings = contribution(storage);
 
+    await settings.executeConfigurationCommand(
+      "user-1",
+      {
+        schemaVersion: 1,
+        type: "user/install-package",
+        commandId: "bootstrap-platform-package",
+        expectedRevision: 0,
+        packageId: "flock",
+        version: "0.0.1",
+      },
+      storage,
+    );
+    await settings.createConnection(
+      "user-1",
+      {
+        connectionId: "flock-default",
+        packageId: "flock",
+        connectionTypeId: "flock-account",
+        displayName: "Flock",
+        state: "ready",
+        providerType: "flock",
+        safeMetadata: {},
+      },
+      storage,
+    );
+
     await expect(
       settings.executeConfigurationCommand(
         "user-1",
@@ -424,7 +611,7 @@ describe("User settings backend Contribution", () => {
           schemaVersion: 1,
           type: "user/set-platform-model",
           commandId: "bootstrap-platform-model",
-          expectedRevision: 0,
+          expectedRevision: 2,
           model: {
             connectionId: "flock-default",
             providerModelId: "@flock/auto",
@@ -432,7 +619,7 @@ describe("User settings backend Contribution", () => {
         },
         storage,
       ),
-    ).resolves.toMatchObject({ status: "applied", revision: 1 });
+    ).resolves.toMatchObject({ status: "applied", revision: 3 });
     expect((await settings.read("user-1")).platformModel).toEqual({
       connectionId: "flock-default",
       providerModelId: "@flock/auto",

package/src/user.ts

@@ -17,6 +17,7 @@ import {
   type PackageSettingValueV1,
   type OperationReceiptV1,
   type PackageInstallationView,
+  type StoredUserSettingsPackageV1,
   type UserConfigurationCommandV1,
   type UserSettingsViewV1,
 } from "@frockbot/configuration-core";
@@ -33,6 +34,7 @@ import type { Plugin } from "cordis";
 
 const STATE_KEY = "user-configuration";
 const DEFAULT_PACKAGES_BOOTSTRAP_KEY = "user-default-packages-bootstrap:v1";
+const DEFAULT_PACKAGES_BOOTSTRAP_VERSION = 2;
 /**
  * The pinned Catalog generation lives beside the settings view rather than in
  * it, so pinning on a read never bumps the settings revision a client is
@@ -397,6 +399,9 @@ function applyUserCommand(
 export class UserSettingsBackendContribution {
   private readonly availablePackages: ReadonlySet<string>;
 
+  /** Catalog-relative facts supplied to the raw stored-settings migration. */
+  private readonly storedSettingsPackages: readonly StoredUserSettingsPackageV1[];
+
   /** Declared Package dependencies, by Package id and version. */
   private readonly packageDependencies: ReadonlyMap<
     string,
@@ -406,6 +411,13 @@ export class UserSettingsBackendContribution {
   /** The immutable first-party installation rows written on first read. */
   private readonly defaultPackages: readonly PackageInstallationView[];
 
+  /**
+   * Packages introduced by the default-enablement rollout, plus their
+   * dependency closure. A v1 marker predates those rows, so this is the one
+   * bounded set that marker migration may add without replaying every default.
+   */
+  private readonly enablementRolloutPackages: readonly PackageInstallationView[];
+
   /** Declared User-level settings, by Package id and version. */
   private readonly packageSettingDefinitions: ReadonlyMap<
     string,
@@ -420,6 +432,11 @@ export class UserSettingsBackendContribution {
   >();
 
   constructor(private readonly host: UserSettingsBackendHost) {
+    this.storedSettingsPackages = host.availablePackages.map((pkg) => ({
+      packageId: pkg.packageId,
+      version: pkg.version,
+      ...(pkg.dependencies ? { dependencies: pkg.dependencies } : {}),
+    }));
     this.availablePackages = new Set(
       host.availablePackages.map(
         ({ packageId, version }) => `${packageId}\u0000${version}`,
@@ -452,6 +469,26 @@ export class UserSettingsBackendContribution {
           ]
         : [],
     );
+    const byPackageId = new Map(
+      host.availablePackages.map((pkg) => [pkg.packageId, pkg]),
+    );
+    const rolloutPackageIds = new Set(
+      host.availablePackages
+        .filter(
+          (pkg) => pkg.installByDefault && pkg.defaultEnablement !== undefined,
+        )
+        .map((pkg) => pkg.packageId),
+    );
+    for (const packageId of rolloutPackageIds) {
+      for (const dependencyId of Object.keys(
+        byPackageId.get(packageId)?.dependencies ?? {},
+      )) {
+        if (byPackageId.has(dependencyId)) rolloutPackageIds.add(dependencyId);
+      }
+    }
+    this.enablementRolloutPackages = this.defaultPackages.filter((pkg) =>
+      rolloutPackageIds.has(pkg.packageId),
+    );
   }
 
   /**
@@ -480,11 +517,49 @@ export class UserSettingsBackendContribution {
           typeof marker !== "object" ||
           Array.isArray(marker) ||
           Object.keys(marker).length !== 1 ||
-          (marker as { schemaVersion?: unknown }).schemaVersion !== 1
+          ((marker as { schemaVersion?: unknown }).schemaVersion !== 1 &&
+            (marker as { schemaVersion?: unknown }).schemaVersion !==
+              DEFAULT_PACKAGES_BOOTSTRAP_VERSION)
         ) {
           throw new Error("Stored default Package bootstrap is invalid");
         }
-        return this.readSnapshot(transaction);
+        if (
+          (marker as { schemaVersion: number }).schemaVersion ===
+          DEFAULT_PACKAGES_BOOTSTRAP_VERSION
+        ) {
+          return this.readSnapshot(transaction);
+        }
+        const stored = await transaction.get<unknown>(STATE_KEY);
+        const current =
+          stored === undefined
+            ? initialState()
+            : decodeUserSettingsViewV1(
+                migrateStoredUserSettingsV1(
+                  stored,
+                  this.storedSettingsPackages,
+                ),
+              );
+        const installedPackageIds = new Set(
+          current.packages.map((pkg) => pkg.packageId),
+        );
+        const additions = this.enablementRolloutPackages.filter(
+          (pkg) => !installedPackageIds.has(pkg.packageId),
+        );
+        const next = {
+          ...current,
+          revision: current.revision + 1,
+          packages: [
+            ...current.packages,
+            ...additions.map((pkg) => structuredClone(pkg)),
+          ],
+        } satisfies UserSettingsViewV1;
+        await transaction.put({
+          [STATE_KEY]: next,
+          [DEFAULT_PACKAGES_BOOTSTRAP_KEY]: {
+            schemaVersion: DEFAULT_PACKAGES_BOOTSTRAP_VERSION,
+          },
+        });
+        return structuredClone(next);
       }
       const current = await this.readSnapshot(transaction);
       const installedPackageIds = new Set(
@@ -503,7 +578,9 @@ export class UserSettingsBackendContribution {
       } satisfies UserSettingsViewV1;
       await transaction.put({
         [STATE_KEY]: next,
-        [DEFAULT_PACKAGES_BOOTSTRAP_KEY]: { schemaVersion: 1 },
+        [DEFAULT_PACKAGES_BOOTSTRAP_KEY]: {
+          schemaVersion: DEFAULT_PACKAGES_BOOTSTRAP_VERSION,
+        },
       });
       return structuredClone(next);
     };