@anionex/dsh-turn-rewind 0.1.1 → 0.1.2

package/src/rewind-host.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import type { Context } from '@deepseek-ai/cordis'
+import { createDeadline } from './deadline.js'
 import { ChangeLedgerError, errorMessage } from './errors.js'
 import type { ChangeLedgerEngine } from './engine.js'
 import { discoverRepositoryRoot } from './git.js'
@@ -114,6 +115,7 @@ export class TurnCheckpointCoordinator {
   private readonly captures = new Map<string, Promise<void>>()
   private readonly pending = new Set<string>()
   private readonly failures = new Map<string, string>()
+  private readonly skips = new Map<string, string>()
   private readonly workspaceTails = new Map<string, Promise<void>>()
 
   constructor(private readonly engine: ChangeLedgerEngine) {}
@@ -127,9 +129,11 @@ export class TurnCheckpointCoordinator {
   }
 
   /** Current capture state for a session turn when no durable checkpoint exists yet. */
-  state(sessionId: string, turn: number): { readonly status: 'pending' | 'failed' | 'missing'; readonly error?: string } {
+  state(sessionId: string, turn: number): { readonly status: 'pending' | 'failed' | 'skipped' | 'missing'; readonly error?: string; readonly reason?: string } {
     const key = checkpointKey(sessionId, turn)
     if (this.pending.has(key)) return { status: 'pending' }
+    const reason = this.skips.get(key)
+    if (reason !== undefined) return { status: 'skipped', reason }
     const error = this.failures.get(key)
     return error === undefined ? { status: 'missing' } : { status: 'failed', error }
   }
@@ -141,48 +145,88 @@ export class TurnCheckpointCoordinator {
     signal: AbortSignal,
   ): Promise<void> {
     const key = checkpointKey(agent.id, turn)
-    const existing = this.captures.get(key)
-    if (existing !== undefined) {
-      await existing
-      return
-    }
     const cwd = agent.session.header.cwd
     if (cwd === undefined) return
     const start = agent.session.events.findLast(event => event.type === 'turn/start' && event.data.turn === turn)
     if (start === undefined) {
-      this.recordFailure(ctx, agent.id, turn, new Error('turn/start is unavailable before the first step'))
+      await this.recordFailure(ctx, agent.id, turn, new Error('turn/start is unavailable before the first step'))
       return
     }
-    this.pending.add(key)
-    this.failures.delete(key)
-    const capture = (async () => {
-      try {
-        const workspace = await discoverRepositoryRoot(cwd, signal)
-        await this.serializeWorkspace(workspace, signal, async () => {
-          await this.engine.createTurnCheckpoint({
-            cwd: workspace,
-            sessionId: agent.id,
-            turn,
-            turnStartSeq: start.seq,
-            signal,
+    const timeoutMs = this.engine.config.turnCheckpointTimeoutMs
+    const outcomeDeadline = createDeadline(timeoutMs)
+    const outcomeSignal = AbortSignal.any([signal, outcomeDeadline.signal])
+    const reserveMs = Math.min(250, Math.max(10, Math.ceil(timeoutMs / 5)))
+    const captureDeadline = createDeadline(Math.max(1, timeoutMs - reserveMs))
+    const captureSignal = AbortSignal.any([signal, captureDeadline.signal])
+    try {
+      const existing = this.captures.get(key)
+      if (existing !== undefined) {
+        await waitWithSignal(existing, captureSignal).catch(() => undefined)
+        return
+      }
+      this.pending.add(key)
+      this.failures.delete(key)
+      this.skips.delete(key)
+      const capture = (async () => {
+        try {
+          const workspace = await discoverRepositoryRoot(cwd, captureSignal)
+          await this.serializeWorkspace(workspace, captureSignal, async () => {
+            try {
+              await this.engine.createTurnCheckpoint({
+                cwd: workspace,
+                sessionId: agent.id,
+                turn,
+                turnStartSeq: start.seq,
+                signal: captureSignal,
+              })
+            } catch (error) {
+              await this.recordFailure(
+                ctx,
+                agent.id,
+                turn,
+                checkpointTimeoutError(error, timeoutMs, captureDeadline.signal, signal),
+                { cwd: workspace, turnStartSeq: start.seq },
+              )
+            }
           })
-        })
+        } catch (error) {
+          await this.recordFailure(
+            ctx,
+            agent.id,
+            turn,
+            checkpointTimeoutError(error, timeoutMs, captureDeadline.signal, signal),
+            { cwd, turnStartSeq: start.seq },
+          )
+        } finally {
+          this.pending.delete(key)
+        }
+      })()
+      this.captures.set(key, capture)
+      try {
+        await waitWithSignal(capture, outcomeSignal)
       } catch (error) {
-        this.recordFailure(ctx, agent.id, turn, error)
-      } finally {
+        const bounded = checkpointTimeoutError(error, timeoutMs, outcomeDeadline.signal, signal)
+        const message = errorMessage(bounded)
         this.pending.delete(key)
+        if (bounded instanceof ChangeLedgerError && isCheckpointSkip(bounded.code)) {
+          this.skips.set(key, message)
+        } else {
+          this.failures.set(key, message)
+        }
       }
-    })()
-    this.captures.set(key, capture)
-    await capture
+    } finally {
+      captureDeadline.cancel()
+      outcomeDeadline.cancel()
+    }
   }
 
   private async serializeWorkspace(workspace: string, signal: AbortSignal, task: () => Promise<void>): Promise<void> {
     const previous = this.workspaceTails.get(workspace) ?? Promise.resolve()
-    const current = previous.catch(() => undefined).then(async () => {
+    const current = (async () => {
+      await waitWithSignal(previous.catch(() => undefined), signal)
       signal.throwIfAborted()
       await task()
-    })
+    })()
     this.workspaceTails.set(workspace, current)
     try {
       await current
@@ -191,18 +235,70 @@ export class TurnCheckpointCoordinator {
     }
   }
 
-  private recordFailure(
+  private async recordFailure(
     ctx: Pick<Context, 'logger'>,
     sessionId: string,
     turn: number,
     error: unknown,
-  ): void {
+    skipContext?: { readonly cwd: string; readonly turnStartSeq: number },
+  ): Promise<void> {
     const message = errorMessage(error)
+    if (error instanceof ChangeLedgerError && isCheckpointSkip(error.code)) {
+      this.skips.set(checkpointKey(sessionId, turn), message)
+      if (skipContext !== undefined) {
+        try {
+          await this.engine.recordTurnCheckpointSkip({
+            cwd: skipContext.cwd,
+            sessionId,
+            turn,
+            turnStartSeq: skipContext.turnStartSeq,
+            reason: message,
+          })
+        } catch (persistError) {
+          ctx.logger.warn(`[turn-rewind] could not persist checkpoint skip for ${sessionId} turn ${String(turn)}: ${errorMessage(persistError)}`)
+        }
+      }
+      ctx.logger.warn(`[turn-rewind] checkpoint skipped for ${sessionId} turn ${String(turn)}: ${message}`)
+      return
+    }
     this.failures.set(checkpointKey(sessionId, turn), message)
     ctx.logger.warn(`[turn-rewind] checkpoint failed for ${sessionId} turn ${String(turn)}: ${message}`)
   }
 }
 
+function isCheckpointSkip(code: string): boolean {
+  return code === 'TURN_CHECKPOINT_DISABLED'
+    || code === 'TURN_CHECKPOINT_TIMEOUT'
+    || code === 'TURN_CHECKPOINT_NEW_CONTENT_LIMIT'
+    || code === 'GIT_OBJECT_STORE_UNSUPPORTED'
+    || code === 'GIT_INDEX_UNSUPPORTED'
+}
+
+async function waitWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  signal.throwIfAborted()
+  let rejectAbort: ((reason?: unknown) => void) | undefined
+  const aborted = new Promise<never>((_resolve, reject) => { rejectAbort = reject })
+  const onAbort = () => rejectAbort?.(signal.reason)
+  signal.addEventListener('abort', onAbort, { once: true })
+  try {
+    return await Promise.race([promise, aborted])
+  } finally {
+    signal.removeEventListener('abort', onAbort)
+  }
+}
+
+function checkpointTimeoutError(
+  error: unknown,
+  timeoutMs: number,
+  deadline: AbortSignal,
+  callerSignal: AbortSignal,
+): unknown {
+  if (!callerSignal.aborted && deadline.aborted) {
+    return new ChangeLedgerError('TURN_CHECKPOINT_TIMEOUT', `automatic checkpoint exceeded ${timeoutMs} ms`, { cause: error })
+  }
+  return error
+}
+
 /** Register the same-origin preview/apply endpoint consumed by the browser half. */
 export function installRewindHttp(
   ctx: Context,
@@ -233,7 +329,15 @@ export function createRewindHttpHandler(
         const limit = pageSize(url.searchParams.get('limit'), detailsOnly ? MAX_CHANGE_PAGE_SIZE : INITIAL_CHANGE_PREVIEW_LIMIT)
         const { target, checkpoint } = await resolveMessageCheckpoint(ctx, engine, sessionId, messageSeq)
         if (checkpoint === undefined) {
-          json(response, 200, coordinator.state(sessionId, target.turn))
+          const durableSkip = await engine.findTurnCheckpointSkip({
+            cwd: target.cwd,
+            sessionId,
+            turn: target.turn,
+            turnStartSeq: target.turnStartSeq,
+          })
+          json(response, 200, durableSkip === undefined
+            ? coordinator.state(sessionId, target.turn)
+            : { status: 'skipped', reason: durableSkip.reason })
           return
         }
         const inspection = await engine.inspect({ cwd: checkpoint.cwd, restorePointId: checkpoint.id })

package/src/snapshot.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto'
-import type { BigIntStats } from 'node:fs'
-import { lstat, readFile, readlink } from 'node:fs/promises'
+import { constants, type BigIntStats } from 'node:fs'
+import { lstat, open, readlink } from 'node:fs/promises'
 import { ChangeLedgerError } from './errors.js'
 import { discoverRepository, sameRepositoryFence, type RepositorySnapshotSource } from './git.js'
 import { isNodeError, resolveWorkspacePath } from './path-utils.js'
@@ -11,10 +11,13 @@ import type {
   WorkspaceChange,
 } from './types.js'
 
+const COMPARISON_READ_BUDGET_BYTES = 128 * 1024 * 1024
+
 /** One captured tree, optionally persisted into the blob store. */
 export interface CapturedTree {
   readonly source: RepositorySnapshotSource
   readonly entries: Readonly<Record<string, SnapshotEntry>>
+  readonly gitEntries?: Readonly<Record<string, SnapshotEntry>>
   readonly treeHash: string
   readonly fileCount: number
   readonly totalBytes: number
@@ -25,6 +28,7 @@ export async function captureTree(options: {
   readonly cwd: string
   readonly config: ResolvedChangeLedgerConfig
   readonly store?: LedgerStore
+  readonly gitObjectFormat?: 'sha1' | 'sha256'
   readonly signal?: AbortSignal
 }): Promise<CapturedTree> {
   throwIfAborted(options.signal)
@@ -37,11 +41,18 @@ export async function captureTree(options: {
   }
 
   const entries: Record<string, SnapshotEntry> = Object.create(null) as Record<string, SnapshotEntry>
+  const gitObjectFormat = options.gitObjectFormat
+  const gitCapture = gitObjectFormat === undefined
+    ? undefined
+    : {
+        objectFormat: gitObjectFormat,
+        entries: Object.create(null) as Record<string, SnapshotEntry>,
+      }
   let totalBytes = 0
-  for (const path of source.paths) {
+  const capturePath = async (path: string): Promise<void> => {
     throwIfAborted(options.signal)
     const entry = await captureEntry(source.state.root, path, options.config.maxFileBytes, options.signal)
-    if (entry === undefined) continue
+    if (entry === undefined) return
     if (entry.kind === 'file') {
       totalBytes += entry.content.length
       if (totalBytes > options.config.maxSnapshotBytes) {
@@ -54,14 +65,49 @@ export async function captureTree(options: {
         await options.store.putBlob(source.state.root, entry.snapshot.blob, entry.content)
       }
       entries[path] = entry.snapshot
-      continue
+      if (gitCapture !== undefined) {
+        gitCapture.entries[path] = gitFileSnapshot(entry.snapshot, entry.content, gitCapture.objectFormat)
+      }
+      return
     }
     entries[path] = entry.snapshot
+    if (gitCapture !== undefined) gitCapture.entries[path] = entry.snapshot
+  }
+  if (gitCapture === undefined) {
+    for (const path of source.paths) await capturePath(path)
+  } else {
+    let next = 0
+    let failed = false
+    let firstError: unknown = new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', 'parallel comparison capture failed')
+    const concurrency = Math.min(
+      32,
+      source.paths.length,
+      Math.max(1, Math.floor(COMPARISON_READ_BUDGET_BYTES / options.config.maxFileBytes)),
+    )
+    const workers = Array.from({ length: concurrency }, async () => {
+      while (!failed && next < source.paths.length) {
+        const index = next
+        next += 1
+        const path = source.paths[index]
+        if (path === undefined) continue
+        try {
+          await capturePath(path)
+        } catch (error) {
+          if (!failed) {
+            failed = true
+            firstError = error
+          }
+        }
+      }
+    })
+    await Promise.all(workers)
+    if (failed) throw firstError
   }
 
   return {
     source,
     entries,
+    ...(gitCapture === undefined ? {} : { gitEntries: gitCapture.entries }),
     treeHash: hashTree(entries),
     fileCount: Object.keys(entries).length,
     totalBytes,
@@ -77,12 +123,14 @@ export async function captureStableTree(options: {
   readonly cwd: string
   readonly config: ResolvedChangeLedgerConfig
   readonly store?: LedgerStore
+  readonly gitObjectFormat?: 'sha1' | 'sha256'
   readonly signal?: AbortSignal
 }): Promise<CapturedTree> {
   for (let attempt = 0; attempt < 3; attempt += 1) {
     const first = await captureTree({
       cwd: options.cwd,
       config: options.config,
+      ...(options.gitObjectFormat === undefined ? {} : { gitObjectFormat: options.gitObjectFormat }),
       ...(options.signal === undefined ? {} : { signal: options.signal }),
     })
     const second = await captureTree(options)
@@ -100,12 +148,16 @@ export async function captureStableTree(options: {
 export function diffTrees(
   before: Readonly<Record<string, SnapshotEntry>>,
   after: Readonly<Record<string, SnapshotEntry>>,
+  comparisonBefore: Readonly<Record<string, SnapshotEntry>> = before,
+  comparisonAfter: Readonly<Record<string, SnapshotEntry>> = after,
 ): WorkspaceChange[] {
   const paths = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(comparePaths)
   const changes: WorkspaceChange[] = []
   for (const path of paths) {
     const left = before[path]
     const right = after[path]
+    const comparisonLeft = comparisonBefore[path]
+    const comparisonRight = comparisonAfter[path]
     if (left === undefined && right !== undefined) {
       changes.push({ path, kind: 'added', after: right })
       continue
@@ -114,16 +166,26 @@ export function diffTrees(
       changes.push({ path, kind: 'deleted', before: left })
       continue
     }
-    if (left === undefined || right === undefined || entriesEqual(left, right)) continue
+    if (left === undefined || right === undefined || entriesEqual(comparisonLeft, comparisonRight)) continue
     if (left.kind !== right.kind) {
       changes.push({ path, kind: 'type-changed', before: left, after: right })
       continue
     }
-    if (left.kind === 'file' && right.kind === 'file' && left.blob === right.blob && left.mode !== right.mode) {
+    if (left.kind === 'file'
+      && right.kind === 'file'
+      && comparisonLeft?.kind === 'file'
+      && comparisonRight?.kind === 'file'
+      && comparisonLeft.blob === comparisonRight.blob
+      && left.mode !== right.mode) {
       changes.push({ path, kind: 'mode-changed', before: left, after: right })
       continue
     }
-    if (left.kind === 'symlink' && right.kind === 'symlink' && left.target === right.target && left.mode !== right.mode) {
+    if (left.kind === 'symlink'
+      && right.kind === 'symlink'
+      && comparisonLeft?.kind === 'symlink'
+      && comparisonRight?.kind === 'symlink'
+      && comparisonLeft.target === comparisonRight.target
+      && left.mode !== right.mode) {
       changes.push({ path, kind: 'mode-changed', before: left, after: right })
       continue
     }
@@ -159,6 +221,29 @@ export function hashTree(entries: Readonly<Record<string, SnapshotEntry>>): stri
   return hash.digest('hex')
 }
 
+/** Byte-verify one workspace-relative path without following a final symlink. */
+export async function captureSnapshotEntry(
+  root: string,
+  path: string,
+  maxFileBytes: number,
+  signal?: AbortSignal,
+  gitObjectFormat?: 'sha1' | 'sha256',
+): Promise<SnapshotEntry | undefined> {
+  const entry = await captureEntry(root, path, maxFileBytes, signal)
+  if (entry === undefined || entry.kind === 'symlink' || gitObjectFormat === undefined) return entry?.snapshot
+  return gitFileSnapshot(entry.snapshot, entry.content, gitObjectFormat)
+}
+
+function gitFileSnapshot(
+  snapshot: SnapshotEntry & { readonly kind: 'file' },
+  content: Buffer,
+  objectFormat: 'sha1' | 'sha256',
+): SnapshotEntry {
+  const header = Buffer.from(`blob ${String(content.length)}\0`)
+  const blob = createHash(objectFormat).update(header).update(content).digest('hex')
+  return { ...snapshot, blob, provider: 'git' }
+}
+
 async function captureEntry(
   root: string,
   path: string,
@@ -193,10 +278,24 @@ async function captureEntry(
         `${JSON.stringify(path)} is ${before.size.toString()} bytes; configured per-file maximum is ${maxFileBytes}`,
       )
     }
-    const content = await readFile(target)
-    throwIfAborted(signal)
-    const after = await lstat(target, { bigint: true })
-    if (!sameStat(before, after) || BigInt(content.length) !== after.size) continue
+    let handle
+    try {
+      handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW)
+    } catch (error) {
+      if (isNodeError(error, 'ELOOP')) continue
+      throw error
+    }
+    let content: Buffer
+    try {
+      const opened = await handle.stat({ bigint: true })
+      if (!opened.isFile() || !sameStat(before, opened)) continue
+      content = await readBoundedFile(handle, Number(opened.size))
+      throwIfAborted(signal)
+      const after = await handle.stat({ bigint: true })
+      if (!sameStat(opened, after) || BigInt(content.length) !== after.size) continue
+    } finally {
+      await handle.close()
+    }
     const blob = createHash('sha256').update(content).digest('hex')
     return {
       kind: 'file',
@@ -207,6 +306,17 @@ async function captureEntry(
   throw new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', `path changed repeatedly while being captured: ${JSON.stringify(path)}`)
 }
 
+async function readBoundedFile(handle: Awaited<ReturnType<typeof open>>, expectedSize: number): Promise<Buffer> {
+  const buffer = Buffer.allocUnsafe(expectedSize + 1)
+  let offset = 0
+  while (offset < buffer.length) {
+    const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset)
+    if (bytesRead === 0) break
+    offset += bytesRead
+  }
+  return buffer.subarray(0, offset)
+}
+
 function sameStat(left: BigIntStats, right: BigIntStats): boolean {
   return left.dev === right.dev
     && left.ino === right.ino