@beunec/rivine 0.1.0

package/dist/protocol/fsExecutor.js

@@ -0,0 +1,471 @@
+/*!
+ * Rivine Code CLI
+ * Licensed and owned by Beunec Technologies, Inc.
+ *
+ * https://aselius.beunec.com
+ *
+ * This software is proprietary. Use is governed by the licence agreement
+ * accompanying it; it is not open source and is not licensed for
+ * redistribution or derivative works.
+ */
+import { spawnSync } from 'node:child_process';
+import { mkdir, readFile, readdir, realpath, stat, writeFile, } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { runShell } from './shell.js';
+import { applyEdit, describeFailure, writeFileAtomic } from './edit.js';
+import { decide } from './permissions.js';
+const VIRTUAL_ROOT = '/workspace';
+const MAX_READ_BYTES = 2 * 1024 * 1024;
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '.turbo', '.venv', 'venv',
+    '__pycache__', '.mypy_cache', '.pytest_cache', 'target', '.cache', 'coverage',
+    '.gradle', '.idea', 'vendor', '.terraform',
+]);
+const MAX_WALK_ENTRIES = 20_000;
+let ripgrepPath;
+function findRipgrep() {
+    if (ripgrepPath !== undefined)
+        return ripgrepPath;
+    const probe = spawnSync('rg', ['--version'], { encoding: 'utf8', timeout: 3000 });
+    ripgrepPath = probe.status === 0 ? 'rg' : null;
+    return ripgrepPath;
+}
+function ripgrepSearch(root, needle, searchPath, glob, limit) {
+    const rg = findRipgrep();
+    if (!rg)
+        return null;
+    const args = [
+        '--fixed-strings',
+        '--json',
+        '--max-filesize', '2M',
+        ...(glob ? ['--glob', glob] : []),
+        '--',
+        needle,
+        searchPath,
+    ];
+    const result = spawnSync(rg, args, {
+        cwd: root,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    if (result.status !== 0 && result.status !== 1)
+        return null;
+    if (result.error)
+        return null;
+    return parseRipgrepOutput(root, result.stdout ?? '', limit);
+}
+export function parseRipgrepOutput(root, stdout, limit) {
+    const matches = [];
+    for (const raw of stdout.split('\n')) {
+        if (!raw.trim() || matches.length >= limit) {
+            if (matches.length >= limit)
+                break;
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (event?.type !== 'match')
+            continue;
+        const filePath = event.data?.path?.text;
+        const line = event.data?.line_number;
+        if (typeof filePath !== 'string' || !Number.isInteger(line))
+            continue;
+        const rel = relative(root, resolve(root, filePath));
+        matches.push({
+            path: `${VIRTUAL_ROOT}/${rel.split(sep).join('/')}`,
+            line,
+            text: String(event.data?.lines?.text ?? '').replace(/\n$/, '').slice(0, 500),
+        });
+    }
+    return matches;
+}
+function rewriteVirtualPaths(command, root) {
+    return command.replace(/\/workspace(?=\/|\s|$|["'`;)])/g, root);
+}
+export async function resolvePath(root, virtualPath) {
+    let candidate = virtualPath.replace(/\\/g, '/');
+    if (candidate === VIRTUAL_ROOT) {
+        candidate = root;
+    }
+    else if (candidate.startsWith(`${VIRTUAL_ROOT}/`)) {
+        candidate = join(root, candidate.slice(VIRTUAL_ROOT.length + 1));
+    }
+    else if (!isAbsolute(candidate)) {
+        candidate = join(root, candidate);
+    }
+    const requested = resolve(candidate);
+    let probe = requested;
+    let suffix = '';
+    for (;;) {
+        try {
+            probe = await realpath(probe);
+            break;
+        }
+        catch {
+            const parent = dirname(probe);
+            if (parent === probe)
+                break;
+            suffix = suffix ? join(probe.slice(parent.length + 1), suffix) : probe.slice(parent.length + 1);
+            probe = parent;
+        }
+    }
+    const real = suffix ? join(probe, suffix) : probe;
+    const realRoot = await realpath(root).catch(() => resolve(root));
+    const rel = relative(realRoot, real);
+    const outsideProject = rel.startsWith('..') || isAbsolute(rel);
+    return {
+        absolute: real,
+        relative: outsideProject ? real : rel === '' ? '.' : rel,
+        outsideProject,
+    };
+}
+function summarize(op, relPath, args) {
+    switch (op) {
+        case 'execute':
+            return String(args.command ?? '').slice(0, 200);
+        case 'write':
+            return `write ${relPath} (${String(args.content ?? '').length} bytes)`;
+        case 'edit':
+            return `edit ${relPath}`;
+        case 'upload':
+            return `write ${(args.files ?? []).length} file(s)`;
+        case 'mcp_call': {
+            const tool = String(args.tool ?? '');
+            const shown = tool.replace(/^mcp__/, '').replace('__', ' · ');
+            const keys = Object.keys((args.args ?? {})).slice(0, 4).join(', ');
+            return keys ? `${shown} (${keys})` : shown;
+        }
+        default:
+            return `${op} ${relPath ?? ''}`.trim();
+    }
+}
+export async function classify(root, request, mode) {
+    const { op, args } = request;
+    const paths = op === 'upload'
+        ? (args.files ?? []).map((f) => String(f.path ?? ''))
+        : op === 'download'
+            ? (args.paths ?? []).map(String)
+            : args.path
+                ? [String(args.path)]
+                : [];
+    let worst = null;
+    for (const p of paths) {
+        const resolved = await resolvePath(root, p);
+        const decision = decide({
+            op,
+            mode,
+            relPath: resolved.relative,
+            outsideProject: resolved.outsideProject,
+            command: args.command,
+        });
+        const rank = (d) => (d.verdict === 'deny' ? 2 : d.verdict === 'ask' ? 1 : 0);
+        if (!worst || rank(decision) > rank(worst.decision))
+            worst = { resolved, decision };
+    }
+    if (!worst) {
+        const decision = decide({
+            op,
+            mode,
+            relPath: null,
+            outsideProject: false,
+            command: args.command,
+        });
+        if (decision.verdict === 'deny')
+            return { approval: null, refusal: { ok: false, error: `Refused: ${decision.reason}` } };
+        if (decision.verdict === 'ask') {
+            return {
+                approval: {
+                    request,
+                    relPath: null,
+                    reason: decision.reason,
+                    summary: summarize(op, null, args),
+                    category: decision.category,
+                },
+                refusal: null,
+            };
+        }
+        return { approval: null, refusal: null };
+    }
+    if (worst.decision.verdict === 'deny') {
+        return { approval: null, refusal: { ok: false, error: `Refused: ${worst.decision.reason}` } };
+    }
+    if (worst.decision.verdict === 'ask') {
+        return {
+            approval: {
+                request,
+                relPath: worst.resolved.relative,
+                reason: worst.decision.reason,
+                summary: summarize(op, worst.resolved.relative, args),
+                category: worst.decision.category,
+            },
+            refusal: null,
+        };
+    }
+    return { approval: null, refusal: null };
+}
+async function walk(root, dir, out, recursive) {
+    if (out.length >= MAX_WALK_ENTRIES)
+        return;
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (out.length >= MAX_WALK_ENTRIES)
+            return;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        const abs = join(dir, entry.name);
+        const rel = relative(root, abs);
+        const isDir = entry.isDirectory();
+        let size;
+        if (!isDir) {
+            size = await stat(abs).then((s) => s.size).catch(() => undefined);
+        }
+        out.push({ path: `${VIRTUAL_ROOT}/${rel.split(sep).join('/')}`, is_dir: isDir, ...(size !== undefined ? { size } : {}) });
+        if (isDir && recursive)
+            await walk(root, abs, out, true);
+    }
+}
+function globToRegExp(pattern) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                if (pattern[i + 2] === '/') {
+                    out += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    out += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                out += '[^/]*';
+            }
+        }
+        else if (ch === '?') {
+            out += '[^/]';
+        }
+        else if ('\\^$+.()|{}[]'.includes(ch)) {
+            out += `\\${ch}`;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+function pathsTouchedBy(op, args) {
+    if (op === 'upload')
+        return (args.files ?? []).map((f) => String(f.path ?? ''));
+    if (op === 'download')
+        return (args.paths ?? []).map(String);
+    return args.path ? [String(args.path)] : [];
+}
+async function enforceScope(root, request, approvedOutside) {
+    if (approvedOutside || process.env.RIVINE_ALLOW_OUTSIDE_PROJECT)
+        return null;
+    for (const candidate of pathsTouchedBy(request.op, request.args)) {
+        const resolved = await resolvePath(root, candidate);
+        if (resolved.outsideProject) {
+            return {
+                ok: false,
+                error: `outside_project — ${candidate} resolves outside the project directory ` +
+                    'and was not approved',
+            };
+        }
+    }
+    return null;
+}
+export async function execute(root, request, hooks = {}) {
+    const { op, args } = request;
+    const outOfScope = await enforceScope(root, request, hooks.approvedOutside === true);
+    if (outOfScope)
+        return outOfScope;
+    try {
+        switch (op) {
+            case 'ls': {
+                const target = await resolvePath(root, String(args.path ?? VIRTUAL_ROOT));
+                const entries = [];
+                await walk(root, target.absolute, entries, false);
+                return { ok: true, data: { entries } };
+            }
+            case 'read': {
+                const target = await resolvePath(root, String(args.path));
+                const info = await stat(target.absolute);
+                if (info.isDirectory())
+                    return { ok: false, error: 'is_directory' };
+                if (info.size > MAX_READ_BYTES) {
+                    return {
+                        ok: false,
+                        error: `file_too_large (${info.size} bytes; cap is ${MAX_READ_BYTES})`,
+                    };
+                }
+                const buf = await readFile(target.absolute);
+                const text = buf.toString('utf8');
+                const isText = Buffer.compare(Buffer.from(text, 'utf8'), buf) === 0;
+                return isText
+                    ? { ok: true, data: { content: text, encoding: 'utf-8' } }
+                    : { ok: true, data: { content: buf.toString('base64'), encoding: 'base64' } };
+            }
+            case 'write': {
+                const target = await resolvePath(root, String(args.path));
+                await mkdir(dirname(target.absolute), { recursive: true });
+                await writeFileAtomic(target.absolute, String(args.content ?? ''));
+                return { ok: true, data: { path: `${VIRTUAL_ROOT}/${target.relative}` } };
+            }
+            case 'edit': {
+                const target = await resolvePath(root, String(args.path));
+                const result = await applyEdit(target.absolute, {
+                    oldString: String(args.old_string ?? ''),
+                    newString: String(args.new_string ?? ''),
+                    replaceAll: Boolean(args.replace_all),
+                });
+                if (!result.ok)
+                    return { ok: false, error: describeFailure(result.error) };
+                return {
+                    ok: true,
+                    data: {
+                        path: `${VIRTUAL_ROOT}/${target.relative}`,
+                        occurrences: result.value.occurrences,
+                        matched: result.value.strategy,
+                    },
+                };
+            }
+            case 'glob': {
+                const base = await resolvePath(root, String(args.path ?? VIRTUAL_ROOT));
+                const re = globToRegExp(String(args.pattern ?? '*'));
+                const entries = [];
+                await walk(root, base.absolute, entries, true);
+                const baseRel = relative(root, base.absolute);
+                const matches = entries.filter((e) => {
+                    const rel = e.path.slice(VIRTUAL_ROOT.length + 1);
+                    const fromBase = baseRel ? relative(baseRel, rel) : rel;
+                    return re.test(fromBase) || re.test(rel) || re.test(basename(rel));
+                });
+                return { ok: true, data: { matches } };
+            }
+            case 'grep': {
+                const base = await resolvePath(root, String(args.path ?? VIRTUAL_ROOT));
+                const needle = String(args.pattern ?? '');
+                if (!needle)
+                    return { ok: true, data: { matches: [] } };
+                const fast = ripgrepSearch(root, needle, base.absolute, args.glob ? String(args.glob) : null, 500);
+                if (fast)
+                    return { ok: true, data: { matches: fast } };
+                const fileFilter = args.glob ? globToRegExp(String(args.glob)) : null;
+                const entries = [];
+                await walk(root, base.absolute, entries, true);
+                const matches = [];
+                for (const entry of entries) {
+                    if (entry.is_dir || matches.length >= 500)
+                        continue;
+                    if ((entry.size ?? 0) > MAX_READ_BYTES)
+                        continue;
+                    const rel = entry.path.slice(VIRTUAL_ROOT.length + 1);
+                    if (fileFilter && !fileFilter.test(rel) && !fileFilter.test(basename(rel)))
+                        continue;
+                    const abs = join(root, rel);
+                    const content = await readFile(abs, 'utf8').catch(() => null);
+                    if (content === null || !content.includes(needle))
+                        continue;
+                    content.split('\n').forEach((line, index) => {
+                        if (matches.length < 500 && line.includes(needle)) {
+                            matches.push({ path: entry.path, line: index + 1, text: line.slice(0, 500) });
+                        }
+                    });
+                }
+                return { ok: true, data: { matches } };
+            }
+            case 'execute': {
+                const command = rewriteVirtualPaths(String(args.command ?? ''), root);
+                const timeoutMs = Math.max(1, Number(args.timeout ?? 600)) * 1000;
+                const shell = await runShell(command, {
+                    cwd: root,
+                    timeoutMs,
+                    onChunk: hooks.onOutput,
+                    cols: process.stdout.columns || 120,
+                    rows: process.stdout.rows || 30,
+                });
+                hooks.onShell?.(shell);
+                try {
+                    const res = await shell.result;
+                    return {
+                        ok: true,
+                        data: {
+                            output: res.output,
+                            exit_code: res.exit_code,
+                            truncated: res.truncated,
+                        },
+                    };
+                }
+                finally {
+                    hooks.onShell?.(null);
+                }
+            }
+            case 'upload': {
+                const files = (args.files ?? []);
+                const results = [];
+                for (const file of files) {
+                    const target = await resolvePath(root, String(file.path));
+                    try {
+                        await mkdir(dirname(target.absolute), { recursive: true });
+                        await writeFile(target.absolute, Buffer.from(String(file.content_b64), 'base64'));
+                        results.push({ path: file.path });
+                    }
+                    catch (err) {
+                        results.push({ path: file.path, error: err.message });
+                    }
+                }
+                return { ok: true, data: { results } };
+            }
+            case 'download': {
+                const paths = (args.paths ?? []);
+                const results = [];
+                for (const p of paths) {
+                    const target = await resolvePath(root, String(p));
+                    try {
+                        const info = await stat(target.absolute);
+                        if (info.isDirectory()) {
+                            results.push({ path: p, error: 'is_directory' });
+                            continue;
+                        }
+                        if (info.size > MAX_READ_BYTES) {
+                            results.push({ path: p, error: 'file_too_large' });
+                            continue;
+                        }
+                        results.push({ path: p, content_b64: (await readFile(target.absolute)).toString('base64') });
+                    }
+                    catch {
+                        results.push({ path: p, error: 'file_not_found' });
+                    }
+                }
+                return { ok: true, data: { results } };
+            }
+            default:
+                return { ok: false, error: `unsupported operation: ${op}` };
+        }
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return { ok: false, error: 'file_not_found' };
+        if (e.code === 'EACCES' || e.code === 'EPERM')
+            return { ok: false, error: 'permission_denied' };
+        if (e.code === 'EISDIR')
+            return { ok: false, error: 'is_directory' };
+        return { ok: false, error: e.message ?? String(err) };
+    }
+}

package/dist/protocol/git.js

@@ -0,0 +1,157 @@
+/*!
+ * Rivine Code CLI
+ * Licensed and owned by Beunec Technologies, Inc.
+ *
+ * https://aselius.beunec.com
+ *
+ * This software is proprietary. Use is governed by the licence agreement
+ * accompanying it; it is not open source and is not licensed for
+ * redistribution or derivative works.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 30_000;
+function gitEnv() {
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_INDEX_FILE;
+    delete env.GIT_OBJECT_DIRECTORY;
+    delete env.GIT_COMMON_DIR;
+    env.GIT_PAGER = 'cat';
+    env.PAGER = 'cat';
+    env.GIT_TERMINAL_PROMPT = '0';
+    return env;
+}
+function run(file, args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return new Promise((resolvePromise) => {
+        let child;
+        try {
+            child = spawn(file, args, { cwd, env: gitEnv() });
+        }
+        catch (err) {
+            resolvePromise({ ok: false, output: err.message });
+            return;
+        }
+        let out = '';
+        let settled = false;
+        const finish = (ok, text) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolvePromise({ ok, output: text.trim() });
+        };
+        child.stdout?.on('data', (c) => {
+            out += c.toString();
+        });
+        child.stderr?.on('data', (c) => {
+            out += c.toString();
+        });
+        child.on('error', (err) => finish(false, err.message));
+        child.on('close', (code) => finish(code === 0, out));
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish(false, `${file} did not finish within ${Math.round(timeoutMs / 1000)}s`);
+        }, timeoutMs);
+    });
+}
+const present = new Map();
+export function hasBinary(name) {
+    const cached = present.get(name);
+    if (cached !== undefined)
+        return cached;
+    const probe = spawnSync(name, ['--version'], {
+        encoding: 'utf8',
+        timeout: 3000,
+        env: gitEnv(),
+    });
+    const ok = probe.status === 0;
+    present.set(name, ok);
+    return ok;
+}
+export function resetBinaryProbeForTests() {
+    present.clear();
+}
+export async function isRepo(cwd) {
+    if (!hasBinary('git'))
+        return false;
+    const res = await run('git', ['rev-parse', '--is-inside-work-tree'], cwd, 5_000);
+    return res.ok && res.output.startsWith('true');
+}
+export function gitBranchLine(cwd = process.cwd()) {
+    if (!hasBinary('git'))
+        return '';
+    const res = spawnSync('git', ['status', '-sb', '--porcelain=v1'], {
+        cwd,
+        encoding: 'utf8',
+        timeout: 2000,
+        env: gitEnv(),
+    });
+    if (res.status !== 0 || !res.stdout)
+        return '';
+    const lines = res.stdout.split('\n');
+    const header = (lines[0] ?? '').replace(/^##\s*/, '').trim();
+    if (!header)
+        return '';
+    const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
+    return `${header} · ${changed === 0 ? 'clean' : `${changed} file(s) changed`}`;
+}
+export async function statusShort(cwd) {
+    if (!hasBinary('git'))
+        return { ok: false, output: 'git is not installed.' };
+    return run('git', ['status', '-sb'], cwd);
+}
+export async function diff(cwd, { full = false } = {}) {
+    if (!hasBinary('git'))
+        return { ok: false, output: 'git is not installed.' };
+    return run('git', full ? ['diff'] : ['diff', '--stat'], cwd);
+}
+export async function hasUpstream(cwd) {
+    const res = await run('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], cwd, 5_000);
+    return res.ok && res.output.length > 0;
+}
+export async function prCreate(cwd, options = {}) {
+    if (!hasBinary('git'))
+        return { ok: false, output: 'git is not installed.' };
+    if (!(await isRepo(cwd)))
+        return { ok: false, output: 'Not a git repository.' };
+    if (!hasBinary('gh')) {
+        return {
+            ok: false,
+            output: 'GitHub CLI (`gh`) is not installed. Install it from https://cli.github.com and run `gh auth login`.',
+        };
+    }
+    const auth = await run('gh', ['auth', 'status'], cwd, 10_000);
+    if (!auth.ok) {
+        return { ok: false, output: 'GitHub CLI is not signed in. Run `gh auth login` first.' };
+    }
+    const branch = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd, 5_000);
+    if (branch.ok && (branch.output === 'main' || branch.output === 'master')) {
+        return {
+            ok: false,
+            output: `You are on ${branch.output}. Make a branch before opening a pull request.`,
+        };
+    }
+    if (!(await hasUpstream(cwd))) {
+        if (!options.push) {
+            return {
+                ok: false,
+                output: `Branch "${branch.output}" has not been pushed. Run \`/pr push\` to push it ` +
+                    'to origin and open a pull request.',
+            };
+        }
+        const pushed = await run('git', ['push', '--set-upstream', 'origin', 'HEAD'], cwd, 120_000);
+        if (!pushed.ok)
+            return { ok: false, output: `Push failed: ${pushed.output}` };
+    }
+    const args = ['pr', 'create'];
+    if (options.title)
+        args.push('--title', options.title);
+    if (!options.title)
+        args.push('--fill');
+    if (options.body)
+        args.push('--body', options.body);
+    if (options.draft)
+        args.push('--draft');
+    return run('gh', args, cwd, 120_000);
+}