fix(std): fix artifact path lookup

The artifacts directory may get mounted at a
different path on macOS, so search for a directory
containing ID file names. On Linux, fall back to
/.tangram/artifacts if we hit the root.

- bump deps
- script tweak

Author: deciduously

.gitignore

@@ -2,3 +2,4 @@
 node_modules
 tangram.lock
 target
+Claude.md

bun.lock

@@ -4,7 +4,7 @@
     "": {
       "dependencies": {
         "@biomejs/biome": "^2.2.4",
-        "@types/bun": "^1.2.22",
+        "@types/bun": "^1.2.23",
       },
     },
   },

packages/rust/proxy/Cargo.lock

@@ -20,7 +20,7 @@ futures = "0.3"
 itertools = "0.14"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tangram_client = { default-features = false, git = "https://github.com/tangramdotdev/tangram", rev = "ba37f71dc591a2c917d75374fa36cb8d1dbcc7f4" }
+tangram_client = { default-features = false, git = "https://github.com/tangramdotdev/tangram", rev = "b7e649add4a5a903883dcf90860886fb50714e21" }
 tokio = { version = "1", default-features = false, features = [
   "rt",
   "fs",

packages/rust/proxy/Cargo.toml

@@ -661,6 +661,21 @@ pub fn template_data_to_symlink_data(
 	}
 }
 
+/// Check if a directory looks like a Tangram artifacts directory by examining its contents.
+/// Returns true if the directory contains at least one entry that parses as a valid Tangram ID.
+fn looks_like_artifacts_dir(path: &Path) -> bool {
+	let Ok(entries) = std::fs::read_dir(path) else {
+		return false;
+	};
+
+	entries.filter_map(Result::ok).any(|entry| {
+		let name = entry.file_name();
+		name.to_str()
+			.and_then(|s| s.parse::<tg::Id>().ok())
+			.is_some()
+	})
+}
+
 /// Compute the closest located artifact path for the current running process, reusing the result for subsequent lookups.
 pub static CLOSEST_ARTIFACT_PATH: LazyLock<String> = LazyLock::new(|| {
 	let mut closest_artifact_path = None;
@@ -671,8 +686,8 @@ pub static CLOSEST_ARTIFACT_PATH: LazyLock<String> = LazyLock::new(|| {
 		vec![]
 	};
 	for path in paths.into_iter().chain(cwd.ancestors().skip(1)) {
-		let directory = path.join(".tangram/artifacts");
-		if directory.exists() {
+		let directory = path.join("artifacts");
+		if directory.exists() && looks_like_artifacts_dir(&directory) {
 			closest_artifact_path = Some(
 				directory
 					.to_str()
@@ -681,6 +696,21 @@ pub static CLOSEST_ARTIFACT_PATH: LazyLock<String> = LazyLock::new(|| {
 			);
 			break;
 		}
+
+		// On Linux, when we reach the root, check /.tangram/artifacts (chroot path)
+		#[cfg(target_os = "linux")]
+		if path == Path::new("/") {
+			let directory = path.join(".tangram/artifacts");
+			if directory.exists() && looks_like_artifacts_dir(&directory) {
+				closest_artifact_path = Some(
+					directory
+						.to_str()
+						.expect("artifacts directory should be valid UTF-8")
+						.to_string(),
+				);
+				break;
+			}
+		}
 	}
 	closest_artifact_path.expect("Failed to find the closest artifact path")
 });

packages/rust/proxy/src/main.rs

@@ -34,7 +34,7 @@ itertools = "0.14"
 libc = "0.2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tangram_client = { default-features = false, git = "https://github.com/tangramdotdev/tangram", rev = "ba37f71dc591a2c917d75374fa36cb8d1dbcc7f4" }
+tangram_client = { default-features = false, git = "https://github.com/tangramdotdev/tangram", rev = "b7e649add4a5a903883dcf90860886fb50714e21" }
 tempfile = "3"
 tokio = { version = "1", default-features = false, features = [
   "rt",

packages/std/Cargo.lock

@@ -412,17 +412,10 @@ async fn run_proxy(environment: Environment, args: Args) -> tg::Result<()> {
 		.map_err(|error| tg::error!(source = error, "cc failed: no output"))?;
 
 	// Verify we did everything correctly.
-	let mut tangram_path = std::env::current_dir()
+	let tangram_path = std::env::current_dir()
 		.map_err(|error| tg::error!(source = error, "failed to get current working directory"))?;
-	while !tangram_path.join(".tangram").exists() {
-		let Some(parent) = tangram_path.parent() else {
-			return Err(tg::error!("failed to find .tangram directory."));
-		};
-		tangram_path = parent.into();
-	}
-	let artifact_path = tangram_path
-		.join(".tangram/artifacts")
-		.join(output_file.id().to_string());
+	let artifacts_dir = tangram_std::find_artifacts_dir(&tangram_path)?;
+	let artifact_path = artifacts_dir.join(output_file.id().to_string());
 	eprintln!("Copying {} to {output:#?}", artifact_path.display());
 	std::fs::copy(artifact_path, output)
 		.map_err(|error| tg::error!(source = error, "failed to copy file"))?;
@@ -465,6 +458,11 @@ async fn create_remapping_table(
 	let mut table = BTreeMap::new();
 	let mut subtrees = Vec::new();
 
+	// Find the artifacts directory once for checking if paths are already artifacts.
+	let artifacts_dir = std::env::current_dir()
+		.ok()
+		.and_then(|cwd| tangram_std::find_artifacts_dir(&cwd).ok());
+
 	for remap_target in remap_targets {
 		// Canonicalize the source path.
 		let path: &Path = remap_target.value.as_ref();
@@ -478,7 +476,10 @@ async fn create_remapping_table(
 		}
 
 		// Check if this is a path that should be a template. Needs to happen after canonicalization in case a local symlink was created pointing to an artifact.
-		if path.starts_with("/.tangram/artifacts") {
+		if artifacts_dir
+			.as_ref()
+			.is_some_and(|dir| path.starts_with(dir))
+		{
 			let template = tangram_std::unrender(path.to_str().unwrap())?;
 			table.insert(remap_target, template);
 			continue;

packages/std/Cargo.toml

@@ -65,26 +65,59 @@ pub fn template_from_artifact_and_subpath(
 	])
 }
 
+/// Check if a directory looks like a Tangram artifacts directory by examining its contents.
+/// Returns true if the directory contains at least one entry that parses as a valid Tangram ID.
+pub fn looks_like_artifacts_dir(path: &std::path::Path) -> bool {
+	let Ok(entries) = std::fs::read_dir(path) else {
+		return false;
+	};
+
+	entries.filter_map(Result::ok).any(|entry| {
+		let name = entry.file_name();
+		name.to_str()
+			.and_then(|s| s.parse::<tg::Id>().ok())
+			.is_some()
+	})
+}
+
+/// Find the artifacts directory by searching up from the given path.
+/// On Linux, falls back to /.tangram/artifacts when reaching the root.
+pub fn find_artifacts_dir(start_path: &std::path::Path) -> tg::Result<PathBuf> {
+	for path in start_path.ancestors() {
+		let directory = path.join("artifacts");
+		if directory.exists() && looks_like_artifacts_dir(&directory) {
+			return Ok(directory);
+		}
+
+		// On Linux, when we reach the root, check /.tangram/artifacts (chroot path)
+		#[cfg(target_os = "linux")]
+		if path == std::path::Path::new("/") {
+			let directory = path.join(".tangram/artifacts");
+			if directory.exists() && looks_like_artifacts_dir(&directory) {
+				return Ok(directory);
+			}
+		}
+	}
+	Err(tg::error!("failed to find artifacts directory"))
+}
+
 /// Compute the closest located artifact path for the current running process, reusing the result for subsequent lookups.
 pub static CLOSEST_ARTIFACT_PATH: LazyLock<String> = LazyLock::new(|| {
-	let mut closest_artifact_path = None;
 	let cwd = std::env::current_exe()
 		.expect("Failed to get the current directory")
 		.canonicalize()
 		.expect("failed to canonicalize current directory");
-	for path in cwd.ancestors().skip(1) {
-		let directory = path.join(".tangram/artifacts");
-		if directory.exists() {
-			closest_artifact_path = Some(
-				directory
-					.to_str()
-					.expect("artifacts directory should be valid UTF-8")
-					.to_string(),
-			);
-			break;
-		}
-	}
-	closest_artifact_path.expect("Failed to find the closest artifact path")
+
+	let parent = cwd
+		.parent()
+		.expect("executable should have a parent directory");
+	let artifacts_dir =
+		find_artifacts_dir(parent).expect("Failed to find the closest artifact path");
+
+	artifacts_dir
+		.to_str()
+		.expect("artifacts directory should be valid UTF-8")
+		.to_string()
 });
 
 /// Render a [`tg::template::Data`] to a `String` using the closest located artifact path.

packages/std/packages/cc_proxy/src/main.rs

@@ -2543,13 +2543,13 @@ export const testSingleArgObjectNoMutations = async () => {
 	} else if (os === "darwin") {
 		tg.assert(
 			text.match(
-				new RegExp(`_NSGetExecutablePath: .*\\.tangram/artifacts/${wrapperID}`),
+				new RegExp(`_NSGetExecutablePath: .*artifacts/${wrapperID}`),
 			),
 			"Expected _NSGetExecutablePath to point to the wrapper",
 		);
 		tg.assert(
 			text.match(
-				new RegExp(`argv\\[0\\]: .*\\.tangram/artifacts/${wrapperID}`),
+				new RegExp(`argv\\[0\\]: .*artifacts/${wrapperID}`),
 			),
 			"Expected argv[0] to point to the wrapper that was invoked",
 		);