Skip to content

Commit 7ffbfbb

Browse files
setup: Preserve Claude settings symlinks and report install failures
Keep symlink-managed Claude settings untouched and classify read, write, path, and invalid-settings outcomes instead of collapsing them into a generic skip. Surface actionable diagnostics and avoid repository authorization lookups when installation did not succeed. Co-authored-by: SCE <sce@crocoder.dev>
1 parent 59a41d9 commit 7ffbfbb

2 files changed

Lines changed: 192 additions & 30 deletions

File tree

‎cli/src/services/setup/claude_telemetry.rs‎

Lines changed: 160 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,15 @@ const SKIPPED_HELPER_SETTING_LINE: &str =
4444
const SKIPPED_MANAGED_LINE: &str =
4545
"Claude telemetry: skipped; managed Claude settings own the telemetry configuration.";
4646
const SKIPPED_INVALID_LINE: &str =
47-
"Claude telemetry: skipped; existing Claude settings could not be parsed and were left unchanged.";
47+
"Claude telemetry: skipped; existing Claude settings contain invalid JSON or an invalid structure and were left unchanged. Fix the settings, then rerun 'sce setup'.";
48+
const SKIPPED_SYMLINK_LINE: &str =
49+
"Claude telemetry: skipped; settings.json is symlink-managed and was left unchanged. Update the telemetry settings at their source (for example Nix or Home Manager), then rerun 'sce setup'.";
50+
const INSTALL_READ_FAILED_LINE: &str =
51+
"Claude telemetry: failed to read Claude settings. Check settings files and directory permissions, then rerun 'sce setup'.";
52+
const INSTALL_WRITE_FAILED_LINE: &str =
53+
"Claude telemetry: failed to write Claude settings. Check directory permissions and available disk space, then rerun 'sce setup'.";
54+
const SETTINGS_PATH_UNAVAILABLE_LINE: &str =
55+
"Claude telemetry: could not resolve the Claude settings path. Set CLAUDE_CONFIG_DIR, then rerun 'sce setup'.";
4856
pub(crate) const CLAUDE_TELEMETRY_DISABLED_BY_CONFIG_LINE: &str =
4957
"Claude telemetry: skipped; SCE telemetry is disabled by config.";
5058

@@ -76,8 +84,13 @@ const MANAGED_NOTE_LINE: &str =
7684
#[derive(Debug, Eq, PartialEq)]
7785
pub(crate) enum ClaudeTelemetryInstallOutcome {
7886
Configured,
87+
AlreadyCurrent,
7988
SkippedConflict(ClaudeTelemetrySkipReason),
8089
SkippedInvalid,
90+
SkippedSymlink,
91+
ReadFailed,
92+
WriteFailed,
93+
SettingsPathUnavailable,
8194
}
8295

8396
pub(crate) fn resolve_claude_settings_path() -> Option<PathBuf> {
@@ -101,22 +114,46 @@ pub(crate) fn managed_claude_settings_path() -> PathBuf {
101114
pub(crate) fn install_claude_telemetry(
102115
settings_path: &Path,
103116
managed_settings_path: &Path,
104-
) -> Result<ClaudeTelemetryInstallOutcome> {
105-
let existing = read_optional(settings_path)?;
106-
let managed = read_optional(managed_settings_path).unwrap_or(None);
117+
) -> ClaudeTelemetryInstallOutcome {
118+
let is_symlink = match fs::symlink_metadata(settings_path) {
119+
Ok(metadata) => metadata.file_type().is_symlink(),
120+
Err(error) if error.kind() == std::io::ErrorKind::NotFound => false,
121+
Err(_) => return ClaudeTelemetryInstallOutcome::ReadFailed,
122+
};
123+
let existing = match read_optional(settings_path) {
124+
Ok(None) if is_symlink => return ClaudeTelemetryInstallOutcome::SkippedSymlink,
125+
Ok(existing) => existing,
126+
Err(_) => return ClaudeTelemetryInstallOutcome::ReadFailed,
127+
};
128+
let Ok(managed) = read_optional(managed_settings_path) else {
129+
return ClaudeTelemetryInstallOutcome::ReadFailed;
130+
};
107131
let source_path = settings_path.display().to_string();
108132

109133
match merge_claude_telemetry_settings(existing.as_deref(), managed.as_deref(), &source_path) {
110-
Err(_) => Ok(ClaudeTelemetryInstallOutcome::SkippedInvalid),
134+
Err(_) => ClaudeTelemetryInstallOutcome::SkippedInvalid,
111135
Ok(ClaudeTelemetryMergeOutcome::AlreadyCurrent) => {
112-
Ok(ClaudeTelemetryInstallOutcome::Configured)
136+
ClaudeTelemetryInstallOutcome::AlreadyCurrent
113137
}
114138
Ok(ClaudeTelemetryMergeOutcome::Skipped(reason)) => {
115-
Ok(ClaudeTelemetryInstallOutcome::SkippedConflict(reason))
139+
ClaudeTelemetryInstallOutcome::SkippedConflict(reason)
116140
}
117141
Ok(ClaudeTelemetryMergeOutcome::Installed(bytes)) => {
118-
write_atomically(settings_path, &bytes)?;
119-
Ok(ClaudeTelemetryInstallOutcome::Configured)
142+
if is_symlink {
143+
return ClaudeTelemetryInstallOutcome::SkippedSymlink;
144+
}
145+
match fs::symlink_metadata(settings_path) {
146+
Ok(metadata) if metadata.file_type().is_symlink() => {
147+
return ClaudeTelemetryInstallOutcome::SkippedSymlink;
148+
}
149+
Ok(_) => {}
150+
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
151+
Err(_) => return ClaudeTelemetryInstallOutcome::ReadFailed,
152+
}
153+
match write_atomically(settings_path, &bytes) {
154+
Ok(()) => ClaudeTelemetryInstallOutcome::Configured,
155+
Err(_) => ClaudeTelemetryInstallOutcome::WriteFailed,
156+
}
120157
}
121158
}
122159
}
@@ -133,7 +170,8 @@ pub(crate) fn format_claude_telemetry_report(
133170
authorization: RepositoryAuthorization,
134171
) -> String {
135172
match outcome {
136-
ClaudeTelemetryInstallOutcome::Configured => match authorization {
173+
ClaudeTelemetryInstallOutcome::Configured
174+
| ClaudeTelemetryInstallOutcome::AlreadyCurrent => match authorization {
137175
RepositoryAuthorization::Authorized => CONFIGURED_LINE.to_string(),
138176
RepositoryAuthorization::Unauthorized => {
139177
format!("{CONFIGURED_LINE}\n{NOT_READY_LINE}")
@@ -144,6 +182,12 @@ pub(crate) fn format_claude_telemetry_report(
144182
skipped_conflict_line(*reason).to_string()
145183
}
146184
ClaudeTelemetryInstallOutcome::SkippedInvalid => SKIPPED_INVALID_LINE.to_string(),
185+
ClaudeTelemetryInstallOutcome::SkippedSymlink => SKIPPED_SYMLINK_LINE.to_string(),
186+
ClaudeTelemetryInstallOutcome::ReadFailed => INSTALL_READ_FAILED_LINE.to_string(),
187+
ClaudeTelemetryInstallOutcome::WriteFailed => INSTALL_WRITE_FAILED_LINE.to_string(),
188+
ClaudeTelemetryInstallOutcome::SettingsPathUnavailable => {
189+
SETTINGS_PATH_UNAVAILABLE_LINE.to_string()
190+
}
147191
}
148192
}
149193

@@ -353,13 +397,101 @@ mod tests {
353397
serde_json::from_slice(&fs::read(path).unwrap()).unwrap()
354398
}
355399

400+
#[cfg(unix)]
401+
#[test]
402+
fn claude_telemetry_install_preserves_symlinks_and_their_targets() {
403+
use std::os::unix::fs::{symlink, MetadataExt};
404+
405+
for case in ["needs_changes", "dangling", "already_current"] {
406+
let dir = tempfile::tempdir().unwrap();
407+
let settings = dir.path().join("settings.json");
408+
let target = dir.path().join("source.json");
409+
let managed = dir.path().join("managed.json");
410+
if case == "already_current" {
411+
assert_eq!(
412+
install_claude_telemetry(&target, &managed),
413+
ClaudeTelemetryInstallOutcome::Configured
414+
);
415+
} else if case == "needs_changes" {
416+
fs::write(&target, b"{\"env\":{\"KEEP\":\"me\"}}\n").unwrap();
417+
}
418+
symlink(&target, &settings).unwrap();
419+
let snapshot = |path: &Path| {
420+
fs::symlink_metadata(path).ok().map(|metadata| {
421+
(
422+
metadata.ino(),
423+
metadata.mode(),
424+
metadata.mtime(),
425+
metadata.mtime_nsec(),
426+
metadata.ctime(),
427+
metadata.ctime_nsec(),
428+
)
429+
})
430+
};
431+
let link_before = snapshot(&settings);
432+
let target_before = snapshot(&target);
433+
let bytes_before = fs::read(&target).ok();
434+
435+
let outcome = install_claude_telemetry(&settings, &managed);
436+
437+
assert_eq!(
438+
outcome,
439+
if case == "already_current" {
440+
ClaudeTelemetryInstallOutcome::AlreadyCurrent
441+
} else {
442+
ClaudeTelemetryInstallOutcome::SkippedSymlink
443+
},
444+
"{case}"
445+
);
446+
assert_eq!(fs::read_link(&settings).unwrap(), target);
447+
assert_eq!(snapshot(&settings), link_before, "{case}");
448+
assert_eq!(snapshot(&target), target_before, "{case}");
449+
assert_eq!(fs::read(&target).ok(), bytes_before, "{case}");
450+
assert!(!settings.with_extension("json.sce-tmp").exists());
451+
}
452+
}
453+
454+
#[test]
455+
fn claude_telemetry_install_classifies_filesystem_failures() {
456+
for case in ["user_read", "managed_read", "write"] {
457+
let dir = tempfile::tempdir().unwrap();
458+
let settings = dir.path().join("settings.json");
459+
let managed = dir.path().join("managed.json");
460+
if case == "user_read" {
461+
fs::create_dir(&settings).unwrap();
462+
} else {
463+
fs::write(&settings, b"{}").unwrap();
464+
if case == "managed_read" {
465+
fs::create_dir(&managed).unwrap();
466+
} else {
467+
fs::create_dir(settings.with_extension("json.sce-tmp")).unwrap();
468+
}
469+
}
470+
let outcome = install_claude_telemetry(&settings, &managed);
471+
assert_eq!(
472+
outcome,
473+
if case == "write" {
474+
ClaudeTelemetryInstallOutcome::WriteFailed
475+
} else {
476+
ClaudeTelemetryInstallOutcome::ReadFailed
477+
},
478+
"{case}"
479+
);
480+
if case == "user_read" {
481+
assert!(settings.is_dir());
482+
} else {
483+
assert_eq!(fs::read(&settings).unwrap(), b"{}");
484+
}
485+
}
486+
}
487+
356488
#[test]
357489
fn claude_telemetry_install_writes_env_and_helper_idempotently() {
358490
let dir = tempfile::tempdir().unwrap();
359491
let settings = dir.path().join("claude").join("settings.json");
360492
let managed = dir.path().join("managed.json");
361493

362-
let outcome = install_claude_telemetry(&settings, &managed).unwrap();
494+
let outcome = install_claude_telemetry(&settings, &managed);
363495
assert_eq!(outcome, ClaudeTelemetryInstallOutcome::Configured);
364496
let first = fs::read(&settings).unwrap();
365497
let parsed: Value = serde_json::from_slice(&first).unwrap();
@@ -369,7 +501,10 @@ mod tests {
369501
.unwrap()
370502
.contains(FIXTURE_TOKEN));
371503

372-
install_claude_telemetry(&settings, &managed).unwrap();
504+
assert_eq!(
505+
install_claude_telemetry(&settings, &managed),
506+
ClaudeTelemetryInstallOutcome::AlreadyCurrent
507+
);
373508
assert_eq!(fs::read(&settings).unwrap(), first);
374509
}
375510

@@ -392,7 +527,7 @@ mod tests {
392527
.unwrap();
393528
fs::set_permissions(&settings, fs::Permissions::from_mode(0o640)).unwrap();
394529

395-
install_claude_telemetry(&settings, &managed).unwrap();
530+
install_claude_telemetry(&settings, &managed);
396531

397532
let parsed = read_json(&settings);
398533
assert_eq!(parsed["permissions"]["allow"][0], "Bash(ls)");
@@ -410,7 +545,7 @@ mod tests {
410545

411546
let dir = tempfile::tempdir().unwrap();
412547
let settings = dir.path().join("settings.json");
413-
install_claude_telemetry(&settings, &dir.path().join("managed.json")).unwrap();
548+
install_claude_telemetry(&settings, &dir.path().join("managed.json"));
414549
assert_eq!(
415550
fs::metadata(&settings).unwrap().permissions().mode() & 0o777,
416551
0o600
@@ -424,8 +559,7 @@ mod tests {
424559
let original = serde_json::to_vec(&json!({"otelHeadersHelper": "my-helper"})).unwrap();
425560
fs::write(&settings, &original).unwrap();
426561

427-
let outcome =
428-
install_claude_telemetry(&settings, &dir.path().join("managed.json")).unwrap();
562+
let outcome = install_claude_telemetry(&settings, &dir.path().join("managed.json"));
429563

430564
assert!(matches!(
431565
outcome,
@@ -436,15 +570,16 @@ mod tests {
436570

437571
#[test]
438572
fn claude_telemetry_install_refuses_malformed_json_without_overwriting() {
439-
let dir = tempfile::tempdir().unwrap();
440-
let settings = dir.path().join("settings.json");
441-
fs::write(&settings, b"{ not json").unwrap();
573+
for original in [b"{ not json".as_slice(), b"[]", b"{\"env\": []}"] {
574+
let dir = tempfile::tempdir().unwrap();
575+
let settings = dir.path().join("settings.json");
576+
fs::write(&settings, original).unwrap();
442577

443-
let outcome =
444-
install_claude_telemetry(&settings, &dir.path().join("managed.json")).unwrap();
578+
let outcome = install_claude_telemetry(&settings, &dir.path().join("managed.json"));
445579

446-
assert_eq!(outcome, ClaudeTelemetryInstallOutcome::SkippedInvalid);
447-
assert_eq!(fs::read(&settings).unwrap(), b"{ not json");
580+
assert_eq!(outcome, ClaudeTelemetryInstallOutcome::SkippedInvalid);
581+
assert_eq!(fs::read(&settings).unwrap(), original);
582+
}
448583
}
449584

450585
#[test]
@@ -458,7 +593,7 @@ mod tests {
458593
)
459594
.unwrap();
460595

461-
let outcome = install_claude_telemetry(&settings, &managed).unwrap();
596+
let outcome = install_claude_telemetry(&settings, &managed);
462597

463598
assert!(matches!(
464599
outcome,
@@ -475,8 +610,7 @@ mod tests {
475610
serde_json::to_vec(&json!({"env": {"CLAUDE_CODE_ENABLE_TELEMETRY": "0"}})).unwrap();
476611
fs::write(&settings, &original).unwrap();
477612

478-
let outcome =
479-
install_claude_telemetry(&settings, &dir.path().join("managed.json")).unwrap();
613+
let outcome = install_claude_telemetry(&settings, &dir.path().join("managed.json"));
480614

481615
assert_eq!(
482616
outcome,

‎cli/src/services/setup/command.rs‎

Lines changed: 32 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -680,12 +680,15 @@ where
680680
}
681681

682682
let installed = match settings_path {
683-
Some(settings_path) => install_claude_telemetry(settings_path, managed_settings_path)
684-
.unwrap_or(ClaudeTelemetryInstallOutcome::SkippedInvalid),
685-
None => ClaudeTelemetryInstallOutcome::SkippedInvalid,
683+
Some(settings_path) => install_claude_telemetry(settings_path, managed_settings_path),
684+
None => ClaudeTelemetryInstallOutcome::SettingsPathUnavailable,
686685
};
687686
let authorization = match (&installed, authorization_check) {
688-
(ClaudeTelemetryInstallOutcome::Configured, RepositoryAuthorizationCheck::Verify) => {
687+
(
688+
ClaudeTelemetryInstallOutcome::Configured
689+
| ClaudeTelemetryInstallOutcome::AlreadyCurrent,
690+
RepositoryAuthorizationCheck::Verify,
691+
) => {
689692
if repository_authorized().await {
690693
RepositoryAuthorization::Authorized
691694
} else {
@@ -881,9 +884,34 @@ mod tests {
881884

882885
const CLAUDE_CONFIGURED_LINE: &str =
883886
"Claude telemetry: configured in user-level Claude settings for native OpenTelemetry export.";
887+
884888
const CLAUDE_NOT_READY_LINE: &str = "Claude telemetry: not ready for this repository; no valid SCE telemetry credential is authorized for it, so Claude will not export. Run 'sce auth login' in this repository with the SCE account it is enrolled under.";
885889
const CLAUDE_NOT_CHECKED_LINE: &str = "Claude telemetry: configured; repository authorization was not checked during non-interactive setup.";
886890

891+
#[test]
892+
fn setup_claude_telemetry_reports_install_failures_without_authorization_lookup() {
893+
for (case, expected) in [
894+
("read", "Claude telemetry: failed to read Claude settings. Check settings files and directory permissions, then rerun 'sce setup'."),
895+
("write", "Claude telemetry: failed to write Claude settings. Check directory permissions and available disk space, then rerun 'sce setup'."),
896+
("invalid", "Claude telemetry: skipped; existing Claude settings contain invalid JSON or an invalid structure and were left unchanged. Fix the settings, then rerun 'sce setup'."),
897+
] {
898+
let dir = tempfile::tempdir().unwrap();
899+
let settings = dir.path().join("settings.json");
900+
match case {
901+
"read" => fs::create_dir(&settings).unwrap(),
902+
"write" => fs::create_dir(settings.with_extension("json.sce-tmp")).unwrap(),
903+
"invalid" => fs::write(&settings, b"{fixture-secret-token").unwrap(),
904+
_ => unreachable!(),
905+
}
906+
let (report, looked_up) = render_claude_telemetry(
907+
true, &settings, &dir.path().join("managed.json"),
908+
RepositoryAuthorizationCheck::Verify, None,
909+
);
910+
assert_eq!(report, expected, "{case}");
911+
assert!(!looked_up, "{case}");
912+
}
913+
}
914+
887915
fn assert_installed(root: &Path) {
888916
let parsed: Value =
889917
serde_json::from_slice(&fs::read(root.join("settings.json")).unwrap()).unwrap();

0 commit comments

Comments
 (0)