chore: fix path syntax in core programs

feat: complete shell revamp
feat: improve bash-like command parsing
2026-05-19 23:19:36 +02:00 · 2026-05-19 21:42:14 +02:00 · 2026-05-19 18:22:43 +02:00 · 2026-05-18 19:25:03 +02:00 · 2026-05-18 19:22:34 +02:00 · 2026-05-18 00:14:49 +02:00
41 changed files with 2936 additions and 37 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,13 @@ dist
 dist-ssr
 *.local

+# Runtime
+bun.lock
+
+# Vercel
+.vercel
+*.env
+
 # Editor directories and files
 .vscode/*
 !.vscode/extensions.json
@@ -22,3 +29,7 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
+
+# temp files
+slop.md
+.env*.local
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -0,0 +1,8 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+    "tab_size": 4,
+    "format_on_save": "off",
+}
--- a/README.md
+++ b/README.md
@@ -6,16 +6,18 @@ Aplikace je zdarma hostovaná přes Vercel a je veřejně dostupná na adrese ht
 ## buildování
 0. Pro buildování je potřeba software třetích stran:
    - Bun -> JavaScriptový/TypeScriptový runtime. Stáhnout lze z více zdrojů. Po instalaci doporučuji přidat Bun executable do PATH. Je možno použít Node.JS a npm.
-        - Univerzálně: pomocí npm příkazem `npm i -g bun`
-        - Win NT:
-            1. ze stránky https://bun.sh/
-            2. přes winget powershellovým příkazem `winget install --id Oven-sh.Bun`
+        - Univerzálně:
+            1. pomocí npm příkazem `npm i -g bun`
+            2. z oficiální stránky https://bun.sh/
+        - M$ Win:
+            1. z powershellu příkazem `powershell -c "irm bun.sh/install.ps1 | iex"`
+            2. (NT 10+) přes winget powershellovým příkazem `winget install --id Oven-sh.Bun`
            3. pomocí chocolatey příkazem `choco install bun`
-        - Arch Linux: 
-            1. ze stránky https://bun.sh/
-            2. z `extra` repozitáře příkazem `pacman -S bun`
+        - Linux: 
+            1. z terminálu příkazem `curl -fsSL https://bun.sh/install | bash`
+            2. (Arch) z `extra` repozitáře příkazem `pacman -S bun`
        - MacOS:
-            1. ze stránky https://bun.sh/
+            1. z terminálu příkazem `curl -fsSL https://bun.sh/install | bash`
            2. pomocí homebrew příkazem `brew tap oven-sh/bun && brew install bun`
    - Vite -> Builder a packer pro webové aplikace
        - Již definováno jako závislost v projektovém `package.json`
@@ -29,22 +31,11 @@ Aplikace je zdarma hostovaná přes Vercel a je veřejně dostupná na adrese ht
 4. Stránka je nyní lokálně dostupná na http://localhost:3000/
 5. (volitelné) Apliakci je možné buildnout pomocí `<bun/npm> run build`. Statická verze stránky je nyní dostupná v adresáři `webshell/dist/`

+## testování
+
+Aplikace je testována v následujících prohlížečích:
+- `Helium 0.12.1.1 (Chromium 148.0.7778.96) (64-bit)`
+
 ## licence

-Tato webová aplikace včetně jejího zdrojového kódu je veřejně dostupná pod licencí Apache 2.0 (SPDX: `Apache-2.0`). Zdrojový kód je veřejně dostupný na https://git.martinpetr.dev/binekrasik/webshell
-
-```md
-Copyright 2026 Vendelín Mžik
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-```
+Tato webová aplikace včetně jejího zdrojového kódu je veřejně dostupná pod licencí Apache 2.0 (SPDX: `Apache-2.0`), jejíž celé znění je dostupné v LICENSE.md. Zdrojový kód je veřejně dostupný na https://git.martinpetr.dev/binekrasik/webshell
--- a/index.html
+++ b/index.html
@@ -2,14 +2,24 @@
 <html lang="en">
    <head>
        <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+        <!-- import main stylesheet -->
+        <link rel="stylesheet" href="/src/styles/app.scss" />
+
        <title>webshell</title>
+        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
    </head>
    <body>
        <div id="app">
+            <div id="cursor"></div>

+            <div id="terminal">
+                <div id="lines"></div>
            </div>
-    <script type="module" src="/src/main.ts"></script>
+        </div>
+
+        <!-- run main script -->
+        <script type="module" src="/src/app.ts"></script>
    </body>
 </html>
--- a/package.json
+++ b/package.json
@@ -10,6 +10,9 @@
  },
  "devDependencies": {
    "typescript": "~5.9.3",
-    "vite": "^8.0.1"
+    "vite": "^8.0.8"
+  },
+  "dependencies": {
+    "sass": "^1.99.0"
  }
 }
--- a/src/app.ts
+++ b/src/app.ts
@@ -0,0 +1,55 @@
+import { Alert } from './gui/Alert'
+import { CreateKeyboardListeners } from './input/keyboard'
+import { Wush } from './shell/wush/Wush'
+import { Terminal } from './terminal/Terminal'
+import { EventBroadcaster } from './utils/EventBroadcaster'
+
+export const WEBSHELL_VERSION = "0.1.0"
+
+// initialize object store for webfs
+let WebfsDatabase: IDBDatabase | null = null
+
+const request = indexedDB.open("webshell")
+
+request.onupgradeneeded = event => {
+    console.log("creating database")
+    WebfsDatabase = (event.target as any).result as IDBDatabase
+    WebfsDatabase.createObjectStore("webfs")
+}
+
+request.onerror = _ => {
+    new Alert(
+        "webfs error",
+        "Failed to initialize the webfs database using IndexedDB. Make sure webshell does not have any IndexedDB related permissions disabled and try again.",
+        'critical',
+    ).Show()
+}
+
+request.onsuccess = event => {
+    WebfsDatabase = (event.target as any).result as IDBDatabase
+    console.log("database initialized")
+
+    // initialize the app after the database
+    init()
+}
+
+export const GetWebfsDatabase = (): IDBDatabase | null => WebfsDatabase
+
+// terminal management
+let CurrentTerminal: Terminal
+export const SetCurrentTerminal = (terminal: Terminal) => CurrentTerminal = terminal
+export const GetCurrentTerminal = (): Terminal => CurrentTerminal
+
+// Initializes the app
+const init = async () => {
+    const localBroadcaster = new EventBroadcaster()
+
+    // creates keyboard listeners for the local event broadcaster
+    CreateKeyboardListeners(
+        (key: string, isCharacter: boolean) => localBroadcaster.emit('keydown', key, isCharacter),
+        (key: string, isCharacter: boolean) => localBroadcaster.emit('keyup', key, isCharacter),
+    )
+
+    const terminal = new Terminal()
+    await terminal.LoadShell(new Wush(localBroadcaster, terminal))
+}
--- a/src/fs/Item.ts
+++ b/src/fs/Item.ts
@@ -0,0 +1,341 @@
+import { GetWebfsDatabase } from "../app"
+
+interface ItemPayload {
+    isDirectory: boolean
+    executable: boolean
+    data: string | null
+    children: string[]
+}
+
+export class Item {
+    private path: string
+    private isDirectory: boolean = false
+    private executable: boolean = false
+    private data: string | null = null
+    private children: string[] = []
+
+    private constructor(path: string) {
+        this.path = Item.NormalizePath(path)
+    }
+
+    // -------------------------------------------------------------------------
+    // Static factories
+    // -------------------------------------------------------------------------
+
+    /**
+     * Opens an existing file or prepares a new one in memory.
+     * Call Create() afterwards if the item does not yet exist.
+     * Use openDir() to prepare a directory instead.
+     * Throws if the path exists but is a directory.
+     * Note: initialData is ignored (with a warning) if the file already exists.
+     */
+    static async open(path: string, initialData: string | null = null): Promise<Item> {
+        const item = new Item(path)
+        if (await item.Exists()) {
+            await item.load()
+            if (item.isDirectory) {
+                throw new Error(`Path is a directory, not a file: ${path}`)
+            }
+            if (initialData !== null) {
+                console.warn(`Item.open(): initialData ignored because file already exists: ${path}`)
+            }
+        } else {
+            item.data = initialData
+            item.isDirectory = false
+        }
+        return item
+    }
+
+    /**
+     * Opens an existing directory or prepares a new one in memory.
+     * Call Create() afterwards if the item does not yet exist.
+     * Throws if the path exists but is a file.
+     */
+    static async openDir(path: string): Promise<Item> {
+        const item = new Item(path)
+        if (await item.Exists()) {
+            await item.load()
+            if (!item.isDirectory) {
+                throw new Error(`Path is a file, not a directory: ${path}`)
+            }
+        } else {
+            item.data = null
+            item.isDirectory = true
+        }
+        return item
+    }
+
+    /**
+     * Returns the root directory, creating it if it doesn't exist yet.
+     */
+    static async Root(): Promise<Item> {
+        const root = new Item('/')
+        if (!(await root.Exists())) {
+            root.isDirectory = true
+            await root.Create()
+        } else {
+            await root.load()
+        }
+        return root
+    }
+
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+
+    async Create(): Promise<void> {
+        if (await this.Exists()) throw new Error(`File already exists: ${this.path}`)
+
+        await this.save()
+
+        if (this.path !== '/') {
+            const parentPath = this.getParentPath()
+            const parent = await Item.openDir(parentPath)
+
+            if (!(await parent.Exists())) {
+                await parent.Create()
+                // Reload the parent after recursive Create() to get the
+                // up-to-date children list before we append to it, so we
+                // don't overwrite any children that Create() already added.
+                await parent.load()
+            }
+
+            if (!parent.children.includes(this.path)) {
+                parent.children.push(this.path)
+                await parent.save()
+            }
+        }
+    }
+
+    async Exists(): Promise<boolean> {
+        const db = GetWebfsDatabase()
+        if (!db) throw new Error("WebFS database is not initialized")
+
+        return new Promise((resolve, reject) => {
+            const request = db
+                .transaction("webfs", "readonly")
+                .objectStore("webfs")
+                .getKey(this.storageKey)
+
+            request.onsuccess = () => resolve(request.result !== undefined)
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    IsDirectory(): boolean {
+        return this.isDirectory
+    }
+
+    IsReadable(): boolean {
+        return true
+    }
+
+    IsWritable(): boolean {
+        return true
+    }
+
+    IsExecutable(): boolean {
+        return this.executable
+    }
+
+    async Append(data: string): Promise<void> {
+        if (!(await this.Exists())) throw new Error(`Cannot append to a file that has not been created: ${this.path}`)
+        if (this.isDirectory) throw new Error("Cannot append data to a directory")
+        this.data = (this.data ?? '') + data
+        await this.save()
+    }
+
+    async Write(data: string): Promise<void> {
+        if (!(await this.Exists())) throw new Error(`Cannot write to a file that has not been created: ${this.path}`)
+        if (this.isDirectory) throw new Error("Cannot write data to a directory")
+        this.data = data
+        await this.save()
+    }
+
+    /**
+     * Sets the executable flag. Only takes effect if the item has already
+     * been created in the filesystem (i.e. Create() has been called).
+     */
+    async SetExecutable(executable: boolean): Promise<void> {
+        this.executable = executable
+        if (await this.Exists()) await this.save()
+    }
+
+    GetPath(): string {
+        return this.path
+    }
+
+    /**
+     * Returns just the filename/directory name, not the full path.
+     */
+    GetName(): string {
+        return this.path === '/' ? '/' : this.path.substring(this.path.lastIndexOf('/') + 1)
+    }
+
+    ReadData(): string | null {
+        return this.data
+    }
+
+    async List(): Promise<Item[]> {
+        if (!this.isDirectory) throw new Error(`Not a directory: ${this.path}`)
+
+        // Always reload from store to ensure children list is current.
+        await this.load()
+
+        const items = await Promise.all(
+            this.children.map(async childPath => {
+                const child = new Item(childPath)
+                if (!(await child.Exists())) return null
+                await child.load()
+                return child
+            })
+        )
+        return items.filter((item): item is Item => item !== null)
+    }
+
+    async Delete(): Promise<void> {
+        if (!(await this.Exists())) return
+
+        // Reload from store to ensure we have the current state,
+        // particularly the up-to-date children list for directories.
+        await this.load()
+
+        if (this.isDirectory) {
+            const children = await this.List()
+            await Promise.all(children.map(child => child.Delete()))
+        }
+
+        await this.remove()
+
+        if (this.path !== '/') {
+            const parent = await Item.openDir(this.getParentPath())
+            parent.children = parent.children.filter(p => p !== this.path)
+            await parent.save()
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+
+    private get storageKey(): string {
+        return this.path
+    }
+
+    public static NormalizePath(path: string): string {
+        if (!path.startsWith('/')) path = '/' + path
+
+        // Resolve . and .. segments.
+        // Split on '/' and walk each part: skip empty strings (from leading
+        // slash or consecutive slashes) and '.', pop on '..', push otherwise.
+        const parts = path.split('/')
+        const resolved: string[] = []
+        for (const part of parts) {
+            if (part === '' || part === '.') {
+                continue
+            } else if (part === '..') {
+                if (resolved.length > 0) resolved.pop() // never climbs above root
+            } else {
+                resolved.push(part)
+            }
+        }
+
+        return '/' + resolved.join('/')
+    }
+
+    private getParentPath(): string {
+        if (this.path === '/') return '/'
+        const lastSlashIndex = this.path.lastIndexOf('/')
+        return lastSlashIndex === 0
+            ? '/'
+            : this.path.substring(0, lastSlashIndex)
+    }
+
+    private db(): IDBDatabase {
+        const db = GetWebfsDatabase()
+        if (!db) throw new Error("WebFS database is not initialized")
+        return db
+    }
+
+    /**
+     * Persists this item to IndexedDB.
+     * Enforces that the isDirectory flag cannot be changed after creation.
+     */
+    private async save(): Promise<void> {
+        // Guard against flipping isDirectory on an already-created item.
+        if (await this.Exists()) {
+            const request = this.db()
+                .transaction("webfs", "readonly")
+                .objectStore("webfs")
+                .get(this.storageKey)
+
+            const stored = await new Promise<ItemPayload | undefined>((resolve, reject) => {
+                request.onsuccess = () => resolve(request.result as ItemPayload | undefined)
+                request.onerror = () => reject(request.error)
+            })
+
+            if (stored && stored.isDirectory !== this.isDirectory) {
+                throw new Error(
+                    `Cannot change isDirectory flag after creation: ${this.path}`
+                )
+            }
+        }
+
+        const payload: ItemPayload = {
+            isDirectory: this.isDirectory,
+            executable: this.executable,
+            data: this.data,
+            children: this.children,
+        }
+
+        return new Promise((resolve, reject) => {
+            const request = this.db()
+                .transaction("webfs", "readwrite")
+                .objectStore("webfs")
+                .put(payload, this.storageKey)
+
+            request.onsuccess = () => resolve()
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    /**
+     * Loads this item's data from IndexedDB into memory.
+     */
+    private load(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const request = this.db()
+                .transaction("webfs", "readonly")
+                .objectStore("webfs")
+                .get(this.storageKey)
+
+            request.onsuccess = () => {
+                const parsed = request.result as ItemPayload | undefined
+                if (parsed) {
+                    this.isDirectory = parsed.isDirectory
+                    this.executable = parsed.executable
+                    this.data = parsed.data
+                    this.children = parsed.children
+                }
+
+                resolve()
+            }
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    /**
+     * Deletes this item's record from IndexedDB.
+     */
+    private remove(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const request = this.db()
+                .transaction("webfs", "readwrite")
+                .objectStore("webfs")
+                .delete(this.storageKey)
+
+            request.onsuccess = () => resolve()
+            request.onerror = () => reject(request.error)
+        })
+    }
+}
--- a/src/gui/Alert.ts
+++ b/src/gui/Alert.ts
@@ -0,0 +1,23 @@
+import HtmlAlertTemplate from "./alertTemplate.html?raw"
+
+export type AlertSeverity = 'debug' | 'info' | 'warning' | 'error' | 'critical'
+
+export class Alert {
+    readonly title: string
+    readonly description: string
+    readonly severity: AlertSeverity
+
+    // a html5 template
+    readonly template: string
+
+    constructor(title: string, description: string, severity: AlertSeverity, template: string = HtmlAlertTemplate) {
+        this.title = title
+        this.description = description
+        this.severity = severity
+        this.template = template
+    }
+
+    Show(time: number = -1): void {
+        alert(`${this.title} [${this.severity}]: ${this.description} (time: ${time})`)
+    }
+}
--- a/src/gui/alertTemplate.html
+++ b/src/gui/alertTemplate.html
@@ -0,0 +1,24 @@
+<div class="webshellAlert">
+    <style>
+    #webshellAlert {
+        border-radius: 0px;
+        border: 2px solid {{severity_color}};
+
+        display: flex;
+        flex-direction: column;
+        width: fit-content;
+        height: fit-content;
+    }
+
+    button {
+        border-radius: 0px;
+        border: 2px solid #86e9d5;
+    }
+    </style>
+
+    <h1>{{title}}</h1>
+    <p>{{description}}</p>
+
+    <button>ok</button>
+    <button>ok</button>
+</div>
--- a/src/input/keyboard.ts
+++ b/src/input/keyboard.ts
@@ -0,0 +1,15 @@
+// creates keyboard listeners
+export const CreateKeyboardListeners = (
+    onKeyDown: (key: string, isCharacter: boolean) => void,
+    onKeyUp: (key: string, isCharacter: boolean) => void,
+) => {
+    document.addEventListener('keydown', event => {
+        onKeyDown(event.key, event.key.length === 1)
+        event.preventDefault()
+    })
+
+    document.addEventListener('keyup', event => {
+        onKeyUp(event.key, event.key.length === 1)
+        event.preventDefault()
+    })
+}
--- a/src/program/Cat.ts
+++ b/src/program/Cat.ts
@@ -0,0 +1,29 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Cat extends Program {
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        if (args.length < 2) {
+            stdout.emit("cat: error: missing path argument\n")
+            return 1
+        }
+
+        const item = await Item.open(Item.NormalizePath(args[1].startsWith('/') ? args[1] : `${workdir.GetPath()}/${args[1]}`))
+
+        if (!(await item.Exists())) {
+            stdout.emit(`cat: error: item ${item.GetPath()} doesn't exist.\n`)
+            return 2
+        }
+
+        if (item.IsDirectory()) {
+            stdout.emit(`cat: error: can't read data from a directory; item ${item.GetPath()} is a directory.\n`)
+            return 3
+        }
+
+        stdout.emit(`${item.ReadData()}`)
+        stdout.emit('<- EOF\n')
+
+        return 0
+    }
+}
--- a/src/program/Cd.ts
+++ b/src/program/Cd.ts
@@ -0,0 +1,39 @@
+import { Item } from '../fs/Item'
+import type { Shell } from '../shell/Shell'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Cd extends Program {
+    private shell: Shell
+
+    constructor(shell: Shell) {
+        super()
+        this.shell = shell
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        // open the target directory, default to workdir
+
+        const item = args[1]
+            ? await Item.openDir(Item.NormalizePath(
+                args[1].startsWith('/')
+                    ? args[1]
+                    : `${workdir.GetPath()}/${args[1]}`
+                ))
+            : workdir
+
+        if (args[1] && !item.IsDirectory()) {
+            stdout.emit("cd: error: the provided path is not a directory\n")
+            return 1
+        }
+
+        if (!(await item.Exists())) {
+            stdout.emit(`cd: error: path ${item.GetPath()} doesn't exist\n`)
+            return 2
+        }
+
+        await this.shell.SetWorkingDirectory(item)
+
+        return 0
+    }
+}
--- a/src/program/Clear.ts
+++ b/src/program/Clear.ts
@@ -0,0 +1,11 @@
+import type { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Clear extends Program {
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, ___: string[]): Promise<number> {
+        stdout.emit('\x1b[2J\x1b[H')
+
+        return 0
+    }
+}
--- a/src/program/Echo.ts
+++ b/src/program/Echo.ts
@@ -0,0 +1,15 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Echo extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, args: string[]): Promise<number> {
+        stdout.emit(args.slice(1).join(' ') + '\n')
+
+        return 0
+    }
+}
--- a/src/program/Eval.ts
+++ b/src/program/Eval.ts
@@ -0,0 +1,19 @@
+import type { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Eval extends Program {
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, _workdir: Item, args: string[]): Promise<number> {
+        const javascript = args.slice(1).join(' ')
+
+        try {
+            // todo: pass workdir to the program
+            eval(javascript)
+        } catch (e) {
+            stdout.emit(`${String(e)}\n`)
+            return 1
+        }
+
+        return 0
+    }
+}
--- a/src/program/Info.ts
+++ b/src/program/Info.ts
@@ -0,0 +1,15 @@
+import { GetCurrentTerminal, WEBSHELL_VERSION } from '../app'
+import type { Item } from '../fs/Item'
+import { Terminal } from '../terminal/Terminal'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Info extends Program {
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, ___: string[]): Promise<number> {
+        stdout.emit(`Webshell v${WEBSHELL_VERSION}\n`)
+        stdout.emit(`Terminal v${Terminal.Version}\n`)
+        stdout.emit(`Running ${GetCurrentTerminal().GetShell()?.Name} v${GetCurrentTerminal().GetShell()?.Version}\n`)
+
+        return 0
+    }
+}
--- a/src/program/Loadprg.ts
+++ b/src/program/Loadprg.ts
@@ -0,0 +1,29 @@
+import type { Item } from '../fs/Item'
+import type { Shell } from '../shell/Shell'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Loadprg extends Program {
+    private shell: Shell
+
+    constructor(shell: Shell) {
+        super()
+        this.shell = shell
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, args: string[]): Promise<number> {
+        const javascript = args.slice(2).join(' ')
+
+        try {
+            const program = eval(javascript)
+
+            this.shell.LoadProgram(new program(), args[1])
+        } catch (e) {
+            stdout.emit(`${String(e)}\n`)
+            stdout.emit(`${String((e as Error).stack)}\n`)
+            return 1
+        }
+
+        return 0
+    }
+}
--- a/src/program/Ls.ts
+++ b/src/program/Ls.ts
@@ -0,0 +1,40 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Ls extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        // open the target directory, default to workdir
+
+        const item = args[1]
+            ? await Item.openDir(Item.NormalizePath(
+                args[1].startsWith('/')
+                    ? args[1]
+                    : `${workdir.GetPath()}/${args[1]}`
+                ))
+            : workdir
+
+        if (args[1] && !item.IsDirectory()) {
+            stdout.emit("ls: error: the provided path is not a directory\n")
+            return 1
+        }
+
+        if (!(await item.Exists())) {
+            stdout.emit(`ls: error: path ${item.GetPath()} doesn't exist\n`)
+            return 2
+        }
+
+        stdout.emit(`-> Listing contents of item: '${item.GetPath()}'\n`)
+        stdout.emit(`   [ drwx     name     ]\n`)
+        const items = await item.List()
+        items.forEach(entry => {
+            stdout.emit(`   | ${`${(entry.IsDirectory() ? 'd' : '-')}${(entry.IsReadable() ? 'r' : '-')}${(entry.IsWritable() ? 'w' : '-')}${(entry.IsExecutable() ? 'x' : '-')}`.padEnd(8, ' ')} ${entry.GetName()}\n`)
+        })
+
+        return 0
+    }
+}
--- a/src/program/Lsprg.ts
+++ b/src/program/Lsprg.ts
@@ -0,0 +1,24 @@
+import type { Item } from '../fs/Item'
+import type { Wush } from '../shell/wush/Wush'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Lsprg extends Program {
+    private wush: Wush
+
+    constructor(wush: Wush) {
+        super()
+        this.wush = wush
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, ___: string[]): Promise<number> {
+        const programs = this.wush.GetPrograms()
+
+        stdout.emit(`-> ${Object.keys(programs).length} loaded programs:\n`)
+
+        for (const program in this.wush.GetPrograms())
+            stdout.emit(` | - ${program}\n`)
+
+        return 0
+    }
+}
--- a/src/program/Mkdir.ts
+++ b/src/program/Mkdir.ts
@@ -0,0 +1,28 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Mkdir extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        if (args.length < 2) {
+            stdout.emit("mkdir: error: missing path argument\n")
+            return 1
+        }
+
+        const item = await Item.openDir(Item.NormalizePath(args[1].startsWith('/') ? args[1] : `${workdir.GetPath()}/${args[1]}`))
+
+
+        if (await item.Exists()) {
+            stdout.emit(`mkdir: directory ${item.GetPath()} already exists.\n`)
+            return 2
+        }
+
+        item.Create()
+
+        return 0
+    }
+}
--- a/src/program/Printf.ts
+++ b/src/program/Printf.ts
@@ -0,0 +1,15 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Printf extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, __: Item, args: string[]): Promise<number> {
+        stdout.emit(args.slice(1).join(' '))
+
+        return 0
+    }
+}
--- a/src/program/Program.ts
+++ b/src/program/Program.ts
@@ -0,0 +1,11 @@
+import type { Item } from "../fs/Item"
+import type { SimpleStream } from "../utils/SimpleStream"
+
+export abstract class Program {
+    abstract Exec(
+        stdin: SimpleStream<string>,
+        stdout: SimpleStream<string>,
+        workdir: Item,
+        args: string[]
+    ): Promise<number>
+}
--- a/src/program/Pwd.ts
+++ b/src/program/Pwd.ts
@@ -0,0 +1,15 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Pwd extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, __: string[]): Promise<number> {
+        stdout.emit(`${workdir.GetPath()}\n`)
+
+        return 0
+    }
+}
--- a/src/program/ResetIndexedDb.ts
+++ b/src/program/ResetIndexedDb.ts
@@ -0,0 +1,44 @@
+import { GetWebfsDatabase } from '../app'
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class ResetIndexedDb extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, ___: Item, ____: string[]): Promise<number> {
+        const db = GetWebfsDatabase()
+
+        if (!db) {
+            stdout.emit("rsindb: error: GetWebfsDatabase returned null")
+            return 1
+        }
+
+        return new Promise<number>(resolve => {
+            const request = indexedDB.deleteDatabase(db.name)
+
+            request.onerror = () => {
+                stdout.emit("rsindb: error: IndexedDB deletion request has failed\n")
+                resolve(2)
+            }
+
+            request.onblocked = () => {
+                stdout.emit("rsindb: debug: database open, closing connection\n")
+                db.close()
+            }
+
+            request.onupgradeneeded = () =>
+                stdout.emit("rsindb: debug: request upgrade needed\n")
+
+            request.onsuccess = () => {
+                stdout.emit("success\n")
+
+                resolve(0)
+
+                location.reload()
+            }
+        })
+    }
+}
--- a/src/program/Rl.ts
+++ b/src/program/Rl.ts
@@ -0,0 +1,15 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Rl extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, __: SimpleStream<string>, ___: Item, ____: string[]): Promise<number> {
+        location.reload()
+
+        return 0
+    }
+}
--- a/src/program/Rm.ts
+++ b/src/program/Rm.ts
@@ -0,0 +1,39 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Rm extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        if (!args[1]) {
+            stdout.emit("rm: error: missing first argument\n")
+            return 1
+        }
+
+        let item: Item
+
+        try {
+            item = await Item.openDir(args[1].startsWith('/')
+                    ? args[1]
+                    : `${workdir.GetPath()}${workdir.GetPath().endsWith('/') ? '' : '/'}${args[1]}`)
+        } catch {
+            item = await Item.open(args[1].startsWith('/')
+                    ? args[1]
+                    : `${workdir.GetPath()}${workdir.GetPath().endsWith('/') ? '' : '/'}${args[1]}`)
+        }
+
+        if (!(await item.Exists())) {
+            stdout.emit(`rm: error: item ${item.GetPath()} doesn't exist.\n`)
+            return 1
+        }
+
+        stdout.emit(`-> removing: '${item.GetPath()}'\n`)
+
+        await item.Delete()
+
+        return 0
+    }
+}
--- a/src/program/Sl.ts
+++ b/src/program/Sl.ts
@@ -0,0 +1,632 @@
+import { GetCurrentTerminal } from '../app'
+import type { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+type SmokeState = {
+    y: number
+    x: number
+    ptrn: number
+    kind: number
+}
+
+type SlOptions = {
+    accident: boolean
+    fly: boolean
+    logo: boolean
+    c51: boolean
+}
+
+export class Sl extends Program {
+    private static readonly D51_HEIGHT = 10
+    private static readonly D51_FUNNEL = 7
+    private static readonly D51_LENGTH = 83
+    private static readonly D51_PATTERNS = 6
+
+    private static readonly LOGO_HEIGHT = 6
+    private static readonly LOGO_FUNNEL = 4
+    private static readonly LOGO_LENGTH = 84
+    private static readonly LOGO_PATTERNS = 6
+
+    private static readonly C51_HEIGHT = 11
+    private static readonly C51_FUNNEL = 7
+    private static readonly C51_LENGTH = 87
+    private static readonly C51_PATTERNS = 6
+
+    private static readonly SMOKE_PATTERNS = 16
+    private static readonly MAX_SMOKE = 1000
+
+    private smokes: SmokeState[] = []
+    private smokeSum = 0
+
+    public async Exec(
+        _: SimpleStream<string>,
+        stdout: SimpleStream<string>,
+        __: Item,
+        args: string[],
+    ): Promise<number> {
+        const options = this.parseOptions(args)
+        const terminal = GetCurrentTerminal()
+        const cols = Math.max(1, Math.floor(terminal.GetWidthCells()))
+        const lines = Math.max(1, Math.floor(terminal.GetHeightCells()))
+
+        this.resetSmoke()
+
+        // Clear screen and move cursor home (ANSI CSI)
+        stdout.emit('\x1b[2J\x1b[H')
+
+        for (let x = cols - 1; ; --x) {
+            const ok = options.logo
+                ? this.addSl(x, stdout, cols, lines, options)
+                : options.c51
+                    ? this.addC51(x, stdout, cols, lines, options)
+                    : this.addD51(x, stdout, cols, lines, options)
+
+            if (!ok)
+                break
+
+            await this.sleep(40)
+        }
+
+        stdout.emit(`\x1b[${Math.max(1, lines)};1H\n`)
+        return 0
+    }
+
+    private parseOptions(args: string[]): SlOptions {
+        const options: SlOptions = {
+            accident: false,
+            fly: false,
+            logo: false,
+            c51: false,
+        }
+
+        for (const arg of args.slice(1)) {
+            if (!arg.startsWith('-'))
+                continue
+
+            for (const flag of arg.slice(1)) {
+                switch (flag) {
+                    case 'a':
+                        options.accident = true
+                        break
+                    case 'F':
+                        options.fly = true
+                        break
+                    case 'l':
+                        options.logo = true
+                        break
+                    case 'c':
+                        options.c51 = true
+                        break
+                }
+            }
+        }
+
+        return options
+    }
+
+    private addSl(
+        x: number,
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        options: SlOptions,
+    ): boolean {
+        if (x < -Sl.LOGO_LENGTH)
+            return false
+
+        let y = Math.max(0, Math.floor(lines / 2) - 3)
+        let py1 = 0
+        let py2 = 0
+        let py3 = 0
+
+        if (options.fly) {
+            y = Math.trunc(x / 6) + lines - Math.trunc(cols / 6) - Sl.LOGO_HEIGHT
+            py1 = 2
+            py2 = 4
+            py3 = 6
+        }
+
+        const pattern = Math.floor((Sl.LOGO_LENGTH + x) / 3) % Sl.LOGO_PATTERNS
+
+        for (let i = 0; i <= Sl.LOGO_HEIGHT; i++) {
+            this.drawString(stdout, cols, lines, y + i, x, Sl.LOGO[pattern][i])
+            this.drawString(stdout, cols, lines, y + i + py1, x + 21, Sl.LOGO_COAL[i])
+            this.drawString(stdout, cols, lines, y + i + py2, x + 42, Sl.LOGO_CAR[i])
+            this.drawString(stdout, cols, lines, y + i + py3, x + 63, Sl.LOGO_CAR[i])
+        }
+
+        if (options.accident) {
+            this.addMan(stdout, cols, lines, y + 1, x + 14)
+            this.addMan(stdout, cols, lines, y + 1 + py2, x + 45)
+            this.addMan(stdout, cols, lines, y + 1 + py2, x + 53)
+            this.addMan(stdout, cols, lines, y + 1 + py3, x + 66)
+            this.addMan(stdout, cols, lines, y + 1 + py3, x + 74)
+        }
+
+        this.addSmoke(stdout, cols, lines, y - 1, x + Sl.LOGO_FUNNEL)
+        return true
+    }
+
+    private addD51(
+        x: number,
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        options: SlOptions,
+    ): boolean {
+        if (x < -Sl.D51_LENGTH)
+            return false
+
+        let y = Math.max(0, Math.floor(lines / 2) - 5)
+        let dy = 0
+
+        if (options.fly) {
+            y = Math.trunc(x / 7) + lines - Math.trunc(cols / 7) - Sl.D51_HEIGHT
+            dy = 1
+        }
+
+        const pattern = (Sl.D51_LENGTH + x) % Sl.D51_PATTERNS
+
+        for (let i = 0; i <= Sl.D51_HEIGHT; i++) {
+            this.drawString(stdout, cols, lines, y + i, x, Sl.D51[pattern][i])
+            this.drawString(stdout, cols, lines, y + i + dy, x + 53, Sl.D51_COAL[i])
+        }
+
+        if (options.accident) {
+            this.addMan(stdout, cols, lines, y + 2, x + 43)
+            this.addMan(stdout, cols, lines, y + 2, x + 47)
+        }
+
+        this.addSmoke(stdout, cols, lines, y - 1, x + Sl.D51_FUNNEL)
+        return true
+    }
+
+    private addC51(
+        x: number,
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        options: SlOptions,
+    ): boolean {
+        if (x < -Sl.C51_LENGTH)
+            return false
+
+        let y = Math.max(0, Math.floor(lines / 2) - 5)
+        let dy = 0
+
+        if (options.fly) {
+            y = Math.trunc(x / 7) + lines - Math.trunc(cols / 7) - Sl.C51_HEIGHT
+            dy = 1
+        }
+
+        const pattern = (Sl.C51_LENGTH + x) % Sl.C51_PATTERNS
+
+        for (let i = 0; i <= Sl.C51_HEIGHT; i++) {
+            this.drawString(stdout, cols, lines, y + i, x, Sl.C51[pattern][i])
+            this.drawString(stdout, cols, lines, y + i + dy, x + 55, Sl.C51_COAL[i])
+        }
+
+        if (options.accident) {
+            this.addMan(stdout, cols, lines, y + 3, x + 45)
+            this.addMan(stdout, cols, lines, y + 3, x + 49)
+        }
+
+        this.addSmoke(stdout, cols, lines, y - 1, x + Sl.C51_FUNNEL)
+        return true
+    }
+
+    private addMan(
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        y: number,
+        x: number,
+    ) {
+        const man = [['', '(O)'], ['Help!', '\\O/']]
+        const index = Math.floor((Sl.LOGO_LENGTH + x) / 12) % 2
+
+        for (let i = 0; i < 2; i++)
+            this.drawString(stdout, cols, lines, y + i, x, man[index][i])
+    }
+
+    private addSmoke(
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        y: number,
+        x: number,
+    ) {
+        if (x % 4 !== 0)
+            return
+
+        for (let i = 0; i < this.smokeSum; i++) {
+            const smoke = this.smokes[i]
+
+            this.drawString(stdout, cols, lines, smoke.y, smoke.x, Sl.SMOKE_ERASER[smoke.ptrn])
+            smoke.y -= Sl.SMOKE_DY[smoke.ptrn]
+            smoke.x += Sl.SMOKE_DX[smoke.ptrn]
+            smoke.ptrn = smoke.ptrn < Sl.SMOKE_PATTERNS - 1 ? smoke.ptrn + 1 : smoke.ptrn
+            this.drawString(stdout, cols, lines, smoke.y, smoke.x, Sl.SMOKE[smoke.kind][smoke.ptrn])
+        }
+
+        this.drawString(stdout, cols, lines, y, x, Sl.SMOKE[this.smokeSum % 2][0])
+
+        if (this.smokeSum < Sl.MAX_SMOKE) {
+            this.smokes[this.smokeSum] = { y, x, ptrn: 0, kind: this.smokeSum % 2 }
+            this.smokeSum++
+        }
+    }
+
+    private drawString(
+        stdout: SimpleStream<string>,
+        cols: number,
+        lines: number,
+        y: number,
+        x: number,
+        text: string,
+    ) {
+        if (y < 0 || y >= lines)
+            return
+
+        let cursorX = x
+        let out = text
+
+        if (cursorX < 0) {
+            out = out.slice(-cursorX)
+            cursorX = 0
+        }
+
+        if (cursorX >= cols || out.length === 0)
+            return
+
+        if (cursorX + out.length > cols)
+            out = out.slice(0, cols - cursorX)
+
+        stdout.emit(`\x1b[${y + 1};${cursorX + 1}H${out}`)
+    }
+
+    private resetSmoke() {
+        this.smokes = []
+        this.smokeSum = 0
+    }
+
+    private sleep(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms))
+    }
+
+    private static readonly LOGO: string[][] = [
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--O========O~\\-+  ',
+            '//// \\_/      \\_/    ',
+            '                     ',
+        ],
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--/O========O\\-+  ',
+            '//// \\_/      \\_/    ',
+            '                     ',
+        ],
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--/~O========O-+  ',
+            '//// \\_/      \\_/    ',
+            '                     ',
+        ],
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--/~\\------/~\\-+  ',
+            '//// \\_O========O    ',
+            '                     ',
+        ],
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--/~\\------/~\\-+  ',
+            '//// \\O========O/    ',
+            '                     ',
+        ],
+        [
+            '     ++      +------ ',
+            '     ||      |+-+ |  ',
+            '   /---------|| | |  ',
+            '  + ========  +-+ |  ',
+            ' _|--/~\\------/~\\-+  ',
+            '//// O========O_/    ',
+            '                     ',
+        ],
+    ]
+
+    private static readonly LOGO_COAL = [
+        '____                 ',
+        '|   \\@@@@@@@@@@@     ',
+        '|    \\@@@@@@@@@@@@@_ ',
+        '|                  | ',
+        '|__________________| ',
+        '   (O)       (O)     ',
+        '                     ',
+    ]
+
+    private static readonly LOGO_CAR = [
+        '____________________ ',
+        '|  ___ ___ ___ ___ | ',
+        '|  |_| |_| |_| |_| | ',
+        '|__________________| ',
+        '|__________________| ',
+        '   (O)        (O)    ',
+        '                     ',
+    ]
+
+    private static readonly D51 = [
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__ ',
+            ' |/-=|___|=    ||    ||    ||    |_____/~\\___/        ',
+            '  \\_/      \\O=====O=====O=====O_/      \\_/            ',
+            '                                                      ',
+        ],
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__ ',
+            ' |/-=|___|=O=====O=====O=====O   |_____/~\\___/        ',
+            '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/            ',
+            '                                                      ',
+        ],
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-O=====O=====O=====O \\ ____Y___________|__ ',
+            ' |/-=|___|=    ||    ||    ||    |_____/~\\___/        ',
+            '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/            ',
+            '                                                      ',
+        ],
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-~O=====O=====O=====O\\ ____Y___________|__ ',
+            ' |/-=|___|=    ||    ||    ||    |_____/~\\___/        ',
+            '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/            ',
+            '                                                      ',
+        ],
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__ ',
+            ' |/-=|___|=   O=====O=====O=====O|_____/~\\___/        ',
+            '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/            ',
+            '                                                      ',
+        ],
+        [
+            '      ====        ________                ___________ ',
+            '  _D _|  |_______/        \\__I_I_____===__|_________| ',
+            '   |(_)---  |   H\\________/ |   |        =|___ ___|   ',
+            '   /     |  |   H  |  |     |   |         ||_| |_||   ',
+            '  |      |  |   H  |__--------------------| [___] |   ',
+            '  | ________|___H__/__|_____/[][]~\\_______|       |   ',
+            '  |/ |   |-----------I_____I [][] []  D   |=======|__ ',
+            '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__ ',
+            ' |/-=|___|=    ||    ||    ||    |_____/~\\___/        ',
+            '  \\_/      \\_O=====O=====O=====O/      \\_/            ',
+            '                                                      ',
+        ],
+    ]
+
+    private static readonly D51_COAL = [
+        '                              ',
+        '                              ',
+        '    _________________         ',
+        '   _|                \\_____A  ',
+        ' =|                        |  ',
+        ' -|                        |  ',
+        '__|________________________|_ ',
+        '|__________________________|_ ',
+        '   |_D__D__D_|  |_D__D__D_|   ',
+        '    \\_/   \\_/    \\_/   \\_/    ',
+        '                              ',
+    ]
+
+    private static readonly C51 = [
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|=[]=-      ||      ||      |  ||=======_|__',
+            '/~\\____|___|/~\\_|  O=======O=======O   |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|=[]=- O=======O=======O    |  ||=======_|__',
+            '/~\\____|___|/~\\_|      ||      ||      |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|==[]=- O=======O=======O   |  ||=======_|__',
+            '/~\\____|___|/~\\_|      ||      ||      |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|===[]=- O=======O=======O  |  ||=======_|__',
+            '/~\\____|___|/~\\_|      ||      ||      |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|===[]=-    ||      ||      |  ||=======_|__',
+            '/~\\____|___|/~\\_|    O=======O=======O |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+        [
+            '        ___                                            ',
+            '       _|_|_  _     __       __             ___________',
+            '    D__/   \\_(_)___|  |__H__|  |_____I_Ii_()|_________|',
+            '     | `---\'   |:: `--\'  H  `--\'         |  |___ ___|  ',
+            '    +|~~~~~~~~++::~~~~~~~H~~+=====+~~~~~~|~~||_| |_||  ',
+            '    ||        | ::       H  +=====+      |  |::  ...|  ',
+            '|    | _______|_::-----------------[][]-----|       |  ',
+            '| /~~ ||   |-----/~~~~\\  /[I_____I][][] --|||_______|__',
+            '------\'|oOo|==[]=-     ||      ||      |  ||=======_|__',
+            '/~\\____|___|/~\\_|   O=======O=======O  |__|+-/~\\_|     ',
+            '\\_/         \\_/  \\____/  \\____/  \\____/      \\_/       ',
+            '                                                       ',
+        ],
+    ]
+
+    private static readonly C51_COAL = [
+        '                              ',
+        '                              ',
+        '                              ',
+        '    _________________         ',
+        '   _|                \\_____A  ',
+        ' =|                        |  ',
+        ' -|                        |  ',
+        '__|________________________|_ ',
+        '|__________________________|_ ',
+        '   |_D__D__D_|  |_D__D__D_|   ',
+        '    \\_/   \\_/    \\_/   \\_/    ',
+        '                              ',
+    ]
+
+    private static readonly SMOKE = [
+        [
+            '(   )',
+            '(    )',
+            '(    )',
+            '(   )',
+            '(  )',
+            '(  )',
+            '( )',
+            '( )',
+            '()',
+            '()',
+            'O',
+            'O',
+            'O',
+            'O',
+            'O',
+            ' ',
+        ],
+        [
+            '(@@@)',
+            '(@@@@)',
+            '(@@@@)',
+            '(@@@)',
+            '(@@)',
+            '(@@)',
+            '(@)',
+            '(@)',
+            '@@',
+            '@@',
+            '@',
+            '@',
+            '@',
+            '@',
+            '@',
+            ' ',
+        ],
+    ]
+
+    private static readonly SMOKE_ERASER = [
+        '     ',
+        '      ',
+        '      ',
+        '     ',
+        '    ',
+        '    ',
+        '   ',
+        '   ',
+        '  ',
+        '  ',
+        ' ',
+        ' ',
+        ' ',
+        ' ',
+        ' ',
+        ' ',
+    ]
+
+    private static readonly SMOKE_DY = [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    private static readonly SMOKE_DX = [-2, -1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3]
+}
--- a/src/program/Touch.ts
+++ b/src/program/Touch.ts
@@ -0,0 +1,27 @@
+import { Item } from '../fs/Item'
+import type { SimpleStream } from '../utils/SimpleStream'
+import { Program } from './Program'
+
+export class Touch extends Program {
+    constructor() {
+        super()
+    }
+
+    async Exec(_: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
+        if (args.length < 2) {
+            stdout.emit("touch: error: missing path argument\n")
+            return 1
+        }
+
+        const item = await Item.open(Item.NormalizePath(args[1].startsWith('/') ? args[1] : `${workdir.GetPath()}/${args[1]}`))
+
+        if (await item.Exists()) {
+            stdout.emit("touch: the file already exists.\n")
+            return 1
+        }
+
+        item.Create()
+
+        return 0
+    }
+}
--- a/src/shell/Shell.ts
+++ b/src/shell/Shell.ts
@@ -0,0 +1,22 @@
+import type { Item } from '../fs/Item'
+import type { Program } from '../program/Program'
+import type { Terminal } from '../terminal/Terminal'
+import type { EventBroadcaster } from '../utils/EventBroadcaster'
+
+export abstract class Shell {
+    readonly abstract Version: string
+    readonly abstract Name: string
+    broadcaster: EventBroadcaster
+    terminal: Terminal
+
+    constructor(broadcaster: EventBroadcaster, terminal: Terminal) {
+        this.broadcaster = broadcaster
+        this.terminal = terminal
+    }
+
+    abstract LoadProgram(program: Program, name: string): void
+    abstract ExecuteProgram(name: string, args: string[]): void
+    abstract Init(): Promise<void>
+    abstract HandleKeyInput(key: string, isCharacter: boolean): void
+    abstract SetWorkingDirectory(directory: Item): Promise<void>
+}
--- a/src/shell/wush/ShellEnvironment.ts
+++ b/src/shell/wush/ShellEnvironment.ts
@@ -0,0 +1,21 @@
+/**
+ * Wush environment manager
+ * Manages environment variables, aliases etc.
+ */
+export class ShellEnvironment {
+    private variables: Record<string, string> = {}
+
+    SetVariable(name: string, value: string | null): void {
+        // remove the variable if value is null
+        if (value === null) {
+            delete this.variables[name]
+            return
+        }
+
+        this.variables[name] = value
+    }
+
+    GetVariable(name: string): string | undefined {
+        return this.variables[name]
+    }
+}
--- a/src/shell/wush/Wush.ts
+++ b/src/shell/wush/Wush.ts
@@ -0,0 +1,707 @@
+// Web-Uno Shell
+// the best name I could come up with lol
+
+import { Clear } from '../../program/Clear'
+import { Eval } from '../../program/Eval'
+import { Loadprg } from '../../program/Loadprg'
+import { Lsprg } from '../../program/Lsprg'
+import { Info } from '../../program/Info'
+import { Program } from '../../program/Program'
+import { Terminal } from '../../terminal/Terminal'
+import type { CursorPosition } from '../../terminal/CursorProperties'
+import { EventBroadcaster } from '../../utils/EventBroadcaster'
+import { SimpleStream } from '../../utils/SimpleStream'
+import { Shell } from '../Shell'
+import { Ls } from '../../program/Ls'
+import { Item } from '../../fs/Item'
+import { Touch } from '../../program/Touch'
+import { Sl } from '../../program/Sl'
+import { Rm } from '../../program/Rm'
+import { Rl } from '../../program/Rl'
+import { ResetIndexedDb } from '../../program/ResetIndexedDb'
+import { Cat } from '../../program/Cat'
+import { Echo } from '../../program/Echo'
+import { Mkdir } from '../../program/Mkdir'
+import { Cd } from '../../program/Cd'
+import { Printf } from '../../program/Printf'
+import { Pwd } from '../../program/Pwd'
+// import { Pwd } from '../program/Pwd'
+// import { Cd } from '../program/Cd'
+
+export class Wush extends Shell {
+    public readonly Version = "0.1.0"
+    public readonly Name = "wush"
+
+    // buffer
+    private buffer: string[] = []
+    private bufferPos: number = 0
+    private promptStart: CursorPosition = { col: 0, row: 0 }
+
+    private history: string[] = []
+    private historyIndex: number | null = null
+    private historyDraft: string = ''
+
+    // exec stuff
+    /**
+     * -1 if the exec is currently running and anything else when it's not
+     */
+    private execExitCode: number = 0
+
+    // todo: workers
+    // private workersAllowed: boolean = false
+
+    // streams
+    readonly stdin: SimpleStream<string>
+    readonly stdout: SimpleStream<string>
+
+    private programs: { [name: string]: Program } = {}
+    private workingDirectory: Item = null as unknown as Item // workdir is initialized in Init so this should be safe
+
+    constructor(broadcaster: EventBroadcaster, terminal: Terminal) {
+        super(broadcaster, terminal)
+
+        // create streams
+        this.stdin = new SimpleStream<string>()
+        this.stdout = new SimpleStream<string>()
+    }
+
+    async Init() {
+        this.broadcaster.on('keydown', (key: string, isCharacter: boolean) =>
+            this.HandleKeyInput(key, isCharacter),
+        )
+
+        // load workdir
+        this.workingDirectory = await Item.Root()
+
+        // load core programs
+        this.programs['clear'] = new Clear()
+        this.programs['eval'] = new Eval()
+        this.programs['loadprg'] = new Loadprg(this)
+        this.programs['lsprg'] = new Lsprg(this)
+        this.programs['info'] = new Info()
+        this.programs['ls'] = new Ls()
+        this.programs['touch'] = new Touch()
+        this.programs['sl'] = new Sl()
+        this.programs['rm'] = new Rm()
+        this.programs['rl'] = new Rl()
+        this.programs['rsindb'] = new ResetIndexedDb()
+        this.programs['cat'] = new Cat()
+        this.programs['echo'] = new Echo()
+        this.programs['mkdir'] = new Mkdir()
+        this.programs['pwd'] = new Pwd()
+        this.programs['cd'] = new Cd(this)
+        this.programs['printf'] = new Printf()
+
+        this.stdout.on(data => this.WriteEscapedString(data))
+        this.Prompt()
+    }
+
+    GetPrograms(): { [name: string]: Program } {
+        return this.programs
+    }
+
+    LoadProgram(program: Program, name: string) {
+        this.programs[name] = program
+    }
+
+    UnloadProgram(name: string) {
+        delete this.programs[name]
+    }
+
+    async ExecuteProgram(name: string, args: string[]): Promise<void> {
+        return new Promise<void>(resolve => {
+            this.programs[name].Exec(this.stdin, this.stdout, this.workingDirectory, args)
+                .then(code => {
+                    this.execExitCode = code != -1 ? code : -2
+                    resolve()
+                })
+                .catch((e) => {
+                    this.WriteEscapedString(`wush: command ${name} exited with the following exception\n`)
+                    this.WriteEscapedString(`    | ${String(e)}\n`)
+                    resolve()
+                })
+                .finally(() => {
+                    // check if the exec actually exited with an exit code
+                    // and if not, set it to -2 to indicate that it didn't exit with a valid code
+                    if (this.execExitCode === -1)
+                        this.execExitCode = -2
+
+                    // this.terminal.Write(`The program exited with exit code ${this.execExitCode}.`)
+                    resolve()
+                })
+        })
+    }
+
+    Prompt() {
+        this.terminal.Write(`user in ${this.workingDirectory.GetPath()} -> `)
+        this.promptStart = this.terminal.GetCursorPosition()
+        this.buffer = []
+        this.bufferPos = 0
+        this.historyIndex = null
+        this.historyDraft = ''
+    }
+
+    /**
+     * Changes the working directory
+     * @param directory the directory to enter into
+     * @throws an error if the directory cannot be opened
+     */
+    async SetWorkingDirectory(directory: Item) {
+        if (!(await directory.Exists()) || !directory.IsDirectory())
+            throw new Error(`Directory  ${directory.GetPath()} doesn't exist`)
+
+        this.workingDirectory = directory
+    }
+
+    WriteStdin(data: string) {
+        this.stdin.emit(data)
+    }
+
+    WriteEscapedString(data: string) {
+        let i = 0
+        let buffer = ''
+
+        const flush = () => {
+            if (buffer.length === 0)
+                return
+
+            this.terminal.Write(buffer)
+            buffer = ''
+        }
+
+        while (i < data.length) {
+            const char = data[i]
+
+            if (char === '\x1b') {
+                flush()
+                const nextIndex = this.ProcessEscapeSequence(data, i)
+                if (nextIndex !== null) {
+                    i = nextIndex
+                    continue
+                }
+            }
+
+            if (char === '\f' || char === '\n') {
+                flush()
+                this.ProcessSimpleControlCode(char)
+                i++
+                continue
+            }
+
+            buffer += char
+            i++
+        }
+
+        flush()
+    }
+
+    PushToBuffer(text: string) {
+        text.split('').forEach(char => {
+            this.buffer.splice(this.bufferPos, 0, char)
+            this.bufferPos++
+        })
+
+        // console.log(this.buffer)
+    }
+
+    RemoveCharFromBuffer(amount: number, index: number) {
+        this.buffer.splice(index - amount, amount)
+        this.bufferPos -= amount
+
+        // console.log(this.buffer)
+    }
+
+    MoveBufferPos(index: number, absolute: boolean = false) {
+        this.bufferPos = Math.max(absolute ? index : this.bufferPos + index, 0)
+    }
+
+    FlushBuffer() {
+        this.buffer = []
+        this.bufferPos = 0
+    }
+
+    async ExecuteBuffer() {
+        type OperatorToken = '&&' | '||' | '|' | ';'
+        type Token = { type: 'word'; value: string } | { type: 'operator'; value: OperatorToken }
+        type ParsedCommand = {
+            args: string[]
+            stdin: null | SimpleStream<string>
+            stdout: null | SimpleStream<string>
+        }
+        type ParsedPipeline = { commands: ParsedCommand[] }
+        type ParsedListItem = { pipeline: ParsedPipeline; operator: '&&' | '||' | ';' | null }
+
+        const tokenize = (text: string): { tokens: Token[]; error: string | null } => {
+            const tokens: Token[] = []
+            let current = ''
+            let wordStarted = false
+            let inSingleQuote = false
+            let inDoubleQuote = false
+            let escapeNext = false
+
+            const pushWord = () => {
+                if (!wordStarted)
+                    return
+
+                tokens.push({ type: 'word', value: current })
+                current = ''
+                wordStarted = false
+            }
+
+            for (let i = 0; i < text.length; i++) {
+                const char = text[i]
+
+                if (escapeNext) {
+                    current += char
+                    escapeNext = false
+                    wordStarted = true
+                    continue
+                }
+
+                if (inSingleQuote) {
+                    if (char === "'") {
+                        inSingleQuote = false
+                        wordStarted = true
+                    } else {
+                        current += char
+                        wordStarted = true
+                    }
+
+                    continue
+                }
+
+                if (inDoubleQuote) {
+                    if (char === '"') {
+                        inDoubleQuote = false
+                        wordStarted = true
+                    } else if (char === '\\') {
+                        if (i + 1 >= text.length)
+                            return { tokens: [], error: 'unterminated escape sequence' }
+
+                        current += text[i + 1]
+                        i++
+                        wordStarted = true
+                    } else {
+                        current += char
+                        wordStarted = true
+                    }
+
+                    continue
+                }
+
+                if (char === '\\') {
+                    escapeNext = true
+                    wordStarted = true
+                    continue
+                }
+
+                if (char === "'") {
+                    inSingleQuote = true
+                    wordStarted = true
+                    continue
+                }
+
+                if (char === '"') {
+                    inDoubleQuote = true
+                    wordStarted = true
+                    continue
+                }
+
+                if (char === ' ' || char === '\t') {
+                    pushWord()
+                    continue
+                }
+
+                if (char === '#') {
+                    if (!wordStarted)
+                        break
+
+                    current += char
+                    wordStarted = true
+                    continue
+                }
+
+                if (char === ';') {
+                    pushWord()
+                    tokens.push({ type: 'operator', value: ';' })
+                    continue
+                }
+
+                if (char === '|') {
+                    pushWord()
+                    if (text[i + 1] === '|') {
+                        tokens.push({ type: 'operator', value: '||' })
+                        i++
+                    } else {
+                        tokens.push({ type: 'operator', value: '|' })
+                    }
+                    continue
+                }
+
+                if (char === '&') {
+                    if (text[i + 1] === '&') {
+                        pushWord()
+                        tokens.push({ type: 'operator', value: '&&' })
+                        i++
+                    } else {
+                        current += char
+                        wordStarted = true
+                    }
+                    continue
+                }
+
+                current += char
+                wordStarted = true
+            }
+
+            if (escapeNext)
+                return { tokens: [], error: 'unterminated escape sequence' }
+            if (inSingleQuote)
+                return { tokens: [], error: 'unterminated single quote' }
+            if (inDoubleQuote)
+                return { tokens: [], error: 'unterminated double quote' }
+
+            pushWord()
+            return { tokens, error: null }
+        }
+
+        const parseTokens = (tokens: Token[]): { list: ParsedListItem[]; error: string | null } => {
+            const list: ParsedListItem[] = []
+            let currentArgs: string[] = []
+            let currentPipeline: ParsedCommand[] = []
+            let expectCommand = false
+
+            const pushCommand = () => {
+                if (currentArgs.length === 0)
+                    return false
+
+                currentPipeline.push({
+                    args: currentArgs,
+                    stdin: null,
+                    stdout: null,
+                })
+                currentArgs = []
+                return true
+            }
+
+            const pushPipeline = (operator: '&&' | '||' | ';' | null) => {
+                if (currentPipeline.length === 0)
+                    return false
+
+                list.push({ pipeline: { commands: currentPipeline }, operator })
+                currentPipeline = []
+                return true
+            }
+
+            for (const token of tokens) {
+                if (token.type === 'word') {
+                    currentArgs.push(token.value)
+                    expectCommand = false
+                    continue
+                }
+
+                if (token.value === '|') {
+                    if (!pushCommand())
+                        return { list: [], error: 'unexpected "|" operator' }
+
+                    expectCommand = true
+                    continue
+                }
+
+                if (!pushCommand() || !pushPipeline(token.value))
+                    return { list: [], error: `unexpected "${token.value}" operator` }
+
+                expectCommand = true
+            }
+
+            if (expectCommand)
+                return { list: [], error: 'unexpected end of input' }
+
+            if (currentArgs.length > 0)
+                pushCommand()
+
+            if (currentPipeline.length > 0)
+                pushPipeline(null)
+
+            return { list, error: null }
+        }
+
+        const line = this.buffer.join('')
+        this.FlushBuffer()
+
+        const { tokens, error } = tokenize(line)
+        if (error) {
+            this.terminal.Write(`wush: error: ${error}`)
+            this.terminal.MoveCursor(0, 1, { x: true, y: false })
+
+            this.Prompt()
+            return
+        }
+
+        const { list, error: parseError } = parseTokens(tokens)
+        if (parseError) {
+            this.terminal.Write(`wush: error: ${parseError}`)
+            this.terminal.MoveCursor(0, 1, { x: true, y: false })
+
+            this.Prompt()
+            return
+        }
+
+        if (list.length === 0) {
+            this.Prompt()
+            return
+        }
+
+        if (list.some(item => item.pipeline.commands.length > 1)) {
+            this.terminal.Write(`wush: error: pipes are not supported yet`)
+            this.terminal.MoveCursor(0, 1, { x: true, y: false })
+
+            this.Prompt()
+            return
+        }
+
+        for (const item of list) {
+            const command = item.pipeline.commands[0]
+
+            this.execExitCode = -1
+
+            if (this.programs[command.args[0]] instanceof Program) {
+                await this.ExecuteProgram(command.args[0], command.args)
+            } else {
+                this.execExitCode = 0
+
+                // don't print anything if there are no arguments
+                if (command.args[0].length !== 0) {
+                    this.terminal.Write(`wush: error: unknown command: ${command.args[0]}.`)
+                    this.terminal.MoveCursor(0, 1, { x: true, y: false })
+
+                    this.execExitCode = 127
+                }
+            }
+        }
+
+        this.Prompt()
+    }
+
+    ProcessSimpleControlCode(code: string): boolean {
+        switch (code) {
+            case '\f':
+                this.terminal.NewPage()
+                return true
+            case '\n':
+                this.terminal.MoveCursor(0, 1, { x: true, y: false })
+                return true
+            default:
+                return false
+        }
+    }
+
+    ProcessEscapeSequence(data: string, index: number): number | null {
+        if (data[index] !== '\x1b' || data[index + 1] !== '[')
+            return null
+
+        let i = index + 2
+        let params = ''
+
+        while (i < data.length) {
+            const char = data[i]
+
+            if ((char >= '0' && char <= '9') || char === ';') {
+                params += char
+                i++
+                continue
+            }
+
+            this.ProcessCsiControlCode(char, params)
+            return i + 1
+        }
+
+        return data.length
+    }
+
+    ProcessCsiControlCode(command: string, params: string): boolean {
+        const values = params.length === 0
+            ? []
+            : params.split(';').map(value => Number.parseInt(value, 10))
+
+        switch (command) {
+            case 'H':
+            case 'f': {
+                const row = Number.isFinite(values[0]) ? values[0] : 1
+                const col = Number.isFinite(values[1]) ? values[1] : 1
+
+                this.terminal.SetCursorPosition(Math.max(col - 1, 0), Math.max(row - 1, 0))
+                return true
+            }
+            case 'J': {
+                this.terminal.NewPage()
+                return true
+            }
+            default:
+                return false
+        }
+    }
+
+    HandleKeyInput(key: string, isCharacter: boolean) {
+        if (this.execExitCode === -1) console.log('program running')
+        if (!isCharacter) {
+            switch (key) {
+                case 'ArrowLeft':
+                    if (this.bufferPos > 0) {
+                        this.bufferPos -= 1
+                        this.SyncCursorToBuffer()
+                    }
+
+                    break
+                case 'ArrowRight':
+                    if (this.bufferPos < this.buffer.length) {
+                        this.bufferPos += 1
+                        this.SyncCursorToBuffer()
+                    }
+                    break
+                case 'ArrowUp':
+                    this.NavigateHistory(-1)
+                    break
+                case 'ArrowDown':
+                    this.NavigateHistory(1)
+                    break
+                case 'Backspace':
+                    // don't erase anything if there's nothing left in the buffer
+                    if (this.bufferPos === 0)
+                        break
+
+                    this.ExitHistoryNavigation()
+                    this.terminal.RemoveCell()
+                    this.RemoveCharFromBuffer(1, this.bufferPos)
+                    this.SyncCursorToBuffer()
+                    break
+                case 'Delete':
+                    if (this.bufferPos >= this.buffer.length || this.buffer.length <= 0)
+                        break
+
+                    this.ExitHistoryNavigation()
+                    this.bufferPos += 1
+                    this.SyncCursorToBuffer()
+                    this.terminal.RemoveCell()
+                    this.RemoveCharFromBuffer(1, this.bufferPos)
+                    this.SyncCursorToBuffer()
+                    break
+                case 'Enter':
+                    // send the buffer to stdin if an exec is running
+                    if (this.execExitCode === -1) {
+                        this.WriteStdin(`${this.buffer.join('')}\n`)
+                        this.FlushBuffer()
+                    } else {
+                        // "execute" the buffer
+                        this.terminal.MoveCursor(0, 1, { x: true, y: false })
+                        const command = this.buffer.join('')
+                        if (command.length > 0)
+                            this.history.push(command)
+
+                        this.historyIndex = null
+                        this.historyDraft = ''
+                        this.ExecuteBuffer()
+                    }
+
+                    break
+                case 'F5':
+                    location.reload()
+                    break
+            }
+        } else {
+            this.ExitHistoryNavigation()
+            // push the character into the buffer
+            this.InsertText(key)
+        }
+    }
+
+    private GetWrapWidth(): number {
+        const width = Math.floor(this.terminal.GetWidthCells())
+        if (!Number.isFinite(width) || width <= 0)
+            return 1
+
+        return Math.max(1, width)
+    }
+
+    private GetCursorPositionForBufferPos(pos: number): CursorPosition {
+        const width = this.GetWrapWidth()
+        const absoluteIndex = this.promptStart.col + Math.max(pos, 0)
+        const rowOffset = Math.floor(absoluteIndex / width)
+        const col = absoluteIndex % width
+
+        return { row: this.promptStart.row + rowOffset, col }
+    }
+
+    private SyncCursorToBuffer() {
+        const position = this.GetCursorPositionForBufferPos(this.bufferPos)
+        this.terminal.SetCursorPosition(position.col, position.row)
+    }
+
+    private ClearBuffer() {
+        if (this.buffer.length === 0)
+            return
+
+        if (this.bufferPos < this.buffer.length) {
+            this.bufferPos = this.buffer.length
+            this.SyncCursorToBuffer()
+        }
+
+        while (this.bufferPos > 0) {
+            this.terminal.RemoveCell()
+            this.RemoveCharFromBuffer(1, this.bufferPos)
+            this.SyncCursorToBuffer()
+        }
+    }
+
+    private InsertText(text: string) {
+        if (text.length === 0)
+            return
+
+        for (const char of text) {
+            this.terminal.InsertCell(char)
+            this.PushToBuffer(char)
+            this.SyncCursorToBuffer()
+        }
+    }
+
+    private SetBuffer(text: string) {
+        this.ClearBuffer()
+        this.InsertText(text)
+    }
+
+    private ExitHistoryNavigation() {
+        this.historyIndex = null
+        this.historyDraft = ''
+    }
+
+    private NavigateHistory(direction: -1 | 1) {
+        if (this.history.length === 0)
+            return
+
+        if (direction === -1) {
+            if (this.historyIndex === null) {
+                this.historyDraft = this.buffer.join('')
+                this.historyIndex = this.history.length - 1
+            } else if (this.historyIndex > 0) {
+                this.historyIndex -= 1
+            } else {
+                return
+            }
+
+            this.SetBuffer(this.history[this.historyIndex])
+            return
+        }
+
+        if (this.historyIndex === null)
+            return
+
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex += 1
+            this.SetBuffer(this.history[this.historyIndex])
+            return
+        }
+
+        this.historyIndex = null
+        this.SetBuffer(this.historyDraft)
+    }
+}
--- a/src/styles/app.scss
+++ b/src/styles/app.scss
@@ -0,0 +1,16 @@
+@forward "terminal.scss";
+@use "./colors.scss" as colors;
+
+body {
+    margin: 10px;
+    background: colors.$terminal-background;
+}
+
+* {
+    box-sizing: border-box;
+}
+
+::selection {
+    background: colors.$terminal-white;
+    color: colors.$terminal-background;
+}
--- a/src/styles/colors.scss
+++ b/src/styles/colors.scss
@@ -0,0 +1,2 @@
+$terminal-background: #141414;
+$terminal-white: #fff;
--- a/src/styles/cursor.scss
+++ b/src/styles/cursor.scss
@@ -0,0 +1,14 @@
+@use "colors.scss" as colors;
+
+#cursor {
+    width: 1px;
+    height: 20px;
+
+    top: 0;
+    left: 0;
+
+    position: absolute;
+
+    backdrop-filter: invert(100%) saturate(0);
+    transition: .2s cubic-bezier(0, 1, 0.3, 1);
+}
--- a/src/styles/terminal.scss
+++ b/src/styles/terminal.scss
@@ -0,0 +1,26 @@
+@use "colors.scss" as colors;
+
+@forward "cursor.scss";
+
+#terminal {
+    background: colors.$terminal-background;
+    color: colors.$terminal-white;
+    font-family: "CaskaydiaCove", "CaskaydiaCove Nerd Font", "JetBrains Mono", "JetBrains Mono Nerd", monospace;
+    font-variant-ligatures: normal;
+    font-feature-settings: "liga" 1, "calt" 1;
+
+    ::-moz-selection {
+        background: colors.$terminal-white;
+        color: colors.$terminal-background;
+    }
+
+    p {
+        margin: 0;
+        height: fit-content;
+    }
+
+    .line {
+        width: fit-content;
+        white-space: pre;
+    }
+}
--- a/src/terminal/CursorProperties.ts
+++ b/src/terminal/CursorProperties.ts
@@ -0,0 +1,6 @@
+export type CursorPosition = {
+    col: number,
+    row: number,
+}
+
+export type CursorStyle = 'bar' | 'underline' | 'cell' | 'cell_hollow'
--- a/src/terminal/Terminal.ts
+++ b/src/terminal/Terminal.ts
@@ -0,0 +1,446 @@
+import { SetCurrentTerminal } from '../app'
+
+import type { Shell } from '../shell/Shell'
+import sqs from '../utils/sqs'
+import type { CursorPosition, CursorStyle } from './CursorProperties'
+
+export class Terminal {
+    public static readonly Version = "0.1.1"
+
+    private terminal: HTMLElement
+    private cursor: HTMLElement
+    private cursorStyle: CursorStyle = 'bar'
+    private cellHeight = 0
+    private cellWidth = 0
+    private lines: string[] = []
+    private lineElements: HTMLElement[] = []
+    private lineWrapped: boolean[] = []
+    private scrollPending = false
+    private cursorRange: Range | null = null
+
+    private cursorPosition: CursorPosition = {
+        col: 0,
+        row: 0,
+    }
+
+    private shell?: Shell
+
+    constructor() {
+        SetCurrentTerminal(this)
+
+        this.terminal = sqs('#terminal')
+        this.cursor = sqs('#cursor')
+        this.cursorRange = document.createRange()
+
+        this.SetCursorStyle('bar')
+        this.NewPage()
+        this.SetupMetricsRefresh()
+    }
+
+    async LoadShell(shell: Shell) {
+        this.shell = shell
+        await this.shell.Init()
+    }
+
+    GetShell(): Shell | undefined {
+        return this.shell
+    }
+
+    NewPage() {
+        this.ResetCellSize()
+
+        this.terminal.innerHTML = ''
+        this.lines = []
+        this.lineElements = []
+        this.lineWrapped = []
+        this.SetCursorPosition(0, 0)
+    }
+
+    AppendLine() {
+        this.EnsureLine(this.lineElements.length)
+    }
+
+    /**
+     * @returns index of the last line on the page. -1 if there are no lines
+     */
+    GetLastLineIndex(): number {
+        return this.lineElements.length - 1
+    }
+
+    Write(text: string) {
+        if (text.length === 0)
+            return
+
+        const width = this.GetWrapWidth()
+        let row = this.cursorPosition.row
+        let col = this.cursorPosition.col
+
+        while (col >= width) {
+            this.EnsureLine(row)
+            this.lineWrapped[row] = true
+            col -= width
+            row += 1
+        }
+
+        this.EnsureLine(row)
+
+        let remaining = text
+        while (remaining.length > 0) {
+            let line = this.lines[row]
+            if (col > line.length)
+                line += ' '.repeat(col - line.length)
+
+            const available = width - col
+            if (available <= 0) {
+                this.lineWrapped[row] = true
+                row += 1
+                col = 0
+                this.EnsureLine(row)
+                continue
+            }
+
+            const chunk = remaining.slice(0, available)
+            if (col === line.length) {
+                line += chunk
+            } else {
+                const prefix = line.slice(0, col)
+                const suffixStart = Math.min(line.length, col + chunk.length)
+                const suffix = line.slice(suffixStart)
+                line = prefix + chunk + suffix
+            }
+
+            this.lines[row] = line
+            this.UpdateLine(row)
+
+            remaining = remaining.slice(chunk.length)
+            col += chunk.length
+
+            if (remaining.length > 0) {
+                this.lineWrapped[row] = true
+                row += 1
+                col = 0
+                this.EnsureLine(row)
+            } else {
+                this.lineWrapped[row] = false
+            }
+        }
+
+        this.cursorPosition.col = Math.max(col, 0)
+        this.cursorPosition.row = Math.max(row, 0)
+        this.UpdateCursor()
+    }
+
+    SetCell(char: string) {
+        const width = this.GetWrapWidth()
+        let row = this.cursorPosition.row
+        let col = this.cursorPosition.col
+
+        while (col >= width) {
+            this.EnsureLine(row)
+            this.lineWrapped[row] = true
+            col -= width
+            row += 1
+        }
+
+        this.EnsureLine(row)
+
+        let line = this.lines[row]
+        if (col > line.length)
+            line += ' '.repeat(col - line.length)
+
+        if (col === line.length) {
+            line += char[0]
+        } else {
+            line = line.slice(0, col) + char[0] + line.slice(col + 1)
+        }
+
+        this.lines[row] = line
+        this.UpdateLine(row)
+    }
+
+    InsertCell(char: string) {
+        const width = this.GetWrapWidth()
+        let row = this.cursorPosition.row
+        let col = this.cursorPosition.col
+
+        while (col >= width) {
+            this.EnsureLine(row)
+            this.lineWrapped[row] = true
+            col -= width
+            row += 1
+        }
+
+        this.EnsureLine(row)
+
+        let line = this.lines[row]
+        if (col > line.length)
+            line += ' '.repeat(col - line.length)
+
+        line = line.slice(0, col) + char[0] + line.slice(col)
+        this.lines[row] = line
+        this.UpdateLine(row)
+        this.ReflowFromRow(row)
+    }
+
+    RemoveCell() {
+        let row = this.cursorPosition.row
+        let removeIndex = this.cursorPosition.col - 1
+
+        if (removeIndex < 0) {
+            if (row <= 0 || !this.lineWrapped[row - 1])
+                return
+
+            row -= 1
+            removeIndex = (this.lines[row] ?? '').length - 1
+            if (removeIndex < 0)
+                return
+        }
+
+        this.EnsureLine(row)
+        let line = this.lines[row]
+        if (removeIndex >= line.length)
+            return
+
+        line = line.slice(0, removeIndex) + line.slice(removeIndex + 1)
+        this.lines[row] = line
+        this.UpdateLine(row)
+        this.ReflowFromRow(row)
+    }
+
+    ResetCellSize() {
+        // dynamically determine cell size using dom
+        const cell = document.createElement('span')
+        cell.textContent = 'A'
+        cell.style.position = 'absolute'
+        cell.style.visibility = 'hidden'
+        cell.style.whiteSpace = 'pre'
+
+        this.terminal.appendChild(cell)
+
+        this.cellWidth = cell.offsetWidth
+        this.cellHeight = cell.offsetHeight
+
+        cell.remove()
+    }
+
+    GetHeightCells(): number {
+        const rect = this.terminal.getBoundingClientRect()
+        const height = Math.max(0, document.documentElement.clientHeight - rect.top)
+        return height / this.cellHeight
+    }
+
+    GetWidthCells(): number {
+        const rect = this.terminal.getBoundingClientRect()
+        const width = Math.max(0, document.documentElement.clientWidth - rect.left)
+        return width / this.cellWidth
+    }
+
+    private GetWrapWidth(): number {
+        const width = this.GetWidthCells()
+        if (!Number.isFinite(width) || width <= 0)
+            return 1
+
+        return Math.max(1, Math.floor(width))
+    }
+
+    UpdateCursor() {
+        this.SetCursorStyle(this.cursorStyle)
+
+        const rect = this.terminal.getBoundingClientRect()
+        const left = this.GetCursorXOffset() + rect.left + window.scrollX
+        const top = this.cursorPosition.row * this.cellHeight + rect.top + window.scrollY
+
+        this.cursor.style.left = `${left}px`
+        this.cursor.style.top = `${top}px`
+    }
+
+    GetCursorPosition(): CursorPosition {
+        return { col: this.cursorPosition.col, row: this.cursorPosition.row }
+    }
+
+    SetCursorPosition(col: number, row: number) {
+        const width = this.GetWrapWidth()
+        const clampedCol = Number.isFinite(width) ? Math.min(col, width - 1) : col
+
+        this.cursorPosition.col = Math.max(clampedCol, 0)
+        this.cursorPosition.row = Math.max(row, 0)
+
+        this.EnsureLine(this.cursorPosition.row)
+        this.UpdateCursor()
+    }
+
+    MoveCursor(col: number, row: number, absolute: { x: boolean; y: boolean } = { x: false, y: false }) {
+        const width = this.GetWrapWidth()
+        let targetCol = !absolute.x ? this.cursorPosition.col + col : col
+        let targetRow = !absolute.y ? this.cursorPosition.row + row : row
+
+        if (!absolute.x && col !== 0) {
+            if (targetCol >= width) {
+                const shift = Math.floor(targetCol / width)
+                targetRow += shift
+                targetCol = targetCol % width
+            } else if (targetCol < 0) {
+                while (targetCol < 0 && targetRow > 0) {
+                    if (!this.lineWrapped[targetRow - 1]) {
+                        targetCol = 0
+                        break
+                    }
+
+                    targetRow -= 1
+                    targetCol += width
+                }
+
+                if (targetCol < 0)
+                    targetCol = 0
+            }
+        }
+
+        this.SetCursorPosition(targetCol, targetRow)
+    }
+
+    SetCursorStyle(style: CursorStyle) {
+        switch (style) {
+            default:
+                this.cursor.style.width = `${this.cellWidth}px`
+                this.cursor.style.height = `${this.cellHeight}px`
+        }
+    }
+
+    private EnsureLine(row: number) {
+        let added = false
+
+        while (this.lineElements.length <= row) {
+            const paragraph = document.createElement('p')
+            paragraph.style.height = `${this.cellHeight}px`
+            paragraph.id = `line-${this.lineElements.length}`
+            paragraph.className = 'line'
+
+            this.terminal.appendChild(paragraph)
+            this.lineElements.push(paragraph)
+            this.lines.push('')
+            this.lineWrapped.push(false)
+            added = true
+        }
+
+        if (added)
+            this.ScheduleScroll()
+    }
+
+    private UpdateLine(row: number) {
+        const line = this.lineElements[row]
+        if (line)
+            line.textContent = this.lines[row]
+    }
+
+    private ReflowFromRow(startRow: number) {
+        const width = this.GetWrapWidth()
+        if (width <= 0)
+            return
+
+        this.EnsureLine(startRow)
+
+        let text = this.lines[startRow] ?? ''
+        let endRow = startRow
+
+        while (this.lineWrapped[endRow]) {
+            endRow += 1
+            if (endRow >= this.lines.length)
+                break
+
+            text += this.lines[endRow] ?? ''
+        }
+
+        let row = startRow
+        let index = 0
+
+        if (text.length === 0) {
+            this.lines[row] = ''
+            this.UpdateLine(row)
+            this.lineWrapped[row] = false
+            row += 1
+        } else {
+            while (index < text.length) {
+                const chunk = text.slice(index, index + width)
+                this.lines[row] = chunk
+                this.UpdateLine(row)
+                this.lineWrapped[row] = index + width < text.length
+
+                row += 1
+                index += width
+
+                if (index < text.length)
+                    this.EnsureLine(row)
+            }
+        }
+
+        for (let i = row; i <= endRow; i++) {
+            if (this.lines[i] !== '' || this.lineWrapped[i]) {
+                this.lines[i] = ''
+                this.UpdateLine(i)
+                this.lineWrapped[i] = false
+            }
+        }
+    }
+
+    private GetCursorXOffset(): number {
+        const row = this.cursorPosition.row
+        const col = this.cursorPosition.col
+        const line = this.lineElements[row]
+        const text = this.lines[row] ?? ''
+
+        if (!line)
+            return col * this.cellWidth
+
+        const textLength = text.length
+        const clamped = Math.min(col, textLength)
+        let width = 0
+
+        const textNode = line.firstChild
+        if (textNode && textNode.nodeType === Node.TEXT_NODE && clamped > 0) {
+            if (clamped === textLength) {
+                width = line.getBoundingClientRect().width
+            } else if (this.cursorRange) {
+                this.cursorRange.setStart(textNode, 0)
+                this.cursorRange.setEnd(textNode, clamped)
+                width = this.cursorRange.getBoundingClientRect().width
+            }
+        }
+
+        if (col > textLength)
+            width += (col - textLength) * this.cellWidth
+
+        return width
+    }
+
+    private RefreshMetrics() {
+        this.ResetCellSize()
+        this.lineElements.forEach(line => {
+            line.style.height = `${this.cellHeight}px`
+        })
+        this.UpdateCursor()
+    }
+
+    private SetupMetricsRefresh() {
+        if ('fonts' in document) {
+            document.fonts.ready.then(() => {
+                this.RefreshMetrics()
+            })
+        }
+
+        window.addEventListener('resize', () => this.RefreshMetrics())
+    }
+
+    private ScheduleScroll() {
+        if (this.scrollPending)
+            return
+
+        this.scrollPending = true
+        requestAnimationFrame(() => {
+            this.scrollPending = false
+
+            const lastLine = this.lineElements[this.lineElements.length - 1]
+            if (lastLine)
+                lastLine.scrollIntoView({ block: 'end' })
+        })
+    }
+}
--- a/src/utils/EventBroadcaster.ts
+++ b/src/utils/EventBroadcaster.ts
@@ -0,0 +1,43 @@
+export class EventBroadcaster {
+    private listeners: Map<string, Set<Function>> = new Map()
+
+    /**
+     * Assigns a listener for the specified event
+     * @param event event name
+     * @param listener function to call when the event is emitted
+     */
+    on(event: string, listener: Function) {
+        if (!this.listeners.has(event))
+            this.listeners.set(event, new Set())
+        this.listeners.get(event)!.add(listener)
+    }
+
+    /**
+     * Removes a listener from the specified event
+     * @param event event name
+     * @param listener function to remove
+     */
+    off(event: string, listener: Function) {
+        if (this.listeners.has(event))
+            this.listeners.get(event)!.delete(listener)
+    }
+
+    /**
+     * Removes all listeners for the specified event
+     * @param event event name
+     */
+    clear(event: string) {
+        if (this.listeners.has(event))
+            this.listeners.get(event)!.clear()
+    }
+
+    /**
+     * Emits an event with the given arguments
+     * @param event event name
+     * @param args arguments to pass to the listeners
+     */
+    emit(event: string, ...args: any[]) {
+        if (this.listeners.has(event))
+            this.listeners.get(event)!.forEach((listener) => listener(...args))
+    }
+}
--- a/src/utils/SimpleStream.ts
+++ b/src/utils/SimpleStream.ts
@@ -0,0 +1,50 @@
+export class SimpleStream<T> {
+    private listeners: Set<Function> = new Set()
+
+    /**
+     * Attaches a listener to the stream
+     * @param listener the function to call when new data is streamed
+     */
+    on(listener: (data: T) => any): void {
+        this.listeners.add(listener)
+    }
+
+    /**
+     * Attaches a one-time listener to the stream
+     * @param listener the function to call when new data is streamed
+     */
+    once(listener: (data: T) => any): void {
+        const func = (data: T) => {
+            listener(data)
+            this.off(func)
+        }
+
+        this.on(func)
+    }
+
+    /**
+     * Patiently waits until new data is streamed, then returns it
+     * @returns a promise for a single chunk of streamed data
+     */
+    wait(): Promise<T> {
+        return new Promise<T>(resolve => {
+            this.once(data => resolve(data))
+        })
+    }
+
+    /**
+     * Removes a listener from the stream
+     * @param listener the function to remove
+     */
+    off(listener: Function): void {
+        this.listeners.delete(listener)
+    }
+
+    /**
+     * Streams data
+     * @param data the data to stream
+     */
+    emit(data: T): void {
+        this.listeners.forEach((listener) => listener(data))
+    }
+}
--- a/src/utils/sqs.ts
+++ b/src/utils/sqs.ts
@@ -0,0 +1,13 @@
+/**
+ * a "safe" wrapper for querySelector. ugly as hell but whatever
+ * @param query css selector query
+ * @returns first element matching the query
+ */
+export default function sqs<T extends HTMLElement>(query: string): T {
+    const element = document.querySelector(query)
+
+    if (!(element instanceof HTMLElement))
+        throw new Error(`Failed to process a short element query: ${query}`)
+
+    return element as T
+}
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -0,0 +1,5 @@
+export default {
+    server: {
+        port: 3000,
+    },
+}
Author	SHA1	Message	Date
binekrasik	b5089251ff	chore: fix path syntax in core programs	2026-05-19 23:19:36 +02:00
binekrasik	1d00cf6deb	feat: complete shell revamp	2026-05-19 21:42:14 +02:00
binekrasik	4a484dd546	feat: improve bash-like command parsing	2026-05-19 18:22:43 +02:00
binekrasik	b5f53473ed	sync: actually sync everything	2026-05-18 19:25:03 +02:00
binekrasik	22d00aa0b3	sync: wip advanced command parser	2026-05-18 19:22:34 +02:00
binekrasik	d8ebbbe9e1	chore: fix build	2026-05-18 00:14:49 +02:00
binekrasik	4f4b72b915	chore: make webfs usable	2026-05-17 23:52:31 +02:00
binekrasik	f8335dcf5f	docs: update tested browsers	2026-05-15 14:29:06 +02:00
binekrasik	063f704e69	chore: add temporary files to .gitignore	2026-05-15 14:27:13 +02:00
binekrasik	d3bfbdf836	chore: remove slop prompt	2026-05-15 14:24:06 +02:00
binekrasik	4c67f2aee3	feat: working filesystem	2026-05-15 14:16:11 +02:00
binekrasik	97b9994594	sync: sync wip stuff	2026-05-12 10:38:30 +02:00
binekrasik	dc706d6262	chore: fix chrome	2026-04-15 11:40:45 +02:00
binekrasik	ea968b8492	sync: wip shell and info fetch	2026-03-27 17:52:58 +01:00
binekrasik	83830c7717	feat: add neofetch, fix buffer backspacing	2026-03-27 09:20:21 +01:00
binekrasik	91eeb33d9e	feat: simple loadprg implementation	2026-03-26 23:58:09 +01:00
binekrasik	983cf59476	feat: add some utilities	2026-03-26 22:33:04 +01:00
binekrasik	21a1a34309	feat: streams, 'clear' command	2026-03-26 21:05:35 +01:00
binekrasik	686abeafb4	docs: remove chrome from tested browsers	2026-03-26 15:40:07 +01:00
binekrasik	ed15d94255	feat: working-ish shell and terminal	2026-03-26 13:57:58 +01:00
binekrasik	1d54c8b650	chore: cleanup Terminal.ts	2026-03-26 11:57:11 +01:00
binekrasik	141204164a	sync: umm progress	2026-03-25 23:07:44 +01:00
binekrasik	e03aa97716	sync: wip terminal cell system	2026-03-24 23:49:51 +01:00
binekrasik	475ba9d8ab	sync: wip changes	2026-03-24 13:58:59 +01:00
binekrasik	6cc4837a8e	feat: basic terminal printing	2026-03-23 23:42:24 +01:00
binekrasik	64717cc652	chore: tidy up things	2026-03-23 21:59:36 +01:00
binekrasik	ca5d60b714	chore: add sass	2026-03-23 21:55:11 +01:00
binekrasik	d8863654f9	docs: what in the legal he-	2026-03-23 17:16:25 +01:00
binekrasik	0152e4da73	docs: clarify dependency installation	2026-03-23 16:24:01 +01:00
binekrasik	8e0db465a7	chore: create app base	2026-03-23 16:21:20 +01:00
binekrasik	788edc6d61	chore: add stuff to gitignore	2026-03-23 16:20:31 +01:00
binekrasik	9a90da9cc9	docs: add testing notice in README.md	2026-03-23 16:15:28 +01:00