offsite 0.0.0 → 0.0.2

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

@@ -0,0 +1,207 @@
+import { execFile } from 'node:child_process';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { readFile, readlink, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { spawn } from '@lydell/node-pty';
+import { defaultShell, platform, readConfig, version } from '../config.js';
+import { prepare } from './shell-integration.js';
+const run = promisify(execFile);
+const iterm2Version = '3.6.8';
+const ghosttyVersion = '1.3.1';
+const shellNames = process.platform === 'win32'
+    ? ['pwsh', 'powershell', 'cmd']
+    : ['zsh', 'bash', 'fish', 'pwsh'];
+export function startShell(cwd) {
+    const options = launch();
+    const env = {};
+    let file;
+    let args;
+    if (process.platform === 'win32') {
+        Object.assign(env, process.env);
+        file = options.command ?? defaultShell();
+        args = [];
+    }
+    else {
+        for (const name of ['HOME', 'USER', 'LOGNAME', 'TMPDIR', 'SSH_AUTH_SOCK']) {
+            const value = process.env[name];
+            if (value !== undefined)
+                env[name] = value;
+        }
+        const shell = defaultShell();
+        env.SHELL = shell;
+        env.LANG = 'en_US.UTF-8';
+        if (process.env.PATH !== undefined)
+            env.PATH = process.env.PATH;
+        const program = (options.shellIntegration
+            ? prepare(env, options.command, shell)
+            : null) ??
+            options.command ??
+            `'${shell}'`;
+        file = '/bin/bash';
+        args = ['--noprofile', '--norc', '-c', `export -n PATH; exec -l ${program}`];
+    }
+    env.TERM = 'xterm-256color';
+    env.COLORTERM = 'truecolor';
+    Object.assign(env, options.environment);
+    return spawn(file, args, {
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+        cwd,
+        env,
+        encoding: null,
+    });
+}
+export async function currentDirectory(pid) {
+    if (process.platform === 'linux')
+        return readlink(`/proc/${pid}/cwd`);
+    if (process.platform === 'darwin') {
+        const { stdout } = await run('lsof', [
+            '-a',
+            '-d',
+            'cwd',
+            '-p',
+            String(pid),
+            '-Fn',
+        ]);
+        const line = stdout.split('\n').find((item) => item.startsWith('n'));
+        if (line === undefined)
+            throw new Error(`lsof found no folder for ${pid}`);
+        return line.slice(1);
+    }
+    throw new Error('reading the directory of another process is not supported on this platform');
+}
+export async function busyProgram(pid) {
+    if (process.platform === 'win32') {
+        const { stdout } = await run('powershell.exe', [
+            '-NoProfile',
+            '-Command',
+            `Get-CimInstance Win32_Process -Filter "ParentProcessId=${pid}" | Select-Object -ExpandProperty Name`,
+        ]);
+        const names = [
+            ...new Set(stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line !== '')),
+        ];
+        return names.length === 0 ? null : names.join(', ');
+    }
+    const group = await foregroundGroup(pid);
+    if (group <= 0)
+        throw new Error('its foreground process group is unknown');
+    if (group === pid)
+        return null;
+    try {
+        return await programName(group);
+    }
+    catch (error) {
+        console.warn(`could not read the name of process ${group}: ${error}`);
+        return `process ${group}`;
+    }
+}
+async function foregroundGroup(pid) {
+    if (process.platform === 'linux') {
+        const text = await readFile(`/proc/${pid}/stat`, 'utf8');
+        return Number(text.slice(text.lastIndexOf(')') + 2).split(' ')[5]);
+    }
+    const { stdout } = await run('ps', ['-o', 'tpgid=', '-p', String(pid)]);
+    return Number(stdout.trim());
+}
+async function programName(pid) {
+    if (process.platform === 'linux')
+        return (await readFile(`/proc/${pid}/comm`, 'utf8')).trimEnd();
+    const { stdout } = await run('ps', ['-o', 'comm=', '-p', String(pid)]);
+    return path.basename(stdout.trim());
+}
+export async function gitBranch(directory) {
+    let git = null;
+    for (let folder = directory;; folder = path.dirname(folder)) {
+        const candidate = path.join(folder, '.git');
+        if ((await stat(candidate).catch(() => null)) !== null) {
+            git = candidate;
+            break;
+        }
+        if (path.dirname(folder) === folder)
+            break;
+    }
+    if (git === null)
+        return null;
+    const info = await stat(git);
+    if (info.isFile()) {
+        const text = await readSmallFile(git);
+        if (text === null || !text.startsWith('gitdir:'))
+            return null;
+        git = path.resolve(path.dirname(git), text.slice('gitdir:'.length).trim());
+    }
+    const head = (await readSmallFile(path.join(git, 'HEAD')))?.trim();
+    if (head === undefined)
+        return null;
+    if (head.startsWith('ref: refs/heads/'))
+        return head.slice('ref: refs/heads/'.length);
+    return head.length >= 7 ? head.slice(0, 7) : null;
+}
+async function readSmallFile(file) {
+    const info = await stat(file).catch(() => null);
+    if (info === null || !info.isFile())
+        return null;
+    return (await readFile(file, 'utf8')).slice(0, 4096);
+}
+function launch() {
+    const config = readConfig().terminal;
+    const [program, terminal, programVersion] = {
+        offsite: ['offsite', 'offsite', version],
+        ghostty: ['ghostty', 'ghostty', ghosttyVersion],
+        iterm2: ['iTerm.app', 'iTerm2', iterm2Version],
+    }[config.behavior.terminalIdentity];
+    return {
+        command: config.shell[platform()],
+        environment: {
+            TERM_PROGRAM: program,
+            TERM_PROGRAM_VERSION: programVersion,
+            LC_TERMINAL: terminal,
+            LC_TERMINAL_VERSION: programVersion,
+        },
+        shellIntegration: config.behavior.shellIntegration,
+    };
+}
+export function listShells() {
+    const candidates = (process.env.PATH ?? '')
+        .split(path.delimiter)
+        .filter((directory) => directory !== '')
+        .flatMap((directory) => shellNames.map((name) => path.join(directory, executable(name))));
+    if (process.platform !== 'win32') {
+        try {
+            candidates.push(...readFileSync('/etc/shells', 'utf8')
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.startsWith('/')));
+        }
+        catch { }
+    }
+    const seen = new Set();
+    const shells = [];
+    for (const name of shellNames) {
+        for (const candidate of candidates) {
+            if (path.basename(candidate) !== executable(name))
+                continue;
+            if (!statSync(candidate, { throwIfNoEntry: false })?.isFile())
+                continue;
+            let target;
+            try {
+                target = realpathSync(candidate);
+            }
+            catch {
+                continue;
+            }
+            if (seen.has(target))
+                continue;
+            seen.add(target);
+            shells.push({ name, path: candidate });
+        }
+    }
+    return shells;
+}
+function executable(name) {
+    return process.platform === 'win32' ? `${name}.exe` : name;
+}

package/apps/server/dist/terminal/shell-check.js

@@ -0,0 +1,91 @@
+function zshOptionsSupported(options) {
+    for (let position = 0; position < options.length; position++) {
+        const word = options[position];
+        if (!word.startsWith('-') && !word.startsWith('+'))
+            return false;
+        const enable = word.startsWith('-');
+        const flags = word.slice(1);
+        if (flags === '' || flags === '-')
+            return false;
+        if (flags.startsWith('-')) {
+            if (!zshOptionAllowed(flags.slice(1), enable))
+                return false;
+            continue;
+        }
+        for (let index = 0; index < flags.length; index++) {
+            const letter = flags[index];
+            if (letter === 'o') {
+                let name = flags.slice(index + 1);
+                if (name === '') {
+                    position++;
+                    if (position === options.length)
+                        return false;
+                    name = options[position];
+                }
+                if (!zshOptionAllowed(name, enable))
+                    return false;
+                break;
+            }
+            if (letter === 'b' || letter === 'c')
+                return false;
+            if (enable && 'dfnprvx'.includes(letter))
+                return false;
+            if (!enable && letter === 'i')
+                return false;
+        }
+    }
+    return true;
+}
+function zshOptionAllowed(option, enable) {
+    let name = option.toLowerCase().replace(/[-_]/g, '');
+    let value = enable;
+    if (name.startsWith('no')) {
+        name = name.slice(2);
+        value = !enable;
+    }
+    if (['rcs', 'globalrcs', 'interactive', 'exec'].includes(name))
+        return value;
+    if (['privileged', 'restricted', 'sourcetrace', 'verbose', 'xtrace'].includes(name))
+        return !value;
+    return true;
+}
+export function shellIntegrationIssue(command, platform, defaultShell) {
+    if (platform === 'windows')
+        return 'Not available on Windows';
+    if (command !== null && /[\n"'\\$`;&|<>()*?[\]{}#!]/.test(command))
+        return 'Not available for commands with shell syntax';
+    const words = command === null
+        ? [defaultShell]
+        : command.split(/[ \t]/).filter((word) => word !== '');
+    if (words.length === 0)
+        return 'Available for bash, zsh and fish';
+    const path = words[0];
+    const name = path.split('/').pop();
+    const options = words.slice(1);
+    if (name === 'bash') {
+        if (platform === 'macos' && (path === '/bin/bash' || !path.includes('/')))
+            return 'Needs a newer bash than the one macOS includes';
+        if (options.every((option) => ['-l', '--login', '-i'].includes(option)))
+            return null;
+        return 'Not available with these bash options';
+    }
+    if (name === 'zsh') {
+        if (zshOptionsSupported(options))
+            return null;
+        return 'Not available with these zsh options';
+    }
+    if (name === 'fish') {
+        const supported = options.every((option) => {
+            if (option.startsWith('--')) {
+                const name = option.slice(2).split('=')[0];
+                return (name === '' ||
+                    !['command', 'no-config', 'no-execute'].some((long) => long.startsWith(name)));
+            }
+            return !(option.startsWith('-') && /[cNn]/.test(option));
+        });
+        if (supported)
+            return null;
+        return 'Not available with these fish options';
+    }
+    return 'Available for bash, zsh and fish';
+}

package/apps/server/dist/terminal/shell-integration.js

@@ -0,0 +1,112 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { platform } from '../config.js';
+import { home } from '../storage.js';
+import { shellIntegrationIssue } from './shell-check.js';
+const scripts = path.join(import.meta.dirname, '..', '..', 'src', 'terminal', 'shell-integration');
+const folder = path.join(home, 'shell-integration');
+export function prepare(env, command, shell) {
+    if (shellIntegrationIssue(command, platform(), shell) !== null)
+        return null;
+    const words = command === null
+        ? [shell]
+        : command.split(/[ \t]/).filter((word) => word !== '');
+    const program = command === null ? `'${shell}'` : words[0];
+    const args = words.slice(1);
+    const name = words[0].split('/').pop();
+    let integration;
+    if (name === 'bash') {
+        const userHome = process.env.HOME;
+        if (userHome === undefined || userHome === '')
+            return null;
+        const script = path.join(folder, 'bash', 'offsite.bash');
+        if (!writeScript(script, 'bash/offsite.bash'))
+            return null;
+        env.ENV = script.replace(/[\\$`"]/g, (character) => `\\${character}`);
+        env.HISTFILE = path.join(userHome, '.bash_history');
+        integration = ' --posix';
+    }
+    else if (name === 'zsh') {
+        if (!zshGlobalsSupported())
+            return null;
+        if (['.zshenv', '.zprofile', '.zshrc', '.zlogin'].every((file) => !existsSync(path.join(os.homedir(), file))))
+            return null;
+        if (!writeScript(path.join(folder, 'zsh', '.zshenv'), 'zsh/.zshenv'))
+            return null;
+        env.ZDOTDIR = path.join(folder, 'zsh');
+        integration = '';
+    }
+    else if (name === 'fish') {
+        const script = path.join(folder, 'fish', 'offsite.fish');
+        if (!writeScript(script, 'fish/offsite.fish'))
+            return null;
+        const source = `source '${script.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+        integration = ` --init-command '${source.replaceAll("'", "'\\''")}'`;
+    }
+    else
+        throw new Error(`shell integration does not support ${name}`);
+    return [`${program}${integration}`, ...args].join(' ');
+}
+function zshGlobalsSupported() {
+    for (const global of ['/etc/zshenv', '/etc/zsh/zshenv']) {
+        let contents;
+        try {
+            contents = readFileSync(global, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            console.warn(`could not read ${global}, zsh starts without shell integration: ${error}`);
+            return false;
+        }
+        for (const rawLine of contents.split('\n')) {
+            const line = rawLine.trimStart();
+            if (line.startsWith('#'))
+                continue;
+            const normalized = line.toLowerCase().replaceAll('_', '');
+            if ([
+                'zdotdir',
+                'rcs',
+                'emulate',
+                'debug',
+                'xtrace',
+                'verbose',
+                'sourcetrace',
+            ].some((word) => normalized.includes(word)))
+                return false;
+            let setting = false;
+            for (const word of line.split(/[ \t;&|]/)) {
+                if (word === '')
+                    continue;
+                if (['set', 'setopt', 'unsetopt'].includes(word)) {
+                    setting = true;
+                    continue;
+                }
+                const flag = word.startsWith('-') || word.startsWith('+');
+                if (setting && flag && /[fxv]/.test(word))
+                    return false;
+                if (!flag)
+                    setting = false;
+            }
+        }
+    }
+    return true;
+}
+function writeScript(target, source) {
+    try {
+        const contents = readFileSync(path.join(scripts, source), 'utf8');
+        const existing = lstatSync(target, { throwIfNoEntry: false });
+        if (existing?.isFile() && readFileSync(target, 'utf8') === contents)
+            return true;
+        mkdirSync(path.dirname(target), { recursive: true });
+        rmSync(`${target}.tmp`, { force: true });
+        writeFileSync(`${target}.tmp`, contents, { flag: 'wx' });
+        renameSync(`${target}.tmp`, target);
+        return true;
+    }
+    catch (error) {
+        console.warn(`could not write ${target}, the shell starts without shell integration: ${error}`);
+        return false;
+    }
+}