feat(native-chat): a half-typed chat message survives quitting Orca, with one draft per chat

src/main/codex-accounts/fs-utils-remove-retry.test.ts

@@ -0,0 +1,60 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import type * as NodeFsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const fsPromises = vi.hoisted(() => ({ rm: vi.fn() }))
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  fsPromises.rm.mockImplementation(actual.rm)
+  return { ...actual, rm: fsPromises.rm }
+})
+
+import { removeFileWithWindowsRetryAsync } from './fs-utils'
+
+const originalPlatform = process.platform
+const dirs: string[] = []
+
+function fileInTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'orca-fs-remove-retry-'))
+  dirs.push(dir)
+  const file = join(dir, 'draft.json')
+  writeFileSync(file, '{}')
+  return file
+}
+
+afterEach(() => {
+  Object.defineProperty(process, 'platform', { value: originalPlatform })
+  fsPromises.rm.mockClear()
+  dirs.splice(0).forEach((dir) => rmSync(dir, { recursive: true, force: true }))
+})
+
+describe('removeFileWithWindowsRetryAsync', () => {
+  // An antivirus scan holding the file open must not fail the delete (#1507).
+  it('retries a Windows sharing violation', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    const file = fileInTempDir()
+    fsPromises.rm.mockRejectedValueOnce(Object.assign(new Error('busy'), { code: 'EBUSY' }))
+
+    await removeFileWithWindowsRetryAsync(file)
+
+    expect(fsPromises.rm).toHaveBeenCalledTimes(2)
+    expect(existsSync(file)).toBe(false)
+  })
+
+  it('treats a missing file as deleted', async () => {
+    const file = fileInTempDir()
+    await removeFileWithWindowsRetryAsync(file)
+    await expect(removeFileWithWindowsRetryAsync(file)).resolves.toBeUndefined()
+  })
+
+  it('does not retry off Windows', async () => {
+    Object.defineProperty(process, 'platform', { value: 'darwin' })
+    fsPromises.rm.mockRejectedValueOnce(Object.assign(new Error('busy'), { code: 'EBUSY' }))
+
+    await expect(removeFileWithWindowsRetryAsync(fileInTempDir())).rejects.toThrow('busy')
+    expect(fsPromises.rm).toHaveBeenCalledOnce()
+  })
+})

src/main/codex-accounts/fs-utils.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import { copyFileSync, existsSync, linkSync, renameSync, rmSync, writeFileSync } from 'node:fs'
-import { rename } from 'node:fs/promises'
+import { rename, rm } from 'node:fs/promises'
 import { dirname } from 'node:path'
 import { setTimeout } from 'node:timers/promises'
 import { grantDirAcl, isPermissionError } from '../win32-utils'
@@ -224,6 +224,21 @@ export async function renameFileWithWindowsRetryAsync(
   }
 }
 
+/** Deletes `target`, treating a missing file as deleted; retries like the rename above (#1507). */
+export async function removeFileWithWindowsRetryAsync(target: string): Promise<void> {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await rm(target, { force: true })
+      return
+    } catch (error) {
+      if (!shouldRetryFileOperation(error, attempt)) {
+        throw error
+      }
+      await setTimeout(attempt * 50)
+    }
+  }
+}
+
 export function copyFileWithWindowsRetry(source: string, target: string): void {
   runFileOperationWithWindowsRetry(() => copyFileSync(source, target))
 }

src/main/durable-file-write-process.test.ts

@@ -0,0 +1,53 @@
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs'
+import type * as NodeFsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const fsPromises = vi.hoisted(() => ({ rm: vi.fn(), rename: vi.fn() }))
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  fsPromises.rm.mockImplementation(actual.rm)
+  fsPromises.rename.mockImplementation(actual.rename)
+  return { ...actual, rm: fsPromises.rm, rename: fsPromises.rename }
+})
+
+import { durableWriteTempPath, writeFileProcessDurable } from './durable-file-write'
+
+const dirs: string[] = []
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'orca-process-durable-'))
+  dirs.push(dir)
+  return dir
+}
+
+afterEach(() => {
+  fsPromises.rm.mockClear()
+  fsPromises.rename.mockClear()
+  dirs.splice(0).forEach((dir) => rmSync(dir, { recursive: true, force: true }))
+})
+
+describe('writeFileProcessDurable', () => {
+  // The temp file is gone once renamed; removing it again is a wasted file-system call.
+  it('renames the temp file into place without removing it afterwards', async () => {
+    const file = join(tempDir(), 'draft.json')
+
+    await writeFileProcessDurable(durableWriteTempPath(file), file, '{"a":1}')
+
+    expect(readFileSync(file, 'utf8')).toBe('{"a":1}')
+    expect(fsPromises.rm).not.toHaveBeenCalled()
+  })
+
+  it('removes the temp file when the rename fails', async () => {
+    const dir = tempDir()
+    const file = join(dir, 'draft.json')
+    fsPromises.rename.mockRejectedValueOnce(Object.assign(new Error('denied'), { code: 'EACCES' }))
+
+    await expect(
+      writeFileProcessDurable(durableWriteTempPath(file), file, '{"a":1}')
+    ).rejects.toThrow('denied')
+    expect(readdirSync(dir)).toEqual([])
+  })
+})

src/main/durable-file-write.ts

@@ -4,7 +4,7 @@
 // hour's loss; fsync stops it from happening.
 
 import { closeSync, fsyncSync, openSync, rmSync, writeFileSync } from 'node:fs'
-import { copyFile, open, readdir, rm, stat } from 'node:fs/promises'
+import { copyFile, open, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import {
   publishFileWithoutOverwrite,
@@ -165,6 +165,26 @@ export async function writeFileDurableIfCurrent(
   }
 }
 
+/**
+ * Write to a temp file and rename it over `finalPath`, with no fsync. Survives the process being
+ * killed once it returns, since the rename sits in the page cache; a power loss can still revert it.
+ */
+export async function writeFileProcessDurable(
+  tmpPath: string,
+  finalPath: string,
+  payload: string
+): Promise<void> {
+  let renamed = false
+  try {
+    await writeFile(tmpPath, payload, { mode: 0o600 })
+    renamed = await renameFileWithWindowsRetryAsync(tmpPath, finalPath)
+  } finally {
+    if (!renamed) {
+      await rm(tmpPath, { force: true }).catch(() => {})
+    }
+  }
+}
+
 /** Temp path for a durable write. Shared shape so `removeStaleDurableWriteTempFiles` can reclaim orphans. */
 export function durableWriteTempPath(finalPath: string): string {
   return `${finalPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`

src/main/ipc/filesystem-auth.ts

@@ -3,6 +3,7 @@ import { realpathSync } from 'node:fs'
 import { realpath } from 'node:fs/promises'
 import type { Store } from '../persistence'
 import { getAllowedRoots } from './filesystem-allowed-roots'
+import { getNativeChatAttachmentAllowedRoots } from '../window/native-chat-attachment-store'
 import { isDescendantOrEqual, isENOENT, normalizeExistingPath } from './filesystem-path-containment'
 import {
   ensureAuthorizedRootsCache,
@@ -54,7 +55,12 @@ type AllowedRootsSnapshot = { get: () => readonly string[] }
 
 function createAllowedRootsSnapshot(store: Store): AllowedRootsSnapshot {
   let roots: readonly string[] | undefined
-  return { get: () => (roots ??= getAllowedRoots(store)) }
+  return { get: () => (roots ??= getAuthorizedRoots(store)) }
+}
+
+/** Workspace roots, plus Orca's own storage for chat draft images so a relaunch can read them. */
+function getAuthorizedRoots(store: Store): string[] {
+  return [...getAllowedRoots(store), ...getNativeChatAttachmentAllowedRoots()]
 }
 
 export function isPathAllowed(
@@ -71,7 +77,7 @@ export function isPathAllowed(
       return true
     }
   }
-  return (allowedRoots?.get() ?? getAllowedRoots(store)).some((root) =>
+  return (allowedRoots?.get() ?? getAuthorizedRoots(store)).some((root) =>
     isDescendantOrEqual(resolvedTarget, root)
   )
 }
@@ -223,7 +229,7 @@ async function isPathAllowedByCanonicalAllowedRoot(
   if (!sourcePath) {
     return false
   }
-  for (const root of allowedRoots?.get() ?? getAllowedRoots(store)) {
+  for (const root of allowedRoots?.get() ?? getAuthorizedRoots(store)) {
     const resolvedRoot = resolve(root)
     if (!isDescendantOrEqual(sourcePath, resolvedRoot)) {
       continue

src/main/ipc/native-chat-drafts.test.ts

@@ -0,0 +1,129 @@
+import { mkdtemp, readdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as SidecarSnapshotFile from '../sidecar-snapshot-file'
+
+const { handlers, listeners, ipcMainMock, isTrustedUIRendererMock } = vi.hoisted(() => {
+  const handlerMap = new Map<string, (...args: unknown[]) => unknown>()
+  const listenerMap = new Map<string, (...args: unknown[]) => void>()
+  return {
+    handlers: handlerMap,
+    listeners: listenerMap,
+    ipcMainMock: {
+      removeHandler: vi.fn(),
+      removeAllListeners: vi.fn(),
+      handle: (channel: string, fn: (...args: unknown[]) => unknown) => handlerMap.set(channel, fn),
+      on: (channel: string, fn: (...args: unknown[]) => void) => listenerMap.set(channel, fn)
+    },
+    isTrustedUIRendererMock: vi.fn(() => true)
+  }
+})
+
+const sidecar = vi.hoisted(() => ({ removeSidecarSnapshot: vi.fn() }))
+
+vi.mock('../sidecar-snapshot-file', async (importOriginal) => {
+  const actual = await importOriginal<typeof SidecarSnapshotFile>()
+  sidecar.removeSidecarSnapshot.mockImplementation(actual.removeSidecarSnapshot)
+  return { ...actual, removeSidecarSnapshot: sidecar.removeSidecarSnapshot }
+})
+vi.mock('electron', () => ({ ipcMain: ipcMainMock }))
+vi.mock('./ui', () => ({ isTrustedUIRenderer: isTrustedUIRendererMock }))
+
+import { drainNativeChatDrafts, registerNativeChatDraftHandlers } from './native-chat-drafts'
+
+const trusted = { sender: { id: 1 } }
+const draft = { text: 'hello', attachments: [] }
+let tempRoot = ''
+let root = ''
+
+function invoke(channel: string, event: unknown, args?: unknown): unknown {
+  const handler = handlers.get(channel)
+  if (!handler) {
+    throw new Error(`no handler for ${channel}`)
+  }
+  return handler(event, args)
+}
+
+function loadSync(event: { sender: { id: number } }): unknown {
+  const reply: { sender: { id: number }; returnValue?: unknown } = { ...event }
+  listeners.get('nativeChat:drafts:loadSync')?.(reply)
+  return reply.returnValue
+}
+
+beforeEach(async () => {
+  tempRoot = await mkdtemp(join(tmpdir(), 'orca-native-chat-draft-ipc-'))
+  root = join(tempRoot, 'native-chat-drafts')
+  isTrustedUIRendererMock.mockReturnValue(true)
+  registerNativeChatDraftHandlers(root)
+})
+
+afterEach(async () => {
+  await drainNativeChatDrafts()
+  await rm(tempRoot, { recursive: true, force: true })
+})
+
+describe('native chat draft IPC', () => {
+  it('saves, loads and clears a draft for the app window', async () => {
+    await expect(
+      invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    ).resolves.toBe('persisted')
+    await expect(invoke('nativeChat:drafts:load', trusted)).resolves.toEqual([
+      { scopeKey: 'session:s1', draft }
+    ])
+    expect(loadSync(trusted)).toEqual([{ scopeKey: 'session:s1', draft }])
+
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft: null })
+    expect(await readdir(root)).toEqual([])
+  })
+
+  it('refuses every other renderer', async () => {
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    isTrustedUIRendererMock.mockReturnValue(false)
+    const other = { sender: { id: 2 } }
+
+    expect(await invoke('nativeChat:drafts:write', other, { scopeKey: 'session:s2', draft })).toBe(
+      'failed'
+    )
+    expect(
+      await invoke('nativeChat:drafts:write', other, { scopeKey: 'session:s1', draft: null })
+    ).toBe('failed')
+    expect(await invoke('nativeChat:drafts:load', other)).toEqual([])
+    expect(loadSync(other)).toEqual([])
+    isTrustedUIRendererMock.mockReturnValue(true)
+    expect(await invoke('nativeChat:drafts:load', trusted)).toEqual([
+      { scopeKey: 'session:s1', draft }
+    ])
+  })
+
+  it('refuses a write without a chat', async () => {
+    expect(await invoke('nativeChat:drafts:write', trusted, { draft })).toBe('failed')
+    expect(await invoke('nativeChat:drafts:write', trusted, null)).toBe('failed')
+  })
+
+  // macOS keeps Orca running with no window; reopening one registers the handlers again.
+  it('keeps the same store when the window is reopened, so a failed clear is still owed', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    sidecar.removeSidecarSnapshot.mockRejectedValueOnce(
+      Object.assign(new Error('denied'), { code: 'EACCES' })
+    )
+    expect(
+      await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft: null })
+    ).toBe('failed')
+
+    registerNativeChatDraftHandlers(root)
+
+    expect(await invoke('nativeChat:drafts:load', trusted)).toEqual([])
+    await drainNativeChatDrafts()
+    expect(await readdir(root)).toEqual([])
+  })
+
+  it('lets a draft written just before quitting land before the app exits', async () => {
+    void invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+
+    await drainNativeChatDrafts()
+
+    expect((await readdir(root)).filter((name) => name.endsWith('.json'))).toHaveLength(1)
+  })
+})