Skip to content

Commit ff0e6e0

Browse files
committed
merge(es-app): publish durable Electron composer storage (anomalyco#115)
2 parents 0c4892b + da60587 commit ff0e6e0

5 files changed

Lines changed: 331 additions & 3 deletions

File tree

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
import { expect, test } from "bun:test"
2+
import { createComposer } from "./composer"
3+
import { composerStorage } from "./composer-storage"
4+
5+
class MemoryStorage {
6+
values = new Map<string, string>()
7+
getItem(key: string) {
8+
return this.values.get(key) ?? null
9+
}
10+
setItem(key: string, value: string) {
11+
this.values.set(key, value)
12+
}
13+
removeItem(key: string) {
14+
this.values.delete(key)
15+
}
16+
}
17+
const key = 'es-app:composer:1:["ses_test","/fixture"]'
18+
19+
test("browser tabs keep independent drafts and never open durable storage", () => {
20+
const first = new MemoryStorage()
21+
const second = new MemoryStorage()
22+
const unavailable = () => {
23+
throw new Error("Browser must not access shared storage")
24+
}
25+
const tab = composerStorage("Mozilla Chrome/130", first, unavailable)
26+
tab.setItem(key, "first tab draft")
27+
expect(tab.getItem(key)).toBe("first tab draft")
28+
expect(composerStorage("Mozilla Chrome/130", second, unavailable).getItem(key)).toBeNull()
29+
})
30+
31+
test("native durable snapshot takes precedence over stale tab data", () => {
32+
const tab = new MemoryStorage()
33+
const durable = new MemoryStorage()
34+
tab.setItem(key, "stale tab")
35+
durable.setItem(key, "durable unknown request")
36+
expect(composerStorage("Chrome/130 Electron/42.3.3", tab, () => durable).getItem(key)).toBe("durable unknown request")
37+
})
38+
39+
test("native migration retains tab data until validated state is durably saved", () => {
40+
const tab = new MemoryStorage()
41+
const durable = new MemoryStorage()
42+
const original = createComposer("ses_test", "/fixture", { storage: tab })
43+
original.setText("task draft")
44+
original.setImages([{ id: "image", mime: "image/png", filename: "fixture.png", url: "data:image/png;base64,AA==" }])
45+
original.selectMode("aside")
46+
original.setText("aside draft")
47+
const saved = tab.getItem(key)
48+
const storage = composerStorage("Electron/42.3.3", tab, () => durable)
49+
expect(storage.getItem(key)).toBe(saved)
50+
expect(durable.getItem(key)).toBeNull()
51+
storage.setItem(key, saved!)
52+
expect(tab.getItem(key)).toBeNull()
53+
const restored = createComposer("ses_test", "/fixture", {
54+
storage: composerStorage("Electron/42.3.3", new MemoryStorage(), () => durable),
55+
})
56+
expect(restored.state.task.text).toBe("task draft")
57+
expect(restored.state.aside.text).toBe("aside draft")
58+
expect(restored.state.task.images[0]?.url).toBe("data:image/png;base64,AA==")
59+
expect(restored.state.mode).toBe("aside")
60+
})
61+
62+
test("failed durable writes preserve the legacy snapshot and propagate a visible error", () => {
63+
const tab = new MemoryStorage()
64+
tab.setItem(key, "original")
65+
const durable = new MemoryStorage()
66+
const storage = composerStorage("Electron/42", tab, () => ({
67+
getItem: (key) => durable.getItem(key),
68+
removeItem: (key) => durable.removeItem(key),
69+
setItem: () => {
70+
throw new DOMException("Quota exceeded", "QuotaExceededError")
71+
},
72+
}))
73+
expect(() => storage.setItem(key, "new")).toThrow("Quota exceeded")
74+
expect(tab.getItem(key)).toBe("original")
75+
})
76+
77+
test("invalid saved request identity is not overwritten by newer typing or resubmitted", () => {
78+
const storage = new MemoryStorage()
79+
storage.setItem(key, '{"version":1,"admission":{"payload":{"requestID":"unknown"}}}')
80+
const composer = createComposer("ses_test", "/fixture", { storage })
81+
composer.setText("new typing")
82+
expect(composer.state.storageError).toContain("Cannot restore saved drafts")
83+
expect(composer.blockedReason()).toContain("request identity must be recovered")
84+
expect(storage.getItem(key)).toBe('{"version":1,"admission":{"payload":{"requestID":"unknown"}}}')
85+
})
86+
87+
test("legacy cleanup failure does not replace a successfully saved image snapshot", () => {
88+
const durable = new MemoryStorage()
89+
const tab = new MemoryStorage()
90+
const storage = composerStorage(
91+
"Electron/42",
92+
{
93+
getItem: (key) => tab.getItem(key),
94+
setItem: (key, value) => tab.setItem(key, value),
95+
removeItem: () => {
96+
throw new Error("Tab storage unavailable")
97+
},
98+
},
99+
() => durable,
100+
)
101+
storage.setItem(key, "complete image snapshot")
102+
expect(durable.getItem(key)).toBe("complete image snapshot")
103+
})
Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
type DraftStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">
2+
3+
export const composerStorage = (userAgent: string, tab: DraftStorage, persistent: () => DraftStorage) => {
4+
// The native shell has one window and a stable, profile-owned origin. Browser tabs stay independent.
5+
if (!/\bElectron\/\d/.test(userAgent)) return tab
6+
const durable = persistent()
7+
return {
8+
getItem: (key: string) => durable.getItem(key) ?? tab.getItem(key),
9+
setItem: (key: string, value: string) => {
10+
durable.setItem(key, value)
11+
// Retire legacy tab data only after the durable write succeeds.
12+
try {
13+
tab.removeItem(key)
14+
} catch {
15+
/* A stale tab copy cannot override durable data. */
16+
}
17+
},
18+
}
19+
}

‎packages/es-app/src/composer.ts‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import { batch } from "solid-js"
22
import { createStore, reconcile } from "solid-js/store"
33
import type { Session, SessionV1InputPayload, SessionV1InputReceipt } from "@opencode-ai/sdk/v2"
44
import { oc } from "./api"
5+
import { composerStorage } from "./composer-storage"
56

67
export type ComposerMode = "send" | "aside" | "queue" | "steer"
78
export type ComposerBuffer = "task" | "aside"
@@ -117,12 +118,14 @@ export const createComposer = (sessionID: string, directory: string, dependencie
117118
let activeInput: string | undefined
118119
let capabilityVersion = 0
119120
let storage: ComposerDependencies["storage"]
121+
let restored = false
122+
let restoreError = ""
120123
try {
121124
storage =
122125
dependencies.storage === undefined
123126
? typeof window === "undefined"
124127
? null
125-
: window.sessionStorage
128+
: composerStorage(navigator.userAgent, window.sessionStorage, () => window.localStorage)
126129
: dependencies.storage
127130
const raw = storage?.getItem(key)
128131
if (raw) {
@@ -184,9 +187,12 @@ export const createComposer = (sessionID: string, directory: string, dependencie
184187
error: "Aside completion is unknown after reload. Cancel this request before asking another.",
185188
})
186189
}
190+
restored = true
187191
}
188192
} catch (error) {
189-
setState("storageError", `Cannot restore saved drafts: ${message(error)}. Keep this tab open.`)
193+
restoreError = `Cannot restore saved drafts: ${message(error)}. Keep this tab open; saved request identity must be recovered before sending.`
194+
setState("storageError", restoreError)
195+
storage = null
190196
}
191197

192198
const persist = () => {
@@ -217,7 +223,7 @@ export const createComposer = (sessionID: string, directory: string, dependencie
217223
storage.setItem(key, JSON.stringify(saved))
218224
setState("storageError", imageWarning())
219225
} catch (error) {
220-
// Keep images in the live buffers even when sessionStorage cannot hold them.
226+
// Keep images in the live buffers even when browser storage cannot hold them.
221227
try {
222228
storage.setItem(
223229
key,
@@ -240,6 +246,8 @@ export const createComposer = (sessionID: string, directory: string, dependencie
240246
}
241247
}
242248
}
249+
// Restore/migrate before exposing the controller; no late async load can replace newer typing.
250+
if (restored) persist()
243251
const draftKey = () => (state.mode === "aside" ? "aside" : "task")
244252
const updateDraft = (value: Partial<ComposerDraft>, revise = true, key: ComposerBuffer = draftKey()) => {
245253
setState(key, { ...value, revision: state[key].revision + (revise ? 1 : 0) })
@@ -264,6 +272,7 @@ export const createComposer = (sessionID: string, directory: string, dependencie
264272
: `This server does not support ${mode} inputs with listing and cancellation.`
265273
}
266274
const blockedReason = () => {
275+
if (restoreError) return restoreError
267276
if (missingImages[draftKey()])
268277
return "Images are missing from this restored draft. Reattach or explicitly clear images before sending."
269278
const unavailable = capabilityReason(state.mode)

‎packages/es-desktop/package.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
"package": "electron-builder --dir --publish never",
1515
"test": "bun test src",
1616
"test:electron": "node test/smoke.mjs",
17+
"test:draft-restart": "node test/draft-restart.mjs",
1718
"typecheck": "tsgo --noEmit"
1819
},
1920
"devDependencies": {
Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
1+
import { _electron, expect } from "@playwright/test"
2+
import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises"
3+
import { tmpdir } from "node:os"
4+
import path from "node:path"
5+
import { fileURLToPath } from "node:url"
6+
import { createFixture, directory } from "../../es-app/test/composer-fixture.mjs"
7+
8+
const root = fileURLToPath(new URL("..", import.meta.url))
9+
const fixture = await createFixture()
10+
const profile = await mkdtemp(path.join(tmpdir(), "editspace-draft-restart-"))
11+
const artifacts = path.join(root, "artifacts")
12+
await mkdir(artifacts, { recursive: true })
13+
expect(["4096", "7777", "3181"]).not.toContain(new URL(fixture.url).port)
14+
expect((await (await fetch(`${fixture.url}/config/providers`)).json()).default).toEqual({ fixture: "test" })
15+
const launch = {
16+
args: [root],
17+
env: {
18+
...process.env,
19+
ELECTRON_RUN_AS_NODE: "",
20+
OPENCODE_URL: fixture.url,
21+
ES_DASHBOARD_URL: fixture.url,
22+
OPENCODE_SERVER_PASSWORD: "",
23+
ES_DESKTOP_USER_DATA: profile,
24+
ES_DESKTOP_RENDERER: "",
25+
},
26+
}
27+
const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl6SAAAAABJRU5ErkJggg=="
28+
const image = { id: "fixture-image", mime: "image/png", filename: "legacy.png", url: `data:image/png;base64,${png}` }
29+
const key = (id) => `es-app:composer:1:${JSON.stringify([id, directory])}`
30+
const result = { profile, fixture: fixture.url, pids: [], checkpoints: [] }
31+
const checkpoint = (text) => {
32+
result.checkpoints.push(text)
33+
console.info(`PASS ${text}`)
34+
}
35+
let app
36+
let page
37+
let origin
38+
const active = () => page.locator(".float-editor").or(page.locator(".prompt-box:not([inert])"))
39+
const mode = (name) => active().getByRole("radio", { name, exact: true })
40+
const saved = (id) => page.evaluate((key) => JSON.parse(localStorage.getItem(key)), key(id))
41+
const go = (id) => page.goto(`${origin}/session/${id}?directory=${encodeURIComponent(directory)}`)
42+
const start = async () => {
43+
app = await _electron.launch(launch)
44+
result.pids.push(app.process().pid)
45+
expect(await app.evaluate(({ app }) => app.getPath("userData"))).toBe(profile)
46+
page = await app.firstWindow()
47+
await page.waitForURL("http://127.0.0.1:*/")
48+
if (origin) expect(new URL(page.url()).origin).toBe(origin)
49+
origin = new URL(page.url()).origin
50+
}
51+
const restart = async () => {
52+
await app.close()
53+
await start()
54+
expect(result.pids.at(-1)).not.toBe(result.pids.at(-2))
55+
}
56+
const attach = async (filename) => {
57+
await active()
58+
.locator("textarea")
59+
.evaluate(
60+
(node, { png, filename }) => {
61+
const data = new DataTransfer()
62+
data.items.add(
63+
new File([Uint8Array.from(atob(png), (char) => char.charCodeAt(0))], filename, { type: "image/png" }),
64+
)
65+
node.dispatchEvent(new DragEvent("drop", { bubbles: true, cancelable: true, dataTransfer: data }))
66+
},
67+
{ png, filename },
68+
)
69+
await expect(active().getByRole("img", { name: filename, exact: true })).toBeVisible()
70+
}
71+
const posts = () => fixture.calls.filter((call) => call.method === "POST")
72+
try {
73+
await start()
74+
await page.evaluate(
75+
({ key, image }) =>
76+
sessionStorage.setItem(
77+
key,
78+
JSON.stringify({
79+
version: 1,
80+
mode: "aside",
81+
asideSeeded: true,
82+
queueAgent: "plan",
83+
tracked: [],
84+
task: { text: "legacy task", images: [image], model: null, selection: [0, 0], revision: 1 },
85+
aside: {
86+
text: "legacy aside",
87+
images: [{ ...image, filename: "legacy-aside.png" }],
88+
model: { providerID: "fixture", modelID: "test" },
89+
selection: [0, 0],
90+
revision: 2,
91+
},
92+
}),
93+
),
94+
{ key: key("ses_a"), image },
95+
)
96+
await go("ses_a")
97+
await expect(active().locator("textarea")).toHaveValue("legacy aside")
98+
await expect(active().getByRole("img", { name: "legacy-aside.png" })).toBeVisible()
99+
expect(await page.evaluate((key) => sessionStorage.getItem(key), key("ses_a"))).toBeNull()
100+
expect((await saved("ses_a")).task.images).toEqual([image])
101+
await active().locator("textarea").fill("newer Aside typing")
102+
await mode("Queue").click()
103+
await active().locator("textarea").fill("newer task typing")
104+
await active().getByRole("combobox", { name: "Queue agent" }).selectOption("plan")
105+
expect(posts()).toHaveLength(0)
106+
await restart()
107+
await go("ses_a")
108+
await expect(active().locator("textarea")).toHaveValue("newer task typing")
109+
await expect(mode("Queue")).toHaveAttribute("aria-checked", "true")
110+
await expect(active().getByRole("combobox", { name: "Queue agent" })).toHaveValue("plan")
111+
await expect(active().getByRole("img", { name: "legacy.png", exact: true })).toHaveAttribute("src", image.url)
112+
await mode("Aside").click()
113+
await expect(active().locator("textarea")).toHaveValue("newer Aside typing")
114+
await expect(active().getByRole("combobox", { name: "Model override" })).toHaveValue("fixture\u0000test")
115+
expect((await saved("ses_a")).aside.images[0].url).toBe(image.url)
116+
expect(posts()).toHaveLength(0)
117+
checkpoint(
118+
"legacy migration, task/Aside text and images, mode/model/agent survive same-profile process restart without submit",
119+
)
120+
121+
await go("ses_b")
122+
await active().getByRole("button", { name: "Choose message delivery" }).click()
123+
await active().getByRole("combobox", { name: "Queue agent" }).selectOption("plan")
124+
await active().locator("textarea").fill("original unknown queue input")
125+
fixture.loseInput = true
126+
await active().getByRole("button", { name: "Queue message", exact: true }).click()
127+
await expect(page.getByRole("region", { name: "Input admission" })).toContainText("Admission unknown")
128+
const original = posts().at(-1).body
129+
await active().locator("textarea").fill("newer unsent task")
130+
await mode("Aside").click()
131+
await active().locator("textarea").fill("original Aside question")
132+
await active().getByRole("combobox", { name: "Model override" }).selectOption("fixture\u0000test")
133+
fixture.holdAside = true
134+
await active().getByRole("button", { name: "Ask aside", exact: true }).click()
135+
await expect.poll(() => posts().length).toBe(2)
136+
const asideID = posts()[1].body.requestID
137+
await active().locator("textarea").fill("newer unsent Aside")
138+
await attach("aside-draft.png")
139+
await mode("Queue").click()
140+
await attach("task-draft.png")
141+
await mode("Aside").click()
142+
await restart()
143+
await go("ses_b")
144+
await expect(active().locator("textarea")).toHaveValue("newer unsent Aside")
145+
await expect(mode("Aside")).toHaveAttribute("aria-checked", "true")
146+
await expect(active().getByRole("img", { name: "aside-draft.png" })).toBeVisible()
147+
await expect(page.locator(".aside-result")).toContainText("unknown")
148+
const restored = await saved("ses_b")
149+
expect(restored.admission.payload).toEqual(original)
150+
expect(restored.asideRequest.requestID).toBe(asideID)
151+
expect(restored.task.text).toBe("newer unsent task")
152+
expect(restored.task.images[0].url).toBe(image.url)
153+
expect(restored.aside.images[0].url).toBe(image.url)
154+
expect(posts()).toHaveLength(2)
155+
await mode("Queue").click()
156+
await expect(active().locator("textarea")).toHaveValue("newer unsent task")
157+
await page.getByRole("button", { name: "Check and retry same input", exact: true }).click()
158+
await expect.poll(() => posts().length).toBe(3)
159+
expect(posts()[2].body).toEqual(original)
160+
expect(fixture.receipts).toHaveLength(1)
161+
await expect(active().locator("textarea")).toHaveValue("newer unsent task")
162+
await expect(page.getByRole("region", { name: "Input admission" })).toHaveCount(0)
163+
checkpoint(
164+
"unknown queue/Aside identities and newer image drafts survive restart; explicit retry reuses exact original payload once",
165+
)
166+
167+
await go("ses_a")
168+
fixture.setStatus("idle")
169+
await active().getByRole("button", { name: "Use normal Send", exact: true }).click()
170+
fixture.loseNormal = true
171+
await active().getByRole("button", { name: "Send", exact: true }).click()
172+
await expect(page.getByRole("region", { name: "Normal Send status" })).toContainText("Outcome unknown")
173+
expect(posts()).toHaveLength(4)
174+
await restart()
175+
await go("ses_a")
176+
await expect(page.getByRole("region", { name: "Normal Send status" })).toContainText("Outcome unknown")
177+
await expect(active().locator("textarea")).toHaveValue("newer task typing")
178+
await expect(active().getByRole("button", { name: "Send", exact: true })).toBeDisabled()
179+
await expect(active().getByRole("img", { name: "legacy.png", exact: true })).toHaveAttribute("src", image.url)
180+
expect(posts()).toHaveLength(4)
181+
await page.screenshot({ path: path.join(artifacts, "drafts-restored.png") })
182+
checkpoint("unknown normal Send remains visible and blocked after restart; no automatic resubmission")
183+
result.origin = origin
184+
result.passed = true
185+
await writeFile(path.join(artifacts, "draft-restart-results.json"), JSON.stringify(result, null, 2))
186+
if (process.argv.includes("--preview")) {
187+
console.info(
188+
`Isolated native preview running; controller PID ${process.pid}, Electron PID ${app.process().pid}, fixture ${fixture.url}. Close the window to stop.`,
189+
)
190+
await new Promise((resolve) => app.on("close", resolve))
191+
}
192+
} finally {
193+
await app?.close().catch(() => {})
194+
await fixture.close()
195+
await rm(profile, { recursive: true, force: true })
196+
}

0 commit comments

Comments
 (0)