offsite 0.0.0 → 0.0.1

package/apps/server/dist/terminal/terminal.js

@@ -0,0 +1,402 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { decodeFrame, encodeFrame, FRAME_INPUT, FRAME_OUTPUT, FRAME_REPLAY, FRAME_REPLY, } from '../protocol.js';
+import { pushActive, sendPush } from '../push.js';
+import { home } from '../storage.js';
+import { ALERT_DELAY, Alerts, Scanner } from './alerts.js';
+import { busyProgram, currentDirectory, gitBranch, startShell, } from './process.js';
+const HISTORY_LIMIT = 2 * 1024 * 1024;
+const OUTPUT_LIMIT = 1024 * 1024;
+const STALL_LIMIT = 10_000;
+const SILENCE_LIMIT = 90_000;
+const KILL_DELAY = 3000;
+const pasteTypes = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+};
+const instance = `${Date.now()}-${randomUUID()}`;
+const projects = new Map();
+const terminals = new Map();
+const connections = new Map();
+const paused = new Set();
+const branchFailures = new Set();
+let nextTab = 0;
+let draining = null;
+let watching = false;
+if (process.platform !== 'win32')
+    setInterval(() => void watchBranches(), 1000);
+export async function terminalRequest(client, message) {
+    if (message.type === 'attach') {
+        attach(client);
+        return;
+    }
+    const connection = connections.get(client);
+    if (connection === undefined)
+        throw new Error('the terminal is not attached');
+    await request(connection, message);
+}
+export function terminalInput(client, frame) {
+    const connection = connections.get(client);
+    if (connection === undefined) {
+        console.warn('terminal input from a browser that is not attached');
+        return;
+    }
+    input(connection, frame);
+}
+export function detachTerminal(client) {
+    const connection = connections.get(client);
+    if (connection === undefined)
+        return;
+    connections.delete(client);
+    for (const terminal of terminals.values())
+        if (terminal.owner === connection)
+            terminal.owner = null;
+}
+export async function busyTerminal(id) {
+    const terminal = terminals.get(id);
+    if (terminal === undefined)
+        return { program: null };
+    try {
+        return { program: await busyProgram(terminal.pty.pid) };
+    }
+    catch (error) {
+        console.warn(`could not tell if terminal ${id} is busy: ${error}`);
+        return { error: String(error) };
+    }
+}
+export function savePastedImage(type, data) {
+    const extension = pasteTypes[type];
+    if (extension === undefined)
+        throw new Error('pasted image must be a PNG, JPEG, GIF or WebP image');
+    const directory = path.join(home, 'paste');
+    mkdirSync(directory, { recursive: true });
+    const file = path.join(directory, `${Date.now()}-${randomUUID()}.${extension}`);
+    writeFileSync(file, data);
+    return file;
+}
+function attach(client) {
+    detachTerminal(client);
+    const connection = { client, sizes: new Map() };
+    connections.set(client, connection);
+    send(connection, {
+        type: 'active',
+        layout: layout(),
+        instance,
+        branches: Object.fromEntries([...terminals].flatMap(([id, terminal]) => terminal.branch === null ? [] : [[id, terminal.branch]])),
+    });
+    for (const project of projects.values())
+        for (const tab of project.tabs)
+            forward(connection, tab.id, true, Buffer.concat(terminals.get(tab.id)?.history ?? []));
+}
+async function request(connection, message) {
+    switch (message.type) {
+        case 'resize': {
+            const terminal = terminals.get(message.id);
+            if (terminal === undefined)
+                return;
+            connection.sizes.set(message.id, {
+                cols: message.cols,
+                rows: message.rows,
+            });
+            terminal.owner = connection;
+            terminal.pty.resize(message.cols, message.rows);
+            return;
+        }
+        case 'createTab':
+            await createTab(message.cwd);
+            break;
+        case 'closeTab':
+            closeTab(message.id);
+            break;
+        case 'renameTab': {
+            const tab = findTab(message.id);
+            if (tab === undefined)
+                return;
+            tab.customName = message.name === '' ? null : message.name;
+            break;
+        }
+        case 'minimizeTab': {
+            const project = [...projects.values()].find((item) => item.tabs.some((tab) => tab.id === message.id));
+            if (project === undefined)
+                return;
+            if (!project.tabs.some((tab) => tab.id !== message.id && !tab.minimized))
+                return;
+            const index = project.tabs.findIndex((tab) => tab.id === message.id);
+            project.tabs[index].minimized = true;
+            if (project.activeTab === message.id) {
+                const next = nearestVisible(project.tabs, index);
+                project.activeTab = next === undefined ? null : project.tabs[next].id;
+            }
+            break;
+        }
+        case 'select': {
+            const project = projects.get(message.cwd) ?? {
+                tabs: [],
+                activeTab: null,
+            };
+            projects.set(message.cwd, project);
+            const tab = project.tabs.find((item) => item.id === message.tabId);
+            if (tab !== undefined) {
+                tab.minimized = false;
+                project.activeTab = tab.id;
+            }
+            if (project.tabs.length === 0)
+                await createTab(message.cwd);
+            break;
+        }
+    }
+    publish();
+}
+function input(connection, bytes) {
+    let frame;
+    try {
+        frame = decodeFrame(bytes);
+    }
+    catch (error) {
+        console.warn(`ignoring terminal input: ${error}`);
+        return;
+    }
+    const terminal = terminals.get(frame.id);
+    if (terminal === undefined) {
+        console.warn(`input for terminal ${frame.id}, which does not exist`);
+        return;
+    }
+    if (frame.kind === FRAME_REPLY) {
+        if (terminal.owner !== null && terminal.owner !== connection)
+            return;
+    }
+    else if (frame.kind === FRAME_INPUT) {
+        const size = connection.sizes.get(frame.id);
+        if (terminal.owner !== connection && size !== undefined) {
+            terminal.owner = connection;
+            terminal.pty.resize(size.cols, size.rows);
+        }
+    }
+    else {
+        console.warn(`ignoring terminal input of unknown kind ${frame.kind}`);
+        return;
+    }
+    terminal.pty.write(Buffer.from(frame.data));
+}
+async function createTab(cwd) {
+    if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) {
+        console.error(`${cwd} is not a folder, terminal not created`);
+        return;
+    }
+    const project = projects.get(cwd) ?? { tabs: [], activeTab: null };
+    projects.set(cwd, project);
+    const active = project.activeTab === null ? undefined : terminals.get(project.activeTab);
+    let directory = cwd;
+    if (active !== undefined) {
+        try {
+            directory = await currentDirectory(active.pty.pid);
+        }
+        catch (error) {
+            console.warn(`starting in the project folder, could not read the folder of the active terminal: ${error}`);
+        }
+    }
+    nextTab += 1;
+    const id = nextTab;
+    let pty;
+    try {
+        pty = startShell(directory);
+    }
+    catch (error) {
+        console.error(`could not start terminal ${id}: ${error}`);
+        return;
+    }
+    const terminal = {
+        pty,
+        history: [],
+        historySize: 0,
+        branch: null,
+        owner: null,
+        alerts: new Alerts(),
+        scanner: new Scanner(),
+    };
+    terminals.set(id, terminal);
+    project.tabs.push({ id, customName: null, minimized: false });
+    project.activeTab = id;
+    pty.onData((data) => output(id, terminal, data));
+    pty.onExit(() => {
+        terminals.delete(id);
+        paused.delete(pty);
+        branchFailures.delete(id);
+        if (closeTab(id))
+            publish();
+    });
+}
+function closeTab(id) {
+    const project = [...projects.values()].find((item) => item.tabs.some((tab) => tab.id === id));
+    if (project === undefined)
+        return false;
+    const index = project.tabs.findIndex((tab) => tab.id === id);
+    project.tabs.splice(index, 1);
+    if (project.activeTab === id) {
+        let next = nearestVisible(project.tabs, index);
+        if (next === undefined && project.tabs.length > 0)
+            next = Math.min(index, project.tabs.length - 1);
+        if (next !== undefined)
+            project.tabs[next].minimized = false;
+        project.activeTab = next === undefined ? null : project.tabs[next].id;
+    }
+    const terminal = terminals.get(id);
+    if (terminal === undefined)
+        return true;
+    terminal.pty.kill();
+    if (process.platform !== 'win32')
+        setTimeout(() => {
+            if (terminals.get(id) === terminal)
+                terminal.pty.kill('SIGKILL');
+        }, KILL_DELAY);
+    return true;
+}
+function output(id, terminal, data) {
+    terminal.history.push(data);
+    terminal.historySize += data.length;
+    while (terminal.historySize > HISTORY_LIMIT && terminal.history.length > 1) {
+        terminal.historySize -= terminal.history[0].length;
+        terminal.history.shift();
+    }
+    for (const connection of connections.values())
+        forward(connection, id, false, data);
+    scan(id, terminal, data);
+    if ([...connections.values()].some((connection) => connection.client.socket.bufferedAmount > OUTPUT_LIMIT)) {
+        terminal.pty.pause();
+        paused.add(terminal.pty);
+        draining ??= drain();
+    }
+}
+function drain() {
+    const progress = new Map();
+    return setInterval(() => {
+        let full = false;
+        for (const connection of connections.values()) {
+            const queued = connection.client.socket.bufferedAmount;
+            if (queued <= OUTPUT_LIMIT)
+                continue;
+            const now = Date.now();
+            const last = progress.get(connection) ?? { queued: Infinity, at: now };
+            if (queued < last.queued)
+                last.at = now;
+            last.queued = queued;
+            progress.set(connection, last);
+            if (now - last.at > STALL_LIMIT) {
+                console.warn('a browser is not reading fast enough, disconnecting it');
+                connection.client.socket.terminate();
+                continue;
+            }
+            full = true;
+        }
+        if (full)
+            return;
+        if (draining !== null)
+            clearInterval(draining);
+        draining = null;
+        for (const pty of paused)
+            pty.resume();
+        paused.clear();
+    }, 10);
+}
+function scan(id, terminal, data) {
+    if (!pushActive()) {
+        terminal.scanner = new Scanner();
+        return;
+    }
+    const alert = terminal.scanner.scan(data);
+    if (alert === null || browserOpen())
+        return;
+    const started = alert.type === 'bell'
+        ? terminal.alerts.startBell()
+        : terminal.alerts.startNotification();
+    if (!started)
+        return;
+    const windowTitle = terminal.scanner.title;
+    setTimeout(() => push(id, alert, windowTitle), ALERT_DELAY);
+}
+function push(id, alert, windowTitle) {
+    const terminal = terminals.get(id);
+    if (terminal === undefined)
+        return;
+    let title = '';
+    let body;
+    if (alert.type === 'bell') {
+        if (!terminal.alerts.finishBell())
+            return;
+        body = 'Bell';
+    }
+    else {
+        title = alert.title;
+        body = alert.body;
+    }
+    if (browserOpen())
+        return;
+    const entry = [...projects].find(([, project]) => project.tabs.some((tab) => tab.id === id));
+    if (entry === undefined)
+        return;
+    const tab = findTab(id);
+    if (title === '')
+        title = tab?.customName ?? (windowTitle || 'Terminal');
+    void sendPush({ title, body, cwd: entry[0], tabId: id });
+}
+function browserOpen() {
+    return [...connections.values()].some((connection) => Date.now() - connection.client.heardAt < SILENCE_LIMIT);
+}
+async function watchBranches() {
+    if (watching)
+        return;
+    watching = true;
+    for (const [id, terminal] of terminals) {
+        let branch;
+        try {
+            branch = await gitBranch(await currentDirectory(terminal.pty.pid));
+        }
+        catch (error) {
+            if (!branchFailures.has(id))
+                console.warn(`could not read the git branch of terminal ${id}: ${error}`);
+            branchFailures.add(id);
+            continue;
+        }
+        branchFailures.delete(id);
+        if (terminal.branch === branch || terminals.get(id) !== terminal)
+            continue;
+        terminal.branch = branch;
+        for (const connection of connections.values())
+            send(connection, { type: 'branch', id, branch });
+    }
+    watching = false;
+}
+function findTab(id) {
+    for (const project of projects.values()) {
+        const tab = project.tabs.find((item) => item.id === id);
+        if (tab !== undefined)
+            return tab;
+    }
+    return undefined;
+}
+function nearestVisible(tabs, index) {
+    for (let position = index; position < tabs.length; position++)
+        if (!tabs[position].minimized)
+            return position;
+    for (let position = Math.min(index, tabs.length) - 1; position >= 0; position--)
+        if (!tabs[position].minimized)
+            return position;
+    return undefined;
+}
+function layout() {
+    return Object.fromEntries(projects);
+}
+function publish() {
+    const event = { type: 'layout', layout: layout() };
+    for (const connection of connections.values())
+        send(connection, event);
+}
+function forward(connection, id, replay, data) {
+    connection.client.socket.send(encodeFrame(replay ? FRAME_REPLAY : FRAME_OUTPUT, id, data));
+}
+function send(connection, event) {
+    connection.client.send({ type: 'terminal', event });
+}

package/apps/server/src/terminal/shell-integration/bash/offsite.bash

@@ -0,0 +1,112 @@
+__offsite_last=$_ __offsite_status=$? __offsite_values=("${PIPESTATUS[@]}")
+builtin declare -a __offsite_last __offsite_status __offsite_errexit __offsite_running __offsite_ready __offsite_pipestatus __offsite_loop
+builtin unset ENV
+builtin export -n HISTFILE
+builtin set +o posix
+builtin shopt -u inherit_errexit 2>/dev/null
+MAILCHECK=60
+__offsite_errexit=0
+__offsite_running=0
+__offsite_ready=0
+__offsite_ps1_mark=('' $'\001\e]6973;B\a\002')
+__offsite_ps0_mark=('' $'\e]6973;C\a')
+__offsite_ps1='${__offsite_ps1_mark+${__offsite_ps1_mark[${__offsite_ready-0}]-}}'
+__offsite_ps0='${__offsite_ps0_mark[${__offsite_ready-0} ? (__offsite_running = 1, __offsite_ready = 0, 1) : 0]-}'
+__offsite_trap='{ __offsite_returned; } 2>/dev/null'
+
+__offsite_returned() {
+    __offsite_last=$_ __offsite_status=$? __offsite_values=("${PIPESTATUS[@]}")
+    if (( ${#BASH_SOURCE[@]} == 2 )) && [[ -o errexit ]]; then
+        __offsite_errexit=1
+        builtin set +e
+    fi
+}
+
+__offsite_return() {
+    builtin local index
+    __offsite_pipestatus=0
+    for index in "${!__offsite_values[@]}"; do
+        __offsite_pipestatus+=",PIPESTATUS[$index]=${__offsite_values[index]}"
+    done
+    builtin return "$__offsite_status"
+}
+
+__offsite_prompt() {
+    __offsite_status=$? __offsite_last=$1 __offsite_values=("${PIPESTATUS[@]}")
+    builtin local attributes
+    if [[ $__offsite_running == 1 ]]; then
+        builtin printf '\e]6973;D;%s\a' "$__offsite_status"
+    fi
+    builtin printf '\e]6973;A\a'
+    __offsite_running=0
+    __offsite_ready=0
+    if [[ -v PS1 && ${PS1@a} != *r* ]]; then
+        attributes=${PS1@a}
+        PS1=${PS1//"$__offsite_ps1"/}
+        if [[ $attributes != *x* ]]; then
+            if builtin shopt -q promptvars && [[ $PS1 != *\\ ]]; then
+                PS1+=$__offsite_ps1
+                __offsite_ready=1
+            fi
+            builtin export -n PS1
+        fi
+    fi
+    if [[ ! -v PS0 || ${PS0@a} != *r* ]]; then
+        attributes=
+        if [[ -v PS0 ]]; then
+            attributes=${PS0@a}
+            PS0=${PS0//"$__offsite_ps0"/}
+        fi
+        if [[ $attributes != *x* ]]; then
+            if (( __offsite_ready )) && [[ ${PS0-} != *\\ ]]; then
+                PS0+=$__offsite_ps0
+            fi
+            if [[ -v PS0 ]]; then
+                builtin export -n PS0
+            fi
+        fi
+    fi
+    if [[ ${PS0-} != *"$__offsite_ps0" ]]; then
+        __offsite_ready=0
+    fi
+    __offsite_return
+}
+
+__offsite_setup() {
+    builtin unset -f __offsite_returned __offsite_setup
+    builtin unset __offsite_trap
+    builtin local commands=${PROMPT_COMMAND-}
+    if (( BASH_VERSINFO[0] > 5 || (BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] >= 1) )); then
+        commands=${PROMPT_COMMAND[*]-}
+    fi
+    if (( BASH_VERSINFO[0] > 4 || (BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] >= 4) )) && [[ ! -v PROMPT_COMMAND || ${PROMPT_COMMAND@a} != *[rx]* ]] && [[ -n $commands || -z $1 ]]; then
+        PROMPT_COMMAND='for ((__offsite_loop = 1; __offsite_loop--; __offsite_pipestatus)); do __offsite_prompt "$_" && ((1)); done 2> /dev/null'${PROMPT_COMMAND:+"; $PROMPT_COMMAND"}
+        builtin export -n PROMPT_COMMAND
+    else
+        builtin unset -f __offsite_prompt
+        builtin unset __offsite_running __offsite_ready __offsite_ps1_mark __offsite_ps0_mark __offsite_ps1 __offsite_ps0
+    fi
+    if (( __offsite_errexit )); then
+        builtin set -e
+    fi
+    builtin unset __offsite_errexit
+    __offsite_return
+}
+
+builtin trap "$__offsite_trap" RETURN
+if [[ -e /etc/profile ]]; then
+    builtin source /etc/profile
+fi
+if (( __offsite_errexit )); then
+    __offsite_errexit=0
+    builtin set -e
+fi
+if [[ -e $HOME/.bash_profile ]]; then
+    builtin source "$HOME/.bash_profile"
+elif [[ -e $HOME/.bash_login ]]; then
+    builtin source "$HOME/.bash_login"
+elif [[ -e $HOME/.profile ]]; then
+    builtin source "$HOME/.profile"
+fi
+if [[ $(builtin trap -p RETURN) == "trap -- '$__offsite_trap' RETURN" ]]; then builtin trap - RETURN; fi 2>/dev/null
+for ((__offsite_loop = 1; __offsite_loop--; __offsite_pipestatus)); do __offsite_setup "$(builtin trap -p DEBUG)" "$__offsite_last" && ((1)); done 2>/dev/null

package/apps/server/src/terminal/shell-integration/fish/offsite.fish

@@ -0,0 +1,22 @@
+if status is-interactive
+    set --local native 0
+    if test (string match --regex '^\d+' -- $version) -ge 4
+        status test-feature mark-prompt
+        if test $status -ne 1
+            set native 1
+        end
+    end
+    if test $native = 0
+        function __offsite_prompt_start --on-event fish_prompt
+            printf '\e]6973;A\a'
+        end
+
+        function __offsite_output_start --on-event fish_preexec
+            printf '\e]6973;C\a'
+        end
+
+        function __offsite_output_end --on-event fish_postexec
+            printf '\e]6973;D;%s\a' $status
+        end
+    end
+end

package/apps/server/src/terminal/shell-integration/zsh/.zshenv

@@ -0,0 +1,100 @@
+__offsite_status=($?) __offsite_last=("$_")
+__offsite_aliases=(${options[aliases]})
+'builtin' 'unsetopt' 'aliases'
+builtin unset ZDOTDIR
+
+if [[ -o interactive ]]; then
+    __offsite_install() {
+        {
+            builtin emulate -L zsh
+            __offsite_running=0
+            precmd_functions=(${precmd_functions:#__offsite_install} __offsite_precmd)
+            preexec_functions+=(__offsite_preexec)
+            if [[ ${widgets[zle-line-init]} == user:azhw:* ]] && (( $+functions[add-zle-hook-widget] )); then
+                add-zle-hook-widget zle-line-init __offsite_line_init
+            else
+                if (( $+widgets[zle-line-init] )); then
+                    builtin zle -A zle-line-init __offsite_line_init_original
+                fi
+                builtin zle -N zle-line-init __offsite_line_init
+            fi
+            __offsite_precmd
+        } 2>/dev/null
+    }
+
+    __offsite_precmd() {
+        {
+            builtin local exit_status=$?
+            builtin emulate -L zsh
+            if builtin zle; then
+                builtin return
+            fi
+            if (( __offsite_running )); then
+                builtin print -n "\e]6973;D;${exit_status}\a"
+            fi
+            __offsite_running=0
+            builtin print -n '\e]6973;A\a'
+        } 2>/dev/null
+    }
+
+    __offsite_preexec() {
+        {
+            builtin emulate -L zsh
+            builtin print -n '\e]6973;C\a'
+            __offsite_running=1
+        } 2>/dev/null
+    }
+
+    __offsite_line_init() {
+        if [[ $CONTEXT == start ]]; then
+            builtin print -n '\e]6973;B\a'
+        fi
+        if (( ${+widgets[__offsite_line_init_original]} )); then
+            builtin zle __offsite_line_init_original -N -- "$@"
+        fi
+    }
+fi
+
+{
+    {
+        __offsite_argzero=(0)
+        if [[ $__offsite_aliases == on ]]; then
+            builtin setopt aliases
+        fi
+        if [[ -r "$HOME/.zshenv" ]]; then
+            __offsite_file=("${(%):-%x}")
+            if [[ -o function_argzero ]]; then
+                __offsite_argzero=(1)
+                builtin unsetopt function_argzero
+                builtin trap 'if [[ ${(%):-%x} != "$__offsite_file" ]]; then __offsite_argzero=(0); builtin setopt function_argzero; builtin trap - DEBUG; fi' DEBUG
+            fi
+            () { builtin return $__offsite_status; } && builtin :
+            builtin source "$HOME/.zshenv"
+            () {
+                __offsite_status=($1) __offsite_last=("$2")
+            } $? "$_" 2>/dev/null
+            {
+                builtin return $__offsite_status
+            } 2>/dev/null
+        fi
+        builtin return $__offsite_status
+    } always {
+        {
+            () {
+                builtin emulate -L zsh
+                TRY_BLOCK_ERROR=0
+                if [[ -o interactive ]]; then
+                    precmd_functions+=(__offsite_install)
+                fi
+            }
+            if (( __offsite_argzero )); then
+                builtin setopt function_argzero
+                builtin trap - DEBUG
+            fi
+            () {
+                builtin unset __offsite_file __offsite_argzero __offsite_aliases __offsite_status __offsite_last
+            } "$__offsite_last"
+        } 2>/dev/null
+    }
+    { :; : ${__offsite_status:?}; } 2>/dev/null
+}