offsite 0.0.3 → 0.0.4

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

@@ -1,402 +0,0 @@
-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 });
-}