Skip to content
This repository
Newer
Older
100644 453 lines (339 sloc) 21.74 kb
af771596 »
2011-04-10 viewstream emitters
1 TermKit
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
2 +++ -
973a91fa »
2010-05-25 Add autocomplete keyboard selection
3 Goal: next gen terminal / command application
4
5 Addresses following problems:
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
6 1) Monospace character grid with ansi colors is not rich enough to display modern files / media / visualizations / metadata. Cannot effectively handle large output, long/wide tables or direct interaction.
973a91fa »
2010-05-25 Add autocomplete keyboard selection
7 2) Piping binary or text streams between apps is bad for everyone:
8 * Humans have to suffer syntax, cannot reflow/manipulate output in real-time
9 * Computers have to suffer ambiguities
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
10 3) Synchronous input/output makes you wait. SSH keystroke latency is frustrating.
11 4) String-based command line requires arcane syntax, results in mistakes, repeated attempts at escaping, etc.
12 5) Unix commands are "useless by default", and when asked, will only tell you raw data, not useful facts. e.g. "rwxr-xr-x" instead of "You can't edit this file."
13
14 +++ -
973a91fa »
2010-05-25 Add autocomplete keyboard selection
15
16 Programs / commands
17 * Output processor for common cli tools
18 * Custom implementation of ls and friends, with support for mimicking classic shell behaviour with a 2.0 twist
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
19 * SQL shell
973a91fa »
2010-05-25 Add autocomplete keyboard selection
20
21 Cool input scenarios:
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
22 * As you type, the command is visually tokenized and highlighted. tokens can display autocomplete suggestions, icons and indicators inline.
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
23 * Instead of quoting and escaping, keys like " and > just trigger the creation of special tokens which are visually different and represent e.g. a quoted string, an argument, a regular expression. to type the special characters literally, just press them twice. the 'command' is just the concatenation of these tokens, interpreted the same way a shell interprets a command.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
24 * Man pages are consulted inline with autocomplete options for arguments and (later) required arguments
973a91fa »
2010-05-25 Add autocomplete keyboard selection
25
26 Cool output scenarios:
27 * Listings of files, anywhere, show an icon with distinguished typography for filename vs meta. Quicklook integration on the icon.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
28 * Can complete several tasks at once asynchronously, show real-time progress for all of them together in e.g. a task-list widget.
973a91fa »
2010-05-25 Add autocomplete keyboard selection
29 * Command output is interactive: has elements which can be focused, selected/unselected, opened, right clicked, dragged and dropped
30
31 Good desktop citizen:
32 * Dragging a file on the terminal window makes a folder icon appear on the side for dropping it on the CWD. Can also drag the file into the command line to reference it as an argument.
33 * Can drag files, snippets, JSON/CSV off the terminal
34 * Tear-off tabs/windows
35
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
36 +++ - Roadmap
973a91fa »
2010-05-25 Add autocomplete keyboard selection
37
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
38 [0.1] UI prototype - DONE
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
39 [X] simulated in safari/webkit.app
40 [X] functional input line with tokenization, cursor keys and backspace/delete
41 [X] functional autocomplete on tokens
42 [X] simulated commands
43 [X] simulated output with collapsible sections
973a91fa »
2010-05-25 Add autocomplete keyboard selection
44
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
45 [0.2] App prototype - DONE
46 [X] cocoa app
47 [X] webkit in single window view
48 [X] design back-end protocol
49 [X] node JS back-end, running separately
50 [X] connect socket
51 [X] run session worker
52 [X] passive command implementation
53 [X] JS module template, integrated both runtimes.
54 [X] wrap unix executable
55 [X] interactive output
973a91fa »
2010-05-25 Add autocomplete keyboard selection
56
57 0.3: Command suite
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
58 [X] Redesign message protocol
af771596 »
2011-04-10 viewstream emitters
59 [X] Viewstream integration
33bc4ccb »
2011-04-17 Working output formatter w/ mime type annotation. Allow widgets to be…
60 [X] 5-pipe command execution
d77b1ec6 »
2011-05-07 Consistent ~ support
61 [X] fix tokenfield
20df933a »
2011-05-09 Don't autocomplete immediately after filling in
62 [X] filesystem autocomplete
4378ebdf »
2011-05-09 Change LS to output JSON listing of files. Add JSON pretty printer.
63 [X] OS X icon loading
64 [X] inline image display
65 [X] json pretty printer
be358872 »
2011-05-10 Grep with plaintext and json support. Universal dataIn reader.
66 [X] json grep
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
67 [ ] unix command execution
971183df »
2011-05-05 Fix autocompletion event handling around up/down arrows. Fix filesyst…
68 [ ] http get/post data piping
d77b1ec6 »
2011-05-07 Consistent ~ support
69 [ ] code syntax highlighting
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
70 [ ] command decoration
71 [ ] interactive execution
72 [ ] inline man-pages tips
73 [ ] version control
74 [ ] interactive quicklook
4378ebdf »
2011-05-09 Change LS to output JSON listing of files. Add JSON pretty printer.
75 [ ] wildcard handling
971183df »
2011-05-05 Fix autocompletion event handling around up/down arrows. Fix filesyst…
76 [ ] regexp hinter
4378ebdf »
2011-05-09 Change LS to output JSON listing of files. Add JSON pretty printer.
77
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
78
79 0.4: Network & Modularity
80 [ ] SSH tunneling
81 [ ] Stand-alone daemon
82 [ ] network preview / local edit
83 [ ] tabs
84 [ ] split off command processor rules / autocomplete handlers into separable blocks
85 [ ] server-side hook system
86 [ ] add plug-in mechanism with drop-in functionality
87
88 0.5: Interactive & Unix Upgrades
89 [ ] widget system
90 [ ] graphing suite
91 [ ] alt view for LS with usable permissions, dates, etc
92 [ ] active 'top' monitor
93 [ ] gnu parallel integration/clone
94
95 0.6: Theming
96 [ ] server-side push css/js / integrated web
97 [ ] themes / stylesheets
98
99 +++ Components
100
101 Node JS daemon = 'NodeKit'.
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
102 + Fast enough for server work, concurrency/scaling included
103 + New JS language features
104 + Cross-platform on unix
105 + Process / io / everything integration
106 + Self-contained binary, can be included in .app
107 - separate from UI / front-end, forced layer of indirection makes it unlike web programming
108 - no mac-specific APIs or low-level C access
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
109
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
110 => back-end platform, runs locally, can run remotely, or perhaps tunnel its interaction over SSH
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
111
112 WebKit/Cocoa front-end
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
113 + Rich, stylable display + jQuery
114 + New JS language features
115 + Intimate OS X access, Obj-C, bridgeable with JS
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
116
117 The split:
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
118 Front-end = display, formatting, interaction. Always local. Runs in an (enhanced) webview/browser with a websocket to back-end.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
119 Back-end:
120
121 1) Local NodeKit: Start node daemon on startup, connect using direct websocket ws://localhost:2222.
122 2) Remote NodeKit SSH: Daemon is running, use ssh to set up tunnel between local rand port # and remote 2222. connect local websocket to tunnel.
123 3) Remote NodeKit WSS: Daemon is running, use WSS to connect directly, must authenticate? don't want to replicate OpenSSH, but rudimentary auth could be useful.
e8fb1644 »
2010-10-18 Icon / QuickLook support + protocol bridge
124 4) Basic remote shell: No nodekit daemon. Only literal commands supported. Enough to execute e.g. "apt-get install termkit".
125
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
126 +++ UNIX execution model
127
128 In the traditional model of computing, a program has an input, an output and does some processing in between. A standard UNIX program follows this model closely, with the following pipes: standard in, out and error. Data flows in through standard in, and output flows either through the out or error pipes. This simple model allows us to chain programs together, redirect specific portions of output into log files and run commands in batch.
129
130 <img>
131
132 But however powerful, this model ignores an important factor in how programs are used, namely whether there is a person involved.
133
134 When run directly by a person, standard in is mainly hooked up to the keyboard while standard out will go directly to the display. The input will be irregular and error prone. The program will be interactive. Output will be unpredictable and formatted mainly for display purposes.
135
136 But if the program is part of a processing chain, hooked up to a data source and/or sink, the situation changes dramatically. The data is now structured, the operation of each step is predictable and certain guarantees have to be made about the formatting of the output. Programs might run for a long time, chugging away at invisible streams and passing around massive amounts of data.
137
138 These two contexts are radically different, but both are forced through the same standard pipes. Oddly enough, this multiplexing seems universally accepted and is woven throughout computing. And yet, it has some noticeable effects.
139
140 For instance, programs don't communicate anything about the data they're sending through: it's just an anonymous, binary stream. As a result, many programs have options to toggle their input/output between various formats, some for people, some for programs. Tools like git examine their environment and disable interactive mode if nobody's there to answer. Machine-friendly data may be requested in several formats. As a result, scripting together a command chain is a careful dance of matching impedances at each step.
141
142 However, because most tools are launched by people for people, the default interchange format of choice is still "somewhat parseable text". As a result, we still have to be careful with things like spaces or Unicode in filenames, in case someone puts text where it doesn't belong. It still matters sometimes whether there is a newline at the end of a file. A misplaced keystroke, easily missed in the cryptic bash wash, can wreak havoc. Relying on text makes us prone to errors, and has lead to a culture where new recruits have to pass a constant trial by fire—to not destroy their system at one of the many opportunities it gives them.
143
af771596 »
2011-04-10 viewstream emitters
144 In fact, where it seems to matter most is the interaction. Text has literally locked down our abililty to evolve the UI, by forcing us to use the same monospace character terminals the previous generations used. Even worse, we are still often limited to a headache inducing, fluorescent EGA color palette from 1984. A terminal can show you the load on your system, but it can't show you a historic graph. It can make little progress bars out of ASCII characters, but it can't show LaTeX math inline. Even the command-line itself with its clunky tab-complete, lack of text selection and standard copy/paste bears little resemblence to the standard text field widget we use every day in modern UIs.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
145
af771596 »
2011-04-10 viewstream emitters
146 In the past decade, user interaction has made astounding leaps. We consume and produce vast quantities of information daily. The web has changed from blobs of markup into full apps, with rich typography, complex infographics, inline interactivity, dynamic layout, etc. UIs like OS X have raised the bar on how we can present and interact with information naturally. Sure, fancy icons and smooth graphs are great in iLife, but they can also be used in technical applications. You are almost certainly sitting in front of a display with more than a million pixels. Why are you telling it to draw a dinky character terminal from the 80s?
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
147
148 <h2>A new model</h2>
149
150 Criticism is easy of course, but what can we do about it? Well, after giving it some thought, I think we need to rebuild the model from the ground up.
151
152 First of all, we need a way to separate out the data between people and programs. The easiest is to split our pipes into 5:
153 * Data In, Data Out
154 * View In, View Out
155 * Error Out
156
157 When chaining together programs, we make a chain out of the Data pipes like usual. The View pipes however are hooked up to a global controller which proxies to the user's terminal.
158
159 Processing of data proceeds normally, but with the additional property that meta-data is explicitly attached to the data pipes, indicating content type, format, name, etc. as available.
160
161 Next, we need a way for programs to output a rich and dynamic UI through the View pipes and receive callback events. This is where things get tricky, because it essentially comes down to network-transparency of UI. This is a complex problem and has only worked for a couple of things, i.e. X11 and the Web, and each comes with a huge set of baggage. We need something simpler, that can be implemented as a thin library in a hundred lines of code. It should still feel like a command-line terminal, but be flexible enough to allow all the things we expect from modern applications.
162
163 Finally, we need a better way to enter commands. We need a modern textfield widget that is aware of strings, regular expressions, pipes, and can do tricks like inline icons, visual tokens, autocomplete dropdowns, etc.
164
165 After all this pontificating, it should be no surprise I'm building something to try and solve this problem. I call it TermKit, a next-gen Terminal and systems tool platform. There's even a shiny icon:
166
167 <img>
168
af771596 »
2011-04-10 viewstream emitters
169 It consists of a desktop WebKit app acting as the front-end, with the UI built out of HTML/CSS and JavaScript. OS services like QuickLook are integrated through Cocoa.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
170
171 On the flip side is a Node.js daemon, connected through Socket.IO, which maintains shells, runs programs and streams the visible output back to the front-end.
172
173 The front-end and back-end exchange messages, which are routed to views on the front, and to worker processes on the back.
174
175 Combining the oil and water of command-line Unix and web isn't an easy job, but it's better than trying to make WebKit sing Unix, or making a rich front-end from scratch. After working on this on and off for a couple of months, I managed to get a prototype of the UI and daemon working, with QuickLook icons as icing on the cake:
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
176
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
177 <img>
178
179 It actually works, and the platform is pretty compelling. With Node.js you get a fast, asynchronous, scriptable back-end with excellent Unix libraries and modules. And using WebKit means you can display anything you can make in HTML5/CSS3, and millions know how to do it already.
180
181 However, despite the clear power of HTML5, it would be a mistake to make HTML the defacto output format of Unix: we'd be swapping one parseable text soup for a much bigger one.
182
183 <h2>Smart views</h2>
184
af771596 »
2011-04-10 viewstream emitters
185 Instead, I wrote a custom View layer. Using simple building blocks, like "item list", "sortable table", "image", "line graph" or "file with icon", the display is built. The idea is to have a wide range of UNIX concepts easily expressed, so it's easier to make nice UIs quickly. The View is interactive and can be updated asynchronously. Making a streaming dashboard is child's play for example.
186
187 On the back end, a bridge makes it easy to interface by instantiating objects and streaming them to the front-end.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
188
189 At the same time, you have access to HTML/CSS if you need it, or you can skip it altogether and just print plain text as well.
190
191 But what about the actual data? While it may sometimes be piped into a file, usually the data has to be displayed at the end. In the new model, data doesn't go to the terminal anymore, which complicates matters.
192
193 Imagine the case of "ls | grep": we're filtering items in a directory, which is displayed as a listing of files and icons. When the listing is output by "ls", sending it on the View out would send it directly to the terminal, preventing grep from filtering the items. If we instead pipe the items through grep, we lose the ability to view the data at all since it will remain in its raw form.
194
af771596 »
2011-04-10 viewstream emitters
195 To solve this, I use the meta-data added to each data pipe, with another unholy web ingredient: MIME. This allows me to keep the data pure, and identify it through its Content-Type and other values. In the case of "ls", we keep piping around plain-text filenames separated by newlines like before, but we annotate it so we can format it at the end of the command chain.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
196
af771596 »
2011-04-10 viewstream emitters
197 The formatter reads the final data and turns it into a View graph, and can be extended to display files, images, JSON, source code, diffs, etc. This can be enabled for existing tools by deriving the Content-Type based on the command. It also makes TermKit web-transparent: you can hook up the data pipes to HTTP GET and POST, and the header information will be correctly interpreted.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
198
199 <h2>Possibilities</h2>
200
af771596 »
2011-04-10 viewstream emitters
201 In practice, the Data/View split has been there all along. It comes down to people vs programs, and the line is not hard to draw. "Wget" outputs a progressbar while streaming data into a file. "Top" displays an interactive dashboard that updates continuously. In this model, each application can do both interactive tasks and data processing tasks at the same time, and do each in the most natural format for the job.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
202
af771596 »
2011-04-10 viewstream emitters
203 Additionally, routing view commands this way allows parallel or background processes to update the view independently in the scrollback, instead of colliding with each other and the prompt.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
204
205 The separation between front-end and back-end also brings other benefits: the back-end can be run remotely, tunneling the websocket over SSH to a local front-end. You get latency-free interaction for remote operations. Even more, we can replace the consoles-within-terminals of SQL and SFTP, and elevate them to first-class shells with all the benefits of the new interaction model.
206
af771596 »
2011-04-10 viewstream emitters
207 Doesn't this mean rewriting all our tools? Not necessarily. Traditional Unix tools can be slotted in transparently, they just don't get the benefits of asynchronous output. Wrapper scripts can add additional functionality, e.g. to give GIT colored, side-by-side diffs or show version control status in an 'ls' listing.
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
208
209 <h2>Status</h2>
210 I've been slowly working on TermKit for about a year now, but it's still mostly vaporware. When I started, I didn't know what the right solution would look like, I just knew I wanted something more modern and usable. There's been a lot of writing and rewriting of code just to get to this stage. It also doesn't help that I'm a code perfectionist in unfamiliar territory.
211
af771596 »
2011-04-10 viewstream emitters
212 The reason I wanted to blog about it is because all of the above is starting to sound like a really compelling argument to me. The idea is to create a flexible platform for making better tools, built out of cross-platform parts and with enough useful assumptions built-in to make a difference.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
213
af771596 »
2011-04-10 viewstream emitters
214 Feedback is welcome, and I invite you to browse the GitHub repo which has mockups and some code diagrams.
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
215
216
217 +++ Protocol considerations
218
219
220 The output of a termkit command is split into data and view. The data is the raw information that is piped from one process to the next.
221
222 The view is a stream of dom-like objects and operators on them.
223
af771596 »
2011-04-10 viewstream emitters
224 View and data are fundamentally different:
225 * Data is a raw binary stream with meta-data annotation, from one process' stdout to another's stdin
226 * View is a packetized stream of UI updates and callback events, going directly to the terminal.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
227
228
229 +++ Command architecture
230
231 The webkit front end is intended to be a view first and foremost. It is an active view that maintains its own contents based on messages to and from the back-end.
232
233 problem: if front-end is agnostic, then how to make commands smarter?
234
235 > shell-OS interface is server-side
236 > server-side only executes processes/commands, routes streams and provides output.
237 > separeate data in/out from ui in/out. datastream vs viewstream
238
239 data in/out:
240 content-type: unix/pipe
241 application/jsonstream
242 ...
243
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
244
245 [ Front-End ] -----> [ Back-end ]
246 [ WebKit ] websocket [ Node.js ]
247 |
248 |
249 v *
250 [ Shell ]
251 [ Worker.js ]
252
253
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
254 Worker sets up process chain:
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
255
1cf66f2c »
2010-11-15 - Cocoa: windows and tabs created on demand
256
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
257 view in - callbacks / command stream
258 view out - view stream
259 stdin = data in (mime typed)
260 stdout = data out (mime typed)
1cf66f2c »
2010-11-15 - Cocoa: windows and tabs created on demand
261
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
262 | callbacks ^ view stream: view updates
263 stdin v |
264 ----> [ "command [args...]" ] ---->
265 stdout
266
267 View streams are multiplexed and sent to the front-end.
268 Front-end callbacks are routed back to the right process.
269
270 Each process has its own view, referenced by ID number.
271 Processes cannot break out of their view.
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
272
273
d2e41bf5 »
2010-09-20 Spin off shell interaction to separate worker.js. Stream environment …
274 +++ Data vs UI glue
275
276 e.g.
277 get http://.../rss.xml
278 content-type: application/xml
279
280 -> process streams out xml data
281
282 get | grep
283 Data Stream: .txt|html|... > .txt|html|...
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
284 View Stream: file metadata, download progress, grep stats (# hits)
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
285 Output Formatting: turn application/xml into dynamic XML tree.
d2e41bf5 »
2010-09-20 Spin off shell interaction to separate worker.js. Stream environment …
286
287 get | ungzip | untar
288 Data Stream: .gz > .tar > nothing
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
289 View Stream: file metadata, download progress, unzip progress (# files)
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
290 Output Formatting: no data output.
d2e41bf5 »
2010-09-20 Spin off shell interaction to separate worker.js. Stream environment …
291
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
292 The output formatter takes a mime-typed blob and turns into a display.
293 - Plain text or HTML
294 - Images
295 - Binary data (hex or escaped)
296 - Url/file reference with icon
297 ...
298
299 Existing tools are wrapped to provide richer output, either by parsing
300 old school output or by interacting directly with the raw library.
d2e41bf5 »
2010-09-20 Spin off shell interaction to separate worker.js. Stream environment …
301
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
302 +++ stream structure
303
304 ><{
305 termkit: '1'
306 }
307
308 >{
309 query: 1
310 method: session.open
311 args:
312 }
313 <{
314 answer: 1
315 success: true
316 args: {
317 session: 1
318 }
319 }
320 >{
321 query: 2
322 method: shell.environment
323 session: 1
324 }
325 <{
326 answer: 2,
327 success: true
328 args: { ... }
329 }
330 >{
331 query: 3
332 method: shell.run
333 session: 1
334 args: {
335 command: ...
336 id: 0
337 }
338 }
339 <{
340 method: view.allocate,
341 session: 1
342 args: {
343 id: 0
344 views: [0, 1]
345 }
346 }
347 <{
348 method: view.add,
349 session: 1
350 args: {
351 view: 0
352 target: null
353 objects: [ ... ]
354 }
355 }
356 <{
357 method: view.add,
358 session: 1
359 args: {
360 view: 0
361 target: [ 0 ]
362 objects: [ ... ]
363 }
364 }
365 >{
366 method: view.callback,
367 session: 1
368 args: {
369 view: 0,
370 message: { .. }
371 }
372 }
373 <{
374 method: view.update
375 args: { ... }
376 }
377 <{
378 answer: 3,
379 success: true,
380 args: {
381 code: 0,
382 }
383 }
384
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
385
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
386 viewstream:
387
971183df »
2011-05-05 Fix autocompletion event handling around up/down arrows. Fix filesyst…
388 > shell-specific interaction rules are server-side.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
389 > rich widget lib for display, extensible
d2e41bf5 »
2010-09-20 Spin off shell interaction to separate worker.js. Stream environment …
390 > widgets are streamed to client like termkit-ML. objects are smartly typed and have callback commands defined for them. callbacks can be stateful or stateless. though stateful is only intended to be used for interactive commands.
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
391
971183df »
2011-05-05 Fix autocompletion event handling around up/down arrows. Fix filesyst…
392 tableview / listcontainer -> generic, scales from simple list to tabled headers w/ simple syntax
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
393 object references for files and other things. are multi-typed and annotated on server-side.
51ff5991 »
2010-07-21 Add Cocoa app. Reorganize graffles
394
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
395 +++ --
51ff5991 »
2010-07-21 Add Cocoa app. Reorganize graffles
396 references:
397
398 textmate html output features
399 http://blog.macromates.com/2005/html-output-for-commands/
400
401 bcat: browser cat tool
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
402
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
403 terminator: java-based terminal++
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
404
b8e22307 »
2011-04-10 Rewrite command/view protocol, use simpler routing. Execution pipeline.
405 protocol:
406 fastcgi
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
407
408 command output:
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
409 * rich output, consisting of an element tree
410 * simple container types (list, table) and various viewers to represent common objects and data types
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
411
412 current widget model:
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
413 * use a viewcontroller for each widget
414 * viewcontroller own its own markup
415 * simple object instantiation, widgets can create child widgets
3f763cef »
2010-09-17 WebSocket bridge between WebKit front-end and node.js back-end, w/ me…
416
417 more ideas:
418 * autocorrection of mistyped commands
419 * unified progress indicator during command
420 * history access
421 * don't execute if invalid command
9b36728d »
2010-10-10 Somewhat working view-stream and outputview tree
422
9a8175a7 »
2011-05-09 Don't let autocomplete block submit
423
424 +++ -
425
426 Code base on May 9th 2011
427
428 front
429 1200 tokenfield + autocomplete
430 690 output view
431 393 command handling
432 184 shell client
433 181 misc
434 465 CSS
435 55 HTML
436 = 3168
437
438 back
439 204 builtin commands
440 214 autocomplete
441 255 output formatter
442 250 command handling
443 103 router
444 166 misc
445 162 view bridge
446 160 processor
447 83 shell
448 = 1597
449
450 tests = 162
451
452 4927 lines of code
453 + jquery + socket.io + syntax highlighter + node + node-mime
Something went wrong with that request. Please try again.