Repair downloads created files' blobs

A default (diff-mode) `repair` downloaded only diff archives, but a
diff has no delta for a file the patch creates. After such a repair
`apply --offline` still could not apply a patch that creates files.

In diff mode, repair now also downloads the blobs of created files
(and lists them under `--offline` and `--dry-run`), reported as
their own blob download.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzdTEhubve9yWfqBE7vAsB

Author: claude

crates/socket-patch-cli/src/commands/repair.rs

@@ -14,6 +14,7 @@ use std::path::Path;
 use std::time::Duration;
 
 use crate::args::{apply_env_toggles, parse_bool_flag, GlobalArgs};
+use crate::commands::fetch_stage::files_diffs_cannot_cover;
 use crate::commands::lock_cli::{acquire_or_emit, error_envelope};
 use crate::commands::rollback::{sweep_failure, sweep_unused_artifacts};
 use crate::json_envelope::{Command, Envelope, PatchAction, PatchEvent, Status};
@@ -341,6 +342,100 @@ fn format_final_line(
     }
 }
 
+/// The `.socket/` source directories a download pass writes into.
+struct SourcePaths<'a> {
+    blobs: &'a Path,
+    packages: &'a Path,
+    diffs: &'a Path,
+}
+
+/// What one download pass did: how many artifacts were missing, and how
+/// many of them it downloaded or failed to.
+#[derive(Default)]
+struct DownloadPass {
+    missing: usize,
+    downloaded: usize,
+    failed: usize,
+}
+
+/// Step 1's pass over `missing` (non-empty), the `mode` artifacts `m`
+/// references: the `--offline` warning, the `--dry-run` preview, or the
+/// download and its result lines.
+async fn download_pass(
+    args: &RepairArgs,
+    client: &mut Option<ApiClient>,
+    m: &socket_patch_core::manifest::schema::PatchManifest,
+    missing: &[String],
+    mode: DownloadMode,
+    paths: &SourcePaths<'_>,
+) -> DownloadPass {
+    let quiet = args.common.json || args.common.silent;
+    let noun = mode.noun();
+    let mut pass = DownloadPass {
+        missing: missing.len(),
+        ..DownloadPass::default()
+    };
+    if args.common.offline {
+        if !quiet {
+            eprintln!("{}", format_offline_warning(missing, noun));
+        }
+        return pass;
+    }
+    if !quiet {
+        println!("{}", format_found_missing(missing.len(), noun));
+    }
+    if args.common.dry_run {
+        if !quiet {
+            println!();
+            println!("Would download:");
+            for line in format_id_list(missing, noun, DRY_RUN_LIST_CAP) {
+                println!("{line}");
+            }
+        }
+        return pass;
+    }
+    let mut status = crate::ui::StatusLine::stderr(args.common.json, args.common.silent);
+    status.set(format!("Downloading {}...", noun.count(missing.len())));
+    if client.is_none() {
+        *client = Some(
+            get_api_client_with_overrides(args.common.api_client_overrides())
+                .await
+                .0,
+        );
+    }
+    let client = client.as_ref().expect("client built just above");
+    let sources = PatchSources {
+        blobs_path: paths.blobs,
+        packages_path: Some(paths.packages),
+        diffs_path: Some(paths.diffs),
+        mem_blobs: None,
+    };
+    let fetch_result = fetch_missing_sources(m, &sources, mode, client, None).await;
+    status.finish();
+    pass.downloaded = fetch_result.downloaded;
+    pass.failed = fetch_result.failed;
+    if !quiet {
+        for line in format_fetch_successes(&fetch_result, noun) {
+            println!("{line}");
+        }
+    }
+    // Failures are error output: stderr, and not muted by `--silent`
+    // (`--json` runs carry them in the envelope).
+    if !args.common.json {
+        for (i, line) in format_fetch_failures(&fetch_result, noun)
+            .iter()
+            .enumerate()
+        {
+            if i == 0 {
+                eprintln!("Error: {line}");
+            } else {
+                eprintln!("{line}");
+            }
+        }
+    }
+    pass
+}
+
 /// Whether an API token will be found, mirroring the client's chain: the
 /// `--api-token` flag (clap also maps SOCKET_API_TOKEN into it), then —
 /// unless `SOCKET_NO_API_TOKEN` vetoes ambient tokens — the env var and the
@@ -454,86 +549,48 @@ async fn repair_inner(
             .into_iter()
             .collect(),
     };
-    let missing_count = missing_artifacts.len();
     let noun = download_mode.noun();
+    let paths = SourcePaths {
+        blobs: &blobs_path,
+        packages: &packages_path,
+        diffs: &diffs_path,
+    };
     // Whether stdout already carries a line, so the blank separators
     // between sections never open the output (the offline warning goes
     // to stderr).
-    let mut stdout_started = true;
-
-    if missing_artifacts.is_empty() {
-        if !quiet {
-            println!("{}", format_nothing_missing(manifest.as_ref(), noun));
+    let mut stdout_started = !args.common.offline || missing_artifacts.is_empty();
+    let primary = match scoped_manifest.as_ref() {
+        Some(m) if !missing_artifacts.is_empty() => {
+            download_pass(args, client, m, &missing_artifacts, download_mode, &paths).await
         }
-    } else if args.common.offline {
-        if !quiet {
-            eprintln!("{}", format_offline_warning(&missing_artifacts, noun));
-        }
-        stdout_started = false;
-    } else {
-        if !quiet {
-            println!("{}", format_found_missing(missing_artifacts.len(), noun));
-        }
-
-        if args.common.dry_run {
+        _ => {
             if !quiet {
-                println!();
-                println!("Would download:");
-                for line in format_id_list(&missing_artifacts, noun, DRY_RUN_LIST_CAP) {
-                    println!("{line}");
-                }
-            }
-        } else {
-            let mut status = crate::ui::StatusLine::stderr(args.common.json, args.common.silent);
-            status.set(format!(
-                "Downloading {}...",
-                noun.count(missing_artifacts.len())
-            ));
-            if client.is_none() {
-                *client = Some(
-                    get_api_client_with_overrides(args.common.api_client_overrides())
-                        .await
-                        .0,
-                );
+                println!("{}", format_nothing_missing(manifest.as_ref(), noun));
             }
-            let client = client.as_ref().expect("client built just above");
-            let sources = PatchSources {
-                blobs_path: &blobs_path,
-                packages_path: Some(&packages_path),
-                diffs_path: Some(&diffs_path),
-                mem_blobs: None,
-            };
-            // Step 1 only runs with a manifest (missing_artifacts is
-            // empty otherwise), so the expect is unreachable.
-            let m = scoped_manifest
-                .as_ref()
-                .expect("step 1 requires a manifest");
-            let fetch_result =
-                fetch_missing_sources(m, &sources, download_mode, client, None).await;
-            status.finish();
-            downloaded_count = fetch_result.downloaded;
-            download_failed_count = fetch_result.failed;
-            if !quiet {
-                for line in format_fetch_successes(&fetch_result, noun) {
-                    println!("{line}");
-                }
-            }
-            // Failures are error output: stderr, and not muted by
-            // `--silent` (`--json` runs carry them in the envelope).
-            if !args.common.json {
-                for (i, line) in format_fetch_failures(&fetch_result, noun)
-                    .iter()
-                    .enumerate()
-                {
-                    if i == 0 {
-                        eprintln!("Error: {line}");
-                    } else {
-                        eprintln!("{line}");
-                    }
-                }
+            DownloadPass::default()
+        }
+    };
+    // A diff archive has no delta for a file the patch creates, so in diff
+    // mode that file's blob is downloaded too: without it, a later
+    // `apply --offline` cannot apply the patch.
+    let created = match (&scoped_manifest, download_mode) {
+        (Some(m), DownloadMode::Diff) => {
+            let created = files_diffs_cannot_cover(m);
+            let missing: Vec<String> = get_missing_blobs(&created, &blobs_path)
+                .await
+                .into_iter()
+                .collect();
+            if missing.is_empty() {
+                DownloadPass::default()
+            } else {
+                download_pass(args, client, &created, &missing, DownloadMode::File, &paths).await
             }
         }
-    }
+        _ => DownloadPass::default(),
+    };
+    let missing_count = primary.missing;
+    downloaded_count += primary.downloaded + created.downloaded;
+    download_failed_count += primary.failed;
 
     // Step 1.5: vendored artifacts — health-check the ledger (and any
     // lockfile vendor references with no ledger coverage) and rebuild
@@ -613,13 +670,13 @@ async fn repair_inner(
         // so a piped stdout never ends in a stray blank line when the
         // line itself goes to stderr.
         let other_failure = matches!(env.status, Status::PartialFailure | Status::Error);
-        let line = format_final_line(
-            download_failed_count,
-            other_failure,
-            noun,
-            args.common.dry_run,
-        );
-        if download_failed_count > 0 || other_failure {
+        let (failed, failed_noun) = if download_failed_count > 0 {
+            (download_failed_count, noun)
+        } else {
+            (created.failed, BLOB)
+        };
+        let line = format_final_line(failed, other_failure, failed_noun, args.common.dry_run);
+        if failed > 0 || other_failure {
             if stdout_started {
                 eprintln!();
             }
@@ -660,6 +717,28 @@ async fn repair_inner(
         ));
         env.mark_partial_failure();
     }
+    if created.downloaded > 0
+        || (!args.common.offline && args.common.dry_run && created.missing > 0)
+    {
+        let (action, count) = if args.common.dry_run {
+            (PatchAction::Verified, created.missing)
+        } else {
+            (PatchAction::Downloaded, created.downloaded)
+        };
+        env.record(
+            PatchEvent::artifact(action).with_details(serde_json::json!({
+                "count": count,
+                "mode": DownloadMode::File.as_tag(),
+            })),
+        );
+    }
+    if created.failed > 0 {
+        env.record(PatchEvent::artifact(PatchAction::Failed).with_error(
+            "download_failed",
+            format!("{} failed to download", BLOB.count(created.failed)),
+        ));
+        env.mark_partial_failure();
+    }
     if blobs_cleaned > 0 {
         let cleanup_action = if args.common.dry_run {
             PatchAction::Verified

crates/socket-patch-cli/tests/diff_created_file_e2e.rs

@@ -237,3 +237,24 @@ async fn default_repair_downloads_the_created_files_blob_for_offline_apply() {
     assert_eq!(code, 0, "apply: stdout={stdout}\nstderr={stderr}");
     assert_fully_patched(&pkg);
 }
+
+#[test]
+fn offline_repair_names_the_created_files_missing_blob() {
+    let tmp = tempfile::tempdir().unwrap();
+    seed_project(tmp.path());
+    seed_cached_diff_archive(tmp.path());
+
+    let (code, stdout, stderr) = run_cli(tmp.path(), &["repair", "--offline"], None);
+
+    assert_eq!(code, 0, "stdout={stdout}\nstderr={stderr}");
+    assert!(
+        stdout.contains("All diff archives are present locally."),
+        "stdout={stdout}"
+    );
+    let short: String = git_sha256(CREATED).chars().take(12).collect();
+    assert!(
+        stderr.contains("Warning: 1 blob is missing (offline mode - not downloading):")
+            && stderr.contains(&short),
+        "the created file's blob is still missing; stderr={stderr}"
+    );
+}