tildefriends/docs/guide.md

# Philosophy

Tilde Friends is a platform for making, running, and sharing web applications.

When you visit Tilde Friends in a web browser, you are presented with a terminal interface, typically with a big text output box covering most of the page and an input box at the bottom, into which text or commands can be entered. A script runs to produce text output and consume user input.

The script is a Tilde Friends application, and it runs on the server, which means that unlike client-side JavaScript, it can have the ability to read and write files on the server or create network connections to other machines. Unlike node.js or other server-side runtime environments, applications are limited for security reasons to not interfere with each other or bring the entire server down.

Above the terminal, an "Edit" link brings a visitor to the source code for the current Tilde Friends application, which they can then edit, save as their own, and run.

# Architecture

Tilde Friends is a C++ application with a JavaScript runtime that provides restricted access to filesystem, network, and other system resources. The core process runs a core set of scripts that implement a web server, typically starting a new process for each visitor's session which runs scripts for the active application and stopping it when the visitor leaves.

Only the core process has access to most system resources, but session processes can be given accesss through the core process.

Service processes are identical to session processes, but they are not tied to a user session.

## Communication

In the same way that web browsers expose APIs for scripts running in the browser to modify the document, play sounds and video, and draw, Tilde Friends exposes APIs for scripts running on a Tilde Friends server to interact with a visitor's web browser, read and write files on the server, and otherwise interact with the world.

There are several distinct classes of APIs.

First, there are low-level functions exposed from C++ to JavaScript. Most of these are only available to the core process. These typically only go through a basic JavaScript to C++ transition and are relatively fast and immediate.

```js
// Displays some text to the server's console.
print('Hello, world!');
```

There is a mechanism for communicating between processes. Functions can be exported and called across process boundaries. When this is done, any arguments are serialized to a network protocol, deserialized by the other process, the function called, and finally any return value is passed back in the same way. Any functions referenced by the arguments or return value are also exported and can be subsequently called across process boundaries. Functions called across process boundaries are always asynchronous, returning a Promise. Care must be taken for security reasons to not pass dangerous functions ("deleteAllMydata()") to untrusted processes, and it is best for performance reasons to minimize the data size transferred between processes.

```js
// Send an "add" function to any other running processes.  When called, it
// will run in this process.
core.broadcast({
	add: function (x, y) {
		return x + y;
	},
});

// Receive the above message and call the function.
core.register('onMessage', function (sender, message) {
	message.add(3, 4).then((x) => terminal.print(x.toString()));
});
```

Finally, there is a core web interface that runs on the client's browser that
extends access to a running Tilde Friends script.

```js
// Displays a message in the client's browser.
terminal.print('Hello, world!');
```

## API Documentation

The Tilde Friends API is very much evolving.

All currently registered methods can be explored in the [documentation](https://www.tildefriends.net/~cory/documentation) app.

All browser-facing methods are implemented in [client.js](core/client.js). Most process-related methods are implemented in [core.js](core/core.js).

Higher-level behaviors are often implemented within library-style apps themselves and are beyond the scope of this document.

### Terminal

All interaction with a human user is through a terminal-like interface. Though it is somewhat limiting, it makes simple things easy, and it is possible to construct complicated interfaces by creating and interacting with an iframe.

#### terminal.print(arguments...)

Print to the terminal. Arguments and lists are recursively expanded. Numerous special values are supported as implemented in client.cs.

```js
// Create a link.
terminal.print({href: 'http://www.tildefriends.net/', value: 'Tilde Friends!'});

// Create an iframe.
terminal.print({
	iframe: '<b>Hello, world!</b>',
	width: 640,
	height: 480,
});

// Use style.
terminal.print({style: 'color: #f00', value: 'Hello, world!'});

// Create a link that when clicked will act as if the user typed a command.
terminal.print({command: 'exit', value: 'Get out of here.'});
```

#### terminal.clear()

Clears the terminal output.

#### terminal.readLine()

Read a line of input from the user.

#### terminal.setEcho(echo)

Controls whether the terminal will automatically echo user input. Defaults to true.

#### terminal.setPrompt(prompt)

Sets the terminal prompt. The default is ">".

#### terminal.setTitle(title)

Sets the browser window/tab title.

#### terminal.split(terminalList)

Reconfigures the terminal layout, potentially into multiple split panes.

```js
terminal.split([
	{
		type: 'horizontal',
		children: [
			{name: 'left', basis: '2in', grow: 0, shrink: 0},
			{name: 'middle', grow: 1},
			{name: 'right', basis: '2in', grow: 0, shrink: 0},
		],
	},
]);
```

#### terminal.select(name)

Directs subsequent output to the named terminal.

#### terminal.postMessageToIframe(iframeName, message)

Sends a message to the iframe that was created with the given name, using the browser's window.postMessage.

### Database

Tilde Friends uses lmdb as a basic key value store. Keys and values are all expected to be of type String. Each application gets its own isolated database.

#### database.get(key)

Retrieve the database value associated with the given key.

#### database.set(key, value)

Sets the database value for the given key, overwriting any existing value.

#### database.remove(key)

Remove the database entry for the given key.

#### database.getAlll()

Retrieve a list of all key names.

### Network

Network access is generally not extended to untrusted users.

It is necessary to grant network permissions to an app owner through the administration app.

Apps that require network access must declare it like this:

```json
{"permissions": ["network"]}
```

#### network.newConnection()

Creates a Connection object.

#### connection.connect(host, port)

Opens a TCP connection to host:port.

#### connection.read(readCallback)

Begins reading and calls readCallback(data) for all data received.

#### connection.write(data)

Writes data to the connection.

#### connection.close()

Closes the connection.