neil/silverbullet
1
0
Fork 0
Code

Merge branch 'main' of github.com:silverbulletmd/silverbullet

Browse Source
This commit is contained in:
Zef Hemel 2022-07-25 14:11:40 +02:00
commit 8f790d6219
14 changed files with 286 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
README.md
View File

@ -1,113 +1,71 @@
# Silver Bullet
Silver Bullet (SB) is a highly extensible, open source **personal knowledge playground**. At its core it’s a Markdown-based writing/note taking application that stores _pages_ (notes) as plain markdown files in a folder referred to as a _space_. Pages can be cross-linked using the `[[link to other page]]` syntax. This makes it a simple tool for [Personal Knowledge Management](https://en.wikipedia.org/wiki/Personal_knowledge_management). However, once you leverage its various extensions (called _plugs_) it can feel more like a _knowledge playground_, allowing you to annotate, combine and query your accumulated knowledge in creative ways, specific to you.
Silver Bullet (SB) is an extensible, open source **personal knowledge platform**. At its core it’s a clean markdown-based writing/note taking application that stores your _pages_ (notes) as plain markdown files in a folder referred to as a _space_. Pages can be cross-linked using the `[[link to other page]]` syntax. This makes it a simple tool for [Personal Knowledge Management](https://en.wikipedia.org/wiki/Personal_knowledge_management). However, once you leverage its various extensions (called _plugs_) it can feel more like a _knowledge platform_, allowing you to annotate, combine and query your accumulated knowledge in creative ways specific to you.
So what is it SB _really_? That is hard to answer. It can do a ton of stuff out of the box, and I’m constantly finding new use cases. It’s like... a silver bullet!
For more in-depth information, an interactive demo, and links to more background, check out the [Silver Bullet website](https://silverbullet.md) (published from this repo’s `website/` folder).
Below is what it looks like in action (when run on the `website` folder in this repo).
Or checkout these two videos:
![Screenshot](https://raw.githubusercontent.com/zefhemel/silverbullet/main/images/silverbullet1.png)
And [here is a video of me demoing some of its features](https://www.youtube.com/watch?v=RYdc3UF9gok).
Here’s how I use it today (but this has grown significantly over time):
* Basic note taking, e.g. meeting notes, notes on books I read, blogs I read, podcasts I listen to, movies I watch.
* Getting a quick glance at the work people in my team are doing by pulling data from our 1:1 notes, recent activity on Github (such as recent pull requests) and other sources.
* Writing:
* [My blog](https://zef.plus) is published via SB’s [Ghost](https://ghost.org) plugin.
* An internal newsletter that I write is written in SB.
* Performance reviews for my team (I work as a people manager) are written and managed using SB (for which I extensively use SB’s meta data features and query that data in various ways).
* A custom SB plugin aggregates data from our OpsGenie account every week, and publishes it to our [Mattermost](https://mattermost.com/) instance.
* It powers part of my smart home: I wired HomeBridge webhooks up to custom HTTP endpoints exposed by my custom smart home SB plug.
That’s a pretty crazy wide range of use cases!
I know, right?
**Disclaimer:** Silver Bullet is under heavy development and significant changes under the hood happen constantly. It’s also low on automated tests and documentation. All this will improve over time. I’ll do better, I promise.
More documentation can be found in the [website space](https://github.com/zefhemel/silverbullet/tree/main/website)
* [A Tour of some of Silver Bullet’s features](https://youtu.be/RYdc3UF9gok) — spoiler alert: it’s cool.
* [A look the SilverBullet architecture](https://youtu.be/mXCGau05p5o) — spoiler alert: it’s plugs all the way down.
## Features
* **Free and open source**
* **Minimalistic** UI with [What You See is What You Mean](https://en.wikipedia.org/wiki/WYSIWYM) Markdown editing.
* **Future proof**: stores all notes in a regular folder with markdown files, no proprietary file formats. While SB uses a SQLite database for indexes, this database can be wiped and rebuilt based on your pages at any time. Your Markdown files are the single source of truth.
* **Run anywhere**: run it on your local machine, or install it on a server. You access it via your web browser (desktop or mobile), or install it as a PWA (giving it its own window frame and dock/launcher/dock icon).
* **Keyboard oriented:** you can fully operate SB via the keyboard.
* **Extensible** through plugs.
* **Free and open source**. Silver Bullet is MIT licensed.
* **The truth is in the markdown.** Silver Bullet doesn’t use proprietary file formats. It keeps it data as plain markdown files on disk. While SB uses a database for indexing and caching some indexes, all of that can be rebuilt from its markdown source at any time. If SB would ever go away, you can still read your pages with any text editor.
* **One single, distraction free mode.** SB doesn’t have a separate view and edit mode. It doesn’t have a “focus mode.” You’re always in focused edit mode, why wouldn’t you?
* **Keyboard oriented**. You can use SB fully using the keyboard, typin’ the keys.
* **Extend it your way**. SB is highly extensible with [plugs](https://silverbullet.md/🔌_Plugs), and you can customize it to your liking and your workflows.
## Installing and running Silver Bullet
## Installing Silver Bullet
To install Silver Bullet, you will need a recent version of [node.js installed](https://nodejs.org/en/) (16+) installed. Silver Bullet has only been tested on MacOS and Linux thus far. It may run on Windows as well, let me know if it does.
## Start with docker
First you have to clone the repo, then configure your port, space/directory in .env file
then run
```
docker compose up
```
then open your browser and ROCK!
e.g.
```
localhost:PORT
```
## Start without docker
To run a release version, you need to have a recent version of npm (8+) and node.js (16+) installed as well as some basic build infrastructure (make, cpp). Silver Bullet has only been tested on MacOS and Linux thus far.
To install and run, create a folder for your pages (can be empty or an existing folder with `.md` files) and run:
To install and run SB, create a folder for your pages (it can be empty, or be an existing folder with `.md` files) and run the following command in your terminal:
npx @silverbulletmd/server <path-to-folder>
Optionally you can use the `--port` argument to specify a HTTP port (defaults to `3000`) and you can pass a `--password` flag to require a password to access. Note this is a rather weak security mechanism, so it’s recommended to add additional layers of security on top of this if you run this on a public server somewhere (at least add TLS). Personally I run it on a tiny Linux VM on my server at home, and use a VPN (Tailscale) to access it from outside my home.
## Stack
* Written in [TypeScript](https://www.typescriptlang.org/)
* Built on the excellent [CodeMirror 6](https://codemirror.net/) editor component
* Front-end (beside CodeMirror) is built using React.js
* [ParcelJS](https://parceljs.org/) is used to build both the front-end and back-end
* Backend runs on node.js using express
## Development
This Silver Bullet repo is a monorepo using npm's "workspaces" feature.
This will do one of three things:
Requirements:
- node 18+ and npm 8+
- C/C++ compilers (for compiling SQLite, on debian/ubuntu style systems you get these via the `build-essential` package)
- python v2.7
1. If you _don’t have_ SB installed, it will download and run the latest version.
2. If you _already have_ SB installed, but there is a newer version available, it will offer to upgrade. Say yes!
3. If you _already have the latest and greatest_ SB installed, it will just run it.
> **Note**
> If you use nvm, you can just `nvm install` and it should use the right version
By default, SB will bind to port `3000`, to use a different port use the `--port` flag. By default SB doesn’t offer any sort of authentication, to add basic password authentication, pass the `--password` flag.
> **Note**
> On MacOs Monterey, python v2.7 is no longer shipped, if you install pyenv, you can `pyenv install` and it should use the right version
Once downloaded and booted, SB will print out a URL to open SB in your browser (spoiler alert: by default this will be http://localhost:3000 ).
#protip: If you have a PWA enabled browser (like any browser based on Chromium) hit that little button right of the location bar to install SB, and give it its own window frame (sans location bar) and desktop/dock icon. At last the PWA has found its killer app.
To run, after clone:
## Developing Silver Bullet
Silver Bullet is written in [TypeScript](https://www.typescriptlang.org/) and built on top of the excellent [CodeMirror 6](https://codemirror.net/) editor component. Additional UI is built using React.js. [ParcelJS](https://parceljs.org/) is used to build both the front-end and back-end bundles. The server backend runs as a HTTP server on node.js using express.
This repo is a monorepo using npm's "workspaces" feature. It consists of a number of npm packages under `packages`.
Requirements: node 16+ and npm 8+ as well as C/C++ compilers (for compiling SQLite, on debian/ubuntu style systems you get these via the `build-essential` package).
After cloning the repo, run the following commands to do an initial build:
```shell
# Install dependencies
npm install
# Run initial build (web app, server, etc.)
npm run build
# Again, to install the CLIs just built (plugos-bundler, silverbullet)
npm install
# Build built-in plugs
npm run build-plugs
# Launch server
npm run clean-build
```
You can then run the server in “watch mode” (automatically restarting when you change source files) with:
```shell
npm run server -- <PATH-TO-YOUR-SPACE>
```
This `<PATH-TO-YOUR-SPACE>` can be any folder with markdown files, upon first boot SB will ensure there is an `index.md` file (root page) and `PLUGS.md` file (with default list of plugs to load). SB will also create a SQLite `data.db` file with various data caches and indices (you can delete this file at any time and use the `Space: Reindex` command to reindex everything).
`<PATH-TO-YOUR-SPACE>` can be any folder with markdown files (or an empty folder).
Open SB at http://localhost:3000 If you're using a browser supporting PWAs, you can install this page as a PWA. This also works on iOS (use the "Add to homescreen" option in the share menu).
After this initial build, I generally run three commands in parallel (in separate terminals):
General development workflow:
Run these in separate terminals
```shell
# Runs ParcelJS in watch mode, rebuilding the server and webapp continuously on change
npm run watch
# Runs the silverbullet server
# Runs the silverbullet server, restarting when changes are detected
npm run server -- <PATH-TO-YOUR-SPACE>
# Builds (and watches for changes) all builtin plugs (in packages/plugs)
# Builds (and watches for changes) all builtin plugs (in packages/plugs), still requires you to run Cmd-Shift-p (Mac) or Ctrl-Shift-p (Linux, Windows) in SB to reload these plugs
npm run plugs
```
## Feedback
If you (hypothetically) find bugs or have feature requests, post them in [our issue tracker](https://github.com/silverbulletmd/silverbullet/issues). Would you like to contribute? [Check out the code](https://github.com/silverbulletmd/silverbullet), and the issue tracker as well for ideas on what to work on.

5
packages/plugs/core/core.plug.yaml
View File

@ -280,7 +280,10 @@ functions:
path: "./plugmanager.ts:getPlugGithub"
events:
- get-plug:github
getPlugGithubRelease:
path: "./plugmanager.ts:getPlugGithubRelease"
events:
- get-plug:ghr
# Debug commands
parseCommand:
path: ./debug.ts:parsePageCommand

15
packages/plugs/core/plugmanager.ts
View File

@ -92,3 +92,18 @@ export async function getPlugGithub(identifier: string): Promise<Manifest> {
`//raw.githubusercontent.com/${owner}/${repoClean}/${branch}/${path}`
);
}
export async function getPlugGithubRelease(identifier: string): Promise<Manifest> {
let [owner, repo, version] = identifier.split("/");
if (!version || version === "latest") {
console.log('fetching the latest version');
const req = await fetch(`https://api.github.com/repos/${owner}/${repo}/releases/latest`);
if (req.status !== 200) {
throw new Error(`Could not fetch latest relase manifest from ${identifier}}`);
}
const result = await req.json();
version = result.name;
}
const finalUrl = `//github.com/${owner}/${repo}/releases/download/${version}/${repo}.plug.json`;
return getPlugHTTPS(finalUrl);
}

34
website/Mounts.md
View File

@ -1,34 +0,0 @@
This is currently implemented in [this github repo](https://github.com/silverbulletmd/silverbullet-mount):
Space mounting in `MOUNTS`
```yaml
- path: file:/Users/zef/git/blog
prefix: blog/
perm: ro,rw #default rw
- path: http://someIP:3000
prefix: prod/
```
Features
* Auto translates internal wiki links (prefixes with prefix) and removes prefix upon save
To do:
* [ ] Handle queries
* `page` and `link` query needs to dynamically add/remove a `and name =~ /^🚪 PREFIX/` clause)
* `task` same but with `page` check
* [x] Add `file:` support
* [x] Add `http:`/`https:` support
* Due to namespacing, the mounted space needs to be namespaced somehow
* Could be an emoji, could be a page prefix (now using `name`)
* On the fly link rewriting on read and write with prefix
* Will require an actual set of `fs` syscalls:
* readFile(path)
* writeFile(path, text)
* listFiles(path) with stat-like results (at least enough for `PageMeta` responses)
* If this exists, should not all disk file access work through plugs as well and have that abstraction happen at this level?
protocols:
* file:
* http/https with “password” field for authentication

36
website/index.md
View File

@ -2,17 +2,18 @@
## Markdown as a platform
Silver Bullet (SB) is highly-extensible, [open source](https://github.com/silverbulletmd/silverbullet) **personal knowledge management** software. Indeed, that’s fancy language for “a note taking app with links.”
At its core, SB is a Markdown editor that stores _pages_ (notes) as plain markdown files in a folder referred to as a _space_. Pages can be cross-linked using the `[[link to other page]]` syntax. However, once you leverage its various extensions (called _plugs_) it can feel more like a _knowledge playground_, allowing you to annotate, combine and query your accumulated knowledge in creative ways, specific to you. To get a good feel for it, [watch this video](https://youtu.be/RYdc3UF9gok).
At its core, SB is a Markdown editor that stores _pages_ (notes) as plain markdown files in a folder referred to as a _space_. Pages can be cross-linked using the `[[link to other page]]` syntax. However, once you leverage its various extensions (called _plugs_) it can feel more like a _knowledge platform_, allowing you to annotate, combine and query your accumulated knowledge in creative ways, specific to you. To get a good feel for it, [watch this video](https://youtu.be/RYdc3UF9gok).
What does Silver Bullet look like? Well, have a look around. **You’re looking at it at this very moment!** 🤯
Note that what you’re looking at is not a fully functional version, because the _back-end is read-only_. That said, it should give you some feel for what it’s like to use SB before making the commitment of running a single `npx` command (see below) to download and run it locally in its fully functioning mode.
## Start playing
So, feel free to make some edits in this space. Don’t worry, you won’t break anything, nothing is saved (just reload the page to see).
Here are some things to try:
* Click on the page name at the top, or hit `Cmd-k` (Mac) or `Ctrl-k` (Linux and Windows) to open the **page switcher**. Type the a name of a non-existing page to create it (although it won’t save in this environment).
* Click on the page title (`index` for this particular one) at the top, or hit `Cmd-k` (Mac) or `Ctrl-k` (Linux and Windows) to open the **page switcher**. Type the a name of a non-existing page to create it (although it won’t save in this environment).
* Click on the run button (top right) or hit `Cmd-/` (Mac) or `Ctrl-/` (Linux and Windows) to open the **command palette** (note not all commands will work in this quasi read-only mode).
* Select some text and hit `Alt-m` to ==highlight== it, or `Cmd-b` (Mac) or `Ctrl-b` to make it **bold**.
* Click a link somewhere in this page to navigate there.
@ -24,16 +25,28 @@ Here are some things to try:
* Open this site on your phone or tablet and… it just works!
* Are you using a browser with **PWA support** (e.g. any Chromium-based browser)? Click on that little icon to the right of your location bar that says “Install Silver Bullet” to give SB its own window frame and desktop icon, like it is a stand-alone app (not particularly useful on silverbullet.md, but definitely do this once you install it yourself).
Cool, no?
There are a few features you don’t get to try in this environment, because they rely on some back-end processing, such as:
There are a few features you don’t get to fully experience in this environment, because they rely on a working back-end, such as:
* Using SB’s powerful page indexing and **query mechanism** where part of pages are automatically rendered and kept up to date by querying various data sources (such as pages and their metadata, back links, tasks embedded in pages, and list items) with an SQL like syntax, rendered with handlebars templates.
* Intelligent page renaming, automatically updating any pages that link to it.
* Full text search.
* Dynamically **extending** and updating SB’s functionality by installing additional [[🔌 Plugs]] and writing your own.
* Intelligent **page renaming**, automatically updating any pages that link to it.
* **Full text search**.
* **Extending** and updating SB’s functionality by installing additional [[🔌 Plugs]] (SB parlance for plug-ins) and writing your own.
To experience these, you’ll have to install SB yourself (see below).
## Extensions
What type of extensions, you ask? Let us demonstrate this in a very meta way: by querying a list of plugs and injecting it into this page!
Here’s a list of (non-built in) plugs documented in this space (note the `#query` ... `/query` notation used):
<!-- #query page where type = “plug” render “template/plug” -->
* [[🔌 Git]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-github))
* [[🔌 Ghost]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-ghost))
* [[🔌 Github]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-github))
* [[🔌 Mattermost]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-mattermost))
* [[🔌 Mount]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-mount))
* [[🔌 Backlinks]] by **Guillermo Vayá** ([repo](https://github.com/Willyfrog/silverbullet-backlinks))
<!-- /query -->.
In a regular SB installation, the body of this query 👆 (in between the placeholders) would automatically be kept up to date as new pages are added to the space that match the query. 🤯 Have a look at the [[template/plug]] _template_ (referenced in the `render` clause) to see how the results are rendered using handlebars syntax, and have a look at one of the linked pages to see how the _meta data_ is specified, which is subsequently used to query and render in this page. And to learn about the specific plug, of course.
## Explore more
Click on the links below to explore various aspects of Silver Bullet more in-depth:
@ -54,7 +67,6 @@ Some core principles that underly Silver Bullet’s philosophy:
* **Free and open source**. Silver Bullet is MIT licensed.
* **The truth is in the markdown.** Markdown is simply text files, stored on disk. Nothing fancy. No proprietary formats or lock in. While SB uses a database for indexing and caching some data, all of that can be rebuilt from its markdown source at any time. If SB would ever go away, you can still read your pages with any text editor.
* **What you see is what it is.** No magic or hidden content.
* **Single, distraction free mode.** SB doesn’t have a separate view and edit mode. It doesn’t have a “focus mode.” You’re always in focused edit mode, why wouldn’t you?
* **Keyboard oriented**. You can use SB fully using the keyboard, typin’ the keys.
* **Extend it your way**. SB is highly extensible with [[🔌 Plugs]], and you can customize it to your liking and your workflows.
@ -66,10 +78,10 @@ To install and run SB, create a folder for your pages (it can be empty, or be an
npx @silverbulletmd/server <path-to-folder>
Optionally you can use the `—port` argument to specify a HTTP port (defaults to `3000`) and you can pass a `—password` flag to require a password to access. Note this is a rather weak security mechanism, so it’s recommended to add additional layers of security on top of this if you run this on a public server somewhere (at least add TLS). Personally I run it on a tiny Linux VM on my server at home, and use a VPN (Tailscale) to access it from outside my home.
Optionally you can use the `--port` argument to specify a HTTP port (defaults to `3000`) and you can pass a `--password` flag to require a password to access. Note this is a rather weak security mechanism, so it’s recommended to add additional layers of security on top of this if you run this on a public server somewhere (at least add TLS). Personally I run it on a tiny Linux VM on my server at home, and use a VPN (Tailscale) to access it from outside my home.
Once downloaded and booted, you will be provided with a URL to open SB in your browser (spoiler alert: by default this will be http://localhost:3000 ).
That’s it! Enjoy.
If you (hypothetically) find bugs or have feature requests, post them in [our issue tracker](https://github.com/silverbulletmd/silverbullet). Want to contribute? [Check out the code](https://github.com/silverbulletmd/silverbullet).
If you (hypothetically) find bugs or have feature requests, post them in [our issue tracker](https://github.com/silverbulletmd/silverbullet/issues). Want to contribute? [Check out the code](https://github.com/silverbulletmd/silverbullet).

1
website/template/plug.md Normal file
View File

@ -0,0 +1 @@
* [[{{name}}]] by **{{author}}** ([repo]({{repo}}))

10
website/🔌 Backlinks.md Normal file
View File

@ -0,0 +1,10 @@
```meta
type: plug
uri: ghr:Willyfrog/silverbullet-backlinks
repo: https://github.com/Willyfrog/silverbullet-backlinks
author: Guillermo Vayá
```
Provides access to pages that link to the one currently being edited.
Use the `Show Backlinks for current page` command to toggle.

28
website/🔌 Ghost.md Normal file
View File

@ -0,0 +1,28 @@
```meta
type: plug
uri: github:silverbulletmd/silverbullet-ghost/ghost.plug.json
repo: https://github.com/silverbulletmd/silverbullet-ghost
author: Zef Hemel
```
Very basic plug to publish pages and posts onto the [Ghost](https://ghost.org) platform
## Configuration
In your `SETTINGS` specify the following settings:
```yaml
ghostUrl: https://your-ghost-blog.ghost.io
ghostPostPrefix: posts
ghostPagePrefix: pages
```
And in your `SECRETS` file:
```yaml
ghostAdminKey: your:adminkey
```
This will assume the naming pattern of `posts/my-post-slug` where the first top-level heading (`# Hello`) will be used as the post title.
Commands to use `Ghost: Publish`

18
website/🔌 Git.md Normal file
View File

@ -0,0 +1,18 @@
```meta
type: plug
uri: github:silverbulletmd/silverbullet-github/github.plug.json
repo: https://github.com/silverbulletmd/silverbullet-github
author: Zef Hemel
```
The git plug provides very basic “git sync” functionality, it assumes you have git configured for push and pull in your space. It offers two commands:
* `Git : Sync`:
* Adds all *.md files in your folder to git
* It commits them with a "Snapshot" commit message
* It `git pull`s changes from the remote server
* It `git push`es changes to the remote server
* `Git: Snapshot`:
* Asks you for a commit message
* Commits

32
website/🔌 Github.md Normal file
View File

@ -0,0 +1,32 @@
```meta
type: plug
uri: github:silverbulletmd/silverbullet-github/github.plug.json
repo: https://github.com/silverbulletmd/silverbullet-github
author: Zef Hemel
```
Provides Github events, notifications and pull requests as query sources using SB's query mechanism
* `gh-event` required filters in the `where` clause:
* `username`: the user whose events to query
* `gh-pull`
* `repo`: the repo to query PRs for
* `gh-notification` requires a `githubToken` to be configured in `SECRETS`.
## Example
Example uses:
## Recent pushes
<!-- #query gh-event where username = "zefhemel" and type = "PushEvent" select type, actor_login, created_at, payload_ref limit 3 -->
<!-- /query -->
## Recent PRs
<!-- #query gh-pull where repo = "silverbulletmd/silverbullet" and user_login = "zefhemel" limit 3 render "template/gh-pull" -->
<!-- /query -->
Where the `template/gh-pull` looks as follows:
* ({{state}}) [{{title}}]({{html_url}})

70
website/🔌 Mattermost.md Normal file
View File

@ -0,0 +1,70 @@
```meta
type: plug
uri: github:silverbulletmd/silverbullet-mattermost/mattermost.plug.json
repo: https://github.com/silverbulletmd/silverbullet-mattermost
author: Zef Hemel
```
Provides a `mm-saved` query provider (and maybe more in the future). Please follow the installation, configuration sections, and have a look at the example.
## Configuration
You need two bits of configuration to make this plug work. In `SETTINGS` provide the `mattermostUrl` and `mattermostDefaultTeam` settings, they default to the following:
```yaml
mattermostUrl: https://community.mattermost.com
mattermostDefaultTeam: core
```
In `SECRETS` provide a Mattermost personal access token (or hijack one from your current session):
```yaml
mattermostToken: your-token
```
To make this look good, it's recommended you render your query results a template. Here is one to start with, you can keep it in e.g. `templates/mm-saved`:
[{{username}}]({{desktopUrl}}) in **{{channelName}}** at {{updatedAt}} {[Unsave]}:
{{prefixLines (substring message 0 300 " ... (More)") "> "}}
---
Note that the `{[Unsaved]}` "button" when clicked, will unsave the post automatically 😎
## Query sources
* `mm-saved` fetches (by default 15) saved posts in Mattermost
## Example
Example uses (using the `template/mm-saved` template above):
<!-- #query mm-saved order by updatedAt desc limit 5 render "template/mm-saved" -->
[lindy.isherwood](mattermost://community.mattermost.com/private-core/pl/u8ospw14ptg47fystidzudigjw) in **R&D Meeting** at 2022-07-22 {[Unsave]}:
> #### [Meeting Recording](https://mattermost.zoom.us/rec/share/e0CmkZr_1xaW0Zd-7N-saD5fir9pmjJy6-xw4JZ7el7IMIUUUr99FiC2WePmBZDw.HRzSgvBjxhsPGQWo)
>
> Access Passcode: `wq$!BA6N`
---
[harrison](mattermost://community.mattermost.com/core/pl/akuzqwdm4if7fdmajjb94hpm5c) in **** at 2022-07-20 {[Unsave]}:
> Hey Zef. Can we chat about the Affirm issue a bit when I get back? From what I've gathered, Devin's told customer support that the issue in Chromium isn't something we can reasonably fix, and while I don't feel like that's anything I should be worried about since it's out of my area, I keep getting ... (More)
---
[zef.hemel](mattermost://community.mattermost.com/core/pl/k41cfgdbhfg5unm8yx1cjkh8ty) in **** at 2022-07-20 {[Unsave]}:
> I'll have to get back to this tomorrow. Filename says "arm64" though
---
[zef.hemel](mattermost://community.mattermost.com/core/pl/9e1ha9yzzpdm9ffhu4od65yykc) in **** at 2022-07-19 {[Unsave]}:
> Agreed. Thinking what are better indicators than what we already ask. I’ll reach out.
---
[zef.hemel](mattermost://community.mattermost.com/private-core/pl/hh79ikgfzb8zmb4ezjuow7a1mw) in **Team: Web Platform** at 2022-07-15 {[Unsave]}:
> @webplatform in yesterday’s 1:1 with @harrison we came up with the concept of “theme weeks” to solve our problem of scheduling _important but not urgent_ work. Examples are: looking at performance improvements, cleaning/fixing lingering bugs from our backlog, working on accessibility tickets, perfor ... (More)
---
<!-- /query -->

33
website/🔌 Mount.md Normal file
View File

@ -0,0 +1,33 @@
```meta
type: plug
uri: github:silverbulletmd/silverbullet-mount/mount.plug.json
repo: https://github.com/silverbulletmd/silverbullet-mount
author: Zef Hemel
```
Enables mounting of external folders or SB instances into your space mounted under a `🚪` prefix.
## Configuration
Create a `MOUNTS` page:
```yaml
# Mounting another local folder with a docs/ prefix
- prefix: docs/
path: file:/Users/me/docs
# Mounting an external SB instance to remote/
- prefix: remote/
path: http://some-ip:3000
password: mypassword
```
This will make these available under `🚪 docs/` and `🚪 remote/` respectively.
## Features
* Auto translates internal wiki links (prefixes with prefix) and removes prefix upon save
## To do
* [ ] Handle queries
* `page` and `link` query needs to dynamically add/remove a `and name =~ /^🚪 PREFIX/` clause)
* `task` same but with `page` check
* [x] Add `file:` support
* [x] Add `http:`/`https:` support

8
website/🔌 Plug Directory.md
View File

@ -1,8 +0,0 @@
Here is a list of plugs you can install. If you know of any more, please let us know by issuing a PR [to the repo](https://github.com/silverbulletmd/silverbullet/tree/main/website)!
* [Git](https://github.com/silverbulletmd/silverbullet-git): adds very rudimentary git sync plug, to synchronize your pages with a git repository.
* [Github](https://github.com/silverbulletmd/silverbullet-github): adds `gh-events` and `gh-pulls` as a query provider.
* [Ghost](https://github.com/silverbulletmd/silverbullet-ghost): adds the ability to publish pages to [Ghost](https://ghost.org/).
* [Mount](https://github.com/silverbulletmd/silverbullet-mount): adds the ability to “mount” external directories and SB instances into your space.
* [Backlinks](https://github.com/Willyfrog/silverbullet-backlinks): persistently shows your page’s backlinks in a side panel.
* [Mattermost](https://github.com/silverbulletmd/silverbullet-mattermost): a basic Mattermost plug exposing saved posts as a query source.

29
website/🔌 Plugs.md
View File

@ -2,25 +2,15 @@ Silver Bullet at its core is bare bones in terms of functionality, most of its p
Plugs are an extension mechanism (implemented using a library called `plugos` that runs plug code on the server in a sandboxed v8 node.js process, and in the browser using web workers). Plugs can hook into SB in various ways: plugs can extend the Markdown parser and its syntax, define new commands and keybindings, respond to various events triggered either on the server or client side, as well as run recurring and background tasks. Plugs can even define their own extension mechanisms through custom events. Each plug runs in its own sandboxed environment and communicates with SB via _syscalls_ that expose a vast range of functionality. Plugs can be loaded, unloaded and updated without having to restart SB itself.
[[🔌 Plug Directory]]
Examples of functionality implemented as plugs:
* _Core functionality_ such as:
* Navigation between pages by clicking or hitting `Cmd/Ctrl-Enter`
* Page auto complete when using the `[[page link]]` syntax
* Indexing of cross-page links and automatically updating all references to them when a page is renamed
* Text editing commands such as bold (`Cmd/Ctrl-b`) and italics (`Cmd/Ctrl-i`) or quote or itemize entire sections.
* Full text indexing and search
* Slash commands such as `/today`, `/tomorrow` and `/meta` (to insert page meta data)
* Emoji auto complete using the `:emoji:` syntax
* An embedded query language that can be used to query various sets of indexed entities, such as:
* Tasks using the Markdown task syntax
* Page backlinks
* Page in your space and its meta data
* Data objects embedded in your pages
* Git integration
* Github integration
## Directory
<!-- #query page where type = “plug” render “template/plug” -->
* [[🔌 Git]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-github))
* [[🔌 Ghost]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-ghost))
* [[🔌 Github]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-github))
* [[🔌 Mattermost]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-mattermost))
* [[🔌 Mount]] by **Zef Hemel** ([repo](https://github.com/silverbulletmd/silverbullet-mount))
* [[🔌 Backlinks]] by **Guillermo Vayá** ([repo](https://github.com/Willyfrog/silverbullet-backlinks))
<!-- /query -->
## How to develop your own plug
At this stage, to get started, it’s probably easiest to fork one of the existing plugs found in the [SilverBullet github org](https://github.com/silverbulletmd), for instance the [github one](https://github.com/silverbulletmd/silverbullet-github).
@ -52,6 +42,7 @@ Reload your list of plugs via the `Plugs: Update` command (`Cmd-Shift-p` on Mac,
Once you’re happy with your plug, you can distribute it in various ways:
* You can put it on github by simply committing the resulting `.plug.json` file there and instructing users to point to by adding `- github:yourgithubuser/yourrepo/yourplugname.plug.json` to their `PLUGS` file
* Add a release in your github repo and instruct users to add the release as `- ghr:yourgithubuser/yourrepo` or if they need a spcecific release `- ghr:yourgithubuser/yourrepo/release-name`
* You can put it on any other web server, and tell people to load it via https, e.g. `- https://mydomain.com/mypugname.plug.json`.
### Recommended development workflow