fix(runtime): handle RTK missing hook (#1539)

Author: zerob13

src/main/lib/agentRuntime/rtkRuntimeService.ts

@@ -58,6 +58,11 @@ interface PrepareShellCommandResult {
   rtkFallbackReason?: string
 }
 
+type RtkRewriteResult =
+  | { status: 'rewritten'; command: string }
+  | { status: 'bypass'; message: string }
+  | { status: 'failure'; message: string }
+
 interface RtkRuntimeServiceDeps {
   runtimeHelper?: Pick<
     RuntimeHelper,
@@ -112,6 +117,37 @@ function getErrorMessage(error: unknown): string {
   return String(error)
 }
 
+function classifyRtkRewriteResult(result: CommandResult): RtkRewriteResult {
+  const stdout = result.stdout.trim()
+  const stderr = result.stderr.trim()
+
+  if (result.code === 0 && stdout) {
+    return {
+      status: 'rewritten',
+      command: stdout
+    }
+  }
+
+  if (result.code === 3 && stdout && /No hook installed/i.test(stderr)) {
+    return {
+      status: 'rewritten',
+      command: stdout
+    }
+  }
+
+  if (result.code === 1) {
+    return {
+      status: 'bypass',
+      message: 'RTK rewrite did not match this command'
+    }
+  }
+
+  return {
+    status: 'failure',
+    message: stderr || stdout || 'rtk rewrite failed'
+  }
+}
+
 async function defaultRunCommand(
   command: string,
   args: string[],
@@ -371,24 +407,22 @@ export class RtkRuntimeService {
         env: preparedEnv,
         timeoutMs: RTK_REWRITE_TIMEOUT_MS
       })
+      const rewrite = classifyRtkRewriteResult(rewriteResult)
 
-      if (rewriteResult.code === 0) {
-        const rewritten = rewriteResult.stdout.trim()
-        if (rewritten) {
-          this.recordRuntimeSuccess()
-          return {
-            originalCommand: rawCommand,
-            command: rewritten,
-            env: preparedEnv,
-            rewritten: true,
-            usedRtk: true,
-            rtkApplied: true,
-            rtkMode: 'rewrite'
-          }
+      if (rewrite.status === 'rewritten') {
+        this.recordRuntimeSuccess()
+        return {
+          originalCommand: rawCommand,
+          command: rewrite.command,
+          env: preparedEnv,
+          rewritten: true,
+          usedRtk: true,
+          rtkApplied: true,
+          rtkMode: 'rewrite'
         }
       }
 
-      if (rewriteResult.code === 1) {
+      if (rewrite.status === 'bypass') {
         this.recordRuntimeSuccess()
         return {
           originalCommand: rawCommand,
@@ -398,13 +432,11 @@ export class RtkRuntimeService {
           usedRtk: false,
           rtkApplied: false,
           rtkMode: 'bypass',
-          rtkFallbackReason: 'RTK rewrite did not match this command'
+          rtkFallbackReason: rewrite.message
         }
       }
 
-      const failureMessage =
-        rewriteResult.stderr.trim() || rewriteResult.stdout.trim() || 'rtk rewrite failed'
-      this.recordRuntimeFailure('rewrite', failureMessage)
+      this.recordRuntimeFailure('rewrite', rewrite.message)
       return {
         originalCommand: rawCommand,
         command: rawCommand,
@@ -413,7 +445,7 @@ export class RtkRuntimeService {
         usedRtk: false,
         rtkApplied: false,
         rtkMode: 'bypass',
-        rtkFallbackReason: failureMessage
+        rtkFallbackReason: rewrite.message
       }
     } catch (error) {
       const failureMessage = getErrorMessage(error)
@@ -569,11 +601,9 @@ export class RtkRuntimeService {
       env: baseEnv,
       timeoutMs: RTK_HEALTH_TIMEOUT_MS
     })
-    if (rewrite.code !== 0 || !rewrite.stdout.trim()) {
-      throw new RtkHealthCheckError(
-        'rewrite',
-        rewrite.stderr.trim() || rewrite.stdout.trim() || 'rtk rewrite failed'
-      )
+    const rewriteCheck = classifyRtkRewriteResult(rewrite)
+    if (rewriteCheck.status !== 'rewritten') {
+      throw new RtkHealthCheckError('rewrite', rewriteCheck.message)
     }
 
     const resolvedRtk = await this.runCommandImpl('rtk', ['--version'], {

test/main/lib/agentRuntime/rtkRuntimeService.test.ts

@@ -99,7 +99,7 @@ function createHealthCheckService(tempRoot: string, runCommand = vi.fn()) {
   })
 }
 
-function createHealthCheckRunCommand() {
+function createHealthCheckRunCommand(rewriteResult = createCommandResult(0, 'rtk git status\n')) {
   return vi.fn(async (command: string, args: string[]) => {
     if (args[0] === 'ls') {
       return createCommandResult(
@@ -114,7 +114,7 @@ function createHealthCheckRunCommand() {
     }
 
     if (command === '/runtime/rtk/rtk.exe' && args[0] === 'rewrite' && args[1] === 'git status') {
-      return createCommandResult(0, 'rtk git status\n')
+      return rewriteResult
     }
 
     if (command === 'rtk' && args[0] === '--version') {
@@ -175,6 +175,29 @@ describe('RtkRuntimeService', () => {
     expect(result.rtkMode).toBe('rewrite')
   })
 
+  it('uses rewrite output when RTK reports a missing global hook', async () => {
+    const runCommand = vi.fn().mockResolvedValue({
+      code: 3,
+      stdout: 'rtk git status\n',
+      stderr: 'No hook installed\n',
+      signal: null,
+      timedOut: false
+    })
+    const service = createService(runCommand)
+
+    const result = await service.prepareShellCommand(
+      'git status',
+      {},
+      { getSetting: vi.fn().mockReturnValue(true) }
+    )
+
+    expect(result.originalCommand).toBe('git status')
+    expect(result.command).toBe('rtk git status')
+    expect(result.rewritten).toBe(true)
+    expect(result.rtkApplied).toBe(true)
+    expect(result.rtkMode).toBe('rewrite')
+  })
+
   it.each([
     'find . -type f -name "*.ts" -o -name "*.vue"',
     'find . -type f ! -name "*.test.ts"',
@@ -240,4 +263,31 @@ describe('RtkRuntimeService', () => {
       fs.rmSync(tempRoot, { recursive: true, force: true })
     }
   })
+
+  it('keeps bundled RTK healthy when rewrite reports a missing global hook', async () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'deepchat-rtk-health-test-'))
+    const runCommand = createHealthCheckRunCommand(
+      createCommandResult(3, 'rtk git status\n', 'No hook installed\n')
+    )
+    const service = createHealthCheckService(tempRoot, runCommand)
+
+    try {
+      const state = await service.startHealthCheck()
+
+      expect(state).toMatchObject({
+        health: 'healthy',
+        source: 'bundled',
+        failureStage: null,
+        failureMessage: null
+      })
+      expect(
+        runCommand.mock.calls.some(
+          ([command, args]) =>
+            command === '/runtime/rtk/rtk.exe' && args[0] === 'rewrite' && args[1] === 'git status'
+        )
+      ).toBe(true)
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true })
+    }
+  })
 })