fix(Mountain): Ensure extension manifest fields are always present for renderer

Add `extensions:getManifest` IPC handler to read `extension/package.json` from a `.vsix` archive without extracting to disk, enabling the "Install from VSIX…" preview dialog.

Three changes prevent renderer crashes when VS Code accesses extension manifest fields unconditionally:

1. **DTO serialization**: Remove `skip_serializing_if = "String::is_empty"` from `ExtensionDescriptionStateDTO.Name`, `Version`, `Publisher`. VS Code's `extensions.contribution.ts` trusted-publishers migration calls `manifest.publisher.toLowerCase()` at boot—if the key is omitted, the renderer crashes with `TypeError: undefined is not an object`.

2. **IPC handler hardening** (`Extensions.rs`): Handle empty/missing `publisher`/`name` with "unknown" fallback, and inject explicit `publisher`, `name`, `version` fields into the manifest object before sending to the renderer. Also guard against non-object manifest values (null) by substituting an empty skeleton.

3. **Log file eager init** (`Entry.rs`, `DevLog.rs`): Call `InitEager()` at binary startup to create the session log before any panic, preserving post-mortem evidence. Also fix `BinarySignature()` to correctly split PascalCase segments (`ElectronProfile` → `electron.profile`) so logs end up in the correct app-data directory.

Also expand the benign ENOENT ignore list with `chatLanguageModels.json`, `configurationDefaultsOverrides`, and window log files (`network.log`, `renderer.log`, `views.log`, `notebook.rendering.log`).

Author: NikolaRHristov

Source/ApplicationState/DTO/ExtensionDescriptionStateDTO.rs

@@ -55,15 +55,32 @@ pub struct ExtensionDescriptionStateDTO {
 	pub Identifier:Value,
 
 	/// Extension name (from package.json "name")
-	#[serde(default, skip_serializing_if = "String::is_empty")]
+	///
+	/// Always serialized, even when empty, because VS Code's scanner and
+	/// the trusted-publishers migration (`extensions.contribution.ts`) both
+	/// evaluate `extension.manifest.name.toLowerCase()` unconditionally.
+	/// Dropping the field would leave a bare `undefined` and crash the
+	/// renderer with `TypeError: undefined is not an object`.
+	#[serde(default)]
 	pub Name:String,
 
-	/// Semantic version string (e.g., "1.0.0")
-	#[serde(default, skip_serializing_if = "String::is_empty")]
+	/// Semantic version string (e.g., "1.0.0").
+	///
+	/// Always serialized for the same reason as `Name` / `Publisher`: the
+	/// renderer reads `manifest.version` in several hot paths and crashes
+	/// if the field is missing outright.
+	#[serde(default)]
 	pub Version:String,
 
-	/// Publisher name or identifier
-	#[serde(default, skip_serializing_if = "String::is_empty")]
+	/// Publisher name or identifier.
+	///
+	/// Always serialized, even when empty. VS Code's
+	/// `extensions.contribution.ts` trusted-publishers migration runs on
+	/// every User-extension at workbench boot and executes
+	/// `extension.manifest.publisher.toLowerCase()`. If the key is omitted
+	/// the renderer crashes with
+	/// `TypeError: undefined is not an object (evaluating 'manifest.publisher')`.
+	#[serde(default)]
 	pub Publisher:String,
 
 	/// Engine compatibility requirements: { vscode: string }

Source/Binary/Main/Entry.rs

@@ -135,6 +135,16 @@ macro_rules! TraceStep {
 /// 9. Runs the Tauri application
 /// 10. Handles graceful shutdown
 pub fn Fn() {
+	// Open `Mountain.dev.log` up front. Forces `InitFileSink` to create
+	// the session log header on disk before any other code can panic, so
+	// an early crash still leaves a file with a timestamp + pid + tag
+	// context for post-mortem. Env vars are read from the shell here (the
+	// `.env.Land` load below may add MORE keys but never overrides
+	// LAND_DEV_LOG / LAND_DEV_LOG_FILE because `set_var` only runs when a
+	// key is currently unset). Harmless to call: the inner `OnceLock`
+	// gates repeat invocations.
+	crate::IPC::DevLog::InitEager();
+
 	// -------------------------------------------------------------------------
 	// [Boot] [Env] Load .env.Land into process env so standalone binary
 	// invocations pick up Product*, Tier*, Network* vars without requiring

Source/ExtensionManagement/VsixInstaller.rs

@@ -159,6 +159,26 @@ pub fn UninstallExtension(InstallDir:&Path) -> Result<(), InstallError> {
 // --- Internals ----------------------------------------------------------
 
 fn ReadManifestFacts(VsixPath:&Path) -> Result<ManifestFacts, InstallError> {
+	let Manifest = ReadFullManifest(VsixPath)?;
+
+	let Publisher = ReadStringField(&Manifest, "publisher")?;
+	let Name = ReadStringField(&Manifest, "name")?;
+	let Version = ReadStringField(&Manifest, "version")?;
+
+	Ok(ManifestFacts { Publisher, Name, Version })
+}
+
+/// Read the full `extension/package.json` from a `.vsix` without extracting
+/// the archive to disk. Used by the IPC `extensions:getManifest` handler so
+/// the "Install from VSIX…" preview dialog and drag-and-drop flow can inspect
+/// a manifest before the user confirms installation.
+///
+/// The returned value is the raw parsed JSON (`serde_json::Value`) - callers
+/// can project it into VS Code's `IExtensionManifest` shape. No NLS bundle
+/// resolution is performed here (the renderer only needs publisher/name/
+/// version/displayName for the preview UI, and NLS keys would require
+/// unpacking `package.nls.json` from the archive too).
+pub fn ReadFullManifest(VsixPath:&Path) -> Result<Value, InstallError> {
 	let Archive = File::open(VsixPath).map_err(|Error| InstallError::ArchiveRead(Error.to_string()))?;
 	let mut Archive = ZipArchive::new(Archive).map_err(|Error| InstallError::ArchiveRead(Error.to_string()))?;
 
@@ -172,14 +192,7 @@ fn ReadManifestFacts(VsixPath:&Path) -> Result<ManifestFacts, InstallError> {
 		.read_to_string(&mut Raw)
 		.map_err(|Error| InstallError::ManifestMissing(Error.to_string()))?;
 
-	let Manifest:Value =
-		serde_json::from_str(&Raw).map_err(|Error| InstallError::ManifestMissing(Error.to_string()))?;
-
-	let Publisher = ReadStringField(&Manifest, "publisher")?;
-	let Name = ReadStringField(&Manifest, "name")?;
-	let Version = ReadStringField(&Manifest, "version")?;
-
-	Ok(ManifestFacts { Publisher, Name, Version })
+	serde_json::from_str(&Raw).map_err(|Error| InstallError::ManifestMissing(Error.to_string()))
 }
 
 fn ReadStringField(Manifest:&Value, Field:&'static str) -> Result<String, InstallError> {

Source/IPC/DevLog.rs

@@ -209,6 +209,20 @@ fn InitFileSink() -> &'static Mutex<Option<BufWriter<File>>> {
 	})
 }
 
+/// Force the file sink to initialize before any `dev_log!` has run.
+///
+/// `WriteToFile` is otherwise lazy - the log file is only opened the first
+/// time a tagged `dev_log!` call fires. When Mountain panics (or the
+/// webview traps the user with an early error) before the first enabled
+/// tag emits, the session log directory ends up with an empty shell and
+/// the post-mortem evidence is lost.
+///
+/// Call this once at the top of `Binary::Main::Fn()` - as early as the
+/// binary can reach - so the header line + `LAND_DEV_LOG_FILE=1` opt-in
+/// are honoured even when nothing else ever logs. Harmless to call
+/// multiple times; the `OnceLock` inside `InitFileSink` gates it.
+pub fn InitEager() { let _ = InitFileSink(); }
+
 /// Append a single formatted line to the session's log file if the file
 /// sink is active. Swallows every error - dev_log must never crash.
 pub fn WriteToFile(Line:&str) {
@@ -250,12 +264,51 @@ fn BinarySignature() -> String {
 	let Segments:Vec<&str> = PackageName.split('_').collect();
 	let Take = Segments.len().min(4);
 	let Start = Segments.len().saturating_sub(Take);
-	let Tail = Segments[Start..].join("_");
-	// Lowercase + `_` → `.` gives the same segment order the Tauri
-	// identifier uses (identifiers are dot-delimited lowercase). We
-	// don't split PascalCase into words here - the substring match
-	// below doesn't need exact equality, just a unique tail.
-	Tail.to_ascii_lowercase().replace('_', ".")
+	// Each underscore-delimited segment is PascalCase (e.g. `ElectronProfile`,
+	// `MountainProfile`, `RestCompiler`). The Tauri identifier Maintain
+	// generates splits every PascalCase word on its capital boundary, so
+	// `ElectronProfile` → `electron.profile`, not `electronprofile`. Without
+	// the per-segment split here the signature becomes `electronprofile`
+	// and `ends_with` never matches the real Tauri app-data dir
+	// `…clean.debug.electron.profile.mountain`, so DevLog silently falls
+	// back to whichever other `*.mountain` directory `read_dir` yielded
+	// first - the bug that sent the electron-profile binary's logs into
+	// the compile-profile directory.
+	let Dotted:String = Segments[Start..]
+		.iter()
+		.flat_map(|Segment| SplitPascalCaseIntoWords(Segment))
+		.collect::<Vec<String>>()
+		.join(".")
+		.to_ascii_lowercase();
+	Dotted
+}
+
+/// Split a PascalCase / UPPERCASE string into lowercase component words,
+/// matching the tokenisation Maintain's `Build/Process.rs` applies when it
+/// stamps the Tauri `identifier`. Example: `ElectronProfile` →
+/// `["electron", "profile"]`; `22NodeVersion` → `["22", "node", "version"]`.
+/// Empty segments are filtered out.
+fn SplitPascalCaseIntoWords(Segment:&str) -> Vec<String> {
+	let mut Words:Vec<String> = Vec::new();
+	let mut Current = String::new();
+	let mut PrevWasUpper = false;
+	let mut PrevWasDigit = false;
+	for Ch in Segment.chars() {
+		let IsUpper = Ch.is_ascii_uppercase();
+		let IsDigit = Ch.is_ascii_digit();
+		let NeedBreak = !Current.is_empty()
+			&& ((IsUpper && !PrevWasUpper) || (IsDigit != PrevWasDigit && !Current.is_empty()));
+		if NeedBreak {
+			Words.push(std::mem::take(&mut Current));
+		}
+		Current.push(Ch);
+		PrevWasUpper = IsUpper;
+		PrevWasDigit = IsDigit;
+	}
+	if !Current.is_empty() {
+		Words.push(Current);
+	}
+	Words.into_iter().filter(|Word| !Word.is_empty()).collect()
 }
 
 fn DetectAppDataPrefix() -> Option<String> {
@@ -366,11 +419,26 @@ const BENIGN_ENOENT_SUBSTRINGS:&[&str] = &[
 	// `resolve_userdata`.
 	"/User/tasks.json",
 	"/User/mcp.json",
+	// Chat language-model registry is written on first chat interaction.
+	// Absent on fresh profiles; VS Code reads-before-first-write every boot.
+	"chatLanguageModels.json",
+	// VS Code writes per-profile configuration default overrides lazily; on
+	// a fresh profile the file does not yet exist and the workbench probes
+	// on every boot to see if it needs reading.
+	"configurationDefaultsOverrides",
 	// Chat images cache directory is lazy-created on first chat attachment.
 	"vscode-chat-images",
 	// Per-window output channel log files probed lazily by the workbench
 	// before first write. Path shape: `$APP/logs/<SESSION>/window<N>/output_<TIMESTAMP>`.
 	"/output_20",
+	// Per-window named log files VS Code stats on boot to detect crash-log
+	// rollovers. The `/<logsPath>/window<N>/<name>.log` layout means the
+	// window index can change, so match on filename alone - these names
+	// are stable VS Code conventions and never collide with real files.
+	"/network.log",
+	"/renderer.log",
+	"/views.log",
+	"/notebook.rendering.log",
 	// Virtual scheme misses already covered by earlier batches.
 	"vscode://schemas-associations/",
 ];

Source/IPC/WindServiceHandlers/Extensions.rs

@@ -30,9 +30,15 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 			let Publisher = Manifest
 				.get("publisher")
 				.and_then(Value::as_str)
+				.filter(|S| !S.is_empty())
+				.unwrap_or("unknown")
+				.to_string();
+			let Name = Manifest
+				.get("name")
+				.and_then(Value::as_str)
+				.filter(|S| !S.is_empty())
 				.unwrap_or("unknown")
 				.to_string();
-			let Name = Manifest.get("name").and_then(Value::as_str).unwrap_or("unknown").to_string();
 			let Id = format!("{}.{}", Publisher, Name);
 
 			// VS Code's `URI.revive()` is a no-op on strings, so the scanner's
@@ -43,9 +49,26 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 			// `location` and the mirror inside `manifest.extensionLocation` so
 			// callers that read either field get the same shape.
 			let Location = NormalizeUri(Manifest.get("extensionLocation"));
-			let mut Manifest = Manifest;
+			// Guarantee the manifest is an object with non-empty `publisher`,
+			// `name` and `version` fields before it reaches the renderer. VS
+			// Code runs a trusted-publishers migration at first-boot
+			// (`extensions.contribution.ts`) that unconditionally calls
+			// `extension.manifest.publisher.toLowerCase()`; any missing
+			// `manifest` object, or a manifest with `publisher === undefined`,
+			// crashes the webview with
+			// `TypeError: undefined is not an object (evaluating 'manifest.publisher')`
+			// before the workbench can render a single pixel. A non-object
+			// value here (null / Value::Null from upstream scan failures) is
+			// replaced with a bare skeleton so the renderer always has shape.
+			let mut Manifest = match Manifest {
+				Value::Object(_) => Manifest,
+				_ => json!({}),
+			};
 			if let Value::Object(ref mut Map) = Manifest {
 				Map.insert("extensionLocation".to_string(), Location.clone());
+				Map.entry("publisher".to_string()).or_insert_with(|| json!(Publisher.clone()));
+				Map.entry("name".to_string()).or_insert_with(|| json!(Name.clone()));
+				Map.entry("version".to_string()).or_insert_with(|| json!("0.0.0"));
 			}
 
 			json!({

Source/IPC/WindServiceHandlers/mod.rs

@@ -363,6 +363,45 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 					)
 					.await
 				},
+
+				// `ExtensionManagementChannelClient.getManifest(vsix: URI)` - reads
+				// the `extension/package.json` from a `.vsix` archive without
+				// extracting it. Called by the "Install from VSIX…" preview and
+				// by drag-and-drop onto the Extensions sidebar. The renderer then
+				// accesses `manifest.publisher` / `.name` / `.displayName` on the
+				// returned object unconditionally; a missing handler or an Err
+				// response crashes the webview with
+				// `TypeError: undefined is not an object (evaluating 'manifest.publisher')`.
+				"extensions:getManifest" => {
+					let VsixPath = match args.first() {
+						Some(serde_json::Value::String(Path)) => Path.clone(),
+						Some(Obj) => Obj
+							.get("fsPath")
+							.and_then(|V| V.as_str())
+							.map(str::to_owned)
+							.or_else(|| Obj.get("path").and_then(|V| V.as_str()).map(str::to_owned))
+							.unwrap_or_default(),
+						None => String::new(),
+					};
+					dev_log!("extensions", "extensions:getManifest vsix={}", VsixPath);
+					if VsixPath.is_empty() {
+						Err("extensions:getManifest: missing VSIX path argument".to_string())
+					} else {
+						let Path = std::path::PathBuf::from(&VsixPath);
+						match crate::ExtensionManagement::VsixInstaller::ReadFullManifest(&Path) {
+							Ok(Manifest) => Ok(Manifest),
+							Err(Error) => {
+								dev_log!(
+									"extensions",
+									"warn: [WindServiceHandlers] extensions:getManifest failed for '{}': {}",
+									VsixPath,
+									Error
+								);
+								Err(format!("extensions:getManifest failed: {}", Error))
+							},
+						}
+					}
+				},
 				// Reinstall and metadata-update still no-op for now; reinstall needs
 				// a gallery cache (we only have the on-disk unpack), and metadata
 				// update only matters for ratings/icons/readme which Land does not