feat: 实现 4 个 NAPI 包 — modifiers/image-processor/audio-capture/url-handler

- modifiers-napi: 使用 Bun FFI 调用 macOS CGEventSourceFlagsState 检测修饰键
- image-processor-napi: 集成 sharp 库，macOS 剪贴板图像读取 (osascript)
- audio-capture-napi: 基于 SoX/arecord 的跨平台音频录制
- url-handler-napi: 完善函数签名（保持 null fallback）
- 修复 image-processor 类型兼容性问题

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

packages/audio-capture-napi/src/index.ts

@@ -1,14 +1,151 @@
-// Auto-generated stub — replace with real implementation
+// audio-capture-napi: cross-platform audio capture using SoX (rec) on macOS
+// and arecord (ALSA) on Linux. Replaces the original cpal-based native module.
+
+import { type ChildProcess, spawn, spawnSync } from 'child_process'
+
+// ─── State ───────────────────────────────────────────────────────────
+
+let recordingProcess: ChildProcess | null = null
+let availabilityCache: boolean | null = null
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function commandExists(cmd: string): boolean {
+  const result = spawnSync(cmd, ['--version'], {
+    stdio: 'ignore',
+    timeout: 3000,
+  })
+  return result.error === undefined
+}
+
+// ─── Public API ──────────────────────────────────────────────────────
+
+/**
+ * Check whether a supported audio recording command is available.
+ * Returns true if `rec` (SoX) is found on macOS, or `arecord` (ALSA) on Linux.
+ * Windows is not supported and always returns false.
+ */
 export function isNativeAudioAvailable(): boolean {
+  if (availabilityCache !== null) {
+    return availabilityCache
+  }
+
+  if (process.platform === 'win32') {
+    availabilityCache = false
+    return false
+  }
+
+  if (process.platform === 'darwin') {
+    // macOS: use SoX rec
+    availabilityCache = commandExists('rec')
+    return availabilityCache
+  }
+
+  if (process.platform === 'linux') {
+    // Linux: prefer arecord, fall back to rec
+    availabilityCache = commandExists('arecord') || commandExists('rec')
+    return availabilityCache
+  }
+
+  availabilityCache = false
   return false
 }
+
+/**
+ * Check whether a recording is currently in progress.
+ */
 export function isNativeRecordingActive(): boolean {
-  return false
+  return recordingProcess !== null && !recordingProcess.killed
 }
-export function stopNativeRecording(): void {}
+
+/**
+ * Stop the active recording process, if any.
+ */
+export function stopNativeRecording(): void {
+  if (recordingProcess) {
+    const proc = recordingProcess
+    recordingProcess = null
+    if (!proc.killed) {
+      proc.kill('SIGTERM')
+    }
+  }
+}
+
+/**
+ * Start recording audio. Raw PCM data (16kHz, 16-bit signed, mono) is
+ * streamed via the onData callback. onEnd is called when recording stops
+ * (either from silence detection or process termination).
+ *
+ * Returns true if recording started successfully, false otherwise.
+ */
 export function startNativeRecording(
-  _onData: (data: Buffer) => void,
-  _onEnd: () => void,
+  onData: (data: Buffer) => void,
+  onEnd: () => void,
 ): boolean {
-  return false
+  // Don't start if already recording
+  if (isNativeRecordingActive()) {
+    stopNativeRecording()
+  }
+
+  if (!isNativeAudioAvailable()) {
+    return false
+  }
+
+  let child: ChildProcess
+
+  if (process.platform === 'darwin' || (process.platform === 'linux' && commandExists('rec'))) {
+    // Use SoX rec: output raw PCM 16kHz 16-bit signed mono to stdout
+    child = spawn(
+      'rec',
+      [
+        '-q',           // quiet
+        '--buffer',
+        '1024',         // small buffer for low latency
+        '-t', 'raw',    // raw PCM output
+        '-r', '16000',  // 16kHz sample rate
+        '-e', 'signed', // signed integer encoding
+        '-b', '16',     // 16-bit
+        '-c', '1',      // mono
+        '-',            // output to stdout
+      ],
+      { stdio: ['pipe', 'pipe', 'pipe'] },
+    )
+  } else if (process.platform === 'linux' && commandExists('arecord')) {
+    // Use arecord: output raw PCM 16kHz 16-bit signed LE mono to stdout
+    child = spawn(
+      'arecord',
+      [
+        '-f', 'S16_LE', // signed 16-bit little-endian
+        '-r', '16000',  // 16kHz sample rate
+        '-c', '1',      // mono
+        '-t', 'raw',    // raw PCM, no header
+        '-q',           // quiet
+        '-',            // output to stdout
+      ],
+      { stdio: ['pipe', 'pipe', 'pipe'] },
+    )
+  } else {
+    return false
+  }
+
+  recordingProcess = child
+
+  child.stdout?.on('data', (chunk: Buffer) => {
+    onData(chunk)
+  })
+
+  // Consume stderr to prevent backpressure
+  child.stderr?.on('data', () => {})
+
+  child.on('close', () => {
+    recordingProcess = null
+    onEnd()
+  })
+
+  child.on('error', () => {
+    recordingProcess = null
+    onEnd()
+  })
+
+  return true
 }

packages/image-processor-napi/package.json

@@ -4,5 +4,8 @@
     "private": true,
     "type": "module",
     "main": "./src/index.ts",
-    "types": "./src/index.ts"
+    "types": "./src/index.ts",
+    "dependencies": {
+        "sharp": "^0.33.5"
+    }
 }

packages/image-processor-napi/src/index.ts

@@ -1,6 +1,125 @@
-export function getNativeModule(): null {
+import sharpModule from 'sharp'
+
+export const sharp = sharpModule
+
+interface NativeModule {
+  hasClipboardImage(): boolean
+  readClipboardImage(
+    maxWidth?: number,
+    maxHeight?: number,
+  ): {
+    png: Buffer
+    width: number
+    height: number
+    originalWidth: number
+    originalHeight: number
+  } | null
+}
+
+function createDarwinNativeModule(): NativeModule {
+  return {
+    hasClipboardImage(): boolean {
+      try {
+        const result = Bun.spawnSync({
+          cmd: [
+            'osascript',
+            '-e',
+            'try\nthe clipboard as «class PNGf»\nreturn "yes"\non error\nreturn "no"\nend try',
+          ],
+          stdout: 'pipe',
+          stderr: 'pipe',
+        })
+        const output = result.stdout.toString().trim()
+        return output === 'yes'
+      } catch {
+        return false
+      }
+    },
+
+    readClipboardImage(
+      maxWidth?: number,
+      maxHeight?: number,
+    ) {
+      try {
+        // Use osascript to read clipboard image as PNG data and write to a temp file,
+        // then read the temp file back
+        const tmpPath = `/tmp/claude_clipboard_native_${Date.now()}.png`
+        const script = `
+set png_data to (the clipboard as «class PNGf»)
+set fp to open for access POSIX file "${tmpPath}" with write permission
+write png_data to fp
+close access fp
+return "${tmpPath}"
+`
+        const result = Bun.spawnSync({
+          cmd: ['osascript', '-e', script],
+          stdout: 'pipe',
+          stderr: 'pipe',
+        })
+
+        if (result.exitCode !== 0) {
+          return null
+        }
+
+        const file = Bun.file(tmpPath)
+        // Use synchronous read via Node compat
+        const fs = require('fs')
+        const buffer: Buffer = fs.readFileSync(tmpPath)
+
+        // Clean up temp file
+        try {
+          fs.unlinkSync(tmpPath)
+        } catch {
+          // ignore cleanup errors
+        }
+
+        if (buffer.length === 0) {
+          return null
+        }
+
+        // Read PNG dimensions from IHDR chunk
+        // PNG header: 8 bytes signature, then IHDR chunk
+        // IHDR starts at offset 8 (4 bytes length) + 4 bytes "IHDR" + 4 bytes width + 4 bytes height
+        let width = 0
+        let height = 0
+        if (buffer.length > 24 && buffer[12] === 0x49 && buffer[13] === 0x48 && buffer[14] === 0x44 && buffer[15] === 0x52) {
+          width = buffer.readUInt32BE(16)
+          height = buffer.readUInt32BE(20)
+        }
+
+        const originalWidth = width
+        const originalHeight = height
+
+        // If maxWidth/maxHeight are specified and the image exceeds them,
+        // we still return the full PNG - the caller handles resizing via sharp
+        // But we report the capped dimensions
+        if (maxWidth && maxHeight) {
+          if (width > maxWidth || height > maxHeight) {
+            const scale = Math.min(maxWidth / width, maxHeight / height)
+            width = Math.round(width * scale)
+            height = Math.round(height * scale)
+          }
+        }
+
+        return {
+          png: buffer,
+          width,
+          height,
+          originalWidth,
+          originalHeight,
+        }
+      } catch {
+        return null
+      }
+    },
+  }
+}
+
+export function getNativeModule(): NativeModule | null {
+  if (process.platform === 'darwin') {
+    return createDarwinNativeModule()
+  }
   return null
 }
 
-const stub: any = {}
-export default stub
+export default sharp

packages/modifiers-napi/src/index.ts

@@ -1,5 +1,68 @@
-export function prewarm(): void {}
+import { dlopen, FFIType, suffix } from "bun:ffi";
 
-export function isModifierPressed(_modifier: string): boolean {
-  return false
+const FLAG_SHIFT = 0x20000;
+const FLAG_CONTROL = 0x40000;
+const FLAG_OPTION = 0x80000;
+const FLAG_COMMAND = 0x100000;
+
+const modifierFlags: Record<string, number> = {
+  shift: FLAG_SHIFT,
+  control: FLAG_CONTROL,
+  option: FLAG_OPTION,
+  command: FLAG_COMMAND,
+};
+
+// kCGEventSourceStateCombinedSessionState = 0
+const kCGEventSourceStateCombinedSessionState = 0;
+
+let cgEventSourceFlagsState: ((stateID: number) => number) | null = null;
+
+function loadFFI(): void {
+  if (cgEventSourceFlagsState !== null || process.platform !== "darwin") {
+    return;
+  }
+
+  try {
+    const lib = dlopen(
+      `/System/Library/Frameworks/Carbon.framework/Carbon`,
+      {
+        CGEventSourceFlagsState: {
+          args: [FFIType.i32],
+          returns: FFIType.u64,
+        },
+      }
+    );
+    cgEventSourceFlagsState = (stateID: number): number => {
+      return Number(lib.symbols.CGEventSourceFlagsState(stateID));
+    };
+  } catch {
+    // If loading fails, keep the function null so isModifierPressed returns false
+    cgEventSourceFlagsState = null;
+  }
+}
+
+export function prewarm(): void {
+  loadFFI();
+}
+
+export function isModifierPressed(modifier: string): boolean {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+
+  loadFFI();
+
+  if (cgEventSourceFlagsState === null) {
+    return false;
+  }
+
+  const flag = modifierFlags[modifier];
+  if (flag === undefined) {
+    return false;
+  }
+
+  const currentFlags = cgEventSourceFlagsState(
+    kCGEventSourceStateCombinedSessionState
+  );
+  return (currentFlags & flag) !== 0;
 }

packages/url-handler-napi/src/index.ts

@@ -1,3 +1,3 @@
-export async function waitForUrlEvent(): Promise<string | null> {
+export async function waitForUrlEvent(timeoutMs?: number): Promise<string | null> {
   return null
 }