kimaki 0.4.77 → 0.4.78

package/src/patch-text-parser.ts

@@ -0,0 +1,107 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText: string): string[] {
+  const custom = [
+    ...patchText.matchAll(
+      /^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm,
+    ),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const moved = [
+    ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const unified = [
+    ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const all = [...custom, ...moved, ...unified].filter(Boolean)
+  return all.filter((v, i, a) => {
+    return a.indexOf(v) === i
+  })
+}
+
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(
+  patchText: string,
+): Map<string, { additions: number; deletions: number }> {
+  const counts = new Map<string, { additions: number; deletions: number }>()
+  const lines = patchText.split('\n')
+  let currentFile = ''
+  let currentType = ''
+  let inHunk = false
+
+  for (const line of lines) {
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/)
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/)
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/)
+
+    if (addMatch || updateMatch || deleteMatch) {
+      const match = addMatch || updateMatch || deleteMatch
+      currentFile = (match?.[1] ?? '').trim()
+      currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete'
+      counts.set(currentFile, { additions: 0, deletions: 0 })
+      inHunk = false
+      continue
+    }
+
+    if (line.startsWith('@@')) {
+      inHunk = true
+      continue
+    }
+
+    if (line.startsWith('*** ')) {
+      inHunk = false
+      continue
+    }
+
+    if (!currentFile) {
+      continue
+    }
+
+    const entry = counts.get(currentFile)
+    if (!entry) {
+      continue
+    }
+
+    if (currentType === 'add') {
+      // all content lines in Add File are additions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.additions++
+      }
+    } else if (currentType === 'delete') {
+      // all content lines in Delete File are deletions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.deletions++
+      }
+    } else if (inHunk) {
+      if (line.startsWith('+')) {
+        entry.additions++
+      } else if (line.startsWith('-')) {
+        entry.deletions++
+      }
+    }
+  }
+  return counts
+}

package/src/session-handler/thread-session-runtime.ts

@@ -123,6 +123,7 @@ import {
   matchThinkingValue,
 } from '../thinking-utils.js'
 import { execAsync } from '../worktrees.js'
+
 import { notifyError } from '../sentry.js'
 import { createDebouncedProcessFlush } from '../debounced-process-flush.js'
 import { cancelHtmlActionsForThread } from '../html-actions.js'
@@ -3534,7 +3535,7 @@ export class ThreadSessionRuntime {
 
     const client = getOpencodeClient(this.projectDirectory)
 
-    // Run git branch, token fetch, and provider list in parallel
+    // Run git branch and token fetch in parallel (fast, no external CLI)
     const [branchResult, contextResult] = await Promise.all([
       errore.tryAsync(() => {
         return execAsync('git symbolic-ref --short HEAD', {

package/src/websockify.ts

@@ -0,0 +1,101 @@
+// In-process WebSocket-to-TCP bridge (websockify replacement).
+// Accepts WebSocket connections and pipes raw bytes to/from a TCP target.
+// Used by /screenshare to bridge noVNC (WebSocket) to a VNC server (TCP).
+// Supports the 'binary' subprotocol required by noVNC.
+
+import { WebSocketServer, WebSocket } from 'ws'
+import net from 'node:net'
+import { createLogger } from './logger.js'
+
+const logger = createLogger('SCREEN')
+
+type WebsockifyOptions = {
+  /** Port for the WebSocket server (0 = auto-assign) */
+  wsPort: number
+  /** TCP target host */
+  tcpHost: string
+  /** TCP target port */
+  tcpPort: number
+}
+
+type WebsockifyInstance = {
+  wss: WebSocketServer
+  /** Resolved port (useful when wsPort=0) */
+  port: number
+  close: () => void
+}
+
+export function startWebsockify({
+  wsPort,
+  tcpHost,
+  tcpPort,
+}: WebsockifyOptions): Promise<WebsockifyInstance> {
+  return new Promise((resolve, reject) => {
+    const wss = new WebSocketServer({
+      port: wsPort,
+      // noVNC negotiates the 'binary' subprotocol
+      handleProtocols: (protocols) => {
+        if (protocols.has('binary')) {
+          return 'binary'
+        }
+        return false
+      },
+    })
+
+    wss.on('listening', () => {
+      const addr = wss.address()
+      const port = typeof addr === 'object' && addr ? addr.port : wsPort
+      logger.log(`Websockify listening on port ${port} → ${tcpHost}:${tcpPort}`)
+      resolve({
+        wss,
+        port,
+        close: () => {
+          for (const client of wss.clients) {
+            client.close()
+          }
+          wss.close()
+        },
+      })
+    })
+
+    wss.on('error', (err) => {
+      reject(new Error('Websockify failed to start', { cause: err }))
+    })
+
+    wss.on('connection', (ws) => {
+      const tcp = net.createConnection(tcpPort, tcpHost, () => {
+        logger.log(`TCP connection established to ${tcpHost}:${tcpPort}`)
+      })
+
+      tcp.on('data', (data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(data)
+        }
+      })
+
+      ws.on('message', (data: Buffer) => {
+        if (!tcp.destroyed) {
+          tcp.write(data)
+        }
+      })
+
+      ws.on('close', () => {
+        tcp.destroy()
+      })
+
+      ws.on('error', (err) => {
+        logger.error('WebSocket error:', err)
+        tcp.destroy()
+      })
+
+      tcp.on('close', () => {
+        ws.close()
+      })
+
+      tcp.on('error', (err) => {
+        logger.error('TCP connection error:', err)
+        ws.close()
+      })
+    })
+  })
+}