an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
fix: write config.json atomically with temp + rename (#578)
Zhen Luof92f04771fa4
diff --git a/evidence/after.png b/evidence/after.pngnew file mode 100644index 00000000..cf68b062Binary files /dev/null and b/evidence/after.png differdiff --git a/evidence/before.png b/evidence/before.pngnew file mode 100644index 00000000..c0ca2b42Binary files /dev/null and b/evidence/before.png differdiff --git a/src/main/config.ts b/src/main/config.tsindex 73310c79..c1092988 100644--- a/src/main/config.ts+++ b/src/main/config.ts@@ -1,5 +1,5 @@import { app } from 'electron';-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';import { dirname, join } from 'node:path';import { homedir } from 'node:os';import {@@ -639,7 +639,20 @@ export function onConfigWritten(listener: ConfigWriteListener): () => void {function persistConfig(next: HarnessConfig): HarnessConfig {const p = configPath();mkdirSync(dirname(p), { recursive: true });- writeFileSync(p, JSON.stringify(next, null, 2), 'utf8');+ // Temp + rename: `rename` is atomic within a filesystem, so a crash mid-write+ // leaves either the old config.json or the new one, never half of either. A+ // bare writeFileSync truncates the live file first, and readConfig maps any+ // unparseable config.json to factory defaults — one torn write would wipe+ // harnessHome, the Slack/webhook secrets and every saved setting. Same+ // discipline as roster.ts and hive.ts atomicWriteJson.+ const tmp = `${p}.tmp-${Math.random().toString(36).slice(2, 10)}`;+ try {+ writeFileSync(tmp, JSON.stringify(next, null, 2), 'utf8');+ renameSync(tmp, p);+ } catch (e) {+ try { rmSync(tmp, { force: true }); } catch { /* the tmp file is disposable */ }+ throw e;+ }// Saving one setting stores only that setting, so fill the rest back in first:// subscribers must see the same complete config a read gives them, never a// half-filled one. Skip the migration — it saves in its own right, and hasdiff --git a/test/repro/bug-17.repro.cjs b/test/repro/bug-17.repro.cjsnew file mode 100644index 00000000..9abcbe6e--- /dev/null+++ b/test/repro/bug-17.repro.cjs@@ -0,0 +1,435 @@+'use strict';++// Repro for: persistConfig writes config.json non-atomically; a crash mid-write+// truncates it, and readConfig silently resets the entire config to defaults.+//+// src/main/config.ts:639-654 — persistConfig flushes every settings save with a+// bare `writeFileSync(p, JSON.stringify(next, null, 2), 'utf8')` DIRECTLY over+// the live config.json. No temp file, no rename, no fsync — truncate-then-write.+// Every other durable store in the repo treats exactly this hazard as worth+// preventing, and says so:+// - roster.ts:158-162: "Temp + rename: `rename` is atomic within a filesystem,+// so a crash leaves either the old file or the new one, never half of either."+// - hive.ts:2657 atomicWriteJson (tmp + renameSync), db.ts WAL + transactional+// migrations, reflect.ts atomic writes.+// Meanwhile readConfig (config.ts:594-600) wraps the parse in a bare catch:+//+// } catch {+// return withTriggerDefaults({ ...DEFAULTS });+// }+//+// — any JSON.parse failure is treated as "no file yet", so a truncated+// config.json silently becomes factory defaults: no log, no backup, no+// recovery. The file is the ONLY copy of harnessHome/recentHives,+// slackSigningSecret/slackBotToken, groqApiKey, webhookTriggers (incl. secrets),+// agentTokenCaps, costCapTokens, missions, integrations metadata.+// migrateTriggersV1's one-shot save (config.ts:579) shares persistConfig.+//+// FAILURE SCENARIO, reproduced end-to-end against the REAL config.ts (loaded+// via test/load-ts.cjs; Electron's app.getPath is stubbed at the module+// boundary exactly like test/config-write-notify.test.cjs — no Electron, no+// display, no network):+//+// 1. A real install is seeded through the public API (writeConfig /+// setAgentTokenCap): home, recents, Slack + Groq + webhook secrets, token+// caps, missions — all on disk, all reading back.+// 2. An ordinary settings save (writeConfig({ notifications: true })) hits+// persistConfig, and the process "loses power" mid-write. The crash is+// modelled deterministically at the fs boundary: the first writeFileSync+// persistConfig performs puts a PREFIX of the new payload on the target+// path (the O_TRUNC truncate has already happened — that is inherent to+// truncate-then-write) and then throws, standing in for the power loss.+// The control test shows this same crash model is survivable under the+// repo's own temp+rename policy, so the model is not what destroys+// the file.+// 3. The live config.json is left a truncated, unparseable prefix.+// 4. "Next launch": readConfig() parses nothing, logs nothing, throws+// nothing, and hands back pure defaults. A recursive scan of the whole+// userData tree finds no backup anywhere — the old config is gone for+// good.+// 5. The one-shot triggers migration (config.ts:548-586) is shown to be+// exposed through the same persistConfig, with the same next-launch wipe.+//+// FAILS on current code (the crash destroys config.json; readConfig resets).+// PASSES after a correct fix (write temp + atomic rename, as roster.ts/hive.ts+// already do): the crash then lands on the temp file before any rename, the+// live file keeps the old complete config, and every preservation assertion+// holds. Run: node test/repro/bug-17.repro.cjs++const test = require('node:test');+const assert = require('node:assert/strict');+const fs = require('node:fs');+const os = require('node:os');+const path = require('node:path');++const loadTs = require(path.join(__dirname, '..', 'load-ts.cjs'));++// config.ts resolves its file through Electron's app.getPath('userData'). Point+// that one dependency at a throwaway root (same trick the repo's own+// config-write-notify.test.cjs uses) so this repro never touches a real config.+const ROOTS = { userData: fs.mkdtempSync(path.join(os.tmpdir(), 'md-bug17-userdata-')) };+const electron = require.resolve('electron');+require.cache[electron] = {+ id: electron,+ filename: electron,+ loaded: true,+ exports: { app: { getPath: () => ROOTS.userData } }+};++const { readConfig, writeConfig, setAgentTokenCap, resetConfig } = loadTs('src/main/config.ts');++const CONFIG_PATH = () => path.join(ROOTS.userData, 'config.json');++// How much of the new payload reaches disk before the "power loss". The claim's+// artifact — '{"harnessHome": "/Users/x/H' — is exactly such a prefix.+const PREFIX_BYTES = 40;++// The hive home an established install points at (a real directory, as the app+// creates one), and the secrets only config.json holds.+const HIVE_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'md-bug17-hive-'));+const SLACK_SIGNING_SECRET = 'whsec-slack-signing-bug17-0f3a9c';+const SLACK_BOT_TOKEN = 'xoxb-1701-bug17-bot-token';+const GROQ_API_KEY = 'gsk_bug17_groq_key_9d2f';+const WEBHOOK_TRIGGER_SECRET = 'whsec-endpoint-bug17-4471';+const LEGACY_WEBHOOK_SECRET = 'whsec-legacy-pre-triggers-install';++test.after(() => {+ fs.rmSync(ROOTS.userData, { recursive: true, force: true });+ fs.rmSync(HIVE_HOME, { recursive: true, force: true });+});++/** Seed one established install's config through the real public API. */+function seedEstablishedInstall() {+ writeConfig({+ onboardingComplete: true,+ harnessHome: HIVE_HOME,+ autoMode: false,+ costCapTokens: 5_000_000,+ slackEnabled: true,+ slackSigningSecret: SLACK_SIGNING_SECRET,+ slackBotToken: SLACK_BOT_TOKEN,+ groqApiKey: GROQ_API_KEY,+ webhookTriggers: [{+ id: 'endpoint-1',+ name: 'CI',+ secret: WEBHOOK_TRIGGER_SECRET,+ enabled: true,+ mode: 'strict',+ schema: '{}',+ createdAt: 1_700_000_000_000+ }],+ missions: [{+ id: 'nightly-report',+ label: 'Nightly report',+ intervalMs: 86_400_000,+ to: 'god',+ body: 'report',+ enabled: true+ }]+ });+ setAgentTokenCap('worker-9', 123456);+ return readConfig();+}++/**+ * Crash hook: while installed, the FIRST writeFileSync persistConfig performs+ * completes only partially — the truncate has already happened (that is what+ * truncate-then-write means) and a prefix of the new payload is on disk at the+ * target path — then it throws, standing in for the power loss / hard crash+ * mid-write. Everything else passes through untouched.+ */+function installMidWriteCrash(state) {+ const realWriteFileSync = fs.writeFileSync;+ state.fired = false;+ state.target = null;+ state.intended = null;+ state.onDiskAfterCrash = null;+ fs.writeFileSync = function patchedWriteFileSync(p, data, opts) {+ if (!state.fired) {+ state.fired = true;+ state.target = path.resolve(String(p));+ const full = typeof data === 'string' ? data : Buffer.from(data).toString('utf8');+ state.intended = full;+ realWriteFileSync.call(fs, p, full.slice(0, PREFIX_BYTES), opts);+ state.onDiskAfterCrash = fs.readFileSync(state.target, 'utf8');+ throw new Error('SIMULATED CRASH: power lost while persistConfig was mid-write');+ }+ return realWriteFileSync.call(fs, p, data, opts);+ };+ return () => { fs.writeFileSync = realWriteFileSync; };+}++/** True when config.json on disk no longer parses. */+function liveFileCorrupt() {+ try {+ JSON.parse(fs.readFileSync(CONFIG_PATH(), 'utf8'));+ return false;+ } catch {+ return true;+ }+}++/** Every file under `root` whose text contains any of `needles`. */+function filesContaining(root, needles) {+ const hits = [];+ let names = [];+ try { names = fs.readdirSync(root, { recursive: true }); } catch { return hits; }+ for (const rel of names) {+ const p = path.join(root, String(rel));+ let st;+ try { st = fs.statSync(p); } catch { continue; }+ if (!st.isFile()) continue;+ let text = '';+ try { text = fs.readFileSync(p, 'utf8'); } catch { continue; }+ if (needles.some((needle) => text.includes(needle))) hits.push(p);+ }+ return hits;+}++/** A save crashed mid-write: the user's config must still be on disk and readable. */+function assertUserConfigSurvived() {+ let parsed = null;+ let parseError = null;+ try {+ parsed = JSON.parse(fs.readFileSync(CONFIG_PATH(), 'utf8'));+ } catch (e) {+ parseError = e;+ }+ assert.ok(+ parsed,+ 'config.json did not survive a crash mid-save. It must, because ' ++ 'persistConfig (config.ts:642) must not write over the live file. What is ' ++ `on disk instead: ${JSON.stringify(fs.readFileSync(CONFIG_PATH(), 'utf8'))} ` ++ `(parse error: ${parseError ? parseError.message : 'none'})`+ );+ const after = readConfig();+ assert.equal(after.harnessHome, HIVE_HOME, 'harnessHome lost after the crash');+ assert.deepEqual(after.recentHives, [HIVE_HOME], 'recent hives lost after the crash');+ assert.equal(after.slackSigningSecret, SLACK_SIGNING_SECRET, 'Slack signing secret lost');+ assert.equal(after.slackBotToken, SLACK_BOT_TOKEN, 'Slack bot token lost');+ assert.equal(after.groqApiKey, GROQ_API_KEY, 'Groq API key lost');+ assert.equal(after.agentTokenCaps?.['worker-9'], 123456, 'per-agent token cap lost');+ assert.equal(after.costCapTokens, 5_000_000, 'breaker cost cap lost');+ assert.equal(after.webhookTriggers[0]?.secret, WEBHOOK_TRIGGER_SECRET, 'webhook trigger + secret lost');+ assert.ok(after.missions.some((m) => m.id === 'nightly-report'), 'custom mission lost');+ assert.equal(after.onboardingComplete, true, 'booted back into onboarding');+ return after;+}++// --- 0. Precondition: the seeding really persists everything -----------------++test('precondition: an established install keeps its config on disk and reads it back', () => {+ const cfg = seedEstablishedInstall();+ assert.equal(cfg.onboardingComplete, true);+ assert.equal(cfg.harnessHome, HIVE_HOME);+ assert.deepEqual(cfg.recentHives, [HIVE_HOME]);+ assert.equal(cfg.slackSigningSecret, SLACK_SIGNING_SECRET);+ assert.equal(cfg.slackBotToken, SLACK_BOT_TOKEN);+ assert.equal(cfg.groqApiKey, GROQ_API_KEY);+ assert.equal(cfg.agentTokenCaps['worker-9'], 123456);+ assert.equal(cfg.costCapTokens, 5_000_000);+ assert.equal(cfg.webhookTriggers[0].secret, WEBHOOK_TRIGGER_SECRET);+ assert.ok(cfg.missions.some((m) => m.id === 'nightly-report'));+ // ...and it is all in the one file that holds it:+ const parsed = JSON.parse(fs.readFileSync(CONFIG_PATH(), 'utf8'));+ assert.equal(parsed.slackSigningSecret, SLACK_SIGNING_SECRET);+});++// --- 1. Control: the repo's own temp+rename policy survives this crash -------++test('control: the same simulated crash under temp+rename (roster.ts:158 policy) keeps the old file', (t) => {+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'md-bug17-atomic-'));+ t.after(() => fs.rmSync(dir, { recursive: true, force: true }));+ const live = path.join(dir, 'config.json');+ const body = JSON.stringify(+ { harnessHome: HIVE_HOME, slackSigningSecret: SLACK_SIGNING_SECRET },+ null,+ 2+ );+ fs.writeFileSync(live, body, 'utf8');++ // The exact discipline roster.ts:158-162 / hive.ts atomicWriteJson use. A+ // crash during the temp write (or even between the temp write and the+ // rename) can never touch the live file.+ const writeAtomicallyThenLosePower = () => {+ const tmp = `${live}.tmp-repro`;+ fs.writeFileSync(tmp, body.slice(0, PREFIX_BYTES), 'utf8'); // truncated temp file+ throw new Error('SIMULATED CRASH: power lost mid-write'); // rename never runs+ };+ assert.throws(writeAtomicallyThenLosePower, /SIMULATED CRASH/);++ // The live file still holds the complete OLD config — nothing was lost.+ const after = JSON.parse(fs.readFileSync(live, 'utf8'));+ assert.equal(after.harnessHome, HIVE_HOME);+ assert.equal(after.slackSigningSecret, SLACK_SIGNING_SECRET);+});++// --- 2. The bug: persistConfig overwrites the live file in place -------------++test('BUG: a crash mid-save destroys config.json — writeFileSync goes straight over the live file', () => {+ const before = seedEstablishedInstall();+ assert.equal(before.slackSigningSecret, SLACK_SIGNING_SECRET, 'seeding precondition');++ const state = {};+ const restore = installMidWriteCrash(state);+ let crash = null;+ try {+ // An ordinary settings save: config.ts:656 writeConfig -> config.ts:639+ // persistConfig -> config.ts:642 writeFileSync straight over config.json.+ writeConfig({ notifications: true });+ } catch (e) {+ crash = e;+ } finally {+ restore();+ }++ assert.ok(crash, 'the simulated mid-write crash fired inside persistConfig');+ assert.ok(state.fired);++ if (liveFileCorrupt()) {+ // Mechanism, observed: the write went at the LIVE file (no temp path), and+ // what is on disk is a bare prefix of the new payload.+ assert.equal(+ state.target, CONFIG_PATH(),+ 'persistConfig wrote DIRECTLY to the live config.json — no temp file, no rename (config.ts:642)'+ );+ assert.equal(+ state.onDiskAfterCrash, state.intended.slice(0, PREFIX_BYTES),+ 'the live file now holds a truncated PREFIX of the new payload'+ );+ }++ // THE BUG: after a mid-write crash the live config.json must still hold a+ // complete config (old or new). On current code it holds an unparseable+ // fragment instead, and every setting below is gone.+ assertUserConfigSurvived();+});++// --- 3. The silent, unrecoverable reset --------------------------------------++test('BUG: the next launch silently resets to defaults — no error, no log, no backup anywhere', () => {+ // Fresh established install, then the same mid-write crash during an+ // ordinary settings save.+ seedEstablishedInstall();+ const state = {};+ const restore = installMidWriteCrash(state);+ try {+ try { writeConfig({ notifications: true }); } catch { /* the crash itself */ }+ } finally {+ restore();+ }++ const raw = fs.readFileSync(CONFIG_PATH(), 'utf8');+ const corrupt = liveFileCorrupt();++ // "Next launch": watch both channels readConfig could use to surface the+ // corruption it is about to throw away.+ const logs = [];+ const origError = console.error;+ const origWarn = console.warn;+ console.error = (...a) => logs.push(a.join(' '));+ console.warn = (...a) => logs.push(a.join(' '));+ let threw = null;+ let cfg = null;+ try { cfg = readConfig(); } catch (e) { threw = e; }+ console.error = origError;+ console.warn = origWarn;++ // readConfig neither throws nor logs on current code (config.ts:594-600):+ // it returns, silently, with factory defaults for the file it just failed to+ // parse. Whether a fix chooses to log, throw, or recover is its own call —+ // the contract this repro pins is below: the user's config must SURVIVE.+ assert.deepEqual(+ logs, [],+ 'readConfig logs NOTHING when it discards the file (config.ts:598-600) — ' ++ 'the reset below is completely silent'+ );++ if (corrupt) {+ // Observed on current code — documented, not asserted as the contract:+ // cfg now holds factory defaults. The contract assertion is below.+ const resetToDefaults =+ cfg.harnessHome === null+ && cfg.slackSigningSecret === undefined+ && cfg.onboardingComplete === false;+ assert.ok(+ resetToDefaults,+ 'observed: readConfig handed back factory defaults for a truncated file'+ );+ // Unrecoverable: the old contents exist nowhere in userData — no .bak, no+ // .tmp with the previous file, nothing.+ assert.deepEqual(+ filesContaining(ROOTS.userData, [+ SLACK_SIGNING_SECRET, SLACK_BOT_TOKEN, GROQ_API_KEY, WEBHOOK_TRIGGER_SECRET+ ]),+ [],+ 'observed: the destroyed config exists nowhere else — no backup was kept'+ );+ assert.ok(!raw.includes(SLACK_SIGNING_SECRET), 'observed: the live file no longer holds the old secrets');+ }++ // THE CONTRACT the fix must satisfy: the user's config survives the crash —+ // on current code readConfig has already reset it to defaults.+ assert.equal(cfg.harnessHome, HIVE_HOME, 'next launch lost the harness home');+ assert.equal(cfg.slackSigningSecret, SLACK_SIGNING_SECRET, 'next launch lost the Slack signing secret');+ assert.equal(cfg.slackBotToken, SLACK_BOT_TOKEN, 'next launch lost the Slack bot token');+ assert.equal(cfg.groqApiKey, GROQ_API_KEY, 'next launch lost the Groq API key');+ assert.equal(cfg.agentTokenCaps?.['worker-9'], 123456, 'next launch lost the per-agent token cap');+ assert.equal(cfg.onboardingComplete, true, 'next launch booted back into onboarding');+});++// --- 4. The one-shot migration write is exposed the same way -----------------++test('BUG: the migrateTriggersV1 save (config.ts:579) goes through the same non-atomic write', () => {+ // Back to first-run defaults on disk, and clear the in-process migration+ // latch (resetConfig does exactly that — config.ts:726) so the migration+ // will run on the next read.+ resetConfig();++ // A pre-Triggers install's config.json, as an older build left it:+ fs.writeFileSync(CONFIG_PATH(), JSON.stringify({+ onboardingComplete: true,+ harnessHome: HIVE_HOME,+ webhookSecret: LEGACY_WEBHOOK_SECRET,+ defaultModel: 'claude-fable-5'+ }, null, 2), 'utf8');++ const state = {};+ const restore = installMidWriteCrash(state);+ let threw = null;+ let thisLaunch = null;+ try {+ thisLaunch = readConfig(); // first read in the process -> migrateTriggersV1 -> persistConfig+ } catch (e) {+ threw = e;+ } finally {+ restore();+ }++ assert.ok(state.fired, 'the migration attempted its one-shot save and crashed mid-write');+ assert.equal(threw, null, 'migrateTriggersV1 catches the crash (config.ts:581) — the save just vanished');+ assert.equal(+ thisLaunch.harnessHome, HIVE_HOME,+ 'THIS launch keeps the legacy config in memory after the migration save failed'+ );++ if (liveFileCorrupt()) {+ // Observed on current code: the migration write destroyed the legacy file+ // it was supposed to replace.+ assert.equal(state.target, CONFIG_PATH(), 'the migration write went directly at the live config.json');+ assert.equal(state.onDiskAfterCrash, state.intended.slice(0, PREFIX_BYTES), 'legacy file left truncated');+ assert.deepEqual(+ filesContaining(ROOTS.userData, [LEGACY_WEBHOOK_SECRET]),+ [],+ 'observed: the legacy webhook secret is unrecoverable'+ );+ }++ // THE CONTRACT: the next launch must still see the legacy install's config —+ // the migration is idempotent from disk (triggersMigratedV1 may or may not+ // have landed; the legacy fields are preserved either way).+ const nextLaunch = readConfig();+ assert.equal(nextLaunch.harnessHome, HIVE_HOME, 'next launch lost the harness home');+ assert.equal(nextLaunch.webhookSecret, LEGACY_WEBHOOK_SECRET, 'next launch lost the legacy webhook secret');+ assert.equal(nextLaunch.onboardingComplete, true, 'next launch booted back into onboarding');+});