@beunec/rivine 0.1.0

package/dist/protocol/shell.js

@@ -0,0 +1,260 @@
+/*!
+ * 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 } from 'node:child_process';
+import { chmodSync, existsSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+export const MAX_OUTPUT_CHARS = 120_000;
+const KILL_GRACE_MS = 5_000;
+const CSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const OSC = /\u001b\][\s\S]*?(?:\u0007|\u001b\\)/g;
+const STRAY = /\u001b[@-Z\\-_]|[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+export function sanitizeForModel(raw) {
+    const clean = raw.replace(OSC, '').replace(CSI, '').replace(/\r\n/g, '\n');
+    const out = [];
+    for (const line of clean.split('\n')) {
+        const settled = line.includes('\r') ? line.slice(line.lastIndexOf('\r') + 1) : line;
+        out.push(settled.replace(STRAY, ''));
+    }
+    return out.join('\n').replace(/\n{4,}/g, '\n\n\n');
+}
+let ptyChecked = false;
+let ptyModule = null;
+function ensureSpawnHelperIsExecutable() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const root = dirname(dirname(require_.resolve('node-pty')));
+        const helperPath = join(root, 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper');
+        if (!existsSync(helperPath))
+            return;
+        if (statSync(helperPath).mode & 0o111)
+            return;
+        chmodSync(helperPath, 0o755);
+    }
+    catch {
+    }
+}
+async function loadPty() {
+    if (ptyChecked)
+        return ptyModule;
+    ptyChecked = true;
+    if (process.env.RIVINE_NO_PTY)
+        return null;
+    try {
+        const specifier = 'node-pty';
+        const mod = await import(specifier);
+        if (process.platform !== 'win32')
+            ensureSpawnHelperIsExecutable();
+        if (typeof mod?.spawn === 'function')
+            ptyModule = mod;
+        else if (typeof mod?.default?.spawn === 'function')
+            ptyModule = mod.default;
+    }
+    catch {
+        ptyModule = null;
+    }
+    return ptyModule;
+}
+export function resetPtyProbeForTests() {
+    ptyChecked = false;
+    ptyModule = null;
+}
+class Tail {
+    limit;
+    buffer = '';
+    dropped = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    push(text) {
+        this.buffer += text;
+        if (this.buffer.length > this.limit * 2) {
+            const excess = this.buffer.length - this.limit;
+            this.dropped += excess;
+            this.buffer = this.buffer.slice(excess);
+        }
+    }
+    settle() {
+        let text = sanitizeForModel(this.buffer);
+        let dropped = this.dropped;
+        if (text.length > this.limit) {
+            dropped += text.length - this.limit;
+            text = text.slice(-this.limit);
+        }
+        if (dropped > 0) {
+            return {
+                output: `…[${dropped} characters trimmed from the start]…\n${text}`,
+                truncated: true,
+            };
+        }
+        return { output: text, truncated: false };
+    }
+}
+function shellInvocation(command) {
+    if (process.platform === 'win32') {
+        return { file: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', command] };
+    }
+    return { file: process.env.SHELL || '/bin/sh', args: ['-c', command] };
+}
+function runWithPty(pty, command, options) {
+    const { file, args } = shellInvocation(command);
+    const tail = new Tail(MAX_OUTPUT_CHARS);
+    const child = pty.spawn(file, args, {
+        name: 'xterm-256color',
+        cols: options.cols ?? 120,
+        rows: options.rows ?? 30,
+        cwd: options.cwd,
+        env: process.env,
+    });
+    let settled = false;
+    let timedOut = false;
+    let killTimer = null;
+    const result = new Promise((resolvePromise) => {
+        const finish = (code, note) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (note)
+                tail.push(`\n${note}\n`);
+            const { output, truncated } = tail.settle();
+            resolvePromise({ output, exit_code: code, truncated, tty: true });
+        };
+        child.onData((data) => {
+            tail.push(data);
+            options.onChunk?.(data);
+        });
+        child.onExit(({ exitCode, signal }) => {
+            if (timedOut) {
+                finish(124, `[command exceeded ${Math.round(options.timeoutMs / 1000)}s and was terminated]`);
+                return;
+            }
+            finish(exitCode || (signal ? 128 + signal : 0));
+        });
+        const deadline = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill();
+            }
+            catch {
+            }
+            killTimer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                }
+                finish(124, `[command exceeded ${Math.round(options.timeoutMs / 1000)}s and was killed]`);
+            }, KILL_GRACE_MS);
+        }, options.timeoutMs);
+    });
+    return {
+        result,
+        tty: true,
+        write: (data) => {
+            try {
+                child.write(data);
+            }
+            catch {
+            }
+        },
+        resize: (cols, rows) => {
+            try {
+                child.resize(Math.max(2, cols), Math.max(2, rows));
+            }
+            catch {
+            }
+        },
+        kill: () => {
+            try {
+                child.kill();
+            }
+            catch {
+            }
+        },
+    };
+}
+function runWithPipes(command, options) {
+    const { file, args } = shellInvocation(command);
+    const tail = new Tail(MAX_OUTPUT_CHARS);
+    const child = spawn(file, args, {
+        cwd: options.cwd,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let settled = false;
+    let timedOut = false;
+    let killTimer = null;
+    const result = new Promise((resolvePromise) => {
+        const finish = (code, note) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (note)
+                tail.push(`\n${note}\n`);
+            const { output, truncated } = tail.settle();
+            resolvePromise({ output, exit_code: code, truncated, tty: false });
+        };
+        const absorb = (chunk) => {
+            const text = chunk.toString();
+            tail.push(text);
+            options.onChunk?.(text);
+        };
+        child.stdout?.on('data', absorb);
+        child.stderr?.on('data', absorb);
+        child.on('error', (err) => {
+            tail.push(String(err.message));
+            finish(127);
+        });
+        child.on('close', (code, signal) => {
+            if (timedOut) {
+                finish(124, `[command exceeded ${Math.round(options.timeoutMs / 1000)}s and was terminated]`);
+                return;
+            }
+            finish(code ?? (signal ? 128 : 0));
+        });
+        const deadline = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS);
+        }, options.timeoutMs);
+    });
+    return {
+        result,
+        tty: false,
+        write: (data) => {
+            try {
+                child.stdin?.write(data);
+            }
+            catch {
+            }
+        },
+        resize: () => {
+        },
+        kill: () => child.kill('SIGTERM'),
+    };
+}
+export async function runShell(command, options) {
+    const pty = await loadPty();
+    if (pty) {
+        try {
+            return runWithPty(pty, command, options);
+        }
+        catch {
+        }
+    }
+    return runWithPipes(command, options);
+}

package/dist/protocol/snapshot.js

@@ -0,0 +1,84 @@
+/*!
+ * 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 { exec } from 'node:child_process';
+import { readdir, stat } from 'node:fs/promises';
+import { basename, join, relative, sep } from 'node:path';
+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_FILES = 2000;
+const MARKER_FILES = [
+    'package.json', 'tsconfig.json', 'pyproject.toml', 'requirements.txt',
+    'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle', 'Gemfile', 'composer.json',
+    'Dockerfile', 'docker-compose.yml', 'Makefile', 'README.md', 'CLAUDE.md',
+    'AGENTS.md', 'RIVINE.md',
+];
+function run(command, cwd, timeout = 4000) {
+    return new Promise((resolvePromise) => {
+        exec(command, { cwd, timeout, maxBuffer: 1024 * 1024 }, (err, stdout) => {
+            resolvePromise(err ? null : stdout.trim());
+        });
+    });
+}
+async function collect(root, dir, out) {
+    if (out.length >= MAX_FILES)
+        return;
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (out.length >= MAX_FILES)
+            return;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collect(root, abs, out);
+        }
+        else if (entry.isFile()) {
+            out.push(relative(root, abs).split(sep).join('/'));
+        }
+    }
+}
+export async function buildSnapshot(root) {
+    const files = [];
+    await collect(root, root, files);
+    const markers = [];
+    for (const marker of MARKER_FILES) {
+        const exists = await stat(join(root, marker)).then(() => true).catch(() => false);
+        if (exists)
+            markers.push(marker);
+    }
+    const snapshot = {
+        name: basename(root),
+        file_count: files.length,
+        truncated: files.length >= MAX_FILES,
+        files: files.sort(),
+        markers,
+    };
+    const branch = await run('git rev-parse --abbrev-ref HEAD', root);
+    if (branch) {
+        const porcelain = (await run('git status --porcelain', root)) ?? '';
+        const changed = porcelain
+            .split('\n')
+            .filter(Boolean)
+            .slice(0, 50)
+            .map((line) => line.slice(3));
+        snapshot.git = { branch, dirty: porcelain.length > 0, changed };
+    }
+    return snapshot;
+}

package/dist/protocol/stream.js

@@ -0,0 +1,41 @@
+/*!
+ * 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.
+ */
+export async function* readTurnStream(response) {
+    const body = response.body;
+    if (!body) {
+        yield { type: 'error', content: 'The engine returned an empty response.' };
+        return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let boundary = buffer.indexOf('\n\n');
+        while (boundary !== -1) {
+            const frame = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            boundary = buffer.indexOf('\n\n');
+            if (!frame.startsWith('data:'))
+                continue;
+            const payload = frame.slice(5).trim();
+            if (payload === '[DONE]') {
+                yield { type: 'done' };
+                return;
+            }
+            try {
+                yield JSON.parse(payload);
+            }
+            catch {
+            }
+        }
+    }
+    yield { type: 'done' };
+}

package/dist/runHeadless.js

@@ -0,0 +1,140 @@
+/*!
+ * 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 { InsufficientCredits } from './api/workspace.js';
+import { siteUrl } from './config.js';
+import { TurnRunner } from './protocol/runner.js';
+import { creditShortfall, startSession } from './session.js';
+import { HeadlessRenderer, installTeardown } from './ui/headless.js';
+export async function runHeadless(options) {
+    const json = options.format === 'json';
+    const out = new HeadlessRenderer(options.mode, json);
+    let runner = null;
+    const filesWritten = new Set();
+    let answer = '';
+    const emit = (ok, exitCode, error) => {
+        if (!json)
+            return;
+        out.result({
+            ok,
+            answer,
+            error: error ?? null,
+            exit_code: exitCode,
+            files_written: [...filesWritten],
+            refused: out.refusalCount,
+        });
+    };
+    const removeTeardown = installTeardown(async () => {
+        await runner?.shutdown();
+    });
+    try {
+        const session = await startSession({
+            cwd: options.cwd,
+            onNotice: (text) => out.status(text),
+            onLoginUrl: (url) => out.status(`Sign in at: ${url}`),
+        });
+        const balance = await session.balance;
+        if (balance === null) {
+            out.line('notice', 'Could not read your credit balance — continuing without the local check.');
+        }
+        const needed = creditShortfall(balance, session.bootstrap.engine_min_credits);
+        if (needed !== null) {
+            out.line('error', `Rivine Code needs ${needed.toFixed(2)} in credits to run.`);
+            out.line('notice', `Top up at ${siteUrl()}/credits`);
+            emit(false, 2, `Insufficient credits: ${needed.toFixed(2)} required.`);
+            return 2;
+        }
+        runner = new TurnRunner({
+            workspaceId: session.bootstrap.workspace_id,
+            chatSpaceId: session.bootstrap.chat_space_id,
+            sessionId: session.bootstrap.session_id,
+            root: options.cwd,
+            mode: options.mode,
+        }, {
+            onToken: (text) => out.token(text),
+            onStage: (label) => out.status(label),
+            onTool: (name, detail) => {
+                out.endAnswer();
+                out.line(name === 'execute' ? 'run' : 'tool', detail ? `${name} ${detail}` : name);
+            },
+            onFileTouched: (path, status) => {
+                if (status === 'written') {
+                    const rel = path.replace(/^\/workspace\//, '');
+                    filesWritten.add(rel);
+                    out.endAnswer();
+                    out.line('file', rel);
+                }
+            },
+            onNotice: (text) => {
+                out.endAnswer();
+                out.line('notice', text);
+            },
+            onOutput: (text) => out.shellOutput(text),
+            requestApproval: async (approval) => {
+                out.endAnswer();
+                return out.refuseApproval(approval);
+            },
+            requestDecision: async (request) => {
+                out.endAnswer();
+                out.line('notice', `Approval needed but no terminal to ask on: ${request.message}`);
+                return { approved: false, feedback: 'No interactive terminal available.' };
+            },
+            askQuestion: async (question) => {
+                out.endAnswer();
+                return out.refuseQuestion(question.prompt);
+            },
+        }, session.mcp);
+        const reports = await session.mcpReady;
+        for (const bad of reports.filter((r) => !r.ok)) {
+            out.line('notice', `MCP server "${bad.name}" did not start: ${bad.error}`);
+        }
+        runner.setMcpTools(session.mcp.listTools());
+        const result = await runner.run(options.prompt, await session.snapshot);
+        out.endAnswer();
+        answer = result.answer ?? '';
+        if (result.error) {
+            out.line('error', result.error);
+            emit(false, 1, result.error);
+            return 1;
+        }
+        if (result.answer) {
+            out.line('agent', result.answer);
+        }
+        if (out.refusalCount > 0) {
+            const advice = options.mode === 'plan'
+                ? 'plan mode makes no changes — re-run without --plan'
+                : `re-run with -m acceptEdits, or --bypass in CI (mode was ${options.mode})`;
+            const message = `${out.refusalCount} operation(s) were skipped because there is no terminal ` +
+                `to approve them: ${advice}.`;
+            out.line('error', message);
+            emit(false, 3, message);
+            return 3;
+        }
+        emit(true, 0);
+        return 0;
+    }
+    catch (err) {
+        out.endAnswer();
+        if (err instanceof InsufficientCredits) {
+            out.line('error', err.detail);
+            out.line('notice', `Top up at ${siteUrl()}/credits`);
+            emit(false, 2, err.detail);
+            return 2;
+        }
+        const message = err.message;
+        out.line('error', message);
+        emit(false, 1, message);
+        return 1;
+    }
+    finally {
+        await runner?.shutdown();
+        removeTeardown();
+    }
+}

package/dist/session.js

@@ -0,0 +1,57 @@
+/*!
+ * 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 { stat } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { bootstrap, fetchCredits } from './api/workspace.js';
+import { isSignedIn, login } from './auth/session.js';
+import { McpManager } from './mcp/manager.js';
+import { buildSnapshot } from './protocol/snapshot.js';
+async function localMemoryPresent(cwd) {
+    try {
+        const info = await stat(join(cwd, '.rivine', 'local_memory.md'));
+        return info.isFile() && info.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startSession(options) {
+    const { cwd } = options;
+    if (!(await isSignedIn())) {
+        options.onNotice?.('Opening your browser to sign in…');
+        await login({
+            onUrl: (url) => options.onLoginUrl?.(url),
+            onNoRefreshToken: (hours) => options.onNotice?.(`This session ends in ~${hours}h and cannot renew itself.`),
+        });
+    }
+    const project = basename(cwd) || 'project';
+    const result = await bootstrap(cwd, project);
+    const mcp = new McpManager();
+    const mcpReady = mcp.connectAll(cwd).catch(() => []);
+    return {
+        bootstrap: result,
+        project,
+        mcp,
+        mcpReady,
+        continuing: !result.created,
+        hasLocalMemory: await localMemoryPresent(cwd),
+        snapshot: buildSnapshot(cwd).catch(() => null),
+        balance: fetchCredits(result.credits_url)
+            .then((c) => (c ? c.balance : null))
+            .catch(() => null),
+    };
+}
+export function creditShortfall(balance, minimums) {
+    const floor = minimums.rivine_code ?? 10;
+    if (balance === null)
+        return null;
+    return balance < floor ? floor : null;
+}