@xortex/xcode 3.0.0

package/utils/claudeDesktop.ts

@@ -0,0 +1,152 @@
+import { readdir, readFile, stat } from 'fs/promises'
+import { homedir } from 'os'
+import { join } from 'path'
+import {
+  type McpServerConfig,
+  McpStdioServerConfigSchema,
+} from '../services/mcp/types.js'
+import { getErrnoCode } from './errors.js'
+import { safeParseJSON } from './json.js'
+import { logError } from './log.js'
+import { getPlatform, SUPPORTED_PLATFORMS } from './platform.js'
+
+export async function getClaudeDesktopConfigPath(): Promise<string> {
+  const platform = getPlatform()
+
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(
+      `Unsupported platform: ${platform} - Claude Desktop integration only works on macOS and WSL.`,
+    )
+  }
+
+  if (platform === 'macos') {
+    return join(
+      homedir(),
+      'Library',
+      'Application Support',
+      'Claude',
+      'claude_desktop_config.json',
+    )
+  }
+
+  // First, try using USERPROFILE environment variable if available
+  const windowsHome = process.env.USERPROFILE
+    ? process.env.USERPROFILE.replace(/\\/g, '/') // Convert Windows backslashes to forward slashes
+    : null
+
+  if (windowsHome) {
+    // Remove drive letter and convert to WSL path format
+    const wslPath = windowsHome.replace(/^[A-Z]:/, '')
+    const configPath = `/mnt/c${wslPath}/AppData/Roaming/Claude/claude_desktop_config.json`
+
+    // Check if the file exists
+    try {
+      await stat(configPath)
+      return configPath
+    } catch {
+      // File doesn't exist, continue
+    }
+  }
+
+  // Alternative approach - try to construct path based on typical Windows user location
+  try {
+    // List the /mnt/c/Users directory to find potential user directories
+    const usersDir = '/mnt/c/Users'
+
+    try {
+      const userDirs = await readdir(usersDir, { withFileTypes: true })
+
+      // Look for Claude Desktop config in each user directory
+      for (const user of userDirs) {
+        if (
+          user.name === 'Public' ||
+          user.name === 'Default' ||
+          user.name === 'Default User' ||
+          user.name === 'All Users'
+        ) {
+          continue // Skip system directories
+        }
+
+        const potentialConfigPath = join(
+          usersDir,
+          user.name,
+          'AppData',
+          'Roaming',
+          'Claude',
+          'claude_desktop_config.json',
+        )
+
+        try {
+          await stat(potentialConfigPath)
+          return potentialConfigPath
+        } catch {
+          // File doesn't exist, continue
+        }
+      }
+    } catch {
+      // usersDir doesn't exist or can't be read
+    }
+  } catch (dirError) {
+    logError(dirError)
+  }
+
+  throw new Error(
+    'Could not find Claude Desktop config file in Windows. Make sure Claude Desktop is installed on Windows.',
+  )
+}
+
+export async function readClaudeDesktopMcpServers(): Promise<
+  Record<string, McpServerConfig>
+> {
+  if (!SUPPORTED_PLATFORMS.includes(getPlatform())) {
+    throw new Error(
+      'Unsupported platform - Claude Desktop integration only works on macOS and WSL.',
+    )
+  }
+  try {
+    const configPath = await getClaudeDesktopConfigPath()
+
+    let configContent: string
+    try {
+      configContent = await readFile(configPath, { encoding: 'utf8' })
+    } catch (e: unknown) {
+      const code = getErrnoCode(e)
+      if (code === 'ENOENT') {
+        return {}
+      }
+      throw e
+    }
+
+    const config = safeParseJSON(configContent)
+
+    if (!config || typeof config !== 'object') {
+      return {}
+    }
+
+    const mcpServers = (config as Record<string, unknown>).mcpServers
+    if (!mcpServers || typeof mcpServers !== 'object') {
+      return {}
+    }
+
+    const servers: Record<string, McpServerConfig> = {}
+
+    for (const [name, serverConfig] of Object.entries(
+      mcpServers as Record<string, unknown>,
+    )) {
+      if (!serverConfig || typeof serverConfig !== 'object') {
+        continue
+      }
+
+      const result = McpStdioServerConfigSchema().safeParse(serverConfig)
+
+      if (result.success) {
+        servers[name] = result.data
+      }
+    }
+
+    return servers
+  } catch (error) {
+    logError(error)
+    return {}
+  }
+}

package/utils/claudeInChrome/chromeNativeHost.ts

@@ -0,0 +1,527 @@
+// biome-ignore-all lint/suspicious/noConsole: file uses console intentionally
+/**
+ * Chrome Native Host - Pure TypeScript Implementation
+ *
+ * This module provides the Chrome native messaging host functionality,
+ * previously implemented as a Rust NAPI binding but now in pure TypeScript.
+ */
+
+import {
+  appendFile,
+  chmod,
+  mkdir,
+  readdir,
+  rmdir,
+  stat,
+  unlink,
+} from 'fs/promises'
+import { createServer, type Server, type Socket } from 'net'
+import { homedir, platform } from 'os'
+import { join } from 'path'
+import { z } from 'zod'
+import { lazySchema } from '../lazySchema.js'
+import { jsonParse, jsonStringify } from '../slowOperations.js'
+import { getSecureSocketPath, getSocketDir } from './common.js'
+
+const VERSION = '1.0.0'
+const MAX_MESSAGE_SIZE = 1024 * 1024 // 1MB - Max message size that can be sent to Chrome
+
+const LOG_FILE =
+  process.env.USER_TYPE === 'ant'
+    ? join(homedir(), '.claude', 'debug', 'chrome-native-host.txt')
+    : undefined
+
+function log(message: string, ...args: unknown[]): void {
+  if (LOG_FILE) {
+    const timestamp = new Date().toISOString()
+    const formattedArgs = args.length > 0 ? ' ' + jsonStringify(args) : ''
+    const logLine = `[${timestamp}] [Claude Chrome Native Host] ${message}${formattedArgs}\n`
+    // Fire-and-forget: logging is best-effort and callers (including event
+    // handlers) don't await
+    void appendFile(LOG_FILE, logLine).catch(() => {
+      // Ignore file write errors
+    })
+  }
+  console.error(`[Claude Chrome Native Host] ${message}`, ...args)
+}
+/**
+ * Send a message to stdout (Chrome native messaging protocol)
+ */
+export function sendChromeMessage(message: string): void {
+  const jsonBytes = Buffer.from(message, 'utf-8')
+  const lengthBuffer = Buffer.alloc(4)
+  lengthBuffer.writeUInt32LE(jsonBytes.length, 0)
+
+  process.stdout.write(lengthBuffer)
+  process.stdout.write(jsonBytes)
+}
+
+export async function runChromeNativeHost(): Promise<void> {
+  log('Initializing...')
+
+  const host = new ChromeNativeHost()
+  const messageReader = new ChromeMessageReader()
+
+  // Start the native host server
+  await host.start()
+
+  // Process messages from Chrome until stdin closes
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  while (true) {
+    const message = await messageReader.read()
+    if (message === null) {
+      // stdin closed, Chrome disconnected
+      break
+    }
+
+    await host.handleMessage(message)
+  }
+
+  // Stop the server
+  await host.stop()
+}
+
+const messageSchema = lazySchema(() =>
+  z
+    .object({
+      type: z.string(),
+    })
+    .passthrough(),
+)
+
+type ToolRequest = {
+  method: string
+  params?: unknown
+}
+
+type McpClient = {
+  id: number
+  socket: Socket
+  buffer: Buffer
+}
+
+class ChromeNativeHost {
+  private mcpClients = new Map<number, McpClient>()
+  private nextClientId = 1
+  private server: Server | null = null
+  private running = false
+  private socketPath: string | null = null
+
+  async start(): Promise<void> {
+    if (this.running) {
+      return
+    }
+
+    this.socketPath = getSecureSocketPath()
+
+    if (platform() !== 'win32') {
+      const socketDir = getSocketDir()
+
+      // Migrate legacy socket: if socket dir path exists as a file/socket, remove it
+      try {
+        const dirStats = await stat(socketDir)
+        if (!dirStats.isDirectory()) {
+          await unlink(socketDir)
+        }
+      } catch {
+        // Doesn't exist, that's fine
+      }
+
+      // Create socket directory with secure permissions
+      await mkdir(socketDir, { recursive: true, mode: 0o700 })
+
+      // Fix perms if directory already existed
+      await chmod(socketDir, 0o700).catch(() => {
+        // Ignore
+      })
+
+      // Clean up stale sockets
+      try {
+        const files = await readdir(socketDir)
+        for (const file of files) {
+          if (!file.endsWith('.sock')) {
+            continue
+          }
+          const pid = parseInt(file.replace('.sock', ''), 10)
+          if (isNaN(pid)) {
+            continue
+          }
+          try {
+            process.kill(pid, 0)
+            // Process is alive, leave it
+          } catch {
+            // Process is dead, remove stale socket
+            await unlink(join(socketDir, file)).catch(() => {
+              // Ignore
+            })
+            log(`Removed stale socket for PID ${pid}`)
+          }
+        }
+      } catch {
+        // Ignore errors scanning directory
+      }
+    }
+
+    log(`Creating socket listener: ${this.socketPath}`)
+
+    this.server = createServer(socket => this.handleMcpClient(socket))
+
+    await new Promise<void>((resolve, reject) => {
+      this.server!.listen(this.socketPath!, () => {
+        log('Socket server listening for connections')
+        this.running = true
+        resolve()
+      })
+
+      this.server!.on('error', err => {
+        log('Socket server error:', err)
+        reject(err)
+      })
+    })
+
+    // Set permissions on Unix (after listen resolves so socket file exists)
+    if (platform() !== 'win32') {
+      try {
+        await chmod(this.socketPath!, 0o600)
+        log('Socket permissions set to 0600')
+      } catch (e) {
+        log('Failed to set socket permissions:', e)
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) {
+      return
+    }
+
+    // Close all MCP clients
+    for (const [, client] of this.mcpClients) {
+      client.socket.destroy()
+    }
+    this.mcpClients.clear()
+
+    // Close server
+    if (this.server) {
+      await new Promise<void>(resolve => {
+        this.server!.close(() => resolve())
+      })
+      this.server = null
+    }
+
+    // Cleanup socket file
+    if (platform() !== 'win32' && this.socketPath) {
+      try {
+        await unlink(this.socketPath)
+        log('Cleaned up socket file')
+      } catch {
+        // ENOENT is fine, ignore
+      }
+
+      // Remove directory if empty
+      try {
+        const socketDir = getSocketDir()
+        const remaining = await readdir(socketDir)
+        if (remaining.length === 0) {
+          await rmdir(socketDir)
+          log('Removed empty socket directory')
+        }
+      } catch {
+        // Ignore
+      }
+    }
+
+    this.running = false
+  }
+
+  async isRunning(): Promise<boolean> {
+    return this.running
+  }
+
+  async getClientCount(): Promise<number> {
+    return this.mcpClients.size
+  }
+
+  async handleMessage(messageJson: string): Promise<void> {
+    let rawMessage: unknown
+    try {
+      rawMessage = jsonParse(messageJson)
+    } catch (e) {
+      log('Invalid JSON from Chrome:', (e as Error).message)
+      sendChromeMessage(
+        jsonStringify({
+          type: 'error',
+          error: 'Invalid message format',
+        }),
+      )
+      return
+    }
+    const parsed = messageSchema().safeParse(rawMessage)
+    if (!parsed.success) {
+      log('Invalid message from Chrome:', parsed.error.message)
+      sendChromeMessage(
+        jsonStringify({
+          type: 'error',
+          error: 'Invalid message format',
+        }),
+      )
+      return
+    }
+    const message = parsed.data
+
+    log(`Handling Chrome message type: ${message.type}`)
+
+    switch (message.type) {
+      case 'ping':
+        log('Responding to ping')
+
+        sendChromeMessage(
+          jsonStringify({
+            type: 'pong',
+            timestamp: Date.now(),
+          }),
+        )
+        break
+
+      case 'get_status':
+        sendChromeMessage(
+          jsonStringify({
+            type: 'status_response',
+            native_host_version: VERSION,
+          }),
+        )
+        break
+
+      case 'tool_response': {
+        if (this.mcpClients.size > 0) {
+          log(`Forwarding tool response to ${this.mcpClients.size} MCP clients`)
+
+          // Extract the data portion (everything except 'type')
+          const { type: _, ...data } = message
+          const responseData = Buffer.from(jsonStringify(data), 'utf-8')
+          const lengthBuffer = Buffer.alloc(4)
+          lengthBuffer.writeUInt32LE(responseData.length, 0)
+          const responseMsg = Buffer.concat([lengthBuffer, responseData])
+
+          for (const [id, client] of this.mcpClients) {
+            try {
+              client.socket.write(responseMsg)
+            } catch (e) {
+              log(`Failed to send to MCP client ${id}:`, e)
+            }
+          }
+        }
+        break
+      }
+
+      case 'notification': {
+        if (this.mcpClients.size > 0) {
+          log(`Forwarding notification to ${this.mcpClients.size} MCP clients`)
+
+          // Extract the data portion (everything except 'type')
+          const { type: _, ...data } = message
+          const notificationData = Buffer.from(jsonStringify(data), 'utf-8')
+          const lengthBuffer = Buffer.alloc(4)
+          lengthBuffer.writeUInt32LE(notificationData.length, 0)
+          const notificationMsg = Buffer.concat([
+            lengthBuffer,
+            notificationData,
+          ])
+
+          for (const [id, client] of this.mcpClients) {
+            try {
+              client.socket.write(notificationMsg)
+            } catch (e) {
+              log(`Failed to send notification to MCP client ${id}:`, e)
+            }
+          }
+        }
+        break
+      }
+
+      default:
+        log(`Unknown message type: ${message.type}`)
+
+        sendChromeMessage(
+          jsonStringify({
+            type: 'error',
+            error: `Unknown message type: ${message.type}`,
+          }),
+        )
+    }
+  }
+
+  private handleMcpClient(socket: Socket): void {
+    const clientId = this.nextClientId++
+    const client: McpClient = {
+      id: clientId,
+      socket,
+      buffer: Buffer.alloc(0),
+    }
+
+    this.mcpClients.set(clientId, client)
+    log(
+      `MCP client ${clientId} connected. Total clients: ${this.mcpClients.size}`,
+    )
+
+    // Notify Chrome of connection
+    sendChromeMessage(
+      jsonStringify({
+        type: 'mcp_connected',
+      }),
+    )
+
+    socket.on('data', (data: Buffer) => {
+      client.buffer = Buffer.concat([client.buffer, data])
+
+      // Process complete messages
+      while (client.buffer.length >= 4) {
+        const length = client.buffer.readUInt32LE(0)
+
+        if (length === 0 || length > MAX_MESSAGE_SIZE) {
+          log(`Invalid message length from MCP client ${clientId}: ${length}`)
+          socket.destroy()
+          return
+        }
+
+        if (client.buffer.length < 4 + length) {
+          break // Wait for more data
+        }
+
+        const messageBytes = client.buffer.slice(4, 4 + length)
+        client.buffer = client.buffer.slice(4 + length)
+
+        try {
+          const request = jsonParse(
+            messageBytes.toString('utf-8'),
+          ) as ToolRequest
+          log(
+            `Forwarding tool request from MCP client ${clientId}: ${request.method}`,
+          )
+
+          // Forward to Chrome
+          sendChromeMessage(
+            jsonStringify({
+              type: 'tool_request',
+              method: request.method,
+              params: request.params,
+            }),
+          )
+        } catch (e) {
+          log(`Failed to parse tool request from MCP client ${clientId}:`, e)
+        }
+      }
+    })
+
+    socket.on('error', err => {
+      log(`MCP client ${clientId} error: ${err}`)
+    })
+
+    socket.on('close', () => {
+      log(
+        `MCP client ${clientId} disconnected. Remaining clients: ${this.mcpClients.size - 1}`,
+      )
+      this.mcpClients.delete(clientId)
+
+      // Notify Chrome of disconnection
+      sendChromeMessage(
+        jsonStringify({
+          type: 'mcp_disconnected',
+        }),
+      )
+    })
+  }
+}
+
+/**
+ * Chrome message reader using async stdin. Synchronous reads can crash Bun, so we use
+ * async reads with a buffer.
+ */
+class ChromeMessageReader {
+  private buffer = Buffer.alloc(0)
+  private pendingResolve: ((value: string | null) => void) | null = null
+  private closed = false
+
+  constructor() {
+    process.stdin.on('data', (chunk: Buffer) => {
+      this.buffer = Buffer.concat([this.buffer, chunk])
+      this.tryProcessMessage()
+    })
+
+    process.stdin.on('end', () => {
+      this.closed = true
+      if (this.pendingResolve) {
+        this.pendingResolve(null)
+        this.pendingResolve = null
+      }
+    })
+
+    process.stdin.on('error', () => {
+      this.closed = true
+      if (this.pendingResolve) {
+        this.pendingResolve(null)
+        this.pendingResolve = null
+      }
+    })
+  }
+
+  private tryProcessMessage(): void {
+    if (!this.pendingResolve) {
+      return
+    }
+
+    // Need at least 4 bytes for length prefix
+    if (this.buffer.length < 4) {
+      return
+    }
+
+    const length = this.buffer.readUInt32LE(0)
+
+    if (length === 0 || length > MAX_MESSAGE_SIZE) {
+      log(`Invalid message length: ${length}`)
+      this.pendingResolve(null)
+      this.pendingResolve = null
+      return
+    }
+
+    // Check if we have the full message
+    if (this.buffer.length < 4 + length) {
+      return // Wait for more data
+    }
+
+    // Extract the message
+    const messageBytes = this.buffer.subarray(4, 4 + length)
+    this.buffer = this.buffer.subarray(4 + length)
+
+    const message = messageBytes.toString('utf-8')
+    this.pendingResolve(message)
+    this.pendingResolve = null
+  }
+
+  async read(): Promise<string | null> {
+    if (this.closed) {
+      return null
+    }
+
+    // Check if we already have a complete message buffered
+    if (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32LE(0)
+      if (
+        length > 0 &&
+        length <= MAX_MESSAGE_SIZE &&
+        this.buffer.length >= 4 + length
+      ) {
+        const messageBytes = this.buffer.subarray(4, 4 + length)
+        this.buffer = this.buffer.subarray(4 + length)
+        return messageBytes.toString('utf-8')
+      }
+    }
+
+    // Wait for more data
+    return new Promise(resolve => {
+      this.pendingResolve = resolve
+      // In case data arrived between check and setting pendingResolve
+      this.tryProcessMessage()
+    })
+  }
+}