feat(onebot): migrate musicSignUrl from per-UIN to global config

musicSignUrl is a deployment-wide signing-service endpoint (same for every
account), so it belongs in the global config/snowluma.json next to rkey, not in
per-UIN onebot_<uin>.json.

- GlobalSettings gains musicSignUrl (http(s)-validated, '' = built-in default);
  consumption switches to globalSettings.musicSignUrl and hot-reloads via
  applyGlobalSettings.
- One-shot copy-up at boot (migrateGlobalSettings, called first in main()):
  lifts the first VALID legacy value from any config/onebot*.json into the
  global store. Idempotent via a key-PRESENCE guard, so an intentional
  clear-to-'' is never reverted by a stale legacy value.
- Remove musicSignUrl from per-UIN OneBotConfig (type + parse/serialize).

Phase 2 of the global-settings split. (WebUI form follows in Phase 3.)
This commit is contained in:
DrSmoothl
2026-06-28 21:38:32 +08:00
parent 659970077a
commit ea1c5ff9eb
8 changed files with 185 additions and 23 deletions
+5
View File
@@ -2,6 +2,7 @@ import { HookManager } from '@snowluma/bridge';
import { closeLogger, createLogger } from '@snowluma/common/logger';
import { loadRuntimeConfig } from '@snowluma/common/runtime';
import { OneBotManager } from '@snowluma/onebot/manager';
import { migrateGlobalSettings } from '@snowluma/onebot/global-config';
import { BridgeManager } from './bridge/manager';
import { createNotificationManager } from './notifications/manager';
import { createStateWiring } from './webui/state-wiring';
@@ -28,6 +29,10 @@ process.on('uncaughtException', (error) => {
async function main() {
log.info('SnowLuma starting');
// One-shot: lift a legacy per-UIN musicSignUrl into the global store before
// any session (and thus any per-UIN config rewrite) can drop it.
migrateGlobalSettings();
const bridgeManager = new BridgeManager();
const oneBotManager = new OneBotManager();
const autoLoadOnDiscovery = resolveAutoLoad(runtimeConfig.hookAutoLoad);
+4
View File
@@ -40,6 +40,10 @@
"types": "./src/config.ts",
"default": "./src/config.ts"
},
"./global-config": {
"types": "./src/global-config.ts",
"default": "./src/global-config.ts"
},
"./types": {
"types": "./src/types.ts",
"default": "./src/types.ts"
-5
View File
@@ -61,7 +61,6 @@ export function makeDefaultOneBotConfig(): OneBotConfig {
}],
wsClients: [],
},
musicSignUrl: '',
statusCommand: makeDefaultStatusCommand(),
notifications: { channelIds: [] },
};
@@ -115,7 +114,6 @@ function toJsonObject(config: OneBotConfig): JsonObject {
wsServers: nets.wsServers.map(wsServerToJson),
wsClients: nets.wsClients.map(wsClientToJson),
},
musicSignUrl: config.musicSignUrl ?? '',
statusCommand: {
enabled: config.statusCommand.enabled,
swallow: config.statusCommand.swallow,
@@ -179,12 +177,10 @@ function wsClientToJson(n: WsClientNetwork): JsonObject {
function fromJson(sources: JsonObject[], freshInstall: boolean): OneBotConfig {
let legacyFormat: MessageFormat | undefined;
let legacyReport: boolean | undefined;
let musicSignUrl = '';
for (const src of sources) {
const mf = parseMessageFormat(src.messageFormat);
if (mf) legacyFormat = mf;
if (typeof src.reportSelfMessage === 'boolean') legacyReport = src.reportSelfMessage;
if (typeof src.musicSignUrl === 'string') musicSignUrl = src.musicSignUrl;
}
const inheritedFormat: MessageFormat = legacyFormat ?? 'array';
const inheritedReport: boolean = legacyReport ?? false;
@@ -208,7 +204,6 @@ function fromJson(sources: JsonObject[], freshInstall: boolean): OneBotConfig {
const networks: OneBotNetworks = { httpServers, httpClients, wsServers, wsClients };
return {
networks,
musicSignUrl,
statusCommand: parseStatusCommand(sources),
notifications: parseNotifications(sources),
};
+91 -2
View File
@@ -17,10 +17,13 @@ const GLOBAL_CONFIG_PATH = path.join(CONFIG_DIR, 'snowluma.json');
export interface GlobalSettings {
/** Opt-in remote rkey fallback (see RKeyConfig). Default: servers empty = off. */
rkey: RKeyConfig;
/** Music-card signing service URL. Deployment-wide (same service for every
* account), so global rather than per-UIN. Empty = use the built-in default. */
musicSignUrl: string;
}
export function defaultGlobalSettings(): GlobalSettings {
return { rkey: { fallbackServers: [] } };
return { rkey: { fallbackServers: [] }, musicSignUrl: '' };
}
/** Keep only well-formed, deduped http(s) URLs (must parse + have a host). */
@@ -59,6 +62,11 @@ export function normalizeGlobalSettings(value: unknown): GlobalSettings {
if (isObject(rkey)) {
out.rkey.fallbackServers = normalizeRkeyServers(rkey.fallbackServers);
}
if (typeof value.musicSignUrl === 'string') {
const v = value.musicSignUrl.trim();
// Empty = "use built-in default"; otherwise must be a real http(s) endpoint.
out.musicSignUrl = v && isHttpUrl(v) ? v : '';
}
return out;
}
@@ -85,6 +93,10 @@ export function saveGlobalSettings(incoming: unknown): GlobalSettings {
if (isObject(incoming.rkey)) {
merged.rkey.fallbackServers = normalizeRkeyServers(incoming.rkey.fallbackServers);
}
if (typeof incoming.musicSignUrl === 'string') {
const v = incoming.musicSignUrl.trim();
merged.musicSignUrl = v && isHttpUrl(v) ? v : '';
}
}
fs.mkdirSync(CONFIG_DIR, { recursive: true });
const tmp = GLOBAL_CONFIG_PATH + '.tmp';
@@ -94,9 +106,86 @@ export function saveGlobalSettings(incoming: unknown): GlobalSettings {
}
function toJson(settings: GlobalSettings): JsonObject {
return { rkey: { fallbackServers: settings.rkey.fallbackServers } };
return {
rkey: { fallbackServers: settings.rkey.fallbackServers },
musicSignUrl: settings.musicSignUrl,
};
}
function isObject(value: unknown): value is JsonObject {
return typeof value === 'object' && value !== null && !Array.isArray(value);
}
/**
* One-shot copy-up: `musicSignUrl` used to live in per-UIN config. If the global
* store has none yet, lift the first non-empty value found in any legacy
* `config/onebot*.json` into `config/snowluma.json`. Idempotent — skips once the
* global value is set. (If an operator later clears the global value while a
* stale per-UIN value lingers, a restart would re-copy it; benign and rare.)
*/
export function migrateGlobalSettings(): void {
// One-shot guard keyed on PRESENCE (not truthiness): once snowluma.json carries
// a musicSignUrl key — written by this migration or any global-config save —
// never re-scan. This is what stops an operator's intentional clear-to-'' from
// being reverted by a stale legacy value on the next boot.
if (globalConfigHasMusicSignUrlKey()) return;
const found = scanLegacyMusicSignUrl();
if (!found) return;
saveGlobalSettings({ musicSignUrl: found.value });
const extra = found.others.length ? `; ignored differing value(s) in ${found.others.join(', ')}` : '';
log.info('migrated musicSignUrl to global config from %s: %s%s', found.source, found.value, extra);
}
function globalConfigHasMusicSignUrlKey(): boolean {
if (!fs.existsSync(GLOBAL_CONFIG_PATH)) return false;
try {
const raw = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf8')) as unknown;
return isObject(raw) && 'musicSignUrl' in raw;
} catch {
return false;
}
}
interface LegacyMusicSignUrl {
value: string;
source: string;
others: string[];
}
/** Scan config/onebot.json + config/onebot_<uin>.json for a non-empty
* musicSignUrl. Returns the first found plus any other files that carried a
* (differing) value, for logging. */
function scanLegacyMusicSignUrl(): LegacyMusicSignUrl | null {
let dir: string[];
try {
dir = fs.readdirSync(CONFIG_DIR);
} catch {
return null;
}
const files = dir
.filter((f) => f === 'onebot.json' || /^onebot_\d+\.json$/.test(f))
.sort();
let first: { value: string; source: string } | null = null;
const others: string[] = [];
for (const file of files) {
let value: unknown;
try {
const raw = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, file), 'utf8')) as unknown;
value = isObject(raw) ? raw.musicSignUrl : undefined;
} catch {
continue;
}
if (typeof value !== 'string') continue;
const v = value.trim();
// Skip empty AND invalid here, so "first found" means "first usable" — a
// garbage value in an earlier-sorting file can't shadow a real URL in a
// later one (it would be dropped to '' on save and then locked by the guard).
if (!v || !isHttpUrl(v)) continue;
if (!first) first = { value: v, source: file };
else if (v !== first.value) others.push(file);
}
return first ? { ...first, others } : null;
}
+2 -1
View File
@@ -108,7 +108,7 @@ export class OneBotInstance {
reactionStore: this.reactionStore,
converterCtx: this.converterCtx,
config,
musicSignUrl: config.musicSignUrl,
musicSignUrl: globalSettings.musicSignUrl,
cacheMessageMeta: (messageId, meta) => this.cacheMessageMeta(messageId, meta),
dispatchEvent: (event) => this.dispatchEvent(event),
};
@@ -139,6 +139,7 @@ export class OneBotInstance {
* the manager when config/snowluma.json is saved from the WebUI. */
applyGlobalSettings(globalSettings: GlobalSettings): void {
this.rkeyCache.setFallbackServers(globalSettings.rkey.fallbackServers);
this.ctx.musicSignUrl = globalSettings.musicSignUrl;
}
dispose(): void {
-2
View File
@@ -103,8 +103,6 @@ export interface RKeyConfig {
/** Per-UIN OneBot configuration. */
export interface OneBotConfig {
networks: OneBotNetworks;
/** Music card signing service URL (optional). */
musicSignUrl?: string;
/** Built-in `#sl` status command settings. Always present after normalization. */
statusCommand: StatusCommandConfig;
/** Which GLOBAL notification channels this account opts into (channel ids are
-3
View File
@@ -24,7 +24,6 @@ describe('makeDefaultOneBotConfig', () => {
expect(config.networks.wsServers[0].messageFormat).toBe('array');
expect(config.networks.wsServers[0].reportSelfMessage).toBe(false);
expect(config.networks.wsClients).toEqual([]);
expect(config.musicSignUrl).toBe('');
expect(config.statusCommand).toEqual({ enabled: true, swallow: false, cooldownSeconds: 5, trigger: '#sl' });
expect(config.notifications).toEqual({ channelIds: [] });
});
@@ -119,8 +118,6 @@ describe('loadOneBotConfig', () => {
expect(config.networks.wsClients[0].messageFormat).toBe('string');
expect(config.networks.wsClients[0].reportSelfMessage).toBe(true);
expect(config.musicSignUrl).toBe('https://example.com/sign');
// File should now be in unified format on disk.
const onDisk = JSON.parse(fs.readFileSync(path.join(dir, `onebot_${uin}.json`), 'utf8'));
expect(onDisk.networks).toBeDefined();
+83 -10
View File
@@ -5,6 +5,7 @@ import path from 'path';
import {
defaultGlobalSettings,
loadGlobalSettings,
migrateGlobalSettings,
normalizeGlobalSettings,
saveGlobalSettings,
} from '../src/global-config';
@@ -25,8 +26,8 @@ describe('global-config (config/snowluma.json)', () => {
});
it('defaults to an empty fallback list (feature off)', () => {
expect(defaultGlobalSettings()).toEqual({ rkey: { fallbackServers: [] } });
expect(loadGlobalSettings()).toEqual({ rkey: { fallbackServers: [] } });
expect(defaultGlobalSettings()).toEqual({ rkey: { fallbackServers: [] }, musicSignUrl: '' });
expect(loadGlobalSettings()).toEqual({ rkey: { fallbackServers: [] }, musicSignUrl: '' });
});
it('keeps only well-formed http(s) URLs, trims, and dedupes', () => {
@@ -38,8 +39,8 @@ describe('global-config (config/snowluma.json)', () => {
});
it('ignores a malformed rkey block', () => {
expect(normalizeGlobalSettings({ rkey: 'nope' })).toEqual({ rkey: { fallbackServers: [] } });
expect(normalizeGlobalSettings(null)).toEqual({ rkey: { fallbackServers: [] } });
expect(normalizeGlobalSettings({ rkey: 'nope' })).toEqual({ rkey: { fallbackServers: [] }, musicSignUrl: '' });
expect(normalizeGlobalSettings(null)).toEqual({ rkey: { fallbackServers: [] }, musicSignUrl: '' });
});
it('round-trips through save → disk → load', () => {
@@ -47,23 +48,95 @@ describe('global-config (config/snowluma.json)', () => {
expect(saved.rkey.fallbackServers).toEqual(['https://r.example/rkey']);
const onDisk = JSON.parse(fs.readFileSync(path.join(tempDir, 'config', 'snowluma.json'), 'utf8'));
expect(onDisk).toEqual({ rkey: { fallbackServers: ['https://r.example/rkey'] } });
expect(onDisk).toEqual({ rkey: { fallbackServers: ['https://r.example/rkey'] }, musicSignUrl: '' });
expect(loadGlobalSettings().rkey.fallbackServers).toEqual(['https://r.example/rkey']);
});
it('section-merges on save: a partial write never wipes a sibling section', () => {
saveGlobalSettings({ rkey: { fallbackServers: ['https://r.example/rkey'] } });
// A save that omits `rkey` (e.g. a future tenant saving only its own block)
// must preserve the existing rkey servers.
const after = saveGlobalSettings({});
// A save touching only musicSignUrl must preserve the rkey servers, and
// vice-versa.
const after = saveGlobalSettings({ musicSignUrl: 'https://sign.example/card' });
expect(after.rkey.fallbackServers).toEqual(['https://r.example/rkey']);
expect(loadGlobalSettings().rkey.fallbackServers).toEqual(['https://r.example/rkey']);
expect(after.musicSignUrl).toBe('https://sign.example/card');
expect(saveGlobalSettings({ rkey: { fallbackServers: [] } }).musicSignUrl).toBe('https://sign.example/card');
});
it('normalizes + round-trips musicSignUrl (trimmed)', () => {
expect(normalizeGlobalSettings({ musicSignUrl: ' https://s.example/c ' }).musicSignUrl).toBe('https://s.example/c');
const saved = saveGlobalSettings({ musicSignUrl: 'https://s.example/c' });
expect(saved.musicSignUrl).toBe('https://s.example/c');
expect(loadGlobalSettings().musicSignUrl).toBe('https://s.example/c');
});
describe('migrateGlobalSettings (musicSignUrl copy-up)', () => {
function writeOnebot(file: string, body: unknown) {
const dir = path.join(tempDir, 'config');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, file), JSON.stringify(body), 'utf8');
}
it('lifts a legacy per-UIN musicSignUrl into the global store', () => {
writeOnebot('onebot_123.json', { musicSignUrl: 'https://legacy.example/sign' });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe('https://legacy.example/sign');
});
it('is a no-op when the global value is already set', () => {
saveGlobalSettings({ musicSignUrl: 'https://kept.example/sign' });
writeOnebot('onebot_123.json', { musicSignUrl: 'https://legacy.example/sign' });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe('https://kept.example/sign');
});
it('takes the first file and tolerates differing/empty values across files', () => {
writeOnebot('onebot.json', { musicSignUrl: '' }); // empty → skipped
writeOnebot('onebot_111.json', { musicSignUrl: 'https://a.example/s' });
writeOnebot('onebot_222.json', { musicSignUrl: 'https://b.example/s' });
migrateGlobalSettings();
// onebot.json sorts first but is empty; onebot_111 is the first non-empty.
expect(loadGlobalSettings().musicSignUrl).toBe('https://a.example/s');
});
it('does nothing when no legacy value exists', () => {
writeOnebot('onebot_123.json', { networks: {} });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe('');
});
it('migrates a value carried by the base onebot.json', () => {
writeOnebot('onebot.json', { musicSignUrl: 'https://base.example/s' });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe('https://base.example/s');
});
it('skips an invalid earlier value and migrates the first VALID one', () => {
writeOnebot('onebot.json', { musicSignUrl: 'not-a-url' }); // earlier-sorting garbage
writeOnebot('onebot_111.json', { musicSignUrl: 'https://real.example/s' });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe('https://real.example/s');
});
it('does NOT re-copy after an intentional clear-to-empty (presence guard)', () => {
// Operator cleared the global value to '' (the key is present in the file)…
saveGlobalSettings({ musicSignUrl: '' });
// …while a stale legacy value still lingers.
writeOnebot('onebot_123.json', { musicSignUrl: 'https://legacy.example/sign' });
migrateGlobalSettings();
expect(loadGlobalSettings().musicSignUrl).toBe(''); // stays cleared, not reverted
});
it('is a safe no-op when config/ does not exist', () => {
// fresh cwd, no config dir at all
expect(() => migrateGlobalSettings()).not.toThrow();
expect(loadGlobalSettings().musicSignUrl).toBe('');
});
});
it('falls back to defaults when the file is corrupt', () => {
fs.mkdirSync(path.join(tempDir, 'config'), { recursive: true });
fs.writeFileSync(path.join(tempDir, 'config', 'snowluma.json'), '{ not json', 'utf8');
expect(loadGlobalSettings()).toEqual({ rkey: { fallbackServers: [] } });
expect(loadGlobalSettings()).toEqual({ rkey: { fallbackServers: [] }, musicSignUrl: '' });
});
});