1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
# TabFS
Mount your browser tabs as a filesystem!
<img src="doc/finder.png" width="500">
Each of your open tabs is mapped to a folder with a bunch of control
and live-updating content files inside it. (TODO: update as I add more)
<img src="doc/finder-contents.png" width="500">
This gives you a _ton_ of power, because now you can apply [all the
existing tools](https://twitter.com/rsnous/status/1018570020324962305)
on your computer that already know how to deal with files -- terminal
commands, scripting languages, etc -- and use them to control and draw
information from your browser. You don't need to write a browser
extension from scratch every time you want to do anything.
## Examples of stuff you can do!
(assuming your shell is in the `fs` subdirectory of this repo)
(TODO: more of these)
### List the titles of all the tabs you have open
```
$ cat mnt/tabs/by-id/*/title
GitHub
Extensions
TabFS/install.sh at master ยท osnr/TabFS
Alternative Extension Distribution Options - Google Chrome
Web Store Hosting and Updating - Google Chrome
Home / Twitter
...
```
### Close all Stack Overflow tabs
```
$ echo remove | tee -a mnt/tabs/by-title/*Stack_Overflow*/control
```
### Save text of all tabs to a file
(wip, FIXME)
```
$ cat mnt/tabs/by-id/*/text > text.txt
```
## Setup
**disclaimer**: security, functionality
First, install the browser extension.
Then, install the C filesystem.
### 1. Install the browser extension
(I think it will work on Edge or Opera or whatever, too. You'll need
to change the native messaging path in install.sh in those cases. Not
sure about Safari.)
#### in Chrome
Go to the [Chrome extensions page](chrome://extensions). Enable
Developer mode (top-right corner).
Load-unpacked the `extension/` folder in this repo.
**Make a note of the extension ID Chrome assigns.** Mine is
`jimpolemfaeckpjijgapgkmolankohgj`. We'll use this later.
#### in Firefox
You'll need to install as a "temporary extension", so it'll only last
in your current FF session.
Go to [about:debugging#/runtime/this-firefox](about:debugging#/runtime/this-firefox).
Load Temporary Add-on...
Choose manifest.json in the extension subfolder of this repo.
### 2. Install the C filesystem
First, make sure you `git submodule update --init` to get the
`fs/cJSON` and `fs/base64` dependencies.
And make sure you have FUSE. On Linux, for example, `sudo apt install
libfuse-dev`. On macOS, get FUSE for macOS.
```
$ cd fs
$ mkdir mnt
$ make
```
Now install the native messaging host into your browser, so the
extension can launch and talk to the filesystem:
#### Chrome and Chromium
Use the extension ID you copied earlier.
```
$ ./install.sh chrome jimpolemfaeckpjijgapgkmolankohgj
```
or
```
$ ./install.sh chromium jimpolemfaeckpjijgapgkmolankohgj
```
### 3. Ready!
Go back to `chrome://extensions` or
`about:debugging#/runtime/this-firefox` and reload the extension.
Now your browser tabs should be mounted in `fs/mnt`!
Open the background page inspector to see the filesystem operations
stream in. (in Chrome, click "background page" next to "Inspect views"
in the extension's entry in the Chrome extensions page; in Firefox,
click "Inspect")
<img src="doc/inspector.png" width="600">
This console is also incredibly helpful for debugging anything that
goes wrong, which probably will happen.
(My OS and applications are pretty chatty! They do a lot of
operations, even when I don't feel like I'm actually doing anything.)
## Design
- `fs/`: Native FUSE filesystem, written in C
- [`tabfs.c`](fs/tabfs.c): Talks to FUSE, implements fs operations, talks to extension.
- `extension/`: Browser extension, written in JS
- [`background.js`](extension/background.js): **The most interesting
file**. Defines all the synthetic files and what browser
operations they invoke behind the scenes.
<!-- TODO: concretize this -->
When you, say, `cat` a file in the tab filesystem:
1. `cat` makes something like a `read` syscall,
2. which goes to the FUSE kernel module which backs that filesystem,
3. FUSE forwards it to the `tabfs_read` implementation in our
userspace filesystem in `fs/tabfs.c`,
4. then `tabfs_read` rephrases the request as a JSON string and
forwards it to the browser extension over 'native messaging',
6. our browser extension in `extension/background.js` handles the
incoming message and calls the browser APIs to construct the data
for that synthetic file;
7. then the data gets sent back in a JSON native message to `tabfs.c`
and and finally back to FUSE and the kernel and `cat`.
(very little actual work happened here, tbh. it's all just
marshalling)
TODO: make diagrams?
## license
GPLv3
## hmm
processes as files. the real process is the browser.
browser and Unix
it's way too hard to make an extension. even 'make an extension' is
a bad framing. lightness
open input space -- filesystem
now you have this whole 'language', this whole toolset, to control and
automate your browser
OSQuery
fake filesystems talk
Screenotate
rmdir a non-empty directory
|
