From 7e194e68737c5ff6b1c094f1a4844621c71d2679 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 20:00:03 -0600 Subject: [PATCH 1/3] fix(desktop): preserve concurrent mock task state --- desktop/e2e/fixtures/mock-devsy.cjs | 14 +++-- desktop/e2e/fixtures/mock-task-state.cjs | 17 +++++++ .../main/__tests__/mock-task-state.test.ts | 51 +++++++++++++++++++ 3 files changed, 79 insertions(+), 3 deletions(-) create mode 100644 desktop/e2e/fixtures/mock-task-state.cjs create mode 100644 desktop/src/main/__tests__/mock-task-state.test.ts diff --git a/desktop/e2e/fixtures/mock-devsy.cjs b/desktop/e2e/fixtures/mock-devsy.cjs index b3ac213864..9323da1795 100755 --- a/desktop/e2e/fixtures/mock-devsy.cjs +++ b/desktop/e2e/fixtures/mock-devsy.cjs @@ -8,6 +8,7 @@ const fs = require("node:fs") const path = require("node:path") const os = require("node:os") +const { mergeTasks } = require("./mock-task-state.cjs") const STATE_FILE = path.join(os.tmpdir(), "devsy-mock-state.json") @@ -88,8 +89,15 @@ function loadState() { } } -function saveState(state) { - fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf8") +function saveState(state, deletedTaskIds = []) { + const latest = loadState() + const updated = { + ...state, + tasks: mergeTasks(latest.tasks || {}, state.tasks || {}, deletedTaskIds), + } + const temporaryFile = `${STATE_FILE}.${process.pid}.tmp` + fs.writeFileSync(temporaryFile, JSON.stringify(updated, null, 2), "utf8") + fs.renameSync(temporaryFile, STATE_FILE) } const state = loadState() @@ -445,7 +453,7 @@ function handleTaskRm(args) { return } delete state.tasks[id] - saveState(state) + saveState(state, [id]) out({}) } diff --git a/desktop/e2e/fixtures/mock-task-state.cjs b/desktop/e2e/fixtures/mock-task-state.cjs new file mode 100644 index 0000000000..2bc7154baf --- /dev/null +++ b/desktop/e2e/fixtures/mock-task-state.cjs @@ -0,0 +1,17 @@ +"use strict" + +function mergeTasks(current, update, deletedIds = []) { + const tasks = { ...current, ...update } + for (const id of deletedIds) delete tasks[id] + + for (const [id, task] of Object.entries(current)) { + const next = update[id] + if (next && task.status !== "pending" && task.status !== next.status) { + tasks[id] = task + } + } + + return tasks +} + +module.exports = { mergeTasks } diff --git a/desktop/src/main/__tests__/mock-task-state.test.ts b/desktop/src/main/__tests__/mock-task-state.test.ts new file mode 100644 index 0000000000..b0d6e46ad8 --- /dev/null +++ b/desktop/src/main/__tests__/mock-task-state.test.ts @@ -0,0 +1,51 @@ +import { createRequire } from "node:module" +import { describe, expect, it } from "vitest" + +const require = createRequire(import.meta.url) +const { mergeTasks } = require("../../../e2e/fixtures/mock-task-state.cjs") as { + mergeTasks: ( + current: Record, + update: Record, + deletedIds?: string[], + ) => Record +} + +describe("mock detached task persistence", () => { + it("preserves tasks created after a process loaded its state snapshot", () => { + const current = { "task-new": { status: "pending" } } + const staleUpdate = { "task-old": { status: "succeeded" } } + + expect(mergeTasks(current, staleUpdate)).toEqual({ + "task-new": { status: "pending" }, + "task-old": { status: "succeeded" }, + }) + }) + + it("does not let a stale pending snapshot undo task cancellation", () => { + expect( + mergeTasks( + { "task-1": { status: "failed" } }, + { "task-1": { status: "pending" } }, + ), + ).toEqual({ "task-1": { status: "failed" } }) + }) + + it("does not let stale completion overwrite task cancellation", () => { + expect( + mergeTasks( + { "task-1": { status: "failed" } }, + { "task-1": { status: "succeeded" } }, + ), + ).toEqual({ "task-1": { status: "failed" } }) + }) + + it("applies explicit task removal", () => { + expect( + mergeTasks( + { "task-1": { status: "succeeded" } }, + {}, + ["task-1"], + ), + ).toEqual({}) + }) +}) From af38994744f42f344c295d55e26f4340c7e4baae Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 23:30:15 -0600 Subject: [PATCH 2/3] fix(desktop): serialize mock task state updates --- desktop/e2e/fixtures/mock-devsy.cjs | 41 ++++--- desktop/e2e/fixtures/mock-task-state.cjs | 71 +++++++++++- .../main/__tests__/mock-task-state.test.ts | 102 ++++++++++++++++++ 3 files changed, 198 insertions(+), 16 deletions(-) diff --git a/desktop/e2e/fixtures/mock-devsy.cjs b/desktop/e2e/fixtures/mock-devsy.cjs index 9323da1795..8159714c22 100755 --- a/desktop/e2e/fixtures/mock-devsy.cjs +++ b/desktop/e2e/fixtures/mock-devsy.cjs @@ -8,7 +8,8 @@ const fs = require("node:fs") const path = require("node:path") const os = require("node:os") -const { mergeTasks } = require("./mock-task-state.cjs") +const { randomUUID } = require("node:crypto") +const { mergeTasks, withFileLock } = require("./mock-task-state.cjs") const STATE_FILE = path.join(os.tmpdir(), "devsy-mock-state.json") @@ -77,31 +78,47 @@ function defaultState() { }, ], tasks: {}, + deletedTasks: {}, } } function loadState() { try { const data = fs.readFileSync(STATE_FILE, "utf8") - return JSON.parse(data) + const state = JSON.parse(data) + state.tasks = state.tasks || {} + state.deletedTasks = state.deletedTasks || {} + return state } catch { return defaultState() } } function saveState(state, deletedTaskIds = []) { - const latest = loadState() - const updated = { - ...state, - tasks: mergeTasks(latest.tasks || {}, state.tasks || {}, deletedTaskIds), - } - const temporaryFile = `${STATE_FILE}.${process.pid}.tmp` - fs.writeFileSync(temporaryFile, JSON.stringify(updated, null, 2), "utf8") - fs.renameSync(temporaryFile, STATE_FILE) + withFileLock(`${STATE_FILE}.lock`, () => { + const latest = loadState() + const deletedTasks = { + ...(latest.deletedTasks || {}), + ...(state.deletedTasks || {}), + ...Object.fromEntries(deletedTaskIds.map((id) => [id, true])), + } + const updated = { + ...state, + deletedTasks, + tasks: mergeTasks( + latest.tasks || {}, + state.tasks || {}, + deletedTaskIds, + deletedTasks, + ), + } + const temporaryFile = `${STATE_FILE}.${process.pid}.tmp` + fs.writeFileSync(temporaryFile, JSON.stringify(updated, null, 2), "utf8") + fs.renameSync(temporaryFile, STATE_FILE) + }) } const state = loadState() -state.tasks = state.tasks || {} const rawArgs = process.argv.slice(2) @@ -294,7 +311,7 @@ function handleUp(args) { a === "-d=true", ) if (isDetach) { - const taskId = `task-${Date.now()}` + const taskId = `task-${randomUUID()}` state.tasks[taskId] = { id: taskId, status: "pending", diff --git a/desktop/e2e/fixtures/mock-task-state.cjs b/desktop/e2e/fixtures/mock-task-state.cjs index 2bc7154baf..dbcf05fec3 100644 --- a/desktop/e2e/fixtures/mock-task-state.cjs +++ b/desktop/e2e/fixtures/mock-task-state.cjs @@ -1,12 +1,75 @@ "use strict" -function mergeTasks(current, update, deletedIds = []) { +const fs = require("node:fs") + +function withFileLock(lockPath, update) { + const waitCell = new Int32Array(new SharedArrayBuffer(4)) + let descriptor + + while (descriptor === undefined) { + try { + descriptor = fs.openSync(lockPath, "wx") + } catch (error) { + if (error.code !== "EEXIST") throw error + if (removeStaleLock(lockPath)) continue + Atomics.wait(waitCell, 0, 0, 10) + } + } + + try { + fs.writeSync(descriptor, String(process.pid)) + return update() + } finally { + fs.closeSync(descriptor) + fs.unlinkSync(lockPath) + } +} + +function removeStaleLock(lockPath) { + let contents + let stat + try { + contents = fs.readFileSync(lockPath, "utf8") + stat = fs.statSync(lockPath) + } catch (error) { + return error.code === "ENOENT" + } + + const owner = Number(contents) + if (Number.isInteger(owner) && owner > 0) { + try { + process.kill(owner, 0) + return false + } catch (error) { + if (error.code !== "ESRCH") return false + } + } else if (Date.now() - stat.mtimeMs < 1000) { + return false + } + + try { + const latest = fs.statSync(lockPath) + if (latest.dev !== stat.dev || latest.ino !== stat.ino) return false + fs.unlinkSync(lockPath) + return true + } catch (error) { + return error.code === "ENOENT" + } +} + +function mergeTasks(current, update, deletedIds = [], tombstones = {}) { + const deleted = new Set([...Object.keys(tombstones), ...deletedIds]) const tasks = { ...current, ...update } - for (const id of deletedIds) delete tasks[id] + for (const id of deleted) delete tasks[id] for (const [id, task] of Object.entries(current)) { const next = update[id] - if (next && task.status !== "pending" && task.status !== next.status) { + if ( + !deleted.has(id) && + next && + task.status !== "pending" && + task.status !== next.status + ) { tasks[id] = task } } @@ -14,4 +77,4 @@ function mergeTasks(current, update, deletedIds = []) { return tasks } -module.exports = { mergeTasks } +module.exports = { mergeTasks, withFileLock } diff --git a/desktop/src/main/__tests__/mock-task-state.test.ts b/desktop/src/main/__tests__/mock-task-state.test.ts index b0d6e46ad8..139fb70131 100644 --- a/desktop/src/main/__tests__/mock-task-state.test.ts +++ b/desktop/src/main/__tests__/mock-task-state.test.ts @@ -1,4 +1,9 @@ import { createRequire } from "node:module" +import { once } from "node:events" +import { spawn, type ChildProcess } from "node:child_process" +import { mkdtempSync, rmSync, writeFileSync } from "node:fs" +import { tmpdir } from "node:os" +import { join } from "node:path" import { describe, expect, it } from "vitest" const require = createRequire(import.meta.url) @@ -7,6 +12,7 @@ const { mergeTasks } = require("../../../e2e/fixtures/mock-task-state.cjs") as { current: Record, update: Record, deletedIds?: string[], + tombstones?: Record, ) => Record } @@ -48,4 +54,100 @@ describe("mock detached task persistence", () => { ), ).toEqual({}) }) + + it("does not recreate a task covered by a deletion tombstone", () => { + expect( + mergeTasks( + {}, + { "task-1": { status: "pending" } }, + [], + { "task-1": true }, + ), + ).toEqual({}) + }) + + it("does not restore a failed task when its ID is explicitly deleted", () => { + expect( + mergeTasks( + { "task-1": { status: "failed" } }, + { "task-1": { status: "pending" } }, + ["task-1"], + ), + ).toEqual({}) + }) + + it("serializes updates from separate processes", async () => { + const directory = mkdtempSync(join(tmpdir(), "mock-task-lock-")) + const lockPath = join(directory, "state.lock") + const releasePath = join(directory, "release") + const helperPath = require.resolve( + "../../../e2e/fixtures/mock-task-state.cjs", + ) + const children: ChildProcess[] = [] + const exits: Promise[] = [] + let output = "" + const observe = (child: ChildProcess) => { + child.stdout?.on("data", (chunk: Buffer) => { + output += chunk.toString() + }) + return (line: string) => + new Promise((resolve, reject) => { + const check = () => { + if (output.includes(line)) resolve() + } + child.stdout?.on("data", check) + child.once("exit", (code) => { + if (!output.includes(line)) + reject(new Error(`child exited with ${code} before ${line}`)) + }) + check() + }) + } + const launch = (source: string) => { + const child = spawn(process.execPath, ["-e", source], { + env: { + ...process.env, + HELPER_PATH: helperPath, + LOCK_PATH: lockPath, + RELEASE_PATH: releasePath, + }, + stdio: ["ignore", "pipe", "inherit"], + }) + children.push(child) + exits.push(once(child, "exit")) + return { child, waitFor: observe(child) } + } + + try { + const first = launch(` + const fs = require("node:fs") + const { withFileLock } = require(process.env.HELPER_PATH) + withFileLock(process.env.LOCK_PATH, () => { + process.stdout.write("locked\\n") + const cell = new Int32Array(new SharedArrayBuffer(4)) + while (!fs.existsSync(process.env.RELEASE_PATH)) Atomics.wait(cell, 0, 0, 10) + }) + `) + await first.waitFor("locked") + + const second = launch(` + const { withFileLock } = require(process.env.HELPER_PATH) + process.stdout.write("waiting\\n") + withFileLock(process.env.LOCK_PATH, () => process.stdout.write("entered\\n")) + `) + await second.waitFor("waiting") + expect(output).not.toContain("entered") + + writeFileSync(releasePath, "") + await second.waitFor("entered") + await Promise.all(exits) + } finally { + writeFileSync(releasePath, "") + for (const child of children) { + if (child.exitCode === null) child.kill() + } + await Promise.all(exits) + rmSync(directory, { recursive: true, force: true }) + } + }) }) From feaa2c64b917ed167a88afe8fe0c8b5f2df065b6 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 27 Sep 2026 00:19:58 -0600 Subject: [PATCH 3/3] test(desktop): stabilize mock task lock assertion --- .../src/main/__tests__/mock-task-state.test.ts | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/desktop/src/main/__tests__/mock-task-state.test.ts b/desktop/src/main/__tests__/mock-task-state.test.ts index 139fb70131..a8a5f18b15 100644 --- a/desktop/src/main/__tests__/mock-task-state.test.ts +++ b/desktop/src/main/__tests__/mock-task-state.test.ts @@ -96,7 +96,7 @@ describe("mock detached task persistence", () => { if (output.includes(line)) resolve() } child.stdout?.on("data", check) - child.once("exit", (code) => { + child.once("close", (code) => { if (!output.includes(line)) reject(new Error(`child exited with ${code} before ${line}`)) }) @@ -136,7 +136,21 @@ describe("mock detached task persistence", () => { withFileLock(process.env.LOCK_PATH, () => process.stdout.write("entered\\n")) `) await second.waitFor("waiting") - expect(output).not.toContain("entered") + await new Promise((resolve, reject) => { + let timer: ReturnType + const check = () => { + if (!output.includes("entered")) return + clearTimeout(timer) + second.child.stdout?.off("data", check) + reject(new Error("entered before release")) + } + timer = setTimeout(() => { + second.child.stdout?.off("data", check) + resolve() + }, 100) + second.child.stdout?.on("data", check) + check() + }) writeFileSync(releasePath, "") await second.waitFor("entered")