CodeIsland 深度解析：13 个 AI 编码 Agent 怎么挤进 MacBook 刘海

public static func normalize(_ name: String) -> String {
    switch name {
    // Cursor (camelCase)
    case "beforeSubmitPrompt":    return "UserPromptSubmit"
    case "beforeShellExecution":  return "PreToolUse"
    case "afterShellExecution":   return "PostToolUse"
    // Gemini
    case "BeforeTool":            return "PermissionRequest"
    case "BeforeAgent":           return "SubagentStart"
    // GitHub Copilot CLI
    case "sessionStart":          return "SessionStart"
    case "preToolUse":            return "PreToolUse"
    // Kiro CLI (camelCase, agent-scoped)
    case "agentSpawn":            return "SessionStart"
    // Traecli (snake_case)
    case "session_start":         return "SessionStart"
    case "pre_tool_use":          return "PreToolUse"
    // Hermes (Nous Research)
    case "pre_tool_call":         return "PreToolUse"
    case "on_session_start":      return "SessionStart"
    // Cline (VSCode extension)
    case "TaskStart":             return "SessionStart"
    case "TaskResume":            return "UserPromptSubmit"
    default:                      return name
    }
}

// Copilot CLI adaptation: its stdin JSON lacks session_id and hook_event_name.
if sourceTag == "copilot" {
    if json["hook_event_name"] == nil, let event = eventTag {
        json["hook_event_name"] = event
    }
    if json["session_id"] == nil, let sessionId = nonEmptyString(json["sessionId"]) {
        json["session_id"] = sessionId
    }
    if let toolName = json["toolName"] as? String {
        json["tool_name"] = toolName
    }
    if let toolArgsStr = json["toolArgs"] as? String,
       let argsData = toolArgsStr.data(using: .utf8),
       let argsObj = try? JSONSerialization.jsonObject(with: argsData) as? [String: Any] {
        json["tool_input"] = argsObj
    }
}

// Cline adaptation: sends hookName and taskId instead of hook_event_name and session_id.
if sourceTag == "cline" {
    if json["hook_event_name"] == nil, let name = nonEmptyString(json["hookName"]) {
        json["hook_event_name"] = name
    }
    // ...
}

func buildAncestry(startingAt pid: pid_t, maxDepth: Int = 6) -> [(pid: pid_t, executablePath: String?)] {
    guard pid > 0 else { return [] }
    var result: [(pid: pid_t, executablePath: String?)] = []
    var current: pid_t? = pid
    var visited = Set<pid_t>()

    while let currentPid = current, currentPid > 0, result.count < maxDepth, !visited.contains(currentPid) {
        visited.insert(currentPid)
        result.append((pid: currentPid, executablePath: executablePath(for: currentPid)))
        current = parentPID(of: currentPid)
    }
    return result
}

// iTerm2 session — extract GUID after "w0t0p0:" prefix for AppleScript matching
if let iterm = env["ITERM_SESSION_ID"], !iterm.isEmpty {
    if let colonIdx = iterm.firstIndex(of: ":") {
        json["_iterm_session"] = String(iterm[iterm.index(after: colonIdx)...])
    }
}

// tmux detection — deep info collection
if let tmux = env["TMUX"], !tmux.isEmpty {
    json["_tmux"] = tmux
    if let pane = env["TMUX_PANE"], !pane.isEmpty {
        json["_tmux_pane"] = pane
        // Get client TTY — use explicit path (hook PATH may lack homebrew)
        if let tmuxBin = findBinary("tmux"),
           let clientTTY = runCommand(tmuxBin, args: ["display-message", "-p", "-t", pane, "-F", "#{client_tty}"]) {
            json["_tmux_client_tty"] = clientTTY
        }
    }
}

// cmux — auto-injects CMUX_SURFACE_ID and CMUX_WORKSPACE_ID
if let cmuxSurface = env["CMUX_SURFACE_ID"], !cmuxSurface.isEmpty {
    json["_cmux_surface_id"] = cmuxSurface
}

// Zellij pane id
if let zellij = env["ZELLIJ_PANE_ID"], !zellij.isEmpty {
    json["_zellij_pane_id"] = zellij
}

// WezTerm / Kaku pane id
if let weztermPane = env["WEZTERM_PANE"], !weztermPane.isEmpty {
    json["_wezterm_pane"] = weztermPane
}

enum NotchWidthMetrics {
    static func effectiveNotchWidth(notchW: CGFloat, collapsedWidthScale: Int, hasNotch: Bool) -> CGFloat {
        let clampedScale = Swift.max(NotchWidthScale.min, Swift.min(collapsedWidthScale, NotchWidthScale.max))
        let scaled = notchW * CGFloat(clampedScale) / 100.0
        if hasNotch { return Swift.max(notchW, scaled) }
        return scaled
    }
}

enum NotchHoverPhase {
    case collapsed
    case prehover
    case expanded
}

enum NotchHoverInteraction {
    static let prehoverAnimationDuration: TimeInterval = 0.21
    static let expandDelay: TimeInterval = 0.5
    static let collapseDelay: TimeInterval = 0.5
    static let prehoverWidthDelta: CGFloat = 7
    static let prehoverScale: CGFloat = 1.004
}

static func hash01(_ n: Int, seed: UInt64 = 0) -> Double {
    var x = UInt64(bitPattern: Int64(n)) &+ 0x9E3779B97F4A7C15 &+ seed &* 0xBF58476D1CE4E5B9
    x = (x ^ (x >> 30)) &* 0xBF58476D1CE4E5B9
    x = (x ^ (x >> 27)) &* 0xBF58476D1CE4E5B9
    x = x ^ (x >> 31)
    return Double(x % 1_000_000) / 1_000_000
}

// 35% inhale, 45% exhale, 20% rest.
if phase < 0.35 {
    let p = phase / 0.35
    return CGFloat(0.5 - 0.5 * cos(p * .pi))            // ease-in-out up
} else if phase < 0.80 {
    let p = (phase - 0.35) / 0.45
    return CGFloat(0.5 + 0.5 * cos(p * .pi))            // ease-in-out down
} else {
    return 0
}

private static let reconnectBackoffSeconds: [Int] = [5, 15, 45, 120, 300]
private static let reconnectMaxAttempts = 10

static func reconnectDelay(attempt: Int) -> Int {
    guard attempt >= 1 else { return reconnectBackoffSeconds[0] }
    let idx = min(attempt - 1, reconnectBackoffSeconds.count - 1)
    return reconnectBackoffSeconds[attempt - 1]
}

let connectionChanged = previous.host != host.host
    || previous.user != host.user
    || previous.port != host.port
    || previous.identityFile != host.identityFile
    || previous.authSocket != host.authSocket
if wasConnected && connectionChanged {
    reconnect(id: host.id)
}

nonisolated static func remoteEventPassesCwdFilter(
    cwd: String?,
    workspaceRoots: [String]?
) -> Bool {
    // Empty filter = allow everything (previous behavior).
    // With a filter set, events must carry a cwd containing one of the entries.
    // Without cwd, drop — on a shared account they can't be attributed.
}

private lazy var session = MCSession(peer: peerID, securityIdentity: nil, encryptionPreference: .required)
private lazy var advertiser = MCNearbyServiceAdvertiser(
    peer: peerID,
    discoveryInfo: ["protocol": "1"],
    serviceType: Self.serviceType
)
// ...
private let bluetooth = AppleCompanionBluetoothPeripheral()

func configure(enabled: Bool, heartbeatSeconds: Double) {
    guard enabled else {
        advertiser.stopAdvertisingPeer()
        bluetooth.configure(enabled: false)
        advertising = false
        connectedPeerNames = []
        session.disconnect()
        return
    }
    lastError = nil
    advertiser.startAdvertisingPeer()
    bluetooth.configure(enabled: true)
    advertising = true
    heartbeatTimer = Timer.scheduledTimer(withTimeInterval: max(1.0, heartbeatSeconds), repeats: true) { [weak self] _ in
        Task { @MainActor in
            self?.flush(reason: "heartbeat")
        }
    }
    flush(reason: "enabled")
}

// minimal-bridge.c — 30 行，C99 编译：cc minimal-bridge.c -o minimal-bridge
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

int main(int argc, char **argv) {
    const char *sock = argc > 1 ? argv[1] : "/tmp/minimal-bridge.sock";

    // 1. 检查 socket 是否存在（不存在或不可用 → 静默退出）
    struct stat st;
    if (stat(sock, &st) != 0 || (st.st_mode & S_IFMT) != S_IFSOCK) return 0;

    // 2. 读 stdin 一次性拿到 hook JSON
    char buf[65536]; ssize_t n = read(0, buf, sizeof(buf) - 1);
    if (n <= 0) return 0; buf[n] = 0;

    // 3. 连接 socket（3s 超时）
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un addr = {.sun_family = AF_UNIX};
    strncpy(addr.sun_path, sock, sizeof(addr.sun_path) - 1);
    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) != 0) return 0;

    // 4. 写 JSON（简化为 socket 半关闭即可）
    write(fd, buf, n);
    shutdown(fd, SHUT_WR);

    // 5. 等服务端 ack（最长 1s）
    struct timeval tv = {1, 0};
    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    char ack[4096]; ssize_t m = read(fd, ack, sizeof(ack));
    if (m > 0) write(1, ack, m);  // 反向写到 stdout（仅阻塞事件需要）

    return 0;
}