fix(desktop): keep a single update banner (#1033)

* fix(desktop): keep a single update banner

* fix(desktop): restore update progress feedback

* fix(desktop): show real download progress in settings page

- getStatus() now returns percent from lastProgress so the settings
  page gets the actual download progress on mount
- Settings page polls getStatus() every 1s during background downloads
  instead of switching to foreground mode (avoids triggering the
  desktop shell banner)
- Fix empty update banner when experience is local-test-feed by
  correcting the idle-state early return logic

* fix(desktop): consolidate update UI and improve diagnostics

- Remove "Check for Updates…" from application menu (single entry via settings)
- Add UpdateBadge to sidebar for dismissed update visibility
- Reset dismissed state on update events so new updates re-surface
- Add progress listener diagnostics to mac-update-driver
- Improve update card layout (fit-content width, word wrap, flex-wrap)
- Mock update server: support slow streaming for real ZIP files
- Export getUpdateManager() from ipc module
- Pin version to 0.1.10 for nightly update testing

* fix(controller): deterministic openclaw config serialization

- Sort skill slugs at all sources (compiler, sync service, workspace
  scanner) so merged skill lists are stable regardless of input order
- Introduce serializeOpenClawConfig() with sorted JSON keys so
  semantically identical configs produce the same output string
- Config writer and gateway service use deterministic serialization
  to avoid unnecessary OpenClaw reloads on key reordering
- Add tests for deterministic skill ordering and key-order skip

* fix(desktop): remove driver-level writeLog calls that lack diagnostic arg

Author: lefarcen

apps/controller/src/lib/openclaw-config-compiler.ts

@@ -227,14 +227,20 @@ function compileAgentList(
   installedSkillSlugs?: readonly string[],
   workspaceSkillsByAgent?: ReadonlyMap<string, readonly string[]>,
 ): OpenClawConfig["agents"]["list"] {
-  const sharedSlugs = installedSkillSlugs ?? [];
+  const sharedSlugs = [...(installedSkillSlugs ?? [])].sort((left, right) =>
+    left.localeCompare(right),
+  );
 
   return config.bots
     .filter((bot) => bot.status === "active")
     .sort((left, right) => left.slug.localeCompare(right.slug))
     .map((bot, index) => {
-      const workspaceSlugs = workspaceSkillsByAgent?.get(bot.id) ?? [];
-      const merged = [...new Set([...sharedSlugs, ...workspaceSlugs])];
+      const workspaceSlugs = [
+        ...(workspaceSkillsByAgent?.get(bot.id) ?? []),
+      ].sort((left, right) => left.localeCompare(right));
+      const merged = Array.from(
+        new Set([...sharedSlugs, ...workspaceSlugs]),
+      ).sort((left, right) => left.localeCompare(right));
 
       return {
         id: bot.id,

apps/controller/src/lib/openclaw-config-serialization.ts

@@ -0,0 +1,27 @@
+import type { OpenClawConfig } from "@nexu/shared";
+
+function sortJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item));
+  }
+
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nestedValue]) => [key, sortJsonValue(nestedValue)]),
+    );
+  }
+
+  return value;
+}
+
+export function normalizeOpenClawConfig(
+  config: OpenClawConfig,
+): OpenClawConfig {
+  return sortJsonValue(config) as OpenClawConfig;
+}
+
+export function serializeOpenClawConfig(config: OpenClawConfig): string {
+  return `${JSON.stringify(normalizeOpenClawConfig(config), null, 2)}\n`;
+}

apps/controller/src/runtime/openclaw-config-writer.ts

@@ -5,6 +5,7 @@ import type { OpenClawConfig } from "@nexu/shared";
 import type { ControllerEnv } from "../app/env.js";
 import { NEXU_INTERNAL_ACCOUNT_PREFIX } from "../lib/channel-binding-compiler.js";
 import { logger } from "../lib/logger.js";
+import { serializeOpenClawConfig } from "../lib/openclaw-config-serialization.js";
 
 /**
  * Sync weixin account IDs from openclaw.json to the openclaw-weixin plugin's
@@ -93,17 +94,24 @@ export class OpenClawConfigWriter {
 
   async write(config: OpenClawConfig): Promise<void> {
     await mkdir(path.dirname(this.env.openclawConfigPath), { recursive: true });
-    const content = `${JSON.stringify(config, null, 2)}\n`;
+    const content = serializeOpenClawConfig(config);
 
     // On cold start, seed the cache from the existing file on disk so the
     // first write() after a process restart doesn't trigger an unnecessary
     // OpenClaw reload when the config hasn't actually changed.
     if (this.lastWrittenContent === null) {
       try {
-        this.lastWrittenContent = await readFile(
+        const existingContent = await readFile(
           this.env.openclawConfigPath,
           "utf8",
         );
+        try {
+          this.lastWrittenContent = serializeOpenClawConfig(
+            JSON.parse(existingContent) as OpenClawConfig,
+          );
+        } catch {
+          this.lastWrittenContent = existingContent;
+        }
       } catch {
         // File doesn't exist yet — leave cache empty.
       }

apps/controller/src/services/openclaw-gateway-service.ts

@@ -12,6 +12,7 @@
 import { createHash } from "node:crypto";
 import type { OpenClawConfig } from "@nexu/shared";
 import { logger } from "../lib/logger.js";
+import { serializeOpenClawConfig } from "../lib/openclaw-config-serialization.js";
 import type { OpenClawWsClient } from "../runtime/openclaw-ws-client.js";
 import type { ControllerRuntimeState } from "../runtime/state.js";
 
@@ -634,6 +635,8 @@ export class OpenClawGatewayService {
   }
 
   private configHash(config: OpenClawConfig): string {
-    return createHash("sha256").update(JSON.stringify(config)).digest("hex");
+    return createHash("sha256")
+      .update(serializeOpenClawConfig(config))
+      .digest("hex");
   }
 }

apps/controller/src/services/openclaw-sync-service.ts

@@ -145,6 +145,7 @@ export class OpenClawSyncService {
           .getAllInstalled()
           .filter((r) => r.source !== "workspace")
           .map((r) => r.slug)
+          .sort((left, right) => left.localeCompare(right))
       : undefined;
 
     const workspaceMap = this.workspaceScanner

apps/controller/src/services/skillhub/workspace-skill-scanner.ts

@@ -34,7 +34,8 @@ export class WorkspaceSkillScanner {
     try {
       return readdirSync(dir, { withFileTypes: true })
         .filter((entry) => existsSync(join(dir, entry.name, "SKILL.md")))
-        .map((entry) => entry.name);
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
     } catch {
       return [];
     }

apps/controller/tests/openclaw-config-compiler.test.ts

@@ -385,11 +385,17 @@ describe("compileOpenClawConfig", () => {
   });
 
   it("does not remap openai models to OAuth providers without persisted OAuth state", () => {
+    const baseConfig = createConfig();
+    const baseBot = baseConfig.bots[0];
+    const baseProvider = baseConfig.providers?.[0];
+    if (!baseBot || !baseProvider) {
+      throw new Error("expected base config fixtures");
+    }
     const result = compileOpenClawConfig(
       createConfig({
         bots: [
           {
-            ...createConfig().bots[0],
+            ...baseBot,
             modelId: "openai/gpt-5.4",
           },
         ],
@@ -403,7 +409,7 @@ describe("compileOpenClawConfig", () => {
         },
         providers: [
           {
-            ...createConfig().providers[0],
+            ...baseProvider,
             apiKey: null,
             models: ["gpt-5.4"],
           },
@@ -622,12 +628,18 @@ describe("compileOpenClawConfig", () => {
   });
 
   it("ignores unsupported custom providers in compiled model config", () => {
+    const baseConfig = createConfig();
+    const baseProviders = baseConfig.providers ?? [];
+    const baseProvider = baseProviders[0];
+    if (!baseProvider) {
+      throw new Error("expected base config providers");
+    }
     const result = compileOpenClawConfig(
       createConfig({
         providers: [
-          ...createConfig().providers,
+          ...baseProviders,
           {
-            ...createConfig().providers[0],
+            ...baseProvider,
             id: "provider-3",
             providerId: "custom",
             displayName: "Custom",
@@ -985,6 +997,40 @@ describe("compileOpenClawConfig", () => {
       expect(botB?.skills).toEqual(["shared-skill"]);
     });
 
+    it("sorts merged skills deterministically regardless of input order", () => {
+      const baseConfig = createConfig();
+      const baseBot = baseConfig.bots[0];
+      if (!baseBot) {
+        throw new Error("expected base config bot");
+      }
+      const config = createConfig({
+        bots: [
+          {
+            ...baseBot,
+            id: "bot-a",
+            slug: "bot-a",
+          },
+        ],
+        channels: [],
+      });
+
+      const compiled = compileOpenClawConfig(
+        config,
+        createEnv(),
+        undefined,
+        ["zeta", "alpha", "shared-skill"],
+        new Map([["bot-a", ["workspace-z", "alpha", "workspace-a"]]]),
+      );
+
+      expect(compiled.agents.list[0]?.skills).toEqual([
+        "alpha",
+        "shared-skill",
+        "workspace-a",
+        "workspace-z",
+        "zeta",
+      ]);
+    });
+
     it("deduplicates when same slug in shared and workspace", () => {
       const config = createConfig();
       const wsMap = new Map<string, readonly string[]>([
@@ -1031,14 +1077,20 @@ describe("compileOpenClawConfig", () => {
   });
 
   it("remaps openai models to OAuth provider ids when persisted OAuth state is connected", () => {
+    const baseConfig = createConfig();
+    const baseBot = baseConfig.bots[0];
+    const baseProvider = baseConfig.providers?.[0];
+    if (!baseBot || !baseProvider) {
+      throw new Error("expected base config fixtures");
+    }
     const oauthState: OAuthConnectionState = {
       connectedProviderIds: ["openai"],
     };
     const result = compileOpenClawConfig(
       createConfig({
         bots: [
           {
-            ...createConfig().bots[0],
+            ...baseBot,
             modelId: "openai/gpt-5.4",
           },
         ],
@@ -1052,7 +1104,7 @@ describe("compileOpenClawConfig", () => {
         },
         providers: [
           {
-            ...createConfig().providers[0],
+            ...baseProvider,
             apiKey: null,
             models: ["gpt-5.4"],
           },

apps/controller/tests/openclaw-config-writer.test.ts

@@ -142,6 +142,41 @@ describe("OpenClawConfigWriter", () => {
     expect(JSON.parse(written)).toEqual(configB);
   });
 
+  it("skips write when config is semantically unchanged but object keys reorder", async () => {
+    const writer = new OpenClawConfigWriter(env);
+    const configA = makeConfig({
+      plugins: {
+        entries: {
+          zed: { enabled: true },
+          alpha: { enabled: true },
+        },
+        load: { paths: [] },
+      },
+    });
+    const configB = makeConfig({
+      plugins: {
+        load: { paths: [] },
+        entries: {
+          alpha: { enabled: true },
+          zed: { enabled: true },
+        },
+      },
+    });
+
+    await writer.write(configA);
+    const firstStat = await stat(env.openclawConfigPath);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    await writer.write(configB);
+    const secondStat = await stat(env.openclawConfigPath);
+
+    expect(secondStat.mtimeMs).toBe(firstStat.mtimeMs);
+    expect(JSON.parse(await readFile(env.openclawConfigPath, "utf8"))).toEqual(
+      configA,
+    );
+  });
+
   it("cold start with no existing file writes normally", async () => {
     // No file exists yet — writer should write without error.
     const writer = new OpenClawConfigWriter(env);
@@ -152,4 +187,37 @@ describe("OpenClawConfigWriter", () => {
     const written = await readFile(env.openclawConfigPath, "utf8");
     expect(JSON.parse(written)).toEqual(config);
   });
+
+  it("new writer instance skips rewrite when existing file only differs by key order", async () => {
+    const configA = makeConfig({
+      plugins: {
+        entries: {
+          zed: { enabled: true },
+          alpha: { enabled: true },
+        },
+        load: { paths: [] },
+      },
+    });
+    const configB = makeConfig({
+      plugins: {
+        load: { paths: [] },
+        entries: {
+          alpha: { enabled: true },
+          zed: { enabled: true },
+        },
+      },
+    });
+
+    const writer1 = new OpenClawConfigWriter(env);
+    await writer1.write(configA);
+    const firstStat = await stat(env.openclawConfigPath);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const writer2 = new OpenClawConfigWriter(env);
+    await writer2.write(configB);
+    const secondStat = await stat(env.openclawConfigPath);
+
+    expect(secondStat.mtimeMs).toBe(firstStat.mtimeMs);
+  });
 });

apps/controller/tests/openclaw-gateway-service.test.ts

@@ -0,0 +1,50 @@
+import type { OpenClawConfig } from "@nexu/shared";
+import { describe, expect, it } from "vitest";
+import { OpenClawGatewayService } from "../src/services/openclaw-gateway-service.js";
+
+function makeConfig(overrides: Partial<OpenClawConfig> = {}): OpenClawConfig {
+  return {
+    gateway: { port: 18789, mode: "local", bind: "127.0.0.1" },
+    agents: { list: [], defaults: {} },
+    channels: {},
+    bindings: [],
+    plugins: { load: { paths: [] }, entries: {} },
+    skills: { load: { watch: true } },
+    commands: { native: "auto" },
+    ...overrides,
+  } as OpenClawConfig;
+}
+
+describe("OpenClawGatewayService", () => {
+  it("treats semantically identical configs as unchanged despite key reorder", async () => {
+    const service = new OpenClawGatewayService(
+      {
+        isConnected: () => true,
+      } as never,
+      {} as never,
+    );
+
+    const configA = makeConfig({
+      plugins: {
+        entries: {
+          zed: { enabled: true },
+          alpha: { enabled: true },
+        },
+        load: { paths: [] },
+      },
+    });
+    const configB = makeConfig({
+      plugins: {
+        load: { paths: [] },
+        entries: {
+          alpha: { enabled: true },
+          zed: { enabled: true },
+        },
+      },
+    });
+
+    service.noteConfigWritten(configA);
+
+    await expect(service.shouldPushConfig(configB)).resolves.toBe(false);
+  });
+});