install: reject an empty root package.json instead of deleting the lockfile

src/install/PackageManager/install_with_manager.rs

@@ -1858,7 +1858,12 @@ fn root_package_json_source(
         root_package_json_path.as_bytes(),
         Default::default(),
     ) {
-        WorkspacePackageJsonCacheResult::Entry(entry) => return Ok(entry.source.clone()),
+        WorkspacePackageJsonCacheResult::Entry(entry) => {
+            if entry.source.contents.is_empty() {
+                exit_on_empty_package_json(root_package_json_path.as_bytes());
+            }
+            return Ok(entry.source.clone());
+        }
         WorkspacePackageJsonCacheResult::ReadErr(err) => ("read", err),
         WorkspacePackageJsonCacheResult::ParseErr(err) => ("parse", err),
     };
@@ -1875,6 +1880,16 @@ fn root_package_json_source(
     Global::exit(1);
 }
 
+/// The parser turns an empty file into `{}`. Installing from that would delete the lockfile.
+pub(crate) fn exit_on_empty_package_json(path: &[u8]) -> ! {
+    Output::err_generic(
+        "failed to parse '{}': file is empty",
+        (bstr::BStr::new(path),),
+    );
+    bun_core::note!("Restore package.json, or write {{}} to it to start without dependencies");
+    Global::exit(1)
+}
+
 #[cold]
 #[inline(never)]
 fn create_new_lockfile_and_enqueue(

src/install/PackageManager/updatePackageJSONAndInstall.rs

@@ -329,6 +329,15 @@ fn update_package_json_and_install_with_manager_with_updates(
     // is taken across this borrow; `PackageJSONEditor` and `do_patch_commit` touch only
     // disjoint manager fields.
     let current_package_json: &mut MapEntry = unsafe { &mut *current_package_json_ptr };
+    // `bun add` and `bun link` fill an empty file. The other commands would print `{}` into
+    // the cache below, past the check in `root_package_json_source`.
+    if current_package_json.source.contents.is_empty()
+        && !matches!(subcommand, Subcommand::Add | Subcommand::Link)
+    {
+        install_with_manager::exit_on_empty_package_json(
+            manager.original_package_json_path.as_bytes(),
+        );
+    }
     let mut current_package_json_root: bun_ast::Expr = current_package_json.root;
     let current_package_json_indent = current_package_json.indentation;
 

test/cli/install/bun-install.test.ts

@@ -5189,6 +5189,7 @@ describe.concurrent("bun-install", () => {
     async function installWithBrokenRootPackageJson(
       withLockfile: boolean,
       breakPackageJson: (packageJsonPath: string) => Promise<void>,
+      command: string[] = ["install"],
     ) {
       using dir = tempDir("broken-root-package-json", {
         "package.json": JSON.stringify({ name: "foo", version: "0.0.1", dependencies: { dep: "file:./dep" } }),
@@ -5213,22 +5214,28 @@ describe.concurrent("bun-install", () => {
       await breakPackageJson(join(String(dir), "package.json"));
 
       await using proc = spawn({
-        cmd: [bunExe(), "install"],
+        cmd: [bunExe(), ...command],
         cwd: String(dir),
         env,
         stdout: "pipe",
         stderr: "pipe",
       });
       const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
-      expect(stdout).toStartWith("bun install v1.");
-      return { stderr: normalizeBunSnapshot(stderr, String(dir)), exitCode };
+      expect(stdout).toStartWith(`bun ${command[0]} v1.`);
+      return {
+        stderr: normalizeBunSnapshot(stderr, String(dir)),
+        exitCode,
+        lockfileKept: await exists(join(String(dir), "bun.lock")),
+      };
     }
 
     const unparseable = (packageJsonPath: string) => writeFile(packageJsonPath, "foo");
     const unreadable = async (packageJsonPath: string) => {
       await rm(packageJsonPath);
       await mkdir(packageJsonPath);
     };
+    // What a writer that died between truncating and writing leaves behind.
+    const empty = (packageJsonPath: string) => writeFile(packageJsonPath, "");
 
     for (const [lockfile, withLockfile] of [
       ["with a bun.lock", true],
@@ -5253,6 +5260,23 @@ describe.concurrent("bun-install", () => {
         expect(stderr).toBe("EISDIR: failed to read '<dir>/package.json'");
         expect(exitCode).toBe(1);
       });
+
+      // An empty file parses as `{}` elsewhere. For the root that would mean "no
+      // dependencies", and the command would delete the lockfile. `bun update` reads
+      // the file on its own path before it installs, so it is checked as well.
+      for (const command of [["install"], ["update"], ["update", "dep"]]) {
+        it(`bun ${command.join(" ")} rejects an empty file and keeps the lockfile ${lockfile}`, async () => {
+          const result = await installWithBrokenRootPackageJson(withLockfile, empty, command);
+          expect(result).toEqual({
+            stderr: [
+              "error: failed to parse '<dir>/package.json': file is empty",
+              "note: Restore package.json, or write {} to it to start without dependencies",
+            ].join("\n"),
+            exitCode: 1,
+            lockfileKept: withLockfile,
+          });
+        });
+      }
     }
   });
 

test/cli/install/migration/pnpm/version-number-dot/package.json

@@ -0,0 +1 @@
+{}