@frockbot/plugin-settings 0.3.8 → 0.3.10

package/package.json

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

package/src/user.test.ts

@@ -746,6 +746,51 @@ describe("User settings backend Contribution", () => {
         },
       }),
     ).resolves.toMatchObject({ status: "applied", revision: 4 });
+
+    // The mirror of the rule above, read the other way round. Disabling the
+    // dependency is allowed — refusing it would make a Package the User never
+    // chose able to pin one they did — and carries its dependents with it, so
+    // the account never lands in the state the enable path refuses:
+    // `custom-models=disabled provider-ollama-cloud=installed`.
+    await expect(
+      settings.executeConfiguration({
+        schemaVersion: 1,
+        userId: "user-1",
+        command: {
+          schemaVersion: 1,
+          type: "user/set-package-enabled",
+          commandId: "disable-custom-models",
+          expectedRevision: 4,
+          packageId: "custom-models",
+          enabled: false,
+        },
+      }),
+    ).resolves.toMatchObject({ status: "applied", revision: 5 });
+    const cascaded = await settings.read("user-1");
+    expect(cascaded.packages[0]).toMatchObject({
+      packageId: "custom-models",
+      state: "disabled",
+    });
+    expect(cascaded.packages[1]).toMatchObject({
+      packageId: "provider-ollama-cloud",
+      state: "disabled",
+    });
+
+    // The cascade is not automatic re-enablement: turning the dependency back
+    // on leaves the dependent off until the User asks for it.
+    await settings.executeConfiguration({
+      schemaVersion: 1,
+      userId: "user-1",
+      command: {
+        schemaVersion: 1,
+        type: "user/set-package-enabled",
+        commandId: "re-enable-custom-models",
+        expectedRevision: 5,
+        packageId: "custom-models",
+        enabled: true,
+      },
+    });
+    expect((await settings.read("user-1")).packages[1]?.state).toBe("disabled");
   });
 
   test("applies the platform model through the backend Contribution", async () => {

package/src/user.ts

@@ -731,6 +731,54 @@ export class UserSettingsBackendContribution {
     return undefined;
   }
 
+  /**
+   * The mirror of `packageDependencyFailure`, read the other way round.
+   *
+   * Enabling B before A is refused, so leaving B enabled once A is switched
+   * off would put the account in exactly the configuration the enable path
+   * will not create. Refusing the disable is not the answer either: a Package
+   * the User never chose — `provider-ollama-cloud` depends on `web` — would
+   * make `web` undisableable. So the disable is allowed and carries its
+   * dependents with it, transitively. Model binding degrades to the platform
+   * default rather than failing, so a cascade that reaches the Package a Bot's
+   * model is bound to costs that Bot its choice, not its next reply.
+   *
+   * Platform-owned Packages are never cascaded: they cannot be disabled by any
+   * other path, and in this application they depend only on each other.
+   */
+  private cascadeDisabledDependents(
+    settings: UserSettingsViewV1,
+  ): UserSettingsViewV1 {
+    let packages = settings.packages;
+    for (;;) {
+      const enabled = new Set(
+        packages
+          .filter((pkg) => pkg.state === "installed")
+          .map((pkg) => pkg.packageId),
+      );
+      const cascaded = packages.map((pkg) => {
+        if (pkg.state !== "installed") return pkg;
+        if (this.platformOwnedPackageIds.has(pkg.packageId)) return pkg;
+        const dependencies = this.packageDependencies.get(
+          `${pkg.packageId}\u0000${pkg.version}`,
+        );
+        if (!dependencies) return pkg;
+        const missing = Object.keys(dependencies).some(
+          (dependencyId) => !enabled.has(dependencyId),
+        );
+        return missing
+          ? { ...pkg, state: "disabled" as const, failure: undefined }
+          : pkg;
+      });
+      if (cascaded.every((pkg, index) => pkg === packages[index])) {
+        return packages === settings.packages
+          ? settings
+          : { ...settings, packages };
+      }
+      packages = cascaded;
+    }
+  }
+
   async readConfiguration(input: unknown): Promise<UserSettingsViewV1> {
     const request = decodeUserConfigurationReadRpcV1(input);
     // Settings owns the stored-record migration and platform-row repair. Run
@@ -1001,9 +1049,16 @@ export class UserSettingsBackendContribution {
       await storage.put(receiptKey, { commandFingerprint, receipt });
       return receipt;
     }
-    const next = applyUserCommand(current, command, (packageId, version) =>
+    const applied = applyUserCommand(current, command, (packageId, version) =>
       this.settingDefinitions(packageId, version),
     );
+    // One command, one revision: the cascade is part of the disable the User
+    // asked for, not a second write they have to reconcile against.
+    const next =
+      command.type === "user/uninstall-package" ||
+      (command.type === "user/set-package-enabled" && !command.enabled)
+        ? this.cascadeDisabledDependents(applied)
+        : applied;
     const receipt: OperationReceiptV1 = {
       schemaVersion: 1,
       commandId: command.commandId,