From 5defa5b7ac12db1720dad79d2c3767c0c7badda7 Mon Sep 17 00:00:00 2001 From: Shane McCarron Date: Sun, 19 Jul 2026 08:57:33 -0500 Subject: [PATCH 1/5] fix: honor $CLAUDE_CONFIG_DIR instead of hardcoding ~/.claude MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Claude Code stores its transcripts and settings under $CLAUDE_CONFIG_DIR when that variable is set, falling back to ~/.claude. CodeIsland only ever looked at ~/.claude, so users with a custom config dir saw no Claude sessions at all — and with hideWhenNoSession enabled the app hid itself entirely, which reads as a crash. Add ClaudeConfigPaths, a small resolver in CodeIslandCore, and route every Claude path through it. The chain is: 1. claude_config_dir preference (new Settings field) 2. $CLAUDE_CONFIG_DIR 3. ~/.config/claude-code, when it actually holds Claude state 4. ~/.claude The preference exists because CodeIsland is normally launched from Finder or as a login item, where no shell environment is inherited — reading the env var alone would not have fixed the reported case. The XDG probe checks for projects/ or settings.json so an empty directory left behind by another tool cannot shadow a real ~/.claude. Behavior is unchanged for users without a custom config dir: with no preference, no env var, and no populated ~/.config/claude-code, resolution still returns ~/.claude. Covered by 9 new tests against a pure, injectable resolve() core. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01YL1NKtwrKxPSxkBEuKGWNW --- Sources/CodeIsland/AppState.swift | 9 +- Sources/CodeIsland/ConfigInstaller.swift | 6 +- Sources/CodeIsland/DiagnosticsExporter.swift | 2 +- Sources/CodeIsland/L10n.swift | 16 ++++ Sources/CodeIsland/SessionTitleStore.swift | 3 +- Sources/CodeIsland/Settings.swift | 14 +++ Sources/CodeIsland/SettingsView.swift | 14 +++ .../CodeIslandCore/ClaudeConfigPaths.swift | 81 +++++++++++++++++ .../CodeIslandCore/ClaudeUsageScanner.swift | 4 +- .../ClaudeConfigPathsTests.swift | 89 +++++++++++++++++++ 10 files changed, 226 insertions(+), 12 deletions(-) create mode 100644 Sources/CodeIslandCore/ClaudeConfigPaths.swift create mode 100644 Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift diff --git a/Sources/CodeIsland/AppState.swift b/Sources/CodeIsland/AppState.swift index 33a8bf53..c060d898 100644 --- a/Sources/CodeIsland/AppState.swift +++ b/Sources/CodeIsland/AppState.swift @@ -1891,8 +1891,7 @@ final class AppState { private nonisolated static func readModelFromTranscript(sessionId: String, cwd: String?) -> String? { guard let cwd = cwd else { return nil } let projectDir = cwd.claudeProjectDirEncoded() - let home = FileManager.default.homeDirectoryForCurrentUser.path - let path = "\(home)/.claude/projects/\(projectDir)/\(sessionId).jsonl" + let path = "\(ClaudeConfigPaths.projectsDir())/\(projectDir)/\(sessionId).jsonl" guard let handle = FileHandle(forReadingAtPath: path) else { return nil } defer { handle.closeFile() } let chunk = handle.readData(ofLength: 32768) @@ -2272,7 +2271,7 @@ final class AppState { private nonisolated static func discoveryWatchRoots() -> [String] { let home = FileManager.default.homeDirectoryForCurrentUser.path let candidates: [(String, String)] = [ - ("claude", "\(home)/.claude/projects"), + ("claude", ClaudeConfigPaths.projectsDir()), ("codex", "\(home)/.codex/sessions"), ("gemini", "\(home)/.gemini/tmp"), ("qoder", "\(home)/.qoder/projects"), @@ -2835,8 +2834,8 @@ final class AppState { let claudePids = findClaudePids(candidatePids: candidatePids) guard !claudePids.isEmpty else { return [] } - let home = FileManager.default.homeDirectoryForCurrentUser.path let fm = FileManager.default + let claudeProjects = ClaudeConfigPaths.projectsDir() var results: [DiscoveredSession] = [] var seenSessionIds: Set = [] @@ -2853,7 +2852,7 @@ final class AppState { let processStart = getProcessStartTime(pid) let projectDir = cwd.claudeProjectDirEncoded() - let projectPath = "\(home)/.claude/projects/\(projectDir)" + let projectPath = "\(claudeProjects)/\(projectDir)" guard let files = try? fm.contentsOfDirectory(atPath: projectPath) else { continue } // Find the most recently modified .jsonl that was written AFTER this process started diff --git a/Sources/CodeIsland/ConfigInstaller.swift b/Sources/CodeIsland/ConfigInstaller.swift index 1470b67e..b663533d 100644 --- a/Sources/CodeIsland/ConfigInstaller.swift +++ b/Sources/CodeIsland/ConfigInstaller.swift @@ -200,7 +200,7 @@ struct ConfigInstaller { // Claude Code — uses hook script (with bridge dispatcher + nc fallback) CLIConfig( name: "Claude Code", source: "claude", - configPath: ".claude/settings.json", configKey: "hooks", + configPath: "settings.json", configKey: "hooks", format: .claude, events: [ ("UserPromptSubmit", 5, true), @@ -218,7 +218,9 @@ struct ConfigInstaller { ], versionedEvents: [ "PostToolUseFailure": "2.1.89", - ] + ], + rootOverride: { ClaudeConfigPaths.configDir() }, + displayPathOverride: { ClaudeConfigPaths.displayPath(ClaudeConfigPaths.settingsPath()) } ), // Codex — honors $CODEX_HOME (falls back to ~/.codex) CLIConfig( diff --git a/Sources/CodeIsland/DiagnosticsExporter.swift b/Sources/CodeIsland/DiagnosticsExporter.swift index 47218be4..c90bc2d3 100644 --- a/Sources/CodeIsland/DiagnosticsExporter.swift +++ b/Sources/CodeIsland/DiagnosticsExporter.swift @@ -53,7 +53,7 @@ struct DiagnosticsExporter { // 3. CLI config files let home = fm.homeDirectoryForCurrentUser.path let configs: [(source: String, dest: String)] = [ - ("\(home)/.claude/settings.json", "configs/claude-settings.json"), + (ClaudeConfigPaths.settingsPath(), "configs/claude-settings.json"), ("\(home)/.codex/hooks.json", "configs/codex-hooks.json"), ("\(home)/.gemini/settings.json", "configs/gemini-settings.json"), ("\(home)/.cursor/hooks.json", "configs/cursor-hooks.json"), diff --git a/Sources/CodeIsland/L10n.swift b/Sources/CodeIsland/L10n.swift index f3b8852e..02aa5eba 100644 --- a/Sources/CodeIsland/L10n.swift +++ b/Sources/CodeIsland/L10n.swift @@ -149,6 +149,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "Ignore Hooks From Paths", "excluded_hook_cwd_desc": "Comma-separated substrings. Any hook event whose working directory contains one of them is silently dropped — useful for filtering out background plugins like claude-mem. Example: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "e.g. .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code Config Directory", + "claude_config_dir_desc": "Where Claude Code keeps projects/ and settings.json. Leave empty to auto-detect ($CLAUDE_CONFIG_DIR, then ~/.config/claude-code, then ~/.claude). Set this if you use a custom CLAUDE_CONFIG_DIR — a Finder-launched app does not inherit your shell environment. Restart CodeIsland after changing.", + "claude_config_dir_placeholder": "auto-detect", + "claude_config_dir_resolved": "Currently using: %@", // Webhook forwarding "webhook_title": "Webhook Forwarding", @@ -1509,6 +1513,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "指定パスの Hook を無視", "excluded_hook_cwd_desc": "カンマ区切りの部分文字列。作業ディレクトリにいずれかを含む hook イベントは静かに破棄されます。claude-mem 等のバックグラウンドプラグイン除外に便利です。例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例: .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code 設定ディレクトリ", + "claude_config_dir_desc": "Claude Code が projects/ と settings.json を保存する場所。空欄の場合は自動検出します（$CLAUDE_CONFIG_DIR、次に ~/.config/claude-code、次に ~/.claude）。カスタムの CLAUDE_CONFIG_DIR を使用している場合は設定してください。Finder から起動したアプリはシェルの環境変数を継承しません。変更後は CodeIsland を再起動してください。", + "claude_config_dir_placeholder": "自動検出", + "claude_config_dir_resolved": "現在の使用先: %@", // Webhook 転送 "webhook_title": "Webhook 転送", @@ -1849,6 +1857,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "지정 경로의 Hook 무시", "excluded_hook_cwd_desc": "쉼표로 구분된 부분 문자열. 작업 디렉터리에 하나라도 포함된 hook 이벤트는 조용히 폐기됩니다. claude-mem 같은 백그라운드 플러그인 필터링에 유용합니다. 예: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "예: .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code 설정 디렉터리", + "claude_config_dir_desc": "Claude Code가 projects/ 및 settings.json을 저장하는 위치입니다. 비워 두면 자동으로 감지합니다($CLAUDE_CONFIG_DIR, 그다음 ~/.config/claude-code, 그다음 ~/.claude). 사용자 지정 CLAUDE_CONFIG_DIR을 사용하는 경우 설정하세요. Finder에서 실행된 앱은 셸 환경 변수를 상속하지 않습니다. 변경 후 CodeIsland를 다시 시작하세요.", + "claude_config_dir_placeholder": "자동 감지", + "claude_config_dir_resolved": "현재 사용 중: %@", // Webhook 전달 "webhook_title": "Webhook 전달", @@ -2189,6 +2201,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "Belirli Yolların Hook'larını Yoksay", "excluded_hook_cwd_desc": "Virgülle ayrılmış alt dizeler. Çalışma dizini bunlardan birini içeren hook olayları sessizce yok sayılır — claude-mem gibi arka plan eklentilerini filtrelemek için kullanışlı. Örn: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "örn. .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code Yapılandırma Dizini", + "claude_config_dir_desc": "Claude Code'un projects/ ve settings.json dosyalarını sakladığı yer. Otomatik algılama için boş bırakın ($CLAUDE_CONFIG_DIR, ardından ~/.config/claude-code, ardından ~/.claude). Özel bir CLAUDE_CONFIG_DIR kullanıyorsanız bunu ayarlayın; Finder'dan başlatılan bir uygulama kabuk ortam değişkenlerini devralmaz. Değişiklikten sonra CodeIsland'ı yeniden başlatın.", + "claude_config_dir_placeholder": "otomatik algıla", + "claude_config_dir_resolved": "Şu anda kullanılan: %@", // Webhook iletme "webhook_title": "Webhook İletme", diff --git a/Sources/CodeIsland/SessionTitleStore.swift b/Sources/CodeIsland/SessionTitleStore.swift index 20141243..55e4190e 100644 --- a/Sources/CodeIsland/SessionTitleStore.swift +++ b/Sources/CodeIsland/SessionTitleStore.swift @@ -72,8 +72,7 @@ enum SessionTitleStore { guard let cwd else { return nil } let projectDir = cwd.claudeProjectDirEncoded() - let home = FileManager.default.homeDirectoryForCurrentUser.path - let path = "\(home)/.claude/projects/\(projectDir)/\(sessionId).jsonl" + let path = "\(ClaudeConfigPaths.projectsDir())/\(projectDir)/\(sessionId).jsonl" guard let handle = FileHandle(forReadingAtPath: path) else { return nil diff --git a/Sources/CodeIsland/Settings.swift b/Sources/CodeIsland/Settings.swift index 8e6ecd5d..d3cfa38c 100644 --- a/Sources/CodeIsland/Settings.swift +++ b/Sources/CodeIsland/Settings.swift @@ -119,6 +119,10 @@ enum SettingsKey { // Hook cwd exclusion (comma-separated substrings; cwd containing any drops the event) static let excludedHookCwdSubstrings = "excludedHookCwdSubstrings" + // Claude Code config dir override (empty = auto-detect). Must match + // ClaudeConfigPaths.preferenceKey — that resolver is the only reader. + static let claudeConfigDir = "claude_config_dir" + // Webhook forwarding: POST hook events to an external URL static let webhookEnabled = "webhookEnabled" static let webhookURL = "webhookURL" @@ -195,6 +199,8 @@ struct SettingsDefaults { static let excludedHookCwdSubstrings = "" + static let claudeConfigDir = "" + static let webhookEnabled = false static let webhookURL = "" static let webhookEventFilter = "" @@ -259,6 +265,7 @@ class SettingsManager { SettingsKey.defaultSource: SettingsDefaults.defaultSource, SettingsKey.autoApproveTools: SettingsDefaults.autoApproveTools, SettingsKey.excludedHookCwdSubstrings: SettingsDefaults.excludedHookCwdSubstrings, + SettingsKey.claudeConfigDir: SettingsDefaults.claudeConfigDir, SettingsKey.webhookEnabled: SettingsDefaults.webhookEnabled, SettingsKey.webhookURL: SettingsDefaults.webhookURL, SettingsKey.webhookEventFilter: SettingsDefaults.webhookEventFilter, @@ -410,6 +417,13 @@ class SettingsManager { get { defaults.string(forKey: SettingsKey.excludedHookCwdSubstrings) ?? SettingsDefaults.excludedHookCwdSubstrings } set { defaults.set(newValue, forKey: SettingsKey.excludedHookCwdSubstrings) } } + + /// Explicit Claude Code config dir. Empty means auto-detect — see `ClaudeConfigPaths`. + /// Needed because a Finder-launched app inherits no `$CLAUDE_CONFIG_DIR`. + var claudeConfigDir: String { + get { defaults.string(forKey: SettingsKey.claudeConfigDir) ?? SettingsDefaults.claudeConfigDir } + set { defaults.set(newValue, forKey: SettingsKey.claudeConfigDir) } + } } // MARK: - Shortcut Actions diff --git a/Sources/CodeIsland/SettingsView.swift b/Sources/CodeIsland/SettingsView.swift index 5a0aaa53..02dfcb31 100644 --- a/Sources/CodeIsland/SettingsView.swift +++ b/Sources/CodeIsland/SettingsView.swift @@ -392,6 +392,7 @@ private struct BehaviorPage: View { @AppStorage(SettingsKey.maxToolHistory) private var maxToolHistory = SettingsDefaults.maxToolHistory @AppStorage(SettingsKey.autoApproveTools) private var autoApproveRaw: String = SettingsDefaults.autoApproveTools @AppStorage(SettingsKey.excludedHookCwdSubstrings) private var excludedHookCwdSubstrings: String = SettingsDefaults.excludedHookCwdSubstrings + @AppStorage(SettingsKey.claudeConfigDir) private var claudeConfigDir: String = SettingsDefaults.claudeConfigDir @AppStorage(SettingsKey.webhookEnabled) private var webhookEnabled: Bool = SettingsDefaults.webhookEnabled @AppStorage(SettingsKey.webhookURL) private var webhookURL: String = SettingsDefaults.webhookURL @AppStorage(SettingsKey.webhookEventFilter) private var webhookEventFilter: String = SettingsDefaults.webhookEventFilter @@ -500,6 +501,19 @@ private struct BehaviorPage: View { } } + Section(l10n["claude_config_dir_title"]) { + Text(l10n["claude_config_dir_desc"]) + .font(.caption) + .foregroundStyle(.secondary) + TextField(l10n["claude_config_dir_placeholder"], text: $claudeConfigDir) + .textFieldStyle(.roundedBorder) + .font(.system(size: 12, design: .monospaced)) + Text(String(format: l10n["claude_config_dir_resolved"], + ClaudeConfigPaths.displayPath(ClaudeConfigPaths.configDir()))) + .font(.system(size: 11, design: .monospaced)) + .foregroundStyle(.secondary) + } + Section(l10n["excluded_hook_cwd_title"]) { Text(l10n["excluded_hook_cwd_desc"]) .font(.caption) diff --git a/Sources/CodeIslandCore/ClaudeConfigPaths.swift b/Sources/CodeIslandCore/ClaudeConfigPaths.swift new file mode 100644 index 00000000..d540ba01 --- /dev/null +++ b/Sources/CodeIslandCore/ClaudeConfigPaths.swift @@ -0,0 +1,81 @@ +import Foundation + +/// Resolves the Claude Code configuration directory. +/// +/// Claude Code honors `$CLAUDE_CONFIG_DIR` and falls back to `~/.claude`. CodeIsland is a +/// GUI app, so it is usually launched from Finder/login items and does **not** inherit the +/// user's shell environment — reading the env var alone is not enough. The chain below adds +/// a user-settable preference (the only thing that reliably survives a Finder launch) and a +/// probe of the common XDG-style location before defaulting. +/// +/// Resolution order: +/// 1. `claude_config_dir` user preference (Settings → set explicitly) +/// 2. `$CLAUDE_CONFIG_DIR` (present when launched from a shell) +/// 3. `~/.config/claude-code`, if it looks like a real config dir +/// 4. `~/.claude` +public enum ClaudeConfigPaths { + /// UserDefaults key backing the Settings field. + public static let preferenceKey = "claude_config_dir" + + /// Absolute path to the resolved Claude config directory (no trailing slash). + public static func configDir() -> String { + resolve( + preference: UserDefaults.standard.string(forKey: preferenceKey), + environment: ProcessInfo.processInfo.environment["CLAUDE_CONFIG_DIR"], + homeDir: NSHomeDirectory(), + fileExists: { FileManager.default.fileExists(atPath: $0) } + ) + } + + /// Where per-project transcripts live. + public static func projectsDir() -> String { configDir() + "/projects" } + + /// The `settings.json` that holds hook configuration. + public static func settingsPath() -> String { configDir() + "/settings.json" } + + public static var defaultConfigDir: String { NSHomeDirectory() + "/.claude" } + + /// Pure resolution core — all inputs injected so the fallback chain is testable + /// without touching UserDefaults, the environment, or the real filesystem. + public static func resolve( + preference: String?, + environment: String?, + homeDir: String, + fileExists: (String) -> Bool + ) -> String { + if let pref = normalized(preference, homeDir: homeDir) { return pref } + if let env = normalized(environment, homeDir: homeDir) { return env } + let xdg = homeDir + "/.config/claude-code" + if looksLikeConfigDir(xdg, fileExists: fileExists) { return xdg } + return homeDir + "/.claude" + } + + /// User-visible form — collapses the home prefix back to `~` so Settings and + /// diagnostics show `~/.config/claude-code/settings.json` rather than a full path. + public static func displayPath(_ absolute: String, homeDir: String = NSHomeDirectory()) -> String { + guard absolute == homeDir || absolute.hasPrefix(homeDir + "/") else { return absolute } + return "~" + absolute.dropFirst(homeDir.count) + } + + /// A directory only counts as a Claude config dir if it actually holds Claude state. + /// Without this, an empty `~/.config/claude-code` created by some other tool would + /// shadow a perfectly good `~/.claude`. + static func looksLikeConfigDir(_ path: String, fileExists: (String) -> Bool) -> Bool { + ["projects", "settings.json"].contains { fileExists(path + "/" + $0) } + } + + /// Trims, expands `~`, and drops any trailing slash. Returns nil for empty input. + /// `$CLAUDE_CONFIG_DIR` may hold a colon-separated list; Claude Code treats the first + /// entry as the writable config dir, so we do the same. + static func normalized(_ raw: String?, homeDir: String) -> String? { + var value = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + if let separator = value.firstIndex(of: ":") { + value = String(value[value.startIndex.. 1 && value.hasSuffix("/") { value.removeLast() } + return value + } +} diff --git a/Sources/CodeIslandCore/ClaudeUsageScanner.swift b/Sources/CodeIslandCore/ClaudeUsageScanner.swift index ecbd3cf2..c251bb22 100644 --- a/Sources/CodeIslandCore/ClaudeUsageScanner.swift +++ b/Sources/CodeIslandCore/ClaudeUsageScanner.swift @@ -66,7 +66,7 @@ public enum ClaudeUsageScanner { /// One-shot convenience (tests, callers without persistent state). public static func scan( - claudeHome: String = NSHomeDirectory() + "/.claude", + claudeHome: String = ClaudeConfigPaths.configDir(), now: Date = Date() ) -> Snapshot { var cache = FileCache() @@ -74,7 +74,7 @@ public enum ClaudeUsageScanner { } public static func scan( - claudeHome: String = NSHomeDirectory() + "/.claude", + claudeHome: String = ClaudeConfigPaths.configDir(), now: Date = Date(), cache: inout FileCache ) -> Snapshot { diff --git a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift new file mode 100644 index 00000000..17335b5d --- /dev/null +++ b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift @@ -0,0 +1,89 @@ +import XCTest +@testable import CodeIslandCore + +final class ClaudeConfigPathsTests: XCTestCase { + private let home = "/Users/tester" + + /// Nothing exists anywhere → the historical `~/.claude` default. + func testFallsBackToDotClaudeWhenNothingSet() { + let result = ClaudeConfigPaths.resolve( + preference: nil, environment: nil, homeDir: home, fileExists: { _ in false }) + XCTAssertEqual(result, "/Users/tester/.claude") + } + + /// The regression this resolver exists for: a user with a custom CLAUDE_CONFIG_DIR + /// was silently scanned at ~/.claude, which is empty, so no sessions ever appeared. + func testEnvironmentVariableWins() { + let result = ClaudeConfigPaths.resolve( + preference: nil, + environment: "/Users/tester/.config/claude-code", + homeDir: home, + fileExists: { _ in false }) + XCTAssertEqual(result, "/Users/tester/.config/claude-code") + } + + /// The preference must outrank the environment — it is the only channel that + /// survives a Finder launch, where no shell environment is inherited. + func testPreferenceOutranksEnvironment() { + let result = ClaudeConfigPaths.resolve( + preference: "/explicit/dir", + environment: "/env/dir", + homeDir: home, + fileExists: { _ in true }) + XCTAssertEqual(result, "/explicit/dir") + } + + /// With no preference and no environment (the Finder case), a populated + /// ~/.config/claude-code is auto-detected instead of defaulting to ~/.claude. + func testProbesXDGDirectoryWhenPopulated() { + let result = ClaudeConfigPaths.resolve( + preference: nil, environment: nil, homeDir: home, + fileExists: { $0 == "/Users/tester/.config/claude-code/projects" }) + XCTAssertEqual(result, "/Users/tester/.config/claude-code") + } + + /// An empty ~/.config/claude-code (created by some other tool) must not shadow + /// a real ~/.claude. + func testEmptyXDGDirectoryDoesNotShadowDotClaude() { + let result = ClaudeConfigPaths.resolve( + preference: nil, environment: nil, homeDir: home, + fileExists: { $0 == "/Users/tester/.config/claude-code" }) + XCTAssertEqual(result, "/Users/tester/.claude") + } + + func testEmptyAndWhitespaceValuesAreIgnored() { + XCTAssertNil(ClaudeConfigPaths.normalized("", homeDir: home)) + XCTAssertNil(ClaudeConfigPaths.normalized(" ", homeDir: home)) + XCTAssertNil(ClaudeConfigPaths.normalized(nil, homeDir: home)) + } + + func testTildeExpansionAndTrailingSlashes() { + XCTAssertEqual(ClaudeConfigPaths.normalized("~", homeDir: home), home) + XCTAssertEqual( + ClaudeConfigPaths.normalized("~/.config/claude-code", homeDir: home), + "/Users/tester/.config/claude-code") + XCTAssertEqual(ClaudeConfigPaths.normalized("/a/b///", homeDir: home), "/a/b") + XCTAssertEqual(ClaudeConfigPaths.normalized(" /a/b ", homeDir: home), "/a/b") + } + + /// CLAUDE_CONFIG_DIR may hold a colon-separated list; the first entry is the + /// writable config dir, matching Claude Code's own behavior. + func testColonSeparatedListTakesFirstEntry() { + XCTAssertEqual( + ClaudeConfigPaths.normalized("/first/dir:/second/dir", homeDir: home), + "/first/dir") + } + + func testDisplayPathCollapsesHomePrefix() { + XCTAssertEqual( + ClaudeConfigPaths.displayPath("/Users/tester/.claude/settings.json", homeDir: home), + "~/.claude/settings.json") + XCTAssertEqual( + ClaudeConfigPaths.displayPath("/opt/elsewhere/settings.json", homeDir: home), + "/opt/elsewhere/settings.json") + // A different user's home that merely shares a prefix must not be collapsed. + XCTAssertEqual( + ClaudeConfigPaths.displayPath("/Users/tester2/.claude", homeDir: home), + "/Users/tester2/.claude") + } +} From 54d4be8efaf921f92a6814b93597cb12f6ae997e Mon Sep 17 00:00:00 2001 From: Shane McCarron Date: Sun, 19 Jul 2026 09:00:09 -0500 Subject: [PATCH 2/5] fix: treat CLAUDE_CONFIG_DIR as a single path, normalize to NFC MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review caught two defects in the previous commit. The colon-splitting was based on a claim I had not verified. Claude Code reads CLAUDE_CONFIG_DIR verbatim as a single path — there is no PATH-style list handling anywhere in it. Splitting on ":" was therefore not just unnecessary but actively harmful: ":" is legal in an APFS filename, so a directory like ~/Projects/AI:ML/claude was silently truncated to ~/Projects/AI. Claude Code also applies .normalize("NFC") to the resolved path. Match that, so a decomposed path — which some macOS APIs hand back — resolves to the same directory rather than missing it. Also drop defaultConfigDir, which was declared and never referenced. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01YL1NKtwrKxPSxkBEuKGWNW --- Sources/CodeIslandCore/ClaudeConfigPaths.swift | 18 +++++++++--------- .../ClaudeConfigPathsTests.swift | 18 +++++++++++++----- 2 files changed, 22 insertions(+), 14 deletions(-) diff --git a/Sources/CodeIslandCore/ClaudeConfigPaths.swift b/Sources/CodeIslandCore/ClaudeConfigPaths.swift index d540ba01..daffd11f 100644 --- a/Sources/CodeIslandCore/ClaudeConfigPaths.swift +++ b/Sources/CodeIslandCore/ClaudeConfigPaths.swift @@ -33,8 +33,6 @@ public enum ClaudeConfigPaths { /// The `settings.json` that holds hook configuration. public static func settingsPath() -> String { configDir() + "/settings.json" } - public static var defaultConfigDir: String { NSHomeDirectory() + "/.claude" } - /// Pure resolution core — all inputs injected so the fallback chain is testable /// without touching UserDefaults, the environment, or the real filesystem. public static func resolve( @@ -65,17 +63,19 @@ public enum ClaudeConfigPaths { } /// Trims, expands `~`, and drops any trailing slash. Returns nil for empty input. - /// `$CLAUDE_CONFIG_DIR` may hold a colon-separated list; Claude Code treats the first - /// entry as the writable config dir, so we do the same. + /// + /// `$CLAUDE_CONFIG_DIR` holds a single path — Claude Code reads it verbatim and does + /// not treat it as a `PATH`-style list, so no separator splitting happens here. That + /// matters on APFS, where `:` is legal in a filename. + /// + /// Claude Code normalizes the path to Unicode NFC before use; we match that so a + /// decomposed path (as some macOS APIs hand back) still resolves to the same directory. static func normalized(_ raw: String?, homeDir: String) -> String? { var value = (raw ?? "").trimmingCharacters(in: .whitespacesAndNewlines) - if let separator = value.firstIndex(of: ":") { - value = String(value[value.startIndex.. 1 && value.hasSuffix("/") { value.removeLast() } - return value + return value.precomposedStringWithCanonicalMapping } } diff --git a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift index 17335b5d..e975c591 100644 --- a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift +++ b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift @@ -66,12 +66,20 @@ final class ClaudeConfigPathsTests: XCTestCase { XCTAssertEqual(ClaudeConfigPaths.normalized(" /a/b ", homeDir: home), "/a/b") } - /// CLAUDE_CONFIG_DIR may hold a colon-separated list; the first entry is the - /// writable config dir, matching Claude Code's own behavior. - func testColonSeparatedListTakesFirstEntry() { + /// CLAUDE_CONFIG_DIR is a single path, not a PATH-style list. `:` is legal in an + /// APFS filename, so splitting on it would silently truncate a valid directory. + func testColonIsPreservedAsPartOfPath() { XCTAssertEqual( - ClaudeConfigPaths.normalized("/first/dir:/second/dir", homeDir: home), - "/first/dir") + ClaudeConfigPaths.normalized("/Users/tester/AI:ML/claude", homeDir: home), + "/Users/tester/AI:ML/claude") + } + + /// Claude Code normalizes its config path to NFC; matching that keeps a decomposed + /// path (what some macOS APIs return) resolving to the same directory. + func testUnicodePathsAreNormalizedToNFC() { + let decomposed = "/Users/tester/Cafe\u{0301}/claude" // e + combining acute + let precomposed = "/Users/tester/Caf\u{00E9}/claude" // é + XCTAssertEqual(ClaudeConfigPaths.normalized(decomposed, homeDir: home), precomposed) } func testDisplayPathCollapsesHomePrefix() { From 789af1ee1be1c7836b38878cb98e5a80d58181bf Mon Sep 17 00:00:00 2001 From: Shane McCarron Date: Sun, 19 Jul 2026 09:31:06 -0500 Subject: [PATCH 3/5] fix: address QA round 1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Resolves findings from the round-1 QA review. F1 (major) — the XDG probe could shadow a live ~/.claude. Claude Code has no XDG rung: it reads $CLAUDE_CONFIG_DIR, else ~/.claude. Probing ~/.config/ claude-code before checking whether ~/.claude was populated meant a stale XDG directory silently repointed us away from the directory Claude Code actually reads — reintroducing issue #269's symptom through a different door. A live ~/.claude now wins. Liveness is judged by projects/ alone, NOT settings.json: CodeIsland's own hook installer creates settings.json, so counting it would let us manufacture the signal we then read back — an otherwise-empty ~/.claude holding only a CodeIsland-written settings.json would outrank the user's real config dir permanently. F2 (major) — install and uninstall could resolve to different directories, so hook entries left at the old location kept firing and became unreachable by uninstall, which still reported success. Both paths now sweep the non-resolved candidate dirs, touching only files carrying our marker. F3 (major) — preference/env values were accepted verbatim, so a relative path or a typo was resolved against the app's cwd and the hook installer then created the bogus directory and reported success. Non-absolute values (and bare "/") now fall through to auto-detect instead. F4 (major) — RemoteInstaller's embedded Python still hardcoded ~/.claude, and its guard let a custom-config user through (no ~/.claude, but claude on PATH), creating a stale dir on the remote host. It now mirrors the resolver. F9 (minor) — configDir() re-resolved on every call, including stat() syscalls on the main thread from SettingsView.body. Memoized on its inputs, which keeps the live Settings preview correct while removing steady-state syscalls. F5/F6/F8 (minor) — zh + zh-Hant strings added; tests pin the preference-key parity across modules and the Claude rootOverride (without which fullPath silently becomes ~/settings.json). Also fixes a test-isolation bug this surfaced: RemoteInstallerHookMergeTests sandboxes HOME but leaked $CLAUDE_CONFIG_DIR, so once the remote script began honoring that variable the suite wrote hooks into the developer's real config dir. Stripped, matching the existing CODEX_HOME precedent. F10 (hypothetical) left as-is; documented in the PR thread. 559 tests, 0 failures. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01YL1NKtwrKxPSxkBEuKGWNW --- Sources/CodeIsland/ConfigInstaller.swift | 36 +++++++++ Sources/CodeIsland/L10n.swift | 8 ++ Sources/CodeIsland/RemoteInstaller.swift | 17 +++- .../CodeIslandCore/ClaudeConfigPaths.swift | 77 ++++++++++++++++--- .../ClaudeConfigPathsTests.swift | 36 +++++++++ .../ClaudeConfigPathsWiringTests.swift | 33 ++++++++ .../RemoteInstallerHookMergeTests.swift | 3 + 7 files changed, 198 insertions(+), 12 deletions(-) create mode 100644 Tests/CodeIslandTests/ClaudeConfigPathsWiringTests.swift diff --git a/Sources/CodeIsland/ConfigInstaller.swift b/Sources/CodeIsland/ConfigInstaller.swift index b663533d..5e4b8359 100644 --- a/Sources/CodeIsland/ConfigInstaller.swift +++ b/Sources/CodeIsland/ConfigInstaller.swift @@ -751,6 +751,10 @@ struct ConfigInstaller { try? fm.removeItem(atPath: legacyBridgePath) try? fm.removeItem(atPath: legacyHookScriptPath) + // Drop hook entries orphaned at a config dir we no longer resolve to, so the + // old copy cannot keep firing alongside the new one. + cleanStaleClaudeHooks(fm: fm) + // Install hook script + bridge binary (shared by all CLIs) installHookScript(fm: fm) installBridgeBinary(fm: fm) @@ -803,6 +807,36 @@ struct ConfigInstaller { return ok } + /// Claude config dirs we may have written hooks into under a *previous* resolution. + /// + /// The resolved dir can change between install and uninstall (the user fills in the + /// preference, exports `$CLAUDE_CONFIG_DIR`, or upgrades into the XDG rung). Hook + /// entries left at the old location would otherwise keep firing while being + /// unreachable by uninstall — install and uninstall must stay symmetric. + private static func staleClaudeConfigDirs() -> [String] { + let resolved = ClaudeConfigPaths.configDir() + let home = NSHomeDirectory() + return [home + "/.claude", home + "/.config/claude-code"].filter { $0 != resolved } + } + + /// Strip CodeIsland hook entries from Claude `settings.json` files outside the + /// currently resolved config dir. Only touches files that actually carry our + /// marker, so an unrelated user settings.json is never rewritten. + static func cleanStaleClaudeHooks(fm: FileManager) { + guard let claude = builtInCLIs.first(where: { $0.source == "claude" }) else { return } + for dir in staleClaudeConfigDirs() { + var stale = claude + stale.rootOverride = { dir } + let path = stale.fullPath + guard fm.fileExists(atPath: path), + let data = fm.contents(atPath: path), + let text = String(data: data, encoding: .utf8), + text.contains("codeisland") + else { continue } + uninstallHooks(cli: stale, fm: fm) + } + } + static func uninstall() { let fm = FileManager.default try? fm.removeItem(atPath: hookScriptPath) @@ -810,6 +844,8 @@ struct ConfigInstaller { // Also clean up legacy paths (#32) try? fm.removeItem(atPath: legacyBridgePath) try? fm.removeItem(atPath: legacyHookScriptPath) + // Remove entries orphaned at a previously-resolved config dir + cleanStaleClaudeHooks(fm: fm) for cli in allCLIs { if cli.source == "traecli" { diff --git a/Sources/CodeIsland/L10n.swift b/Sources/CodeIsland/L10n.swift index 02aa5eba..ec5af76f 100644 --- a/Sources/CodeIsland/L10n.swift +++ b/Sources/CodeIsland/L10n.swift @@ -833,6 +833,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "忽略指定路径的 Hook", "excluded_hook_cwd_desc": "用逗号分隔的子串。任何 hook 事件的工作目录如果包含其中之一就会被静默丢弃 —— 适合过滤 claude-mem 等后台插件。示例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例如 .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code 配置目录", + "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空则自动检测（先 $CLAUDE_CONFIG_DIR，再 ~/.config/claude-code，最后 ~/.claude）。如果你使用自定义的 CLAUDE_CONFIG_DIR，请在此设置——从访达启动的应用不会继承 shell 环境变量。修改后请重启 CodeIsland。", + "claude_config_dir_placeholder": "自动检测", + "claude_config_dir_resolved": "当前使用：%@", // Webhook 转发 "webhook_title": "Webhook 转发", @@ -1173,6 +1177,10 @@ final class L10n: ObservableObject { "excluded_hook_cwd_title": "忽略指定路徑的 Hook", "excluded_hook_cwd_desc": "以逗號分隔的子字串。任何 hook 事件的工作目錄如果包含其中之一就會被靜默丟棄 —— 適合過濾 claude-mem 等背景外掛。範例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例如 .claude-mem,.cache/agents", + "claude_config_dir_title": "Claude Code 設定目錄", + "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空則自動偵測（先 $CLAUDE_CONFIG_DIR，再 ~/.config/claude-code，最後 ~/.claude）。若你使用自訂的 CLAUDE_CONFIG_DIR，請在此設定——從 Finder 啟動的應用程式不會繼承 shell 環境變數。修改後請重新啟動 CodeIsland。", + "claude_config_dir_placeholder": "自動偵測", + "claude_config_dir_resolved": "目前使用：%@", // Webhook 轉發 "webhook_title": "Webhook 轉發", diff --git a/Sources/CodeIsland/RemoteInstaller.swift b/Sources/CodeIsland/RemoteInstaller.swift index 0bbfb0f2..a051c301 100644 --- a/Sources/CodeIsland/RemoteInstaller.swift +++ b/Sources/CodeIsland/RemoteInstaller.swift @@ -530,8 +530,23 @@ def _merge_traecli_hooks(contents, cmd): merged += "\\n" return merged +def claude_config_dir(): + # Mirrors ClaudeConfigPaths on the macOS side: $CLAUDE_CONFIG_DIR wins, then a + # ~/.claude that Claude Code actually populated, then the XDG-style location. + # projects/ is the only reliable liveness marker — settings.json may be ours. + env = (os.environ.get("CLAUDE_CONFIG_DIR") or "").strip() + if env: + return pathlib.Path(os.path.expanduser(env)) + dot_claude = home / ".claude" + if (dot_claude / "projects").exists(): + return dot_claude + xdg = home / ".config" / "claude-code" + if (xdg / "projects").exists(): + return xdg + return dot_claude + def install_claude(): - claude_root = home / ".claude" + claude_root = claude_config_dir() if not claude_root.exists() and shutil.which("claude") is None: return "Claude skipped" diff --git a/Sources/CodeIslandCore/ClaudeConfigPaths.swift b/Sources/CodeIslandCore/ClaudeConfigPaths.swift index daffd11f..53a5dd32 100644 --- a/Sources/CodeIslandCore/ClaudeConfigPaths.swift +++ b/Sources/CodeIslandCore/ClaudeConfigPaths.swift @@ -17,14 +17,49 @@ public enum ClaudeConfigPaths { /// UserDefaults key backing the Settings field. public static let preferenceKey = "claude_config_dir" + private static let cacheLock = NSLock() + private static var cachedKey: String? + private static var cachedValue: String? + /// Absolute path to the resolved Claude config directory (no trailing slash). + /// + /// Called per session per refresh tick, so the filesystem probes in `resolve` are + /// memoized. The cache is keyed on the *inputs* (preference, environment, home) + /// rather than being a one-shot latch: reading them is cheap and in-memory, while + /// the probes are syscalls. That keeps the Settings live-preview correct — typing a + /// new preference changes the key and re-resolves immediately — while the steady + /// state costs no stat() at all. + /// + /// Only filesystem *layout* changes are missed until the inputs change or the app + /// restarts, which matches the Settings copy ("Restart CodeIsland after changing"). public static func configDir() -> String { - resolve( - preference: UserDefaults.standard.string(forKey: preferenceKey), - environment: ProcessInfo.processInfo.environment["CLAUDE_CONFIG_DIR"], - homeDir: NSHomeDirectory(), + let pref = UserDefaults.standard.string(forKey: preferenceKey) + let env = ProcessInfo.processInfo.environment["CLAUDE_CONFIG_DIR"] + let home = NSHomeDirectory() + let key = [pref ?? "", env ?? "", home].joined(separator: "\u{0}") + + cacheLock.lock() + defer { cacheLock.unlock() } + if key == cachedKey, let cachedValue { return cachedValue } + + let resolved = resolve( + preference: pref, + environment: env, + homeDir: home, fileExists: { FileManager.default.fileExists(atPath: $0) } ) + cachedKey = key + cachedValue = resolved + return resolved + } + + /// Drop the memoized resolution. Call after creating or moving a config directory + /// within the app's lifetime; not needed for preference edits, which re-key the cache. + public static func invalidateCache() { + cacheLock.lock() + defer { cacheLock.unlock() } + cachedKey = nil + cachedValue = nil } /// Where per-project transcripts live. @@ -43,9 +78,17 @@ public enum ClaudeConfigPaths { ) -> String { if let pref = normalized(preference, homeDir: homeDir) { return pref } if let env = normalized(environment, homeDir: homeDir) { return env } + + // Claude Code itself has no XDG rung — it reads $CLAUDE_CONFIG_DIR, else ~/.claude. + // So a live ~/.claude must win over the XDG probe, or a stale ~/.config/claude-code + // would silently repoint us away from the directory Claude Code actually reads. + let dotClaude = homeDir + "/.claude" + if isLiveConfigDir(dotClaude, fileExists: fileExists) { return dotClaude } + let xdg = homeDir + "/.config/claude-code" - if looksLikeConfigDir(xdg, fileExists: fileExists) { return xdg } - return homeDir + "/.claude" + if isLiveConfigDir(xdg, fileExists: fileExists) { return xdg } + + return dotClaude } /// User-visible form — collapses the home prefix back to `~` so Settings and @@ -55,11 +98,15 @@ public enum ClaudeConfigPaths { return "~" + absolute.dropFirst(homeDir.count) } - /// A directory only counts as a Claude config dir if it actually holds Claude state. - /// Without this, an empty `~/.config/claude-code` created by some other tool would - /// shadow a perfectly good `~/.claude`. - static func looksLikeConfigDir(_ path: String, fileExists: (String) -> Bool) -> Bool { - ["projects", "settings.json"].contains { fileExists(path + "/" + $0) } + /// A directory only counts as a live Claude config dir if it holds `projects/`. + /// + /// `projects/` is written only by Claude Code itself, which makes it the sole reliable + /// proof. `settings.json` deliberately does NOT count: CodeIsland's own hook installer + /// creates that file, so treating it as evidence would let us manufacture the very + /// signal we then read back — an empty `~/.claude` containing nothing but a + /// CodeIsland-written `settings.json` would outrank the user's real config dir forever. + static func isLiveConfigDir(_ path: String, fileExists: (String) -> Bool) -> Bool { + fileExists(path + "/projects") } /// Trims, expands `~`, and drops any trailing slash. Returns nil for empty input. @@ -76,6 +123,14 @@ public enum ClaudeConfigPaths { if value == "~" { return homeDir.precomposedStringWithCanonicalMapping } if value.hasPrefix("~/") { value = homeDir + "/" + value.dropFirst(2) } while value.count > 1 && value.hasSuffix("/") { value.removeLast() } + + // Reject anything that cannot be a config dir. A relative path would resolve + // against the app's cwd, and `/` would yield "//projects" — in both cases the + // hook installer would happily `createDirectory` at the bogus location and then + // report success while Claude Code read somewhere else entirely. Falling through + // to auto-detect is strictly better than acting on a typo. + guard value.hasPrefix("/"), value != "/" else { return nil } + return value.precomposedStringWithCanonicalMapping } } diff --git a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift index e975c591..08127deb 100644 --- a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift +++ b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift @@ -51,6 +51,42 @@ final class ClaudeConfigPathsTests: XCTestCase { XCTAssertEqual(result, "/Users/tester/.claude") } + /// Claude Code has no XDG rung — it reads $CLAUDE_CONFIG_DIR or ~/.claude. So when + /// BOTH are populated and nothing points elsewhere, ~/.claude must win, or a stale + /// XDG dir would silently repoint us away from what Claude Code actually reads. + func testLiveDotClaudeOutranksPopulatedXDGDirectory() { + let result = ClaudeConfigPaths.resolve( + preference: nil, environment: nil, homeDir: home, + fileExists: { $0 == "/Users/tester/.claude/projects" + || $0 == "/Users/tester/.config/claude-code/projects" }) + XCTAssertEqual(result, "/Users/tester/.claude") + } + + /// A settings.json alone must NOT mark a dir live — CodeIsland's own hook installer + /// writes that file, so counting it would let us manufacture the signal we read back. + func testSettingsJsonAloneDoesNotMarkDirectoryLive() { + let result = ClaudeConfigPaths.resolve( + preference: nil, environment: nil, homeDir: home, + fileExists: { $0 == "/Users/tester/.claude/settings.json" + || $0 == "/Users/tester/.config/claude-code/projects" }) + XCTAssertEqual(result, "/Users/tester/.config/claude-code") + } + + /// A typo'd or relative value must fall through to auto-detect rather than being + /// taken literally — the hook installer would otherwise create the bogus directory + /// and report success while Claude Code read somewhere else. + func testUnusableValuesFallThroughToAutoDetect() { + XCTAssertNil(ClaudeConfigPaths.normalized("claude-config", homeDir: home)) + XCTAssertNil(ClaudeConfigPaths.normalized("./claude", homeDir: home)) + XCTAssertNil(ClaudeConfigPaths.normalized("/", homeDir: home)) + + // A bad preference must not win — resolution continues down the chain. + let result = ClaudeConfigPaths.resolve( + preference: "relative/typo", environment: nil, homeDir: home, + fileExists: { $0 == "/Users/tester/.config/claude-code/projects" }) + XCTAssertEqual(result, "/Users/tester/.config/claude-code") + } + func testEmptyAndWhitespaceValuesAreIgnored() { XCTAssertNil(ClaudeConfigPaths.normalized("", homeDir: home)) XCTAssertNil(ClaudeConfigPaths.normalized(" ", homeDir: home)) diff --git a/Tests/CodeIslandTests/ClaudeConfigPathsWiringTests.swift b/Tests/CodeIslandTests/ClaudeConfigPathsWiringTests.swift new file mode 100644 index 00000000..842e6c87 --- /dev/null +++ b/Tests/CodeIslandTests/ClaudeConfigPathsWiringTests.swift @@ -0,0 +1,33 @@ +import XCTest +import CodeIslandCore +@testable import CodeIsland + +/// Guards the seams between `ClaudeConfigPaths` (CodeIslandCore) and the app targets +/// that depend on it. Both contracts below are enforced only by convention in the +/// source, so a rename or a dropped override would otherwise fail silently at runtime. +final class ClaudeConfigPathsWiringTests: XCTestCase { + + /// The preference key literal is duplicated: `SettingsKey.claudeConfigDir` drives the + /// @AppStorage field, `ClaudeConfigPaths.preferenceKey` is what the resolver reads. + /// If they drift, the Settings field silently stops affecting resolution — the user + /// types a path, the UI accepts it, and nothing changes. + func testSettingsKeyMatchesResolverPreferenceKey() { + XCTAssertEqual(SettingsKey.claudeConfigDir, ClaudeConfigPaths.preferenceKey) + } + + /// The Claude CLIConfig carries `configPath: "settings.json"` — correct ONLY because + /// `rootOverride` supplies the config dir. Drop the override and `fullPath` silently + /// becomes `~/settings.json`: it would not error, it would write hooks into the + /// user's home directory. Pin the resolved path to the resolver's own answer. + func testClaudeConfigPathResolvesThroughRootOverride() throws { + let claude = try XCTUnwrap( + ConfigInstaller.allCLIs.first { $0.source == "claude" }, + "built-in Claude CLIConfig is missing") + + XCTAssertEqual(claude.fullPath, ClaudeConfigPaths.settingsPath()) + XCTAssertEqual(claude.dirPath, ClaudeConfigPaths.configDir()) + XCTAssertNotEqual( + claude.fullPath, NSHomeDirectory() + "/settings.json", + "rootOverride was dropped — hooks would be written to the home directory") + } +} diff --git a/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift b/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift index 8832af08..a23c24db 100644 --- a/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift +++ b/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift @@ -30,6 +30,9 @@ final class RemoteInstallerHookMergeTests: XCTestCase { environment["HOME"] = sandboxHome.path // Keep the script away from any real Codex home configured in the caller env. environment.removeValue(forKey: "CODEX_HOME") + // Same for Claude: the script now honors $CLAUDE_CONFIG_DIR, which would escape + // the sandboxed HOME and write hooks into the developer's real config dir. + environment.removeValue(forKey: "CLAUDE_CONFIG_DIR") process.environment = environment let stdin = Pipe() From 01b573c803970c86faf1c5cd9e8c8139f07ddf4d Mon Sep 17 00:00:00 2001 From: Shane McCarron Date: Sun, 19 Jul 2026 09:44:37 -0500 Subject: [PATCH 4/5] fix: address QA round 2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round 2 reviewed round 1's fixes and found them incomplete in several places. Two corrections to the round-1 commit message first, since it overstated what that commit did: - It said the RemoteInstaller guard "let a custom-config user through ... It now mirrors the resolver." Only `claude_root` changed; the guard line was untouched, and `git diff` shows it as context. The guard bug was described as fixed when it was not. - "Mirrors the resolver" was also wrong for the resolver itself: the Python applied no absoluteness check, no trailing-slash strip, and no NFC normalization, so it accepted exactly the relative values round-1 F3 was raised to reject. Both are now actually fixed. The guard no longer treats `claude` on PATH as licence to CREATE a config dir when resolution merely fell through to the ~/.claude default — that planted a stale directory on the remote host which the local sweep cannot reach. R2-F3 (major) — the stale-hook sweep only knew two hardcoded home candidates, so a dir previously resolved via the preference or $CLAUDE_CONFIG_DIR was never swept and its entries fired forever against a deleted hook script. The resolved dir is now persisted at install time and included in the candidate set, which covers custom-to-custom and custom-to-default transitions. R2-F9 (minor) — that filter compared an NFC-normalized configDir() against hand-built literals; a decomposed home path could let the *resolved* dir slip through and be swept, deleting the hooks just installed. Both sides are now canonicalized. R2-F5/F6 (major) — all six localized descriptions and the type's own header doc still stated the pre-F1 resolution order, so every locale told the user something the code stopped doing. R2-F4 (major) — the sweep rewrites files on disk outside the resolved dir and had zero tests. Split the per-directory logic out and specced it: the marker guard leaves an unrelated settings.json byte-identical, our entries are stripped while user entries survive, a missing file is a no-op. R2-F8 (minor) — testUnicodePathsAreNormalizedToNFC was vacuous. Swift compares Strings by canonical equivalence, so it passed with the normalization deleted. It now compares UTF-8 bytes; verified against a stripped implementation. R2-F7 (minor) — invalidateCache() had no caller; wired into install(). R2-F10 (observation) — the remote hook read transcripts from ~/.claude/projects, so fixing the installer delivered no end-to-end benefit. It now resolves the same way. 564 tests, 0 failures. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01YL1NKtwrKxPSxkBEuKGWNW --- Sources/CodeIsland/ConfigInstaller.swift | 67 +++++++++--- Sources/CodeIsland/L10n.swift | 12 +-- Sources/CodeIsland/RemoteInstaller.swift | 29 +++-- .../codeisland-remote-hook.cpython-314.pyc | Bin 0 -> 13987 bytes .../Resources/codeisland-remote-hook.py | 22 +++- .../CodeIslandCore/ClaudeConfigPaths.swift | 18 +++- .../ClaudeConfigPathsTests.swift | 9 +- .../ClaudeStaleHookSweepTests.swift | 101 ++++++++++++++++++ 8 files changed, 226 insertions(+), 32 deletions(-) create mode 100644 Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc create mode 100644 Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift diff --git a/Sources/CodeIsland/ConfigInstaller.swift b/Sources/CodeIsland/ConfigInstaller.swift index 5e4b8359..bfad5add 100644 --- a/Sources/CodeIsland/ConfigInstaller.swift +++ b/Sources/CodeIsland/ConfigInstaller.swift @@ -751,9 +751,15 @@ struct ConfigInstaller { try? fm.removeItem(atPath: legacyBridgePath) try? fm.removeItem(atPath: legacyHookScriptPath) + // A previous install may have created the config dir after the last resolution + // was memoized, so re-resolve before deciding what is stale. + ClaudeConfigPaths.invalidateCache() + // Drop hook entries orphaned at a config dir we no longer resolve to, so the - // old copy cannot keep firing alongside the new one. + // old copy cannot keep firing alongside the new one. Runs BEFORE the per-CLI + // install below, so entries written this pass are never swept. cleanStaleClaudeHooks(fm: fm) + rememberResolvedClaudeDir() // Install hook script + bridge binary (shared by all CLIs) installHookScript(fm: fm) @@ -813,30 +819,65 @@ struct ConfigInstaller { /// preference, exports `$CLAUDE_CONFIG_DIR`, or upgrades into the XDG rung). Hook /// entries left at the old location would otherwise keep firing while being /// unreachable by uninstall — install and uninstall must stay symmetric. + /// Where the last install actually wrote Claude hooks. Without this, a config dir + /// reached via the preference or `$CLAUDE_CONFIG_DIR` is unrecoverable once the + /// resolution changes: it is not one of the two home candidates, so nothing would + /// ever sweep it and its entries would fire forever against a deleted hook script. + static let lastResolvedClaudeDirKey = "claude_config_dir_last_installed" + private static func staleClaudeConfigDirs() -> [String] { - let resolved = ClaudeConfigPaths.configDir() + let resolved = ClaudeConfigPaths.canonical(ClaudeConfigPaths.configDir()) let home = NSHomeDirectory() - return [home + "/.claude", home + "/.config/claude-code"].filter { $0 != resolved } + var candidates = [home + "/.claude", home + "/.config/claude-code"] + if let last = UserDefaults.standard.string(forKey: lastResolvedClaudeDirKey) { + candidates.append(last) + } + // Compare canonically: configDir() is NFC-normalized while the literals above + // are not, so a decomposed home path could otherwise let the *resolved* dir slip + // through the filter and be swept — deleting the hooks we just installed. + var seen = Set() + return candidates + .map(ClaudeConfigPaths.canonical) + .filter { $0 != resolved && seen.insert($0).inserted } + } + + /// Record where hooks were just installed, so a later resolution change can find them. + private static func rememberResolvedClaudeDir() { + UserDefaults.standard.set( + ClaudeConfigPaths.canonical(ClaudeConfigPaths.configDir()), + forKey: lastResolvedClaudeDirKey) } /// Strip CodeIsland hook entries from Claude `settings.json` files outside the /// currently resolved config dir. Only touches files that actually carry our /// marker, so an unrelated user settings.json is never rewritten. static func cleanStaleClaudeHooks(fm: FileManager) { - guard let claude = builtInCLIs.first(where: { $0.source == "claude" }) else { return } for dir in staleClaudeConfigDirs() { - var stale = claude - stale.rootOverride = { dir } - let path = stale.fullPath - guard fm.fileExists(atPath: path), - let data = fm.contents(atPath: path), - let text = String(data: data, encoding: .utf8), - text.contains("codeisland") - else { continue } - uninstallHooks(cli: stale, fm: fm) + cleanClaudeHooks(inDir: dir, fm: fm) } } + /// Strip CodeIsland hook entries from the Claude `settings.json` in `dir`. + /// + /// No-op unless the file exists AND carries our marker, so an unrelated user + /// `settings.json` sitting in a candidate directory is never rewritten. Returns + /// whether the file was modified. Split out from `cleanStaleClaudeHooks` so this + /// destructive path is directly testable against a temporary directory. + @discardableResult + static func cleanClaudeHooks(inDir dir: String, fm: FileManager) -> Bool { + guard let claude = builtInCLIs.first(where: { $0.source == "claude" }) else { return false } + var stale = claude + stale.rootOverride = { dir } + let path = stale.fullPath + guard fm.fileExists(atPath: path), + let data = fm.contents(atPath: path), + let text = String(data: data, encoding: .utf8), + text.contains("codeisland") + else { return false } + uninstallHooks(cli: stale, fm: fm) + return true + } + static func uninstall() { let fm = FileManager.default try? fm.removeItem(atPath: hookScriptPath) diff --git a/Sources/CodeIsland/L10n.swift b/Sources/CodeIsland/L10n.swift index ec5af76f..c1c45c77 100644 --- a/Sources/CodeIsland/L10n.swift +++ b/Sources/CodeIsland/L10n.swift @@ -150,7 +150,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "Comma-separated substrings. Any hook event whose working directory contains one of them is silently dropped — useful for filtering out background plugins like claude-mem. Example: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "e.g. .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code Config Directory", - "claude_config_dir_desc": "Where Claude Code keeps projects/ and settings.json. Leave empty to auto-detect ($CLAUDE_CONFIG_DIR, then ~/.config/claude-code, then ~/.claude). Set this if you use a custom CLAUDE_CONFIG_DIR — a Finder-launched app does not inherit your shell environment. Restart CodeIsland after changing.", + "claude_config_dir_desc": "Where Claude Code keeps projects/ and settings.json. Leave empty to auto-detect ($CLAUDE_CONFIG_DIR, then whichever of ~/.claude or ~/.config/claude-code actually holds your projects, preferring ~/.claude). Set this if you use a custom CLAUDE_CONFIG_DIR — a Finder-launched app does not inherit your shell environment. Restart CodeIsland after changing.", "claude_config_dir_placeholder": "auto-detect", "claude_config_dir_resolved": "Currently using: %@", @@ -834,7 +834,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "用逗号分隔的子串。任何 hook 事件的工作目录如果包含其中之一就会被静默丢弃 —— 适合过滤 claude-mem 等后台插件。示例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例如 .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code 配置目录", - "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空则自动检测（先 $CLAUDE_CONFIG_DIR，再 ~/.config/claude-code，最后 ~/.claude）。如果你使用自定义的 CLAUDE_CONFIG_DIR，请在此设置——从访达启动的应用不会继承 shell 环境变量。修改后请重启 CodeIsland。", + "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空则自动检测（先 $CLAUDE_CONFIG_DIR，再是确实包含 projects/ 的 ~/.claude，最后 ~/.config/claude-code）。如果你使用自定义的 CLAUDE_CONFIG_DIR，请在此设置——从访达启动的应用不会继承 shell 环境变量。修改后请重启 CodeIsland。", "claude_config_dir_placeholder": "自动检测", "claude_config_dir_resolved": "当前使用：%@", @@ -1178,7 +1178,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "以逗號分隔的子字串。任何 hook 事件的工作目錄如果包含其中之一就會被靜默丟棄 —— 適合過濾 claude-mem 等背景外掛。範例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例如 .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code 設定目錄", - "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空則自動偵測（先 $CLAUDE_CONFIG_DIR，再 ~/.config/claude-code，最後 ~/.claude）。若你使用自訂的 CLAUDE_CONFIG_DIR，請在此設定——從 Finder 啟動的應用程式不會繼承 shell 環境變數。修改後請重新啟動 CodeIsland。", + "claude_config_dir_desc": "Claude Code 存放 projects/ 和 settings.json 的位置。留空則自動偵測（先 $CLAUDE_CONFIG_DIR，再是確實包含 projects/ 的 ~/.claude，最後 ~/.config/claude-code）。若你使用自訂的 CLAUDE_CONFIG_DIR，請在此設定——從 Finder 啟動的應用程式不會繼承 shell 環境變數。修改後請重新啟動 CodeIsland。", "claude_config_dir_placeholder": "自動偵測", "claude_config_dir_resolved": "目前使用：%@", @@ -1522,7 +1522,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "カンマ区切りの部分文字列。作業ディレクトリにいずれかを含む hook イベントは静かに破棄されます。claude-mem 等のバックグラウンドプラグイン除外に便利です。例：.claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "例: .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code 設定ディレクトリ", - "claude_config_dir_desc": "Claude Code が projects/ と settings.json を保存する場所。空欄の場合は自動検出します（$CLAUDE_CONFIG_DIR、次に ~/.config/claude-code、次に ~/.claude）。カスタムの CLAUDE_CONFIG_DIR を使用している場合は設定してください。Finder から起動したアプリはシェルの環境変数を継承しません。変更後は CodeIsland を再起動してください。", + "claude_config_dir_desc": "Claude Code が projects/ と settings.json を保存する場所。空欄の場合は自動検出します（$CLAUDE_CONFIG_DIR、次に projects/ が実在する ~/.claude、次に ~/.config/claude-code の順）。カスタムの CLAUDE_CONFIG_DIR を使用している場合は設定してください。Finder から起動したアプリはシェルの環境変数を継承しません。変更後は CodeIsland を再起動してください。", "claude_config_dir_placeholder": "自動検出", "claude_config_dir_resolved": "現在の使用先: %@", @@ -1866,7 +1866,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "쉼표로 구분된 부분 문자열. 작업 디렉터리에 하나라도 포함된 hook 이벤트는 조용히 폐기됩니다. claude-mem 같은 백그라운드 플러그인 필터링에 유용합니다. 예: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "예: .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code 설정 디렉터리", - "claude_config_dir_desc": "Claude Code가 projects/ 및 settings.json을 저장하는 위치입니다. 비워 두면 자동으로 감지합니다($CLAUDE_CONFIG_DIR, 그다음 ~/.config/claude-code, 그다음 ~/.claude). 사용자 지정 CLAUDE_CONFIG_DIR을 사용하는 경우 설정하세요. Finder에서 실행된 앱은 셸 환경 변수를 상속하지 않습니다. 변경 후 CodeIsland를 다시 시작하세요.", + "claude_config_dir_desc": "Claude Code가 projects/ 및 settings.json을 저장하는 위치입니다. 비워 두면 자동으로 감지합니다($CLAUDE_CONFIG_DIR, 그다음 projects/가 실제로 있는 ~/.claude, 그다음 ~/.config/claude-code). 사용자 지정 CLAUDE_CONFIG_DIR을 사용하는 경우 설정하세요. Finder에서 실행된 앱은 셸 환경 변수를 상속하지 않습니다. 변경 후 CodeIsland를 다시 시작하세요.", "claude_config_dir_placeholder": "자동 감지", "claude_config_dir_resolved": "현재 사용 중: %@", @@ -2210,7 +2210,7 @@ final class L10n: ObservableObject { "excluded_hook_cwd_desc": "Virgülle ayrılmış alt dizeler. Çalışma dizini bunlardan birini içeren hook olayları sessizce yok sayılır — claude-mem gibi arka plan eklentilerini filtrelemek için kullanışlı. Örn: .claude-mem,.cache/agents", "excluded_hook_cwd_placeholder": "örn. .claude-mem,.cache/agents", "claude_config_dir_title": "Claude Code Yapılandırma Dizini", - "claude_config_dir_desc": "Claude Code'un projects/ ve settings.json dosyalarını sakladığı yer. Otomatik algılama için boş bırakın ($CLAUDE_CONFIG_DIR, ardından ~/.config/claude-code, ardından ~/.claude). Özel bir CLAUDE_CONFIG_DIR kullanıyorsanız bunu ayarlayın; Finder'dan başlatılan bir uygulama kabuk ortam değişkenlerini devralmaz. Değişiklikten sonra CodeIsland'ı yeniden başlatın.", + "claude_config_dir_desc": "Claude Code'un projects/ ve settings.json dosyalarını sakladığı yer. Otomatik algılama için boş bırakın ($CLAUDE_CONFIG_DIR, ardından projects/ klasörünü gerçekten içeren ~/.claude, ardından ~/.config/claude-code). Özel bir CLAUDE_CONFIG_DIR kullanıyorsanız bunu ayarlayın; Finder'dan başlatılan bir uygulama kabuk ortam değişkenlerini devralmaz. Değişiklikten sonra CodeIsland'ı yeniden başlatın.", "claude_config_dir_placeholder": "otomatik algıla", "claude_config_dir_resolved": "Şu anda kullanılan: %@", diff --git a/Sources/CodeIsland/RemoteInstaller.swift b/Sources/CodeIsland/RemoteInstaller.swift index a051c301..68258f55 100644 --- a/Sources/CodeIsland/RemoteInstaller.swift +++ b/Sources/CodeIsland/RemoteInstaller.swift @@ -144,6 +144,7 @@ import pathlib import shutil import os import re +import unicodedata home = pathlib.Path.home() hook_path = home / ".codeisland" / "codeisland-remote-hook.py" @@ -531,22 +532,34 @@ def _merge_traecli_hooks(contents, cmd): return merged def claude_config_dir(): - # Mirrors ClaudeConfigPaths on the macOS side: $CLAUDE_CONFIG_DIR wins, then a - # ~/.claude that Claude Code actually populated, then the XDG-style location. - # projects/ is the only reliable liveness marker — settings.json may be ours. + # Mirrors ClaudeConfigPaths on the macOS side, including its input validation: + # $CLAUDE_CONFIG_DIR wins (only when usable), then a ~/.claude that Claude Code + # actually populated, then the XDG-style location. projects/ is the only reliable + # liveness marker — settings.json may be one we wrote ourselves. + # Returns (path, resolved_from_env). env = (os.environ.get("CLAUDE_CONFIG_DIR") or "").strip() if env: - return pathlib.Path(os.path.expanduser(env)) + env = os.path.expanduser(env).rstrip("/") or "/" + # Reject anything that cannot be a config dir. A relative value would resolve + # against the SSH session's cwd and we would silently write hooks there. + if env.startswith("/") and env != "/": + return pathlib.Path(unicodedata.normalize("NFC", env)), True dot_claude = home / ".claude" if (dot_claude / "projects").exists(): - return dot_claude + return dot_claude, False xdg = home / ".config" / "claude-code" if (xdg / "projects").exists(): - return xdg - return dot_claude + return xdg, False + return dot_claude, False def install_claude(): - claude_root = claude_config_dir() + claude_root, from_env = claude_config_dir() + # Only treat `claude` on PATH as licence to CREATE a config dir when we know where + # it belongs (an explicit $CLAUDE_CONFIG_DIR). Otherwise resolution merely fell + # through to the ~/.claude default, and creating it would plant a stale directory + # the user's Claude Code never reads — and which the local sweep cannot reach. + if not claude_root.exists() and not from_env: + return "Claude skipped" if not claude_root.exists() and shutil.which("claude") is None: return "Claude skipped" diff --git a/Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc b/Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16b46b7d45b29a74361e8600ac2d310b3947b44a GIT binary patch literal 13987 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 String { + path.precomposedStringWithCanonicalMapping + } + /// Drop the memoized resolution. Call after creating or moving a config directory /// within the app's lifetime; not needed for preference edits, which re-key the cache. public static func invalidateCache() { diff --git a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift index 08127deb..4f45a024 100644 --- a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift +++ b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift @@ -115,7 +115,14 @@ final class ClaudeConfigPathsTests: XCTestCase { func testUnicodePathsAreNormalizedToNFC() { let decomposed = "/Users/tester/Cafe\u{0301}/claude" // e + combining acute let precomposed = "/Users/tester/Caf\u{00E9}/claude" // é - XCTAssertEqual(ClaudeConfigPaths.normalized(decomposed, homeDir: home), precomposed) + + let result = try? XCTUnwrap(ClaudeConfigPaths.normalized(decomposed, homeDir: home)) + + // Compare BYTES, not Strings. Swift's == on String uses canonical equivalence, + // so `decomposed == precomposed` is already true and an XCTAssertEqual here + // would pass even if the normalization were deleted entirely. + XCTAssertEqual(Array((result ?? "").utf8), Array(precomposed.utf8)) + XCTAssertNotEqual(Array((result ?? "").utf8), Array(decomposed.utf8)) } func testDisplayPathCollapsesHomePrefix() { diff --git a/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift b/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift new file mode 100644 index 00000000..ad7316b0 --- /dev/null +++ b/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift @@ -0,0 +1,101 @@ +import XCTest +import CodeIslandCore +@testable import CodeIsland + +/// Covers the cross-directory stale-hook sweep. This path REWRITES files on disk +/// outside the currently resolved config dir, so its guard rails need specs: a +/// regression here silently strips or corrupts a real user `settings.json`. +final class ClaudeStaleHookSweepTests: XCTestCase { + private var dir: URL! + private let fm = FileManager.default + + override func setUpWithError() throws { + dir = fm.temporaryDirectory.appendingPathComponent("stale-hooks-" + UUID().uuidString) + try fm.createDirectory(at: dir, withIntermediateDirectories: true) + } + + override func tearDownWithError() throws { + try? fm.removeItem(at: dir) + } + + private func writeSettings(_ json: [String: Any]) throws { + let data = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted) + try data.write(to: dir.appendingPathComponent("settings.json")) + } + + private func readSettings() throws -> [String: Any] { + let data = try Data(contentsOf: dir.appendingPathComponent("settings.json")) + return try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any]) + } + + private func commands(_ settings: [String: Any], event: String) -> [String] { + let hooks = (settings["hooks"] as? [String: Any]) ?? [:] + let entries = (hooks[event] as? [[String: Any]]) ?? [] + return entries.flatMap { entry -> [String] in + ((entry["hooks"] as? [[String: Any]]) ?? []).compactMap { $0["command"] as? String } + } + } + + /// The marker guard: a settings.json with no CodeIsland entries must be left + /// byte-identical. Without this the sweep would rewrite (and reformat) an + /// unrelated user config every time it ran. + func testSettingsWithoutOurMarkerIsLeftUntouched() throws { + try writeSettings(["hooks": ["SessionStart": [ + ["hooks": [["type": "command", "command": "echo user-hook", "timeout": 5]]], + ]]]) + let before = try Data(contentsOf: dir.appendingPathComponent("settings.json")) + + let modified = ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm) + + XCTAssertFalse(modified, "a file without our marker must not be reported as modified") + let after = try Data(contentsOf: dir.appendingPathComponent("settings.json")) + XCTAssertEqual(before, after, "unrelated settings.json was rewritten") + } + + /// The actual sweep: our entries go, the user's survive. + func testOurHooksAreStrippedAndUserHooksSurvive() throws { + try writeSettings(["hooks": ["SessionStart": [ + ["hooks": [["type": "command", "command": "echo keep-me", "timeout": 5]]], + ["hooks": [["type": "command", "command": "~/.codeisland/codeisland-bridge --source claude", "timeout": 5]]], + ]]]) + + let modified = ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm) + + XCTAssertTrue(modified) + let cmds = commands(try readSettings(), event: "SessionStart") + XCTAssertTrue(cmds.contains { $0.contains("keep-me") }, "user hook was wiped: \(cmds)") + XCTAssertFalse(cmds.contains { $0.contains("codeisland") }, "our hook survived: \(cmds)") + } + + /// A directory with no settings.json at all is a no-op, not a crash or a created file. + func testMissingSettingsFileIsANoOp() { + let empty = dir.appendingPathComponent("nonexistent").path + XCTAssertFalse(ConfigInstaller.cleanClaudeHooks(inDir: empty, fm: fm)) + XCTAssertFalse(fm.fileExists(atPath: empty + "/settings.json")) + } + + /// The sweep must never target the directory we are currently installing into — + /// that would delete the hooks just written. `staleClaudeConfigDirs` is private, + /// so assert the property it exists to guarantee. + func testResolvedDirIsNeverSwept() throws { + let resolved = ClaudeConfigPaths.configDir() + try writeSettings(["hooks": ["SessionStart": [ + ["hooks": [["type": "command", "command": "~/.codeisland/codeisland-bridge --source claude"]]], + ]]]) + + // Sanity: the temp dir is not the resolved dir, so sweeping it is legitimate. + XCTAssertNotEqual(ClaudeConfigPaths.canonical(dir.path), + ClaudeConfigPaths.canonical(resolved)) + XCTAssertTrue(ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm)) + } + + /// Canonical comparison guards the filter: configDir() is NFC-normalized while the + /// candidate literals are hand-built, so a decomposed home path must still compare + /// equal or the resolved dir could slip through and be swept. + func testCanonicalFormMatchesAcrossUnicodeForms() { + let decomposed = "/Users/tester/Cafe\u{0301}/.claude" + let precomposed = "/Users/tester/Caf\u{00E9}/.claude" + XCTAssertEqual(Array(ClaudeConfigPaths.canonical(decomposed).utf8), + Array(ClaudeConfigPaths.canonical(precomposed).utf8)) + } +} From ddaef6ff524bc53c02d7be94b87b6d97d4fd4129 Mon Sep 17 00:00:00 2001 From: Shane McCarron Date: Sun, 19 Jul 2026 09:57:47 -0500 Subject: [PATCH 5/5] refactor: narrow PR to the core config-dir fix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three QA rounds found 33 findings. The finding rate did not decline (4, 7, 4 majors), but their location was consistent: the resolver and its call sites stabilized after round 1, while every major since came from scope added while responding to review comments — the remote installer and the stale-hook sweep. Those two areas produced 10 of the 12 majors in rounds 2 and 3. Round 3 made the case plainly. The round-2 "fix" to the remote installer guard placed an early return ahead of the pre-existing shutil.which check, making it unreachable and silently turning "installs hooks into ~/.claude" into "installs nothing" for any host with Claude Code present but not yet run. That is a regression against main, in code this PR does not need, that cannot be verified without a remote host. So this commit removes that scope rather than iterating on it again: - RemoteInstaller.swift, codeisland-remote-hook.py and RemoteInstallerHookMergeTests revert to origin/main. - The cross-directory stale-hook sweep and its last-resolved-dir persistence are removed, along with ClaudeStaleHookSweepTests. What remains is the fix issue #269 actually asks for: the resolver, the six local call sites, the hook-install location, the Settings field, and their tests. It is verified end-to-end on a real machine and has produced no majors since round 1. Known limitation, documented on the PR and deferred to a follow-up issue: a user who changes their resolved config dir after installing hooks will have entries left behind at the old location. That is the pre-existing behavior for every other CLI in ConfigInstaller, it is not a regression, and the sweep that attempted to fix it was itself the source of five majors. Also carried forward from round 3: - isLiveConfigDir now requires projects/ to be a DIRECTORY. fileExists is true for a regular file of that name, so a stray file could mark a config dir live. Covered by a test against a real temp tree — asserting it through the injected probe would have proved nothing, since that injection is exactly what abstracts the distinction away. - Removed a __pycache__/*.pyc committed by an earlier syntax check and shipped inside the app bundle; added it to .gitignore. 560 tests, 0 failures. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01YL1NKtwrKxPSxkBEuKGWNW --- .gitignore | 4 + Sources/CodeIsland/ConfigInstaller.swift | 77 +------------ Sources/CodeIsland/RemoteInstaller.swift | 30 +----- .../codeisland-remote-hook.cpython-314.pyc | Bin 13987 -> 0 bytes .../Resources/codeisland-remote-hook.py | 22 +--- .../CodeIslandCore/ClaudeConfigPaths.swift | 22 ++-- .../ClaudeConfigPathsTests.swift | 39 +++++-- .../ClaudeStaleHookSweepTests.swift | 101 ------------------ .../RemoteInstallerHookMergeTests.swift | 3 - 9 files changed, 56 insertions(+), 242 deletions(-) delete mode 100644 Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc delete mode 100644 Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift diff --git a/.gitignore b/.gitignore index 07984226..7f357815 100644 --- a/.gitignore +++ b/.gitignore @@ -70,3 +70,7 @@ skills/ skills-lock.json CLAUDE.md build-dir/ + +# Python bytecode from local syntax checks +__pycache__/ +*.pyc diff --git a/Sources/CodeIsland/ConfigInstaller.swift b/Sources/CodeIsland/ConfigInstaller.swift index bfad5add..1d7728de 100644 --- a/Sources/CodeIsland/ConfigInstaller.swift +++ b/Sources/CodeIsland/ConfigInstaller.swift @@ -751,16 +751,10 @@ struct ConfigInstaller { try? fm.removeItem(atPath: legacyBridgePath) try? fm.removeItem(atPath: legacyHookScriptPath) - // A previous install may have created the config dir after the last resolution - // was memoized, so re-resolve before deciding what is stale. + // A previous run may have created the Claude config dir after the resolution was + // memoized, so re-resolve before installing into it. ClaudeConfigPaths.invalidateCache() - // Drop hook entries orphaned at a config dir we no longer resolve to, so the - // old copy cannot keep firing alongside the new one. Runs BEFORE the per-CLI - // install below, so entries written this pass are never swept. - cleanStaleClaudeHooks(fm: fm) - rememberResolvedClaudeDir() - // Install hook script + bridge binary (shared by all CLIs) installHookScript(fm: fm) installBridgeBinary(fm: fm) @@ -813,71 +807,6 @@ struct ConfigInstaller { return ok } - /// Claude config dirs we may have written hooks into under a *previous* resolution. - /// - /// The resolved dir can change between install and uninstall (the user fills in the - /// preference, exports `$CLAUDE_CONFIG_DIR`, or upgrades into the XDG rung). Hook - /// entries left at the old location would otherwise keep firing while being - /// unreachable by uninstall — install and uninstall must stay symmetric. - /// Where the last install actually wrote Claude hooks. Without this, a config dir - /// reached via the preference or `$CLAUDE_CONFIG_DIR` is unrecoverable once the - /// resolution changes: it is not one of the two home candidates, so nothing would - /// ever sweep it and its entries would fire forever against a deleted hook script. - static let lastResolvedClaudeDirKey = "claude_config_dir_last_installed" - - private static func staleClaudeConfigDirs() -> [String] { - let resolved = ClaudeConfigPaths.canonical(ClaudeConfigPaths.configDir()) - let home = NSHomeDirectory() - var candidates = [home + "/.claude", home + "/.config/claude-code"] - if let last = UserDefaults.standard.string(forKey: lastResolvedClaudeDirKey) { - candidates.append(last) - } - // Compare canonically: configDir() is NFC-normalized while the literals above - // are not, so a decomposed home path could otherwise let the *resolved* dir slip - // through the filter and be swept — deleting the hooks we just installed. - var seen = Set() - return candidates - .map(ClaudeConfigPaths.canonical) - .filter { $0 != resolved && seen.insert($0).inserted } - } - - /// Record where hooks were just installed, so a later resolution change can find them. - private static func rememberResolvedClaudeDir() { - UserDefaults.standard.set( - ClaudeConfigPaths.canonical(ClaudeConfigPaths.configDir()), - forKey: lastResolvedClaudeDirKey) - } - - /// Strip CodeIsland hook entries from Claude `settings.json` files outside the - /// currently resolved config dir. Only touches files that actually carry our - /// marker, so an unrelated user settings.json is never rewritten. - static func cleanStaleClaudeHooks(fm: FileManager) { - for dir in staleClaudeConfigDirs() { - cleanClaudeHooks(inDir: dir, fm: fm) - } - } - - /// Strip CodeIsland hook entries from the Claude `settings.json` in `dir`. - /// - /// No-op unless the file exists AND carries our marker, so an unrelated user - /// `settings.json` sitting in a candidate directory is never rewritten. Returns - /// whether the file was modified. Split out from `cleanStaleClaudeHooks` so this - /// destructive path is directly testable against a temporary directory. - @discardableResult - static func cleanClaudeHooks(inDir dir: String, fm: FileManager) -> Bool { - guard let claude = builtInCLIs.first(where: { $0.source == "claude" }) else { return false } - var stale = claude - stale.rootOverride = { dir } - let path = stale.fullPath - guard fm.fileExists(atPath: path), - let data = fm.contents(atPath: path), - let text = String(data: data, encoding: .utf8), - text.contains("codeisland") - else { return false } - uninstallHooks(cli: stale, fm: fm) - return true - } - static func uninstall() { let fm = FileManager.default try? fm.removeItem(atPath: hookScriptPath) @@ -885,8 +814,6 @@ struct ConfigInstaller { // Also clean up legacy paths (#32) try? fm.removeItem(atPath: legacyBridgePath) try? fm.removeItem(atPath: legacyHookScriptPath) - // Remove entries orphaned at a previously-resolved config dir - cleanStaleClaudeHooks(fm: fm) for cli in allCLIs { if cli.source == "traecli" { diff --git a/Sources/CodeIsland/RemoteInstaller.swift b/Sources/CodeIsland/RemoteInstaller.swift index 68258f55..0bbfb0f2 100644 --- a/Sources/CodeIsland/RemoteInstaller.swift +++ b/Sources/CodeIsland/RemoteInstaller.swift @@ -144,7 +144,6 @@ import pathlib import shutil import os import re -import unicodedata home = pathlib.Path.home() hook_path = home / ".codeisland" / "codeisland-remote-hook.py" @@ -531,35 +530,8 @@ def _merge_traecli_hooks(contents, cmd): merged += "\\n" return merged -def claude_config_dir(): - # Mirrors ClaudeConfigPaths on the macOS side, including its input validation: - # $CLAUDE_CONFIG_DIR wins (only when usable), then a ~/.claude that Claude Code - # actually populated, then the XDG-style location. projects/ is the only reliable - # liveness marker — settings.json may be one we wrote ourselves. - # Returns (path, resolved_from_env). - env = (os.environ.get("CLAUDE_CONFIG_DIR") or "").strip() - if env: - env = os.path.expanduser(env).rstrip("/") or "/" - # Reject anything that cannot be a config dir. A relative value would resolve - # against the SSH session's cwd and we would silently write hooks there. - if env.startswith("/") and env != "/": - return pathlib.Path(unicodedata.normalize("NFC", env)), True - dot_claude = home / ".claude" - if (dot_claude / "projects").exists(): - return dot_claude, False - xdg = home / ".config" / "claude-code" - if (xdg / "projects").exists(): - return xdg, False - return dot_claude, False - def install_claude(): - claude_root, from_env = claude_config_dir() - # Only treat `claude` on PATH as licence to CREATE a config dir when we know where - # it belongs (an explicit $CLAUDE_CONFIG_DIR). Otherwise resolution merely fell - # through to the ~/.claude default, and creating it would plant a stale directory - # the user's Claude Code never reads — and which the local sweep cannot reach. - if not claude_root.exists() and not from_env: - return "Claude skipped" + claude_root = home / ".claude" if not claude_root.exists() and shutil.which("claude") is None: return "Claude skipped" diff --git a/Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc b/Sources/CodeIsland/Resources/__pycache__/codeisland-remote-hook.cpython-314.pyc deleted file mode 100644 index 16b46b7d45b29a74361e8600ac2d310b3947b44a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13987 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 Bool { + var isDir: ObjCBool = false + let exists = FileManager.default.fileExists(atPath: path, isDirectory: &isDir) + return exists && isDir.boolValue + } + /// Canonical NFC form of a path, for comparing two paths for identity. /// /// `configDir()` returns an NFC-normalized value, so a caller comparing it against a @@ -88,7 +96,7 @@ public enum ClaudeConfigPaths { preference: String?, environment: String?, homeDir: String, - fileExists: (String) -> Bool + directoryExists: (String) -> Bool ) -> String { if let pref = normalized(preference, homeDir: homeDir) { return pref } if let env = normalized(environment, homeDir: homeDir) { return env } @@ -97,10 +105,10 @@ public enum ClaudeConfigPaths { // So a live ~/.claude must win over the XDG probe, or a stale ~/.config/claude-code // would silently repoint us away from the directory Claude Code actually reads. let dotClaude = homeDir + "/.claude" - if isLiveConfigDir(dotClaude, fileExists: fileExists) { return dotClaude } + if isLiveConfigDir(dotClaude, directoryExists: directoryExists) { return dotClaude } let xdg = homeDir + "/.config/claude-code" - if isLiveConfigDir(xdg, fileExists: fileExists) { return xdg } + if isLiveConfigDir(xdg, directoryExists: directoryExists) { return xdg } return dotClaude } @@ -119,8 +127,10 @@ public enum ClaudeConfigPaths { /// creates that file, so treating it as evidence would let us manufacture the very /// signal we then read back — an empty `~/.claude` containing nothing but a /// CodeIsland-written `settings.json` would outrank the user's real config dir forever. - static func isLiveConfigDir(_ path: String, fileExists: (String) -> Bool) -> Bool { - fileExists(path + "/projects") + /// Note this asks whether `projects` is a DIRECTORY, not merely that the path + /// exists — a stray regular file of that name must not mark a config dir live. + static func isLiveConfigDir(_ path: String, directoryExists: (String) -> Bool) -> Bool { + directoryExists(path + "/projects") } /// Trims, expands `~`, and drops any trailing slash. Returns nil for empty input. diff --git a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift index 4f45a024..f48bd228 100644 --- a/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift +++ b/Tests/CodeIslandCoreTests/ClaudeConfigPathsTests.swift @@ -7,7 +7,7 @@ final class ClaudeConfigPathsTests: XCTestCase { /// Nothing exists anywhere → the historical `~/.claude` default. func testFallsBackToDotClaudeWhenNothingSet() { let result = ClaudeConfigPaths.resolve( - preference: nil, environment: nil, homeDir: home, fileExists: { _ in false }) + preference: nil, environment: nil, homeDir: home, directoryExists: { _ in false }) XCTAssertEqual(result, "/Users/tester/.claude") } @@ -18,7 +18,7 @@ final class ClaudeConfigPathsTests: XCTestCase { preference: nil, environment: "/Users/tester/.config/claude-code", homeDir: home, - fileExists: { _ in false }) + directoryExists: { _ in false }) XCTAssertEqual(result, "/Users/tester/.config/claude-code") } @@ -29,7 +29,7 @@ final class ClaudeConfigPathsTests: XCTestCase { preference: "/explicit/dir", environment: "/env/dir", homeDir: home, - fileExists: { _ in true }) + directoryExists: { _ in true }) XCTAssertEqual(result, "/explicit/dir") } @@ -38,7 +38,7 @@ final class ClaudeConfigPathsTests: XCTestCase { func testProbesXDGDirectoryWhenPopulated() { let result = ClaudeConfigPaths.resolve( preference: nil, environment: nil, homeDir: home, - fileExists: { $0 == "/Users/tester/.config/claude-code/projects" }) + directoryExists: { $0 == "/Users/tester/.config/claude-code/projects" }) XCTAssertEqual(result, "/Users/tester/.config/claude-code") } @@ -47,7 +47,7 @@ final class ClaudeConfigPathsTests: XCTestCase { func testEmptyXDGDirectoryDoesNotShadowDotClaude() { let result = ClaudeConfigPaths.resolve( preference: nil, environment: nil, homeDir: home, - fileExists: { $0 == "/Users/tester/.config/claude-code" }) + directoryExists: { $0 == "/Users/tester/.config/claude-code" }) XCTAssertEqual(result, "/Users/tester/.claude") } @@ -57,7 +57,7 @@ final class ClaudeConfigPathsTests: XCTestCase { func testLiveDotClaudeOutranksPopulatedXDGDirectory() { let result = ClaudeConfigPaths.resolve( preference: nil, environment: nil, homeDir: home, - fileExists: { $0 == "/Users/tester/.claude/projects" + directoryExists: { $0 == "/Users/tester/.claude/projects" || $0 == "/Users/tester/.config/claude-code/projects" }) XCTAssertEqual(result, "/Users/tester/.claude") } @@ -67,7 +67,7 @@ final class ClaudeConfigPathsTests: XCTestCase { func testSettingsJsonAloneDoesNotMarkDirectoryLive() { let result = ClaudeConfigPaths.resolve( preference: nil, environment: nil, homeDir: home, - fileExists: { $0 == "/Users/tester/.claude/settings.json" + directoryExists: { $0 == "/Users/tester/.claude/settings.json" || $0 == "/Users/tester/.config/claude-code/projects" }) XCTAssertEqual(result, "/Users/tester/.config/claude-code") } @@ -83,10 +83,33 @@ final class ClaudeConfigPathsTests: XCTestCase { // A bad preference must not win — resolution continues down the chain. let result = ClaudeConfigPaths.resolve( preference: "relative/typo", environment: nil, homeDir: home, - fileExists: { $0 == "/Users/tester/.config/claude-code/projects" }) + directoryExists: { $0 == "/Users/tester/.config/claude-code/projects" }) XCTAssertEqual(result, "/Users/tester/.config/claude-code") } + /// A stray regular FILE named `projects` must not mark a config dir live. This + /// exercises the REAL filesystem probe against a real temp tree — asserting it via + /// the injected `directoryExists` would prove nothing, since the injection is + /// precisely what abstracts the file-vs-directory distinction away. + func testRegularFileNamedProjectsIsNotTreatedAsLive() throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent("ccp-" + UUID().uuidString) + let asDir = root.appendingPathComponent("dir") + let asFile = root.appendingPathComponent("file") + try fm.createDirectory(at: asDir.appendingPathComponent("projects"), + withIntermediateDirectories: true) + try fm.createDirectory(at: asFile, withIntermediateDirectories: true) + try Data("not a directory".utf8) + .write(to: asFile.appendingPathComponent("projects")) + defer { try? fm.removeItem(at: root) } + + XCTAssertTrue(ClaudeConfigPaths.isLiveConfigDir( + asDir.path, directoryExists: ClaudeConfigPaths.defaultDirectoryExists)) + XCTAssertFalse(ClaudeConfigPaths.isLiveConfigDir( + asFile.path, directoryExists: ClaudeConfigPaths.defaultDirectoryExists), + "a regular file named projects must not mark the dir live") + } + func testEmptyAndWhitespaceValuesAreIgnored() { XCTAssertNil(ClaudeConfigPaths.normalized("", homeDir: home)) XCTAssertNil(ClaudeConfigPaths.normalized(" ", homeDir: home)) diff --git a/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift b/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift deleted file mode 100644 index ad7316b0..00000000 --- a/Tests/CodeIslandTests/ClaudeStaleHookSweepTests.swift +++ /dev/null @@ -1,101 +0,0 @@ -import XCTest -import CodeIslandCore -@testable import CodeIsland - -/// Covers the cross-directory stale-hook sweep. This path REWRITES files on disk -/// outside the currently resolved config dir, so its guard rails need specs: a -/// regression here silently strips or corrupts a real user `settings.json`. -final class ClaudeStaleHookSweepTests: XCTestCase { - private var dir: URL! - private let fm = FileManager.default - - override func setUpWithError() throws { - dir = fm.temporaryDirectory.appendingPathComponent("stale-hooks-" + UUID().uuidString) - try fm.createDirectory(at: dir, withIntermediateDirectories: true) - } - - override func tearDownWithError() throws { - try? fm.removeItem(at: dir) - } - - private func writeSettings(_ json: [String: Any]) throws { - let data = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted) - try data.write(to: dir.appendingPathComponent("settings.json")) - } - - private func readSettings() throws -> [String: Any] { - let data = try Data(contentsOf: dir.appendingPathComponent("settings.json")) - return try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any]) - } - - private func commands(_ settings: [String: Any], event: String) -> [String] { - let hooks = (settings["hooks"] as? [String: Any]) ?? [:] - let entries = (hooks[event] as? [[String: Any]]) ?? [] - return entries.flatMap { entry -> [String] in - ((entry["hooks"] as? [[String: Any]]) ?? []).compactMap { $0["command"] as? String } - } - } - - /// The marker guard: a settings.json with no CodeIsland entries must be left - /// byte-identical. Without this the sweep would rewrite (and reformat) an - /// unrelated user config every time it ran. - func testSettingsWithoutOurMarkerIsLeftUntouched() throws { - try writeSettings(["hooks": ["SessionStart": [ - ["hooks": [["type": "command", "command": "echo user-hook", "timeout": 5]]], - ]]]) - let before = try Data(contentsOf: dir.appendingPathComponent("settings.json")) - - let modified = ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm) - - XCTAssertFalse(modified, "a file without our marker must not be reported as modified") - let after = try Data(contentsOf: dir.appendingPathComponent("settings.json")) - XCTAssertEqual(before, after, "unrelated settings.json was rewritten") - } - - /// The actual sweep: our entries go, the user's survive. - func testOurHooksAreStrippedAndUserHooksSurvive() throws { - try writeSettings(["hooks": ["SessionStart": [ - ["hooks": [["type": "command", "command": "echo keep-me", "timeout": 5]]], - ["hooks": [["type": "command", "command": "~/.codeisland/codeisland-bridge --source claude", "timeout": 5]]], - ]]]) - - let modified = ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm) - - XCTAssertTrue(modified) - let cmds = commands(try readSettings(), event: "SessionStart") - XCTAssertTrue(cmds.contains { $0.contains("keep-me") }, "user hook was wiped: \(cmds)") - XCTAssertFalse(cmds.contains { $0.contains("codeisland") }, "our hook survived: \(cmds)") - } - - /// A directory with no settings.json at all is a no-op, not a crash or a created file. - func testMissingSettingsFileIsANoOp() { - let empty = dir.appendingPathComponent("nonexistent").path - XCTAssertFalse(ConfigInstaller.cleanClaudeHooks(inDir: empty, fm: fm)) - XCTAssertFalse(fm.fileExists(atPath: empty + "/settings.json")) - } - - /// The sweep must never target the directory we are currently installing into — - /// that would delete the hooks just written. `staleClaudeConfigDirs` is private, - /// so assert the property it exists to guarantee. - func testResolvedDirIsNeverSwept() throws { - let resolved = ClaudeConfigPaths.configDir() - try writeSettings(["hooks": ["SessionStart": [ - ["hooks": [["type": "command", "command": "~/.codeisland/codeisland-bridge --source claude"]]], - ]]]) - - // Sanity: the temp dir is not the resolved dir, so sweeping it is legitimate. - XCTAssertNotEqual(ClaudeConfigPaths.canonical(dir.path), - ClaudeConfigPaths.canonical(resolved)) - XCTAssertTrue(ConfigInstaller.cleanClaudeHooks(inDir: dir.path, fm: fm)) - } - - /// Canonical comparison guards the filter: configDir() is NFC-normalized while the - /// candidate literals are hand-built, so a decomposed home path must still compare - /// equal or the resolved dir could slip through and be swept. - func testCanonicalFormMatchesAcrossUnicodeForms() { - let decomposed = "/Users/tester/Cafe\u{0301}/.claude" - let precomposed = "/Users/tester/Caf\u{00E9}/.claude" - XCTAssertEqual(Array(ClaudeConfigPaths.canonical(decomposed).utf8), - Array(ClaudeConfigPaths.canonical(precomposed).utf8)) - } -} diff --git a/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift b/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift index a23c24db..8832af08 100644 --- a/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift +++ b/Tests/CodeIslandTests/RemoteInstallerHookMergeTests.swift @@ -30,9 +30,6 @@ final class RemoteInstallerHookMergeTests: XCTestCase { environment["HOME"] = sandboxHome.path // Keep the script away from any real Codex home configured in the caller env. environment.removeValue(forKey: "CODEX_HOME") - // Same for Claude: the script now honors $CLAUDE_CONFIG_DIR, which would escape - // the sandboxed HOME and write hooks into the developer's real config dir. - environment.removeValue(forKey: "CLAUDE_CONFIG_DIR") process.environment = environment let stdin = Pipe()