@cyber-dash-tech/revela 0.17.5 → 0.17.7

package/lib/refine/comment-requests.ts

@@ -0,0 +1,77 @@
+export type CommentRequestStatus = "pending" | "completed" | "failed" | "expired"
+
+export interface PendingCommentRequest {
+  requestId: string
+  status: CommentRequestStatus
+  deckVersion: string
+  createdAt: number
+  updatedAt: number
+  error?: string
+}
+
+const REQUEST_TTL_MS = 120 * 1000
+const requests = new Map<string, PendingCommentRequest>()
+
+export function createCommentRequest(input: {
+  requestId: string
+  deckVersion: string
+}): PendingCommentRequest {
+  cleanupCommentRequests()
+  const now = Date.now()
+  const request: PendingCommentRequest = {
+    requestId: input.requestId,
+    status: "pending",
+    deckVersion: input.deckVersion,
+    createdAt: now,
+    updatedAt: now,
+  }
+  requests.set(input.requestId, request)
+  return request
+}
+
+export function getCommentRequest(requestId: string): PendingCommentRequest | undefined {
+  cleanupCommentRequests()
+  const request = requests.get(requestId)
+  if (!request) return undefined
+  if (request.status === "pending" && Date.now() - request.createdAt > REQUEST_TTL_MS) {
+    request.status = "expired"
+    request.error = "Review agent timed out before completing the comment request."
+    request.updatedAt = Date.now()
+  }
+  return request
+}
+
+export function completeCommentRequest(requestId: string): PendingCommentRequest | undefined {
+  const request = getCommentRequest(requestId)
+  if (!request || request.status !== "pending") return request
+  request.status = "completed"
+  request.updatedAt = Date.now()
+  return request
+}
+
+export function failCommentRequest(requestId: string, error: string): PendingCommentRequest | undefined {
+  const request = getCommentRequest(requestId)
+  if (!request || request.status !== "pending") return request
+  request.status = "failed"
+  request.error = error
+  request.updatedAt = Date.now()
+  return request
+}
+
+export function cleanupCommentRequests(now = Date.now()): void {
+  for (const [requestId, request] of requests) {
+    if (request.status === "pending" && now - request.createdAt > REQUEST_TTL_MS) {
+      request.status = "expired"
+      request.error = "Review agent timed out before completing the comment request."
+      request.updatedAt = now
+      continue
+    }
+    if (request.status !== "pending" && now - request.updatedAt > REQUEST_TTL_MS) {
+      requests.delete(requestId)
+    }
+  }
+}
+
+export function clearCommentRequestsForTests(): void {
+  requests.clear()
+}

package/lib/refine/open.ts

@@ -8,6 +8,7 @@ import { ensureEditableDeckState } from "../edit/deck-state"
 import { openUrl } from "../edit/open"
 import { resolveEditableDeck, type EditableDeck } from "../edit/resolve-deck"
 import { buildPrompt } from "../prompt-builder"
+import type { ReviewPromptBridge } from "./prompt-bridge"
 import { startRefineServer, type RefineMode } from "./server"
 
 export interface OpenRefineDeckResult {
@@ -27,12 +28,13 @@ export interface EnsureRefineDeckOpenResult extends OpenRefineDeckResult {
 }
 
 export interface OpenRefineDeckOptions {
-  client: any
-  sessionID: string
+  client?: any
+  sessionID?: string
   workspaceRoot: string
   mode?: RefineMode
   openBrowser?: boolean
   openUrl?: (url: string) => void
+  promptBridge?: ReviewPromptBridge
 }
 
 export function openRefineDeck(target: string, options: OpenRefineDeckOptions): OpenRefineDeckResult {
@@ -70,6 +72,7 @@ function openRefineDeckInternal(
     workspaceRoot: options.workspaceRoot,
     deck,
     mode,
+    promptBridge: options.promptBridge,
   })
   const url = `${refineServer.baseUrl}/refine?token=${encodeURIComponent(session.token)}`
   const shouldOpen = options.openBrowser !== false && !(behavior.skipLiveSession && session.live)

package/lib/refine/prompt-bridge.ts

@@ -0,0 +1,219 @@
+import { spawn } from "child_process"
+import type { InspectionResult } from "../inspection-context/result"
+
+export type ReviewPromptAction = "comment" | "inspect"
+export type ReviewPromptBridgeKind = "opencode" | "codex-exec"
+
+export interface ReviewPromptInput {
+  action: ReviewPromptAction
+  prompt: string
+  workspaceRoot: string
+  file: string
+  requestId?: string
+  timeoutMs?: number
+}
+
+export type ReviewPromptResult =
+  | { ok: true; status: "sent" | "completed"; result?: InspectionResult; raw?: string }
+  | { ok: false; status: "failed" | "unsupported"; error: string; raw?: string }
+
+export interface ReviewPromptBridge {
+  kind: ReviewPromptBridgeKind
+  send(input: ReviewPromptInput): Promise<ReviewPromptResult>
+}
+
+export interface CodexExecRunResult {
+  exitCode: number | null
+  stdout: string
+  stderr: string
+}
+
+export type CodexExecRunner = (input: {
+  prompt: string
+  workspaceRoot: string
+  timeoutMs: number
+}) => Promise<CodexExecRunResult>
+
+export function createOpenCodeReviewPromptBridge(client: any, sessionID: string): ReviewPromptBridge {
+  return {
+    kind: "opencode",
+    async send(input) {
+      if (!client?.session?.prompt || !sessionID) {
+        return {
+          ok: false,
+          status: "failed",
+          error: "OpenCode Review bridge requires client.session.prompt and sessionID.",
+        }
+      }
+      await client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          parts: [{ type: "text", text: input.prompt }],
+        },
+      })
+      return { ok: true, status: "sent" }
+    },
+  }
+}
+
+export function createCodexExecReviewPromptBridge(options: {
+  runner?: CodexExecRunner
+  timeoutMs?: number
+} = {}): ReviewPromptBridge {
+  const runner = options.runner ?? runCodexExec
+  const timeoutMs = options.timeoutMs ?? 120_000
+  return {
+    kind: "codex-exec",
+    async send(input) {
+      const output = await runner({
+        prompt: input.prompt,
+        workspaceRoot: input.workspaceRoot,
+        timeoutMs: input.timeoutMs ?? timeoutMs,
+      })
+      const raw = [output.stdout, output.stderr].filter(Boolean).join("\n")
+      if (output.exitCode !== 0) {
+        return {
+          ok: false,
+          status: "failed",
+          error: `codex exec failed with exit code ${output.exitCode ?? "unknown"}.`,
+          raw,
+        }
+      }
+      if (input.action === "comment") return { ok: true, status: "completed", raw }
+      const result = extractInspectionResult(output.stdout)
+      if (!result) {
+        return {
+          ok: false,
+          status: "failed",
+          error: "codex exec did not return a valid inspection result JSON object.",
+          raw,
+        }
+      }
+      return { ok: true, status: "completed", result, raw }
+    },
+  }
+}
+
+async function runCodexExec(input: {
+  prompt: string
+  workspaceRoot: string
+  timeoutMs: number
+}): Promise<CodexExecRunResult> {
+  return new Promise((resolve) => {
+    const child = spawn("codex", ["exec", "--json", "--ephemeral", "-C", input.workspaceRoot, input.prompt], {
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+    let stdout = ""
+    let stderr = ""
+    const timer = setTimeout(() => {
+      child.kill()
+      resolve({
+        exitCode: 124,
+        stdout,
+        stderr: `${stderr}${stderr ? "\n" : ""}codex exec timed out after ${input.timeoutMs}ms.`,
+      })
+    }, input.timeoutMs)
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString()
+    })
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString()
+    })
+    child.on("error", (error) => {
+      clearTimeout(timer)
+      resolve({ exitCode: 127, stdout, stderr: error.message })
+    })
+    child.on("close", (code) => {
+      clearTimeout(timer)
+      resolve({ exitCode: code, stdout, stderr })
+    })
+  })
+}
+
+function extractInspectionResult(stdout: string): InspectionResult | undefined {
+  const direct = parseJson(stdout)
+  const fromDirect = findInspectionResult(direct)
+  if (fromDirect) return fromDirect
+
+  for (const line of stdout.split(/\r?\n/).reverse()) {
+    const parsed = parseJson(line)
+    const found = findInspectionResult(parsed)
+    if (found) return found
+  }
+
+  for (const block of extractJsonBlocks(stdout).reverse()) {
+    const parsed = parseJson(block)
+    const found = findInspectionResult(parsed)
+    if (found) return found
+  }
+}
+
+function findInspectionResult(value: unknown): InspectionResult | undefined {
+  if (!value) return undefined
+  if (typeof value === "string") return findInspectionResult(parseJson(value))
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findInspectionResult(item)
+      if (found) return found
+    }
+    return undefined
+  }
+  if (typeof value !== "object") return undefined
+  const record = value as Record<string, unknown>
+  if (record.version === 1 && typeof record.status === "string" && record.cards && typeof record.cards === "object") {
+    return record as unknown as InspectionResult
+  }
+  for (const key of ["result", "output", "message", "content", "text", "final", "lastMessage"]) {
+    const found = findInspectionResult(record[key])
+    if (found) return found
+  }
+  return undefined
+}
+
+function parseJson(value: string | undefined): unknown {
+  const text = value?.trim()
+  if (!text) return undefined
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+function extractJsonBlocks(text: string): string[] {
+  const blocks: string[] = []
+  let depth = 0
+  let start = -1
+  let inString = false
+  let escaped = false
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index]
+    if (inString) {
+      if (escaped) {
+        escaped = false
+      } else if (char === "\\") {
+        escaped = true
+      } else if (char === "\"") {
+        inString = false
+      }
+      continue
+    }
+    if (char === "\"") {
+      inString = true
+      continue
+    }
+    if (char === "{") {
+      if (depth === 0) start = index
+      depth += 1
+      continue
+    }
+    if (char === "}") {
+      depth -= 1
+      if (depth === 0 && start >= 0) {
+        blocks.push(text.slice(start, index + 1))
+        start = -1
+      }
+    }
+  }
+  return blocks
+}

package/lib/refine/qa-suppression.ts

@@ -0,0 +1,41 @@
+import { resolve } from "path"
+
+export interface ReviewApplyFixArtifactQaSuppressionInput {
+  workspaceRoot: string
+  file: string
+  sessionID?: string
+  ttlMs?: number
+}
+
+const DEFAULT_TTL_MS = 5 * 60 * 1000
+const suppressions = new Map<string, number>()
+
+export function suppressReviewApplyFixArtifactQa(input: ReviewApplyFixArtifactQaSuppressionInput): void {
+  const key = suppressionKey(input)
+  if (!key) return
+  suppressions.set(key, Date.now() + (input.ttlMs ?? DEFAULT_TTL_MS))
+}
+
+export function shouldSuppressReviewApplyFixArtifactQa(input: ReviewApplyFixArtifactQaSuppressionInput): boolean {
+  const key = suppressionKey(input)
+  if (!key) return false
+  const expiresAt = suppressions.get(key)
+  if (!expiresAt) return false
+  if (Date.now() > expiresAt) {
+    suppressions.delete(key)
+    return false
+  }
+  return true
+}
+
+export function clearReviewApplyFixArtifactQaSuppressionsForTests(): void {
+  suppressions.clear()
+}
+
+function suppressionKey(input: ReviewApplyFixArtifactQaSuppressionInput): string {
+  const sessionID = input.sessionID?.trim()
+  if (!sessionID) return ""
+  const workspaceRoot = resolve(input.workspaceRoot)
+  const file = resolve(workspaceRoot, input.file)
+  return `${workspaceRoot}\0${file}\0${sessionID}`
+}

package/lib/refine/server.ts

@@ -9,10 +9,13 @@ import { buildPrompt } from "../prompt-builder"
 import type { InspectionElementSnapshot } from "../inspection-context/match"
 import { buildInspectionPrompt } from "../inspect/prompt"
 import { projectWorkspaceElement } from "../inspect/request"
-import { createInspectRequest, failInspectRequest, getInspectRequest } from "../inspect/requests"
+import { completeInspectRequest, createInspectRequest, failInspectRequest, getInspectRequest } from "../inspect/requests"
 import { saveMediaAsset } from "../media/save"
 import { searchRemoteImages, type ImageCandidate } from "../media/search"
 import type { MediaAssetRecord, MediaPurpose } from "../media/types"
+import { completeCommentRequest, createCommentRequest, failCommentRequest, getCommentRequest } from "./comment-requests"
+import { createOpenCodeReviewPromptBridge, type ReviewPromptBridge } from "./prompt-bridge"
+import { suppressReviewApplyFixArtifactQa } from "./qa-suppression"
 import { annotateVisualEditTargets, applyVisualTargetChanges, type VisualEditTarget } from "./visual-targets"
 
 const TOKEN_BYTES = 24
@@ -27,8 +30,9 @@ interface EditAsset {
 
 interface EditSession {
   token: string
-  client: any
-  sessionID: string
+  client?: any
+  sessionID?: string
+  promptBridge: ReviewPromptBridge
   deck: string
   file: string
   absoluteFile: string
@@ -47,7 +51,14 @@ export type RefineMode = "edit" | "inspect"
 
 export interface RefineServerHandle {
   baseUrl: string
-  getOrCreateSession(input: { client: any; sessionID: string; workspaceRoot: string; deck: EditableDeck; mode?: RefineMode }): EditServerSessionResult
+  getOrCreateSession(input: {
+    client?: any
+    sessionID?: string
+    workspaceRoot: string
+    deck: EditableDeck
+    mode?: RefineMode
+    promptBridge?: ReviewPromptBridge
+  }): EditServerSessionResult
 }
 
 export interface EditServerSessionResult {
@@ -80,6 +91,7 @@ export function startRefineServer(): RefineServerHandle {
       if (existing) {
         existing.session.client = input.client
         existing.session.sessionID = input.sessionID
+        existing.session.promptBridge = input.promptBridge ?? createOpenCodeReviewPromptBridge(input.client, input.sessionID ?? "")
         existing.session.deck = input.deck.slug
         existing.session.file = input.deck.file
         existing.session.workspaceRoot = resolve(input.workspaceRoot)
@@ -97,6 +109,7 @@ export function startRefineServer(): RefineServerHandle {
         token,
         client: input.client,
         sessionID: input.sessionID,
+        promptBridge: input.promptBridge ?? createOpenCodeReviewPromptBridge(input.client, input.sessionID ?? ""),
         deck: input.deck.slug,
         file: input.deck.file,
         absoluteFile: input.deck.absoluteFile,
@@ -182,6 +195,12 @@ async function handleRequest(req: Request): Promise<Response> {
     return handleComment(req, session.value)
   }
 
+  if (url.pathname === "/api/comment-result" && req.method === "GET") {
+    const session = validateSession(url.searchParams.get("token"))
+    if (!session.ok) return session.response
+    return handleCommentResult(url.searchParams.get("requestId"), session.value)
+  }
+
   if (url.pathname === "/api/inspect" && req.method === "POST") {
     const session = validateSession(url.searchParams.get("token"))
     if (!session.ok) return session.response
@@ -727,19 +746,51 @@ async function handleComment(req: Request, session: EditSession): Promise<Respon
     comment,
     elements,
     comments,
+    suppressAutomaticArtifactQa: true,
   })
   const deckVersion = readDeckVersion(session).version
+  const requestId = typeof (body as any).requestId === "string" && (body as any).requestId.trim()
+    ? (body as any).requestId.trim()
+    : randomBytes(10).toString("base64url")
+  createCommentRequest({ requestId, deckVersion })
+  suppressReviewApplyFixArtifactQa({
+    workspaceRoot: session.workspaceRoot,
+    file: session.file,
+    sessionID: session.sessionID,
+  })
 
-  await session.client.session.prompt({
-    path: { id: session.sessionID },
-    body: {
-      parts: [{ type: "text", text: prompt }],
-    },
+  void session.promptBridge.send({
+    action: "comment",
+    prompt,
+    workspaceRoot: session.workspaceRoot,
+    file: session.file,
+    requestId,
+  }).then((result) => {
+    if (result.ok) {
+      completeCommentRequest(requestId)
+    } else {
+      failCommentRequest(requestId, result.error)
+    }
+  }).catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error)
+    failCommentRequest(requestId, message)
   })
 
   session.lastActiveAt = Date.now()
   scheduleIdleStop()
-  return jsonResponse({ ok: true, deckVersion })
+  return jsonResponse({ ok: true, requestId, commentRequestId: requestId, deckVersion, status: "pending" })
+}
+
+function handleCommentResult(requestId: string | null, session: EditSession): Response {
+  if (!requestId) return jsonResponse({ ok: false, error: "Missing requestId" }, 400)
+  const request = getCommentRequest(requestId)
+  if (!request) return jsonResponse({ ok: false, requestId, error: "Comment request not found" }, 404)
+  session.lastActiveAt = Date.now()
+  scheduleIdleStop()
+  if (request.status === "failed" || request.status === "expired") {
+    return jsonResponse({ ok: true, requestId, status: request.status, deckVersion: request.deckVersion, error: request.error || "Review agent failed" })
+  }
+  return jsonResponse({ ok: true, requestId, status: request.status, deckVersion: request.deckVersion })
 }
 
 async function handleInspect(req: Request, session: EditSession): Promise<Response> {
@@ -766,22 +817,29 @@ async function handleInspect(req: Request, session: EditSession): Promise<Respon
     session.lastActiveAt = Date.now()
     scheduleIdleStop()
 
-    void session.client.session.prompt({
-      path: { id: session.sessionID },
-      body: {
-        parts: [{
-          type: "text",
-          text: buildInspectionPrompt({
-            requestId,
-            file: session.file,
-            language,
-            comment,
-            projection: staleReason
-              ? { ...projection, stale: { stale: true, reason: staleReason } } as any
-              : projection,
-          }),
-        }],
-      },
+    const prompt = buildInspectionPrompt({
+      requestId,
+      file: session.file,
+      language,
+      comment,
+      delivery: session.promptBridge.kind === "codex-exec" ? "json" : "tool",
+      projection: staleReason
+        ? { ...projection, stale: { stale: true, reason: staleReason } } as any
+        : projection,
+    })
+
+    void session.promptBridge.send({
+      action: "inspect",
+      prompt,
+      workspaceRoot: session.workspaceRoot,
+      file: session.file,
+      requestId,
+    }).then((result) => {
+      if (result.ok && result.result) {
+        completeInspectRequest(requestId, result.result)
+      } else if (!result.ok) {
+        failInspectRequest(requestId, result.error)
+      }
     }).catch((error: unknown) => {
       const message = error instanceof Error ? error.message : String(error)
       failInspectRequest(requestId, message)
@@ -2038,14 +2096,14 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           });
           const body = await res.json().catch(() => ({}));
           if (!res.ok || !body.ok) throw new Error(body.error || 'Failed to send comment');
-          updatePendingCommentStatus(commentId, 'sent', { baseDeckVersion: body.deckVersion || state.deckVersion });
+          updatePendingCommentStatus(commentId, 'sent', { baseDeckVersion: body.deckVersion || state.deckVersion, requestId: body.commentRequestId || body.requestId || '' });
           if (pendingCommentStatus(commentId) !== 'updated') setStatus('Comment sent. Waiting for deck update...');
-          state.sendingEdit = false;
-          updateSendState();
+          if (body.commentRequestId || body.requestId) pollCommentResult(commentId, body.commentRequestId || body.requestId);
         } catch (error) {
           updatePendingCommentStatus(commentId, 'failed');
-          state.sendingEdit = false;
           reportError(error);
+        } finally {
+          state.sendingEdit = false;
           updateSendState();
         }
       }
@@ -2398,8 +2456,9 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           });
           const body = await res.json().catch(() => ({}));
           if (!res.ok || !body.ok) throw new Error(body.error || 'Failed to send asset placement');
-          updatePendingCommentStatus(commentId, 'sent', { baseDeckVersion: body.deckVersion || state.deckVersion });
+          updatePendingCommentStatus(commentId, 'sent', { baseDeckVersion: body.deckVersion || state.deckVersion, requestId: body.commentRequestId || body.requestId || '' });
           if (pendingCommentStatus(commentId) !== 'updated') setStatus('Asset placement sent. Waiting for deck update...');
+          if (body.commentRequestId || body.requestId) pollCommentResult(commentId, body.commentRequestId || body.requestId);
         } catch (error) {
           updatePendingCommentStatus(commentId, 'failed');
           reportError(error);
@@ -2483,6 +2542,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           createdAt: Date.now(),
           baseDeckVersion: state.deckVersion,
           updatedVersion: null,
+          requestId: '',
         });
         renderCommentThread();
         return id;
@@ -2531,6 +2591,34 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         return state.pendingComments.find((comment) => comment.id === id)?.status || '';
       }
 
+      async function pollCommentResult(commentId, requestId) {
+        if (!requestId) return;
+        for (let attempt = 0; attempt < 140; attempt++) {
+          await delay(1000);
+          if (pendingCommentStatus(commentId) === 'updated') return;
+          try {
+            const res = await fetch('/api/comment-result?token=' + encodeURIComponent(token) + '&requestId=' + encodeURIComponent(requestId), { cache: 'no-store' });
+            const body = await res.json().catch(() => ({}));
+            if (!res.ok || !body.ok) throw new Error(body.error || 'Comment result failed');
+            if (body.status === 'failed' || body.status === 'expired') {
+              updatePendingCommentStatus(commentId, 'failed');
+              setStatus(body.error || 'Review agent failed to apply the comment.');
+              return;
+            }
+            if (body.status === 'completed') {
+              return;
+            }
+          } catch (error) {
+            reportError(error);
+            return;
+          }
+        }
+        if (pendingCommentStatus(commentId) !== 'updated') {
+          updatePendingCommentStatus(commentId, 'failed');
+          setStatus('Review agent timed out before applying the comment.');
+        }
+      }
+
       function renderCommentThread() {
         els.commentThread.textContent = '';
         state.pendingComments.forEach((comment) => {
@@ -2555,8 +2643,8 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
         if (status === 'updated') return 'Deck file updated';
         if (status === 'stale') return 'Still waiting for deck file update';
         if (status === 'failed') return 'Failed to send';
-        if (status === 'sending') return 'Sending to OpenCode...';
-        return '⏳ Sent to OpenCode';
+        if (status === 'sending') return 'Sending to Review agent...';
+        return 'Sent to Review agent';
       }
 
       function targetFromPointer(event) {
@@ -2735,7 +2823,7 @@ export function renderRefineShell(token: string, defaultMode: RefineMode = "edit
           }
           if (body.status === 'failed' || body.status === 'expired') throw new Error(body.error || 'Insight failed');
         }
-        throw new Error('Insight timed out while waiting for OpenCode result');
+        throw new Error('Insight timed out while waiting for Review agent result');
       }
 
       function collectReferenceSnapshot() {