refactor(core): extract buildCoreConfig helper (#44)

Author: loss-and-quick

control-center/src/lib/__tests__/core-config.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { EMPTY_SETTINGS } from "../../store/defaults";
+import { activeConfigChanged, buildCoreConfig } from "../core-config";
+import { emptyProfile, type Profile } from "../schema";
+
+function vless(overrides: Partial<Extract<Profile, { protocol: "vless" }>>): Profile {
+  return { ...(emptyProfile("vless") as Extract<Profile, { protocol: "vless" }>), ...overrides };
+}
+
+describe("buildCoreConfig / activeConfigChanged", () => {
+  it("reports no change when only volatile fields (id) differ", () => {
+    const base = { remarks: "Node", address: "ex.com", port: 443, uuid: "u-1" } as const;
+    const a = buildCoreConfig(vless({ id: "p1", ...base }), EMPTY_SETTINGS, [], []);
+    const b = buildCoreConfig(vless({ id: "p2", ...base }), EMPTY_SETTINGS, [], []);
+    expect(activeConfigChanged(a, b)).toBe(false);
+  });
+
+  it("reports a change when the port differs", () => {
+    const base = { remarks: "Node", address: "ex.com", uuid: "u-1" } as const;
+    const a = buildCoreConfig(vless({ id: "p1", port: 443, ...base }), EMPTY_SETTINGS, [], []);
+    const b = buildCoreConfig(vless({ id: "p2", port: 8443, ...base }), EMPTY_SETTINGS, [], []);
+    expect(activeConfigChanged(a, b)).toBe(true);
+  });
+});

control-center/src/lib/core-config.ts

@@ -0,0 +1,43 @@
+// ============================================================
+// src/lib/core-config.ts
+// Resolve the core engine for a profile and build the exact config
+// JSON that `kasumi-proxyctl start` would receive. Shared by the
+// bridge (to launch the core) and the store (to decide whether an
+// active profile actually needs a restart after a subscription
+// update — see activeConfigChanged).
+// ============================================================
+
+import {
+  type AdvancedSettings,
+  type CoreEngineT,
+  type Profile,
+  type RoutingRule,
+  resolveCore,
+} from "./schema";
+import { buildSingboxConfigJSON } from "./singbox-config";
+import { buildXrayConfigJSON } from "./xray-config";
+
+export interface CoreConfig {
+  engine: CoreEngineT;
+  config: string;
+}
+
+/** Engine + config JSON for a profile, mirroring what the core is launched with. */
+export function buildCoreConfig(
+  profile: Profile,
+  settings: AdvancedSettings,
+  routingRules: RoutingRule[],
+  profiles: Profile[],
+): CoreConfig {
+  const engine = resolveCore(profile, settings);
+  const config =
+    engine === "sing-box"
+      ? buildSingboxConfigJSON(profile, settings, routingRules, profiles)
+      : buildXrayConfigJSON(profile, settings, routingRules, profiles);
+  return { engine, config };
+}
+
+/** True when two resolved core configs differ — i.e. the core must be restarted. */
+export function activeConfigChanged(prev: CoreConfig, next: CoreConfig): boolean {
+  return prev.engine !== next.engine || prev.config !== next.config;
+}

control-center/src/lib/ksu-bridge.ts

@@ -271,22 +271,13 @@ export const ksuBridge: Bridge = {
     const state = lastState ?? (await this.readState());
     const profile = state.profiles.find((p) => p.id === profileId);
     if (!profile) throw new Error(`Profile not found: ${profileId}`);
-    const { resolveCore } = await import("./schema/core");
-    const engine = resolveCore(profile, state.settings);
-    const config =
-      engine === "sing-box"
-        ? (await import("./singbox-config")).buildSingboxConfigJSON(
-            profile,
-            state.settings,
-            state.routingRules ?? [],
-            state.profiles,
-          )
-        : (await import("./xray-config")).buildXrayConfigJSON(
-            profile,
-            state.settings,
-            state.routingRules ?? [],
-            state.profiles,
-          );
+    const { buildCoreConfig } = await import("./core-config");
+    const { engine, config } = buildCoreConfig(
+      profile,
+      state.settings,
+      state.routingRules ?? [],
+      state.profiles,
+    );
     const socksPort = String(state.settings.localSocksPort ?? 10808);
     return acceptServiceState(
       "start",

control-center/src/store/__tests__/state-mutations.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import type { AppState } from "../../lib/bridge";
+import { emptyProfile, type Profile } from "../../lib/schema";
+import {
+  mapFetchedSubscriptionProfiles,
+  nextActiveIdAfterSubscriptionUpdate,
+} from "../state-mutations";
+
+function vless(overrides: Partial<Extract<Profile, { protocol: "vless" }>>): Profile {
+  return { ...(emptyProfile("vless") as Extract<Profile, { protocol: "vless" }>), ...overrides };
+}
+
+function stateWith(profiles: Profile[], activeId: string | null): AppState {
+  return { profiles, activeId } as AppState;
+}
+
+const sub = { id: "s1", groupId: undefined } as never;
+
+describe("nextActiveIdAfterSubscriptionUpdate", () => {
+  it("keeps the active id when the active profile is not from this subscription", () => {
+    const active = vless({ id: "p1", subId: "other" });
+    const fresh = mapFetchedSubscriptionProfiles([vless({ remarks: "X" })], sub, null);
+    expect(nextActiveIdAfterSubscriptionUpdate(stateWith([active], "p1"), "s1", fresh)).toBe("p1");
+  });
+
+  it("matches the re-created active profile by exact identity", () => {
+    const active = vless({ id: "p1", subId: "s1", remarks: "Node", address: "ex.com", port: 443 });
+    const fresh = mapFetchedSubscriptionProfiles(
+      [vless({ remarks: "Node", address: "ex.com", port: 443 })],
+      sub,
+      null,
+    );
+    const next = nextActiveIdAfterSubscriptionUpdate(stateWith([active], "p1"), "s1", fresh);
+    expect(next).toBe(fresh[0].id);
+  });
+
+  it("falls back to the same-name profile when the endpoint (port) changed", () => {
+    const active = vless({ id: "p1", subId: "s1", remarks: "Node", address: "ex.com", port: 443 });
+    const fresh = mapFetchedSubscriptionProfiles(
+      [vless({ remarks: "Node", address: "ex.com", port: 8443 })],
+      sub,
+      null,
+    );
+    const next = nextActiveIdAfterSubscriptionUpdate(stateWith([active], "p1"), "s1", fresh);
+    expect(next).toBe(fresh[0].id);
+  });
+
+  it("returns null when the active profile no longer exists in the update", () => {
+    const active = vless({ id: "p1", subId: "s1", remarks: "Gone" });
+    const fresh = mapFetchedSubscriptionProfiles([vless({ remarks: "Other" })], sub, null);
+    expect(nextActiveIdAfterSubscriptionUpdate(stateWith([active], "p1"), "s1", fresh)).toBeNull();
+  });
+});

control-center/src/store/state-mutations.ts

@@ -114,7 +114,17 @@ export function nextActiveIdAfterSubscriptionUpdate(
   const activeProfile = current.profiles.find((profile) => profile.id === current.activeId);
   const activeAffected = activeProfile?.subId === subId;
   if (!activeAffected) return current.activeId;
-  return freshMapped.find((profile) => sameProfileIdentity(profile, activeProfile))?.id ?? null;
+  // Prefer an exact identity match; otherwise fall back to the profile with the
+  // same name (remarks). The fallback lets the active selection "follow" an
+  // endpoint change (e.g. the server port changed) instead of being treated as
+  // removed — the caller then diffs the rebuilt config to decide on a restart.
+  const exact = freshMapped.find((profile) => sameProfileIdentity(profile, activeProfile));
+  if (exact) return exact.id;
+  const byName = freshMapped.find(
+    (profile) =>
+      profile.protocol === activeProfile.protocol && profile.remarks === activeProfile.remarks,
+  );
+  return byName?.id ?? null;
 }
 
 export function mergeBackupState(

control-center/src/store/useAppStore.ts

@@ -160,6 +160,29 @@ export const useAppStore = create<Store>((set, get) => {
 
     set({ service, uploadRate, downloadRate });
   };
+  // A subscription update re-creates the active profile under a new id. Rebuild
+  // the core config for the old vs the new active profile and report whether
+  // they actually differ — callers restart the core only when this is true, so
+  // an unchanged re-fetch (or a no-op wake from the daemon) doesn't churn the
+  // connection. `prev` is the pre-update snapshot; the new state is read live.
+  const activeProfileConfigChanged = async (
+    prev: Store,
+    nextActiveId: string,
+  ): Promise<boolean> => {
+    const oldActive = prev.profiles.find((p) => p.id === prev.activeId);
+    const next = get();
+    const newActive = next.profiles.find((p) => p.id === nextActiveId);
+    if (!oldActive || !newActive) return true; // can't compare → restart to be safe
+    try {
+      const { buildCoreConfig, activeConfigChanged } = await import("../lib/core-config");
+      return activeConfigChanged(
+        buildCoreConfig(oldActive, prev.settings, prev.routingRules, prev.profiles),
+        buildCoreConfig(newActive, next.settings, next.routingRules, next.profiles),
+      );
+    } catch {
+      return true; // config build failed → don't risk leaving a stale config
+    }
+  };
   const consumeSubCacheImpl = async () => {
     let cached: Awaited<ReturnType<typeof bridge.listSubCache>>;
     try {
@@ -201,12 +224,16 @@ export const useAppStore = create<Store>((set, get) => {
         }));
         await get().flush();
         if (activeAffected && current.service.state === "running") {
-          set({ busy: true });
-          try {
-            syncService(nextActiveId ? await bridge.start(nextActiveId) : await bridge.stop());
-          } finally {
-            set({ busy: false });
-            await get().refreshStatus();
+          const needsRestart =
+            !nextActiveId || (await activeProfileConfigChanged(current, nextActiveId));
+          if (needsRestart) {
+            set({ busy: true });
+            try {
+              syncService(nextActiveId ? await bridge.start(nextActiveId) : await bridge.stop());
+            } finally {
+              set({ busy: false });
+              await get().refreshStatus();
+            }
           }
         }
         if (get().settings.dedupOnUpdate) {
@@ -800,7 +827,11 @@ export const useAppStore = create<Store>((set, get) => {
         }));
         await get().flush();
 
-        if (activeAffected && current.service.state === "running") {
+        if (
+          activeAffected &&
+          current.service.state === "running" &&
+          (!nextActiveId || (await activeProfileConfigChanged(current, nextActiveId)))
+        ) {
           set({ busy: true });
           try {
             if (nextActiveId) {