oppi.li
mount an atproto PDS repository as a FUSE filesystem
oppi.li/posts/mounting_the_atmosphere/
Add -d mode for agents and don't wait for newline
Claude Code is struggling a lot with using pdsfs. This is the changes it suggests to make pdsfs actually usable.
---
## Summary
Add daemon mode (`-d` flag) and change foreground mode to use ctrl-c instead of "hit enter".
**Motivation:** The "hit enter to unmount" pattern doesn't work well with scripts or automated tools - stdin may be closed or unavailable. The ctrl-c pattern is more standard for long-running foreground processes.
**Changes:**
- Add `-d`/`--daemon` flag that backgrounds the mount process and exits the parent when the mount is ready (follows the same pattern as `rclone mount --daemon`)
- Change foreground mode from "hit enter" to ctrl-c
- Update readme to reflect new behavior
**Usage:**
```bash
# Foreground (ctrl-c to unmount)
pdsfs oppi.li
# Daemon mode (parent exits when mount is ready)
pdsfs -d oppi.li && ls mnt/
```
The daemon mode uses a Unix socket pair for the child to signal readiness to the parent, with a 120-second timeout.
authored by
+11
Cargo.lock
+11
Cargo.lock
···
2315
2315
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
2316
2316
2317
2317
[[package]]
2318
+
name = "signal-hook-registry"
2319
+
version = "1.4.8"
2320
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2321
+
checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
2322
+
dependencies = [
2323
+
"errno",
2324
+
"libc",
2325
+
]
2326
+
2327
+
[[package]]
2318
2328
name = "slab"
2319
2329
version = "0.4.10"
2320
2330
source = "registry+https://github.com/rust-lang/crates.io-index"
···
2532
2542
"libc",
2533
2543
"mio",
2534
2544
"pin-project-lite",
2545
+
"signal-hook-registry",
2535
2546
"slab",
2536
2547
"socket2 0.5.10",
2537
2548
"tokio-macros",
+1
-1
Cargo.toml
+1
-1
Cargo.toml
···
23
23
serde_ipld_dagcbor = "0.6.3"
24
24
serde_json = "1.0.141"
25
25
thiserror = "2.0.12"
26
-
tokio = { version = "1.46.1", features = ["fs", "sync", "rt-multi-thread"] }
26
+
tokio = { version = "1.46.1", features = ["fs", "sync", "rt-multi-thread", "signal"] }
27
27
tokio-tungstenite = { version = "0.24", features = ["native-tls"] }
28
28
xdg = "3.0.0"
+10
-2
readme.txt
+10
-2
readme.txt
···
23
23
24
24
λ pdsfs oppi.li
25
25
mounted at "mnt"
26
-
hit enter to unmount and exit...
26
+
ctrl-c to unmount
27
+
28
+
29
+
pass -d to run in daemon mode. the parent process will exit
30
+
once the mount is ready, useful for scripting:
31
+
32
+
33
+
λ pdsfs -d oppi.li && ls mnt/
34
+
did:plc:qfpnj4og54vl56wngdriaxug/
27
35
28
36
29
37
oppi.li is my handle in the atmosphere. the tool does some
···
111
119
download complete for...did:plc:3danwc67lo7obz2fmdg6jxcr
112
120
download complete for...did:plc:wshs7t2adsemcrrd4snkeqli
113
121
mounted at "mnt"
114
-
hit enter to unmount and exit...
122
+
ctrl-c to unmount
115
123
116
124
117
125
# -- in a separate shell --
+67
-19
src/main.rs
+67
-19
src/main.rs
···
13
13
use futures::{StreamExt, stream};
14
14
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
15
15
use std::{
16
-
io::{Cursor, Write},
16
+
io::{Cursor, Read as _, Write as _},
17
+
os::unix::net::UnixStream,
17
18
path::PathBuf,
18
19
process::Command,
19
20
sync::Arc,
20
21
};
21
22
22
23
fn main() {
23
-
let rt = tokio::runtime::Runtime::new().unwrap();
24
24
let matches = clap::command!()
25
25
.arg(
26
26
clap::Arg::new("handles")
···
35
35
.action(clap::ArgAction::Set)
36
36
.value_parser(clap::value_parser!(PathBuf)),
37
37
)
38
+
.arg(
39
+
clap::Arg::new("daemon")
40
+
.short('d')
41
+
.long("daemon")
42
+
.action(clap::ArgAction::SetTrue)
43
+
.help("Run in background and exit parent when mount is ready"),
44
+
)
45
+
.arg(
46
+
clap::Arg::new("__child")
47
+
.long("__child")
48
+
.hide(true)
49
+
.action(clap::ArgAction::Set),
50
+
)
38
51
.get_matches();
39
-
let handles = matches
40
-
.get_many::<String>("handles")
41
-
.unwrap()
42
-
.cloned()
43
-
.collect::<Vec<_>>();
44
-
let mountpoint = matches
45
-
.get_one::<PathBuf>("mountpoint")
46
-
.map(ToOwned::to_owned)
47
-
.unwrap_or(PathBuf::from("mnt"));
52
+
53
+
let handles: Vec<String> = matches.get_many::<String>("handles").unwrap().cloned().collect();
54
+
let mountpoint = matches.get_one::<PathBuf>("mountpoint").cloned()
55
+
.unwrap_or_else(|| PathBuf::from("mnt"));
56
+
57
+
// Daemon mode: spawn child and wait for ready signal
58
+
if matches.get_flag("daemon") {
59
+
let (mut rx, tx) = UnixStream::pair().unwrap();
60
+
rx.set_read_timeout(Some(std::time::Duration::from_secs(120))).ok();
61
+
62
+
use std::os::unix::io::AsRawFd;
63
+
let fd = tx.as_raw_fd();
64
+
let exe = std::env::current_exe().unwrap();
65
+
66
+
unsafe {
67
+
use std::os::unix::process::CommandExt;
68
+
let mut cmd = Command::new(&exe);
69
+
cmd.args(std::env::args().skip(1).filter(|a| a != "-d" && a != "--daemon"));
70
+
cmd.arg("--__child").arg(fd.to_string());
71
+
cmd.pre_exec(move || {
72
+
libc::fcntl(fd, libc::F_SETFD, 0); // clear close-on-exec
73
+
libc::setsid();
74
+
Ok(())
75
+
});
76
+
cmd.spawn().expect("Failed to spawn daemon");
77
+
}
78
+
drop(tx);
79
+
80
+
let mut buf = [0u8; 1];
81
+
match rx.read_exact(&mut buf) {
82
+
Ok(_) => std::process::exit(0),
83
+
Err(e) => { eprintln!("Daemon failed: {}", e); std::process::exit(1); }
84
+
}
85
+
}
86
+
87
+
// Child mode: signal parent when ready
88
+
let signal_fd: Option<i32> = matches.get_one::<String>("__child")
89
+
.and_then(|s| s.parse().ok());
90
+
91
+
let rt = tokio::runtime::Runtime::new().unwrap();
48
92
49
93
// Clean up any stale mount before proceeding
50
94
cleanup_stale_mount(&mountpoint);
···
128
172
});
129
173
}
130
174
131
-
println!("mounted at {mountpoint:?}");
132
-
print!("hit enter to unmount and exit...");
133
-
std::io::stdout().flush().unwrap();
134
-
135
-
// Wait for user input
136
-
let mut input = String::new();
137
-
std::io::stdin().read_line(&mut input).unwrap();
175
+
// Signal parent if in daemon mode
176
+
if let Some(fd) = signal_fd {
177
+
use std::os::unix::io::FromRawFd;
178
+
let mut sock = unsafe { UnixStream::from_raw_fd(fd) };
179
+
let _ = sock.write_all(b"R");
180
+
} else {
181
+
eprintln!("mounted at {mountpoint:?}");
182
+
eprintln!("ctrl-c to unmount");
183
+
}
138
184
139
-
println!("unmounted {mountpoint:?}");
185
+
// Wait for ctrl-c
186
+
rt.block_on(tokio::signal::ctrl_c()).ok();
187
+
eprintln!("unmounted {mountpoint:?}");
140
188
}
141
189
142
190
async fn cached_download(