mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 19:34:29 +00:00
* [comment audit] Tighten watcher lifetime and file-write constraints [skip ci] * [comment audit] Clarify IPC routing and notification comments [skip ci] * [comment audit] Shorten watcher, preflight and PTY comments [skip ci] * [comment audit] Clarify PTY delivery and restore ownership [skip ci] * [comment audit] Tighten PTY environment and flow-control rationale [skip ci] * [comment audit] Clarify IPC spawn and stable-pane guarantees [skip ci] * [comment audit] Tighten PTY provider and filesystem ownership rationale [skip ci] * [comment audit] Clarify clone ownership and remote runtime recovery [skip ci] * [comment audit] Condense upload, settings and SSH lifecycle comments [skip ci] * [comment audit] Shorten shutdown, preview and worktree watcher rationale [skip ci] * [comment audit] Clarify worktree identity, remote ownership and copy limits [skip ci] * [comment audit] Shorten worktree catalog, removal and WSL routing rationale [skip ci] * [comment audit] Tighten Linear credential, pagination and export comments [skip ci] * [comment audit] Condense managed-server activation, snapshot and launch rationale [skip ci] * [comment audit] Trim runtime installation and managed-server lifecycle comments [skip ci] * [comment audit] Simplify managed tunnel, memory and menu comments [skip ci] * [comment audit] Condense integration, model catalog and attachment rationale [skip ci] * [comment audit] Shorten journal persistence, replay and queue rationale [skip ci] * [comment audit] Condense journal ordering and timeline lifecycle comments [skip ci] * [comment audit] Trim timeline and subscriber delivery explanations [skip ci] * [comment audit] Shorten Stop, child-exit and recovery contracts [skip ci] * [comment audit] Simplify handover and host recovery comments [skip ci] * [comment audit] Trim queue delivery and provider startup commentary [skip ci] * [comment audit] Clarify restart and rewind safety comments [skip ci] * [comment audit] Trim status, Stop and completion commentary [skip ci] * [comment audit] Simplify transcript lookup and visual containment comments [skip ci] * [comment audit] Trim transcript reader, watcher and WSL transport commentary [skip ci] --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
321 lines
11 KiB
TypeScript
321 lines
11 KiB
TypeScript
import { pruneOpenCodeFingerprintCache } from './transcript-opencode-fingerprint-window'
|
|
export { pruneOpenCodeFingerprintCache as pruneOpenCodeFingerprintCacheForTest } from './transcript-opencode-fingerprint-window'
|
|
import { errorMessage } from '../ai-vault/session-scanner-values'
|
|
import {
|
|
DESKTOP_READ_WINDOW,
|
|
UNFLUSHED_SETTLE_MS,
|
|
type NativeChatTranscriptSubscription,
|
|
type SubscribeNativeChatTranscriptArgs
|
|
} from './transcript-watch-contract'
|
|
import type { OpenCodeTranscriptItem } from './transcript-opencode-sqlite-query'
|
|
import { openCodeTranscriptDefaultDeps, type OpenCodeTranscriptDeps } from './transcript-opencode'
|
|
import {
|
|
openCodeTranscriptPageLimit,
|
|
OPENCODE_TRANSCRIPT_MAX_WINDOW
|
|
} from '../../shared/opencode-transcript-page-limit'
|
|
|
|
const OPENCODE_POLL_MS = 1_000
|
|
|
|
export function subscribeOpenCodeNativeChatTranscript(
|
|
args: SubscribeNativeChatTranscriptArgs,
|
|
setupSignal?: AbortSignal,
|
|
deps: OpenCodeTranscriptDeps = {},
|
|
agent?: 'zcode'
|
|
): NativeChatTranscriptSubscription {
|
|
setupSignal?.throwIfAborted()
|
|
const controller = new AbortController()
|
|
const resolveDbPath = deps.resolveDbPath ?? openCodeTranscriptDefaultDeps.resolveDbPath
|
|
const readSignal = deps.readSignal ?? openCodeTranscriptDefaultDeps.readSignal
|
|
const readPage = (page: Parameters<NonNullable<OpenCodeTranscriptDeps['readPage']>>[0]) =>
|
|
(deps.readPage ?? openCodeTranscriptDefaultDeps.readPage)(
|
|
{ ...page, ...(agent ? { agent } : {}) },
|
|
controller.signal
|
|
)
|
|
const pollMs = args.resolvePollIntervalMs ?? OPENCODE_POLL_MS
|
|
const initialLimit = openCodeTranscriptPageLimit(
|
|
args.initialLimit && args.initialLimit > 0 ? args.initialLimit : DESKTOP_READ_WINDOW
|
|
)
|
|
|
|
let closed = false
|
|
let pollTimer: ReturnType<typeof setTimeout> | null = null
|
|
let dbPath: string | null = null
|
|
let lastSignal: string | null = null
|
|
let lastEmittedRowId = 0
|
|
let lastCounts = { messages: 0, parts: 0 }
|
|
let windowLimit = initialLimit
|
|
const fingerprints = new Map<number, string>()
|
|
let gateErrorEmitted = false
|
|
let settled = false
|
|
let settleTimer: ReturnType<typeof setTimeout> | null = null
|
|
|
|
const onAbort = () => unsubscribe()
|
|
setupSignal?.addEventListener('abort', onAbort, { once: true })
|
|
|
|
function stopSettleTimer(): void {
|
|
if (settleTimer) {
|
|
clearTimeout(settleTimer)
|
|
settleTimer = null
|
|
}
|
|
}
|
|
|
|
function settleUnflushed(): void {
|
|
settleTimer = null
|
|
if (closed || settled || !args.onTranscriptPending) {
|
|
return
|
|
}
|
|
settled = true
|
|
emitSafely(() => args.onTranscriptPending?.(), 'pending')
|
|
}
|
|
|
|
if (args.onTranscriptPending) {
|
|
settleTimer = setTimeout(settleUnflushed, UNFLUSHED_SETTLE_MS)
|
|
settleTimer.unref?.()
|
|
}
|
|
// Escaping subscriber errors would skip scheduling and permanently stop polling.
|
|
function emitSafely(run: () => void, what: string): void {
|
|
try {
|
|
run()
|
|
} catch (err) {
|
|
console.warn(
|
|
`OpenCode native-chat subscriber (${what}) threw; polling continues. ${errorMessage(err)}`
|
|
)
|
|
}
|
|
}
|
|
|
|
function scheduleTick(): void {
|
|
if (closed) {
|
|
return
|
|
}
|
|
pollTimer = setTimeout(() => {
|
|
pollTimer = null
|
|
void tick()
|
|
}, pollMs)
|
|
pollTimer.unref?.()
|
|
}
|
|
|
|
async function tick(): Promise<void> {
|
|
if (closed) {
|
|
return
|
|
}
|
|
try {
|
|
dbPath ??= await resolveDbPath(args.sessionId, controller.signal, agent)
|
|
if (closed) {
|
|
return
|
|
}
|
|
if (!dbPath) {
|
|
scheduleTick()
|
|
return
|
|
}
|
|
const signal = await readSignal(dbPath, args.sessionId, controller.signal, agent)
|
|
if (closed) {
|
|
return
|
|
}
|
|
if (!signal) {
|
|
// Hooks may arrive before the session row.
|
|
scheduleTick()
|
|
return
|
|
}
|
|
const fingerprint = `${signal.messageCount}:${signal.partCount}:${signal.maxMessageRowId}:${signal.maxPartTimeUpdated}`
|
|
const firstSnapshot = lastSignal === null
|
|
if (!firstSnapshot && fingerprint === lastSignal) {
|
|
scheduleTick()
|
|
return
|
|
}
|
|
const page = await readPage({
|
|
dbPath,
|
|
sessionId: args.sessionId,
|
|
limit: firstSnapshot
|
|
? initialLimit
|
|
: Math.min(
|
|
OPENCODE_TRANSCRIPT_MAX_WINDOW,
|
|
windowLimit + Math.max(0, signal.messageCount - lastCounts.messages)
|
|
)
|
|
})
|
|
if (closed) {
|
|
return
|
|
}
|
|
if (!page) {
|
|
scheduleTick()
|
|
return
|
|
}
|
|
if (firstSnapshot) {
|
|
lastSignal = fingerprint
|
|
lastCounts = { messages: signal.messageCount, parts: signal.partCount }
|
|
rememberItems(page.items)
|
|
settled = true
|
|
stopSettleTimer()
|
|
const snapshot = page.items.map((item) => item.message)
|
|
const snapshotHasMore = page.hasMore
|
|
const snapshotBefore = page.beforeMessageRowId ?? 0
|
|
emitSafely(
|
|
() => args.onInitialSnapshot?.(snapshot, snapshotHasMore, snapshotBefore),
|
|
'snapshot'
|
|
)
|
|
scheduleTick()
|
|
return
|
|
}
|
|
// Imported ZCode rows may precede the frontier regardless of storage rowid.
|
|
if (agent === 'zcode') {
|
|
if (
|
|
await replaceWithBridgedWindow(dbPath, page, signal.messageCount < lastCounts.messages)
|
|
) {
|
|
lastSignal = fingerprint
|
|
lastCounts = { messages: signal.messageCount, parts: signal.partCount }
|
|
}
|
|
scheduleTick()
|
|
return
|
|
}
|
|
let changed = page.items.some(
|
|
(item) =>
|
|
item.rowid <= lastEmittedRowId && fingerprints.get(item.rowid) !== item.fingerprint
|
|
)
|
|
const shrinking =
|
|
signal.messageCount < lastCounts.messages || signal.partCount < lastCounts.parts
|
|
const present = new Set(page.items.map((item) => item.rowid))
|
|
if (
|
|
!changed &&
|
|
!shrinking &&
|
|
page.hasMore &&
|
|
fingerprints.size === OPENCODE_TRANSCRIPT_MAX_WINDOW &&
|
|
page.items.length === OPENCODE_TRANSCRIPT_MAX_WINDOW
|
|
) {
|
|
const oldest = page.items[0]!.rowid
|
|
const displaced = [...fingerprints.keys()].filter((rowid) => rowid < oldest)
|
|
if (displaced.length > 0) {
|
|
// Check displaced rows: tail eviction and deletion otherwise look identical.
|
|
const older = await readPage({
|
|
dbPath,
|
|
sessionId: args.sessionId,
|
|
limit: displaced.length,
|
|
beforeMessageRowId: oldest
|
|
})
|
|
if (closed || !older) {
|
|
scheduleTick()
|
|
return
|
|
}
|
|
for (const item of older.items) {
|
|
present.add(item.rowid)
|
|
changed ||= fingerprints.get(item.rowid) !== item.fingerprint
|
|
}
|
|
}
|
|
}
|
|
// Balanced delete/append can hide a removed row before the new tail.
|
|
const removed = [...fingerprints.keys()].some((rowid) => !present.has(rowid))
|
|
if (changed || shrinking || removed) {
|
|
if (await replaceWithBridgedWindow(dbPath, page, shrinking)) {
|
|
lastSignal = fingerprint
|
|
lastCounts = { messages: signal.messageCount, parts: signal.partCount }
|
|
}
|
|
scheduleTick()
|
|
return
|
|
}
|
|
const appended = page.items.filter((item) => item.rowid > lastEmittedRowId)
|
|
if (appended.length > 0 && appended.length === page.items.length && page.hasMore) {
|
|
if (await replaceWithBridgedWindow(dbPath, page)) {
|
|
lastSignal = fingerprint
|
|
lastCounts = { messages: signal.messageCount, parts: signal.partCount }
|
|
}
|
|
scheduleTick()
|
|
return
|
|
}
|
|
if (appended.length > 0) {
|
|
rememberItems(appended)
|
|
const appendedMessages = appended.map((item) => item.message)
|
|
emitSafely(() => args.onAppend(appendedMessages), 'append')
|
|
}
|
|
lastSignal = fingerprint
|
|
lastCounts = { messages: signal.messageCount, parts: signal.partCount }
|
|
scheduleTick()
|
|
} catch (err) {
|
|
if (!closed && lastSignal === null && !gateErrorEmitted && args.onInitialSnapshot) {
|
|
gateErrorEmitted = true
|
|
// Keep retryable errors visible instead of overwriting with empty settlement.
|
|
settled = true
|
|
stopSettleTimer()
|
|
const failure = errorMessage(err)
|
|
emitSafely(() => args.onInitialSnapshot?.([], false, 0, failure), 'error')
|
|
}
|
|
scheduleTick()
|
|
}
|
|
}
|
|
|
|
function rememberItems(items: OpenCodeTranscriptItem[]): void {
|
|
for (const item of items) {
|
|
fingerprints.set(item.rowid, item.fingerprint)
|
|
if (item.rowid > lastEmittedRowId) {
|
|
lastEmittedRowId = item.rowid
|
|
}
|
|
}
|
|
pruneOpenCodeFingerprintCache(fingerprints, OPENCODE_TRANSCRIPT_MAX_WINDOW, agent)
|
|
windowLimit = Math.max(windowLimit, fingerprints.size)
|
|
}
|
|
|
|
// Widen bounded worker reads until they overlap the emitted frontier, bridging poll-gap bursts.
|
|
// If even the cap cannot overlap, retain the old signal/frontier and retry without losing rows.
|
|
async function replaceWithBridgedWindow(
|
|
db: string,
|
|
page: Awaited<ReturnType<typeof readPage>>,
|
|
shrinking = false
|
|
): Promise<boolean> {
|
|
let limit = Math.max(windowLimit, page?.items.length ?? 0)
|
|
for (;;) {
|
|
const replacement =
|
|
page ??
|
|
(await readPage({
|
|
dbPath: db,
|
|
sessionId: args.sessionId,
|
|
limit
|
|
}))
|
|
if (closed || !replacement) {
|
|
return false
|
|
}
|
|
const oldest = replacement.items[0]?.rowid
|
|
if (oldest === undefined) {
|
|
// Non-renderable-only changes leave nothing to bridge.
|
|
const hasMore = replacement.hasMore
|
|
const before = replacement.beforeMessageRowId ?? 0
|
|
fingerprints.clear()
|
|
lastEmittedRowId = 0
|
|
emitSafely(() => args.onReplace?.([], hasMore, before), 'replace')
|
|
return true
|
|
}
|
|
const overlaps =
|
|
agent === 'zcode'
|
|
? replacement.items.some((item) => fingerprints.has(item.rowid))
|
|
: oldest <= lastEmittedRowId
|
|
if (shrinking || overlaps || !replacement.hasMore) {
|
|
fingerprints.clear()
|
|
lastEmittedRowId = 0
|
|
rememberItems(replacement.items)
|
|
const messages = replacement.items.map((item) => item.message)
|
|
const hasMore = replacement.hasMore
|
|
const before = replacement.beforeMessageRowId ?? 0
|
|
emitSafely(() => args.onReplace?.(messages, hasMore, before), 'replace')
|
|
return true
|
|
}
|
|
if (limit >= OPENCODE_TRANSCRIPT_MAX_WINDOW) {
|
|
return false
|
|
}
|
|
limit = Math.min(limit * 2, OPENCODE_TRANSCRIPT_MAX_WINDOW)
|
|
page = null
|
|
}
|
|
}
|
|
|
|
function unsubscribe(): void {
|
|
if (closed) {
|
|
return
|
|
}
|
|
closed = true
|
|
controller.abort()
|
|
setupSignal?.removeEventListener('abort', onAbort)
|
|
stopSettleTimer()
|
|
if (pollTimer) {
|
|
clearTimeout(pollTimer)
|
|
pollTimer = null
|
|
}
|
|
}
|
|
|
|
void tick()
|
|
return { unsubscribe, watching: true }
|
|
}
|