From a7521b0f1b4cc07bf2d3b46a1027bc045930d167 Mon Sep 17 00:00:00 2001 From: Miguel Angel Simon Sierra Date: Sun, 27 Sep 2026 15:52:49 -0700 Subject: [PATCH] fix(studio): undo offers reload the open composition and name only a change still in effect --- .../src/history/projectHistory.test.ts | 18 +++++++++- .../src/history/projectHistory.ts | 36 +++++++++++++++---- .../studio-server/src/routes/history.test.ts | 5 ++- packages/studio-server/src/routes/history.ts | 28 ++++----------- .../src/hooks/useEditHistoryActions.test.tsx | 25 +++++++++++-- .../studio/src/hooks/useEditHistoryActions.ts | 9 +++-- 6 files changed, 84 insertions(+), 37 deletions(-) diff --git a/packages/studio-server/src/history/projectHistory.test.ts b/packages/studio-server/src/history/projectHistory.test.ts index bec95ae21a..1711ec55f6 100644 --- a/packages/studio-server/src/history/projectHistory.test.ts +++ b/packages/studio-server/src/history/projectHistory.test.ts @@ -1678,10 +1678,26 @@ describe("claim: a writer that records after writing", () => { await history.claim(you, "Moved Title", ["index.html"]); await history.step("back", you); - expect(await history.step("back", you)).toMatchObject({ ok: false }); + expect(await history.step("back", you)).toMatchObject({ + ok: false, + changedSince: { id: turn.id, label: "Agent turn", paths: ["index.html"] }, + }); expect(history.changedSince(history.next("back", you)!.id)?.id).toBe(turn.id); }); + it("names no later change when none of them is still in effect", async () => { + const { history, write } = await project({ "index.html": "A" }); + const first = await change(history, agent, "Agent turn", () => write("index.html", "B")); + write("index.html", "C"); + await history.claim(you, "Moved Title", ["index.html"]); + await change(history, agent, "Agent turn 2", () => write("index.html", "D")); + await history.undo(first.id, { who: agent, mode: "just-this" }); + + const refused = await history.step("back", you); + expect(refused).toMatchObject({ ok: false }); + expect(refused).not.toHaveProperty("changedSince", expect.anything()); + }); + it("names the agent's earlier turn, not its undo of a later one or the turn it undid", async () => { const { history, write } = await project({ "index.html": "A" }); write("index.html", "B"); diff --git a/packages/studio-server/src/history/projectHistory.ts b/packages/studio-server/src/history/projectHistory.ts index a6814a3a49..20d25cab35 100644 --- a/packages/studio-server/src/history/projectHistory.ts +++ b/packages/studio-server/src/history/projectHistory.ts @@ -108,9 +108,12 @@ export interface HistoryListItem extends HistoryEntry { undone: boolean; } +/** The later change a refused undo can offer to undo first. */ +export type HistoryName = { id: string; label: string; paths: string[] }; + export type HistoryResult = | { ok: true; entry: HistoryEntry | null } - | { ok: false; conflict: { files: string[]; newer: string[] } }; + | { ok: false; conflict: { files: string[]; newer: string[] }; changedSince?: HistoryName }; export interface HistoryWindow { readonly id: string; @@ -147,7 +150,7 @@ export interface ProjectHistory { step(direction: "back" | "forward", who: HistoryWho, options?: Writing): Promise; /** The entry `who`'s next step reverts, pending changes included, as of the last scan (a step scans first). */ next(direction: "back" | "forward", who: HistoryWho): HistoryEntry | undefined; - changedSince(id: string): HistoryEntry | undefined; + changedSince(id: string): HistoryName | undefined; /** A file changed since returns a conflict; `mode` takes a choice (keep-later-edits: null when none is left). */ undo(id: string, options: { who: HistoryWho; mode?: UndoMode } & Writing): Promise; /** Makes the files equal what they were right after `point` (an entry id, or START). */ @@ -879,7 +882,13 @@ class Engine { async undoNow(id: string, who: HistoryWho, mode?: UndoMode): Promise { const entry = this.entry(id); const changed = this.movedOn(entry); - if (changed.length && !mode) return { ok: false, conflict: this.conflict(entry, changed) }; + if (changed.length && !mode) { + return { + ok: false, + conflict: this.conflict(entry, changed), + changedSince: this.blockerOf(entry, changed), + }; + } if (mode === "back-to-before") { const index = this.log.entries.indexOf(entry); const point = index > 0 ? this.log.entries[index - 1]!.id : START; @@ -903,6 +912,22 @@ class Engine { return entry.files.filter((file) => (this.tracked.get(file.path)?.hash ?? null) !== file.after); } + /** The newest later change to `changed` that an undo can still take, so undoing it first unblocks `entry`. */ + blockerOf(entry: HistoryEntry, changed: HistoryFileChange[]): HistoryName | undefined { + const paths = new Set(changed.map((file) => file.path)); + const undone = undoneIds(this.log.entries); + const later = this.log.entries.slice(this.log.entries.indexOf(entry) + 1).reverse(); + const blocker = later.find( + (candidate) => + !candidate.undoes && + !undone.has(candidate.id) && + candidate.files.some((file) => paths.has(file.path)) && + !this.movedOn(candidate).length, + ); + if (!blocker) return undefined; + return { id: blocker.id, label: blocker.label, paths: blocker.files.map((file) => file.path) }; + } + next(direction: "back" | "forward", who: HistoryWho): HistoryEntry | undefined { // An outside change has no known author, so it is everyone's; a step commits it after the held claim. const mine = (author: HistoryWho) => sameWho(author, who) || sameWho(author, OUTSIDE); @@ -1018,10 +1043,7 @@ class Engine { this.assertOpen(); const entry = this.log.entries.find((candidate) => candidate.id === id); const changed = entry ? this.movedOn(entry) : []; - if (!entry || !changed.length) return undefined; - const undone = undoneIds(this.log.entries); - const newer = this.conflict(entry, changed).newer.map((later) => this.entry(later)); - return newer.reverse().find((later) => !later.undoes && !undone.has(later.id)); + return entry && changed.length ? this.blockerOf(entry, changed) : undefined; }, readBlob: async (hash) => { this.assertOpen(); diff --git a/packages/studio-server/src/routes/history.test.ts b/packages/studio-server/src/routes/history.test.ts index 7f152aa46b..858b4332b0 100644 --- a/packages/studio-server/src/routes/history.test.ts +++ b/packages/studio-server/src/routes/history.test.ts @@ -245,7 +245,7 @@ describe("history routes", () => { }); }); - it("offer no later change on a refused redo", async () => { + it("name the later change on a refused redo too", async () => { const { projectDir, history, call } = await demoProject(); writeFileSync(join(projectDir, "index.html"), "B"); await call("/claim", { label: "Moved Title", paths: ["index.html"] }); @@ -255,8 +255,7 @@ describe("history routes", () => { await window.close(); const refused = await (await call("/step", { direction: "forward" })).json(); - expect(refused).toMatchObject({ ok: false }); - expect(refused).not.toHaveProperty("changedSince"); + expect(refused).toMatchObject({ ok: false, changedSince: { label: "Agent turn" } }); }); it("name the next later change when undoing the offered one is refused too", async () => { diff --git a/packages/studio-server/src/routes/history.ts b/packages/studio-server/src/routes/history.ts index 097ee50181..924e321f81 100644 --- a/packages/studio-server/src/routes/history.ts +++ b/packages/studio-server/src/routes/history.ts @@ -4,11 +4,10 @@ import { createWriteToken } from "../helpers/fileVersion.js"; import { MAX_WINDOW_IDLE_MS, UNDO_MODES, - type HistoryResult, type HistoryWindow, type ProjectHistory, } from "../history/projectHistory.js"; -import type { HistoryEntry, HistoryWho } from "../history/historyLog.js"; +import type { HistoryWho } from "../history/historyLog.js"; const YOU: HistoryWho = { kind: "person", name: "You" }; @@ -59,18 +58,10 @@ function nextStep(history: ProjectHistory, direction: "back" | "forward") { const target = history.next(direction, YOU); if (!target) return null; const paths = target.files.map((file) => file.path); - const changedSince = direction === "back" ? nameOf(history.changedSince(target.id)) : undefined; + const changedSince = direction === "back" ? history.changedSince(target.id) : undefined; return { id: target.id, label: target.label, endedAt: target.endedAt, paths, changedSince }; } -function nameOf(entry: HistoryEntry | undefined) { - return entry && { id: entry.id, label: entry.label, paths: entry.files.map((file) => file.path) }; -} - -function withChangedSince(history: ProjectHistory, refused: HistoryResult, id: string | undefined) { - return { ...refused, changedSince: nameOf(id ? history.changedSince(id) : undefined) }; -} - /** Runs `task` on the project's history; no history is a 404, an engine refusal ("no longer kept") a 409. */ async function withHistory( adapter: StudioApiAdapter, @@ -99,19 +90,14 @@ export function registerHistoryRoutes(api: Hono, adapter: StudioApiAdapter): voi }), ); api.post(`${base}/step`, (c) => - withHistory(adapter, c, async (history, body) => { - const direction = body.direction === "forward" ? "forward" : "back"; - const result = await history.step(direction, YOU, writing(c)); - if (result.ok || direction === "forward") return result; - return withChangedSince(history, result, history.next("back", YOU)?.id); - }), + withHistory(adapter, c, (history, body) => + history.step(body.direction === "forward" ? "forward" : "back", YOU, writing(c)), + ), ); api.post(`${base}/undo`, (c) => - withHistory(adapter, c, async (history, body) => { + withHistory(adapter, c, (history, body) => { const mode = UNDO_MODES.find((known) => known === body.mode); - const entryId = text(body.entryId) ?? ""; - const result = await history.undo(entryId, { who: whoOf(body), mode, ...writing(c) }); - return result.ok ? result : withChangedSince(history, result, entryId); + return history.undo(text(body.entryId) ?? "", { who: whoOf(body), mode, ...writing(c) }); }), ); api.post(`${base}/restore`, (c) => diff --git a/packages/studio/src/hooks/useEditHistoryActions.test.tsx b/packages/studio/src/hooks/useEditHistoryActions.test.tsx index 419f93badb..a766309ff3 100644 --- a/packages/studio/src/hooks/useEditHistoryActions.test.tsx +++ b/packages/studio/src/hooks/useEditHistoryActions.test.tsx @@ -45,9 +45,10 @@ function mount(result: { actions = useEditHistoryActions(deps); return null; } + const render = () => act(() => root!.render(createElement(Probe))); root = createRoot(document.createElement("div")); - act(() => root!.render(createElement(Probe))); - return { deps, actions }; + render(); + return { deps, actions, render }; } describe("useEditHistoryActions", () => { @@ -95,6 +96,26 @@ describe("useEditHistoryActions", () => { ]); }); + it("reloads the SDK session for the composition open when the offer is clicked", async () => { + const { deps, actions, render } = mount({ + ok: false, + reason: "content-mismatch", + paths: ["scene.html"], + changedSince: { id: "turn-1", label: "Agent turn", paths: ["scene.html"] }, + }); + deps.editHistory.undoEntry.mockResolvedValue({ + ok: true, + label: "Undid: Agent turn", + paths: ["scene.html"], + }); + await act(() => actions.undo()); + const [, , offer] = deps.showToast.mock.calls[0]!; + deps.activeCompPath = "scene.html"; + render(); + await act(async () => offer.run()); + await vi.waitFor(() => expect(deps.forceReloadSdkSession).toHaveBeenCalled()); + }); + it("offers no undo of the later change when a redo is refused", async () => { const { deps, actions } = mount({ ok: false, diff --git a/packages/studio/src/hooks/useEditHistoryActions.ts b/packages/studio/src/hooks/useEditHistoryActions.ts index 7ab31f7ea7..de7311d2bc 100644 --- a/packages/studio/src/hooks/useEditHistoryActions.ts +++ b/packages/studio/src/hooks/useEditHistoryActions.ts @@ -1,5 +1,5 @@ // fallow-ignore-file complexity -import { useCallback, useMemo } from "react"; +import { useCallback, useMemo, useRef } from "react"; import { STUDIO_MOTION_PATH } from "../components/editor/studioMotion"; import { serializeStudioFileMutations } from "../utils/studioFileMutationCoordinator"; import type { ToastAction } from "../utils/studioHelpers"; @@ -60,6 +60,9 @@ export function useEditHistoryActions({ activeCompPath, forceReloadSdkSession, }: UseEditHistoryActionsOptions) { + // Offers run long after the render that showed them; read the composition open at click time. + const activeCompPathRef = useRef(activeCompPath); + activeCompPathRef.current = activeCompPath; const readHistoryFile = useCallback( (path: string): Promise => path === STUDIO_MOTION_PATH ? readOptionalProjectFile(path) : readProjectFile(path), @@ -104,7 +107,8 @@ export function useEditHistoryActions({ if (result.ok && result.label) { const restore = { paths: result.paths, files: result.files }; onAfterUndoRedo?.(restore); - if (activeCompPath && result.paths?.includes(activeCompPath)) { + const openPath = activeCompPathRef.current; + if (openPath && result.paths?.includes(openPath)) { forceReloadSdkSession?.(); } await syncHistoryPreviewAfterApply(restore); @@ -119,7 +123,6 @@ export function useEditHistoryActions({ waitForPendingDomEditSaves, serializeHistoryFiles, onAfterUndoRedo, - activeCompPath, forceReloadSdkSession, ], );