@beunec/rivine 0.1.0

package/dist/protocol/permissions.js

@@ -0,0 +1,210 @@
+/*!
+ * 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 const PERMISSION_MODES = ['plan', 'default', 'acceptEdits', 'bypass'];
+export const CYCLE_MODES = ['plan', 'default', 'acceptEdits'];
+export function isBatchable(category) {
+    return category === 'write' || category === 'mcp';
+}
+export function mcpServerOf(toolName) {
+    const match = /^mcp__([^_]+(?:_[^_]+)*?)__/.exec(toolName);
+    return match ? match[1] : null;
+}
+const READ_OPS = new Set(['ls', 'read', 'glob', 'grep', 'download']);
+const WRITE_OPS = new Set(['write', 'edit', 'upload']);
+const SECRET_PATTERNS = [
+    /(^|\/)\.env($|\.|\/)/i,
+    /(^|\/)\.npmrc$/i,
+    /(^|\/)\.netrc$/i,
+    /(^|\/)\.pypirc$/i,
+    /(^|\/)\.ssh(\/|$)/i,
+    /(^|\/)\.aws(\/|$)/i,
+    /(^|\/)\.gnupg(\/|$)/i,
+    /(^|\/)id_(rsa|dsa|ecdsa|ed25519)($|\.)/i,
+    /\.(pem|p12|pfx|keystore|jks)$/i,
+    /(^|\/)(credentials|secrets?)(\.[a-z0-9]+)?$/i,
+    /(^|\/)service[-_]?account.*\.json$/i,
+];
+const READ_ONLY_COMMANDS = new Set([
+    'ls', 'cat', 'head', 'tail', 'wc', 'pwd', 'echo', 'file', 'stat', 'du', 'df',
+    'grep', 'rg', 'ag', 'find', 'fd', 'tree', 'which', 'whoami', 'date', 'env',
+    'diff', 'sort', 'uniq', 'cut', 'awk', 'sed', 'jq', 'basename', 'dirname',
+]);
+const READ_ONLY_SUBCOMMANDS = {
+    git: new Set(['status', 'log', 'diff', 'show', 'branch', 'remote', 'blame', 'ls-files', 'describe', 'rev-parse', 'config']),
+    npm: new Set(['ls', 'list', 'view', 'outdated', 'why', 'audit', 'config']),
+    pnpm: new Set(['ls', 'list', 'why', 'outdated']),
+    yarn: new Set(['list', 'why', 'info']),
+    cargo: new Set(['tree', 'metadata']),
+    docker: new Set(['ps', 'images', 'version', 'info']),
+    kubectl: new Set(['get', 'describe', 'logs', 'version']),
+    poetry: new Set(['show', 'check']),
+};
+const ALWAYS_ASK_COMMANDS = [
+    { pattern: /\brm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)/, reason: 'recursive or forced delete' },
+    { pattern: /\bgit\s+push\b/, reason: 'pushes to a remote' },
+    { pattern: /--force\b|--hard\b|-f\b(?=.*\bpush\b)/, reason: 'force operation' },
+    { pattern: /\bgit\s+reset\s+--hard\b/, reason: 'discards local changes' },
+    { pattern: /\bgit\s+clean\s+-[a-zA-Z]*[fd]/, reason: 'deletes untracked files' },
+    { pattern: /\bsudo\b/, reason: 'runs as administrator' },
+    { pattern: /\bnpm\s+publish\b|\byarn\s+publish\b|\bpnpm\s+publish\b/, reason: 'publishes a package' },
+    { pattern: /\b(vercel|netlify|fly|heroku)\s+(deploy|launch)\b/, reason: 'deploys' },
+    { pattern: /\bwrangler\s+(deploy|publish)\b/, reason: 'deploys to Cloudflare' },
+    { pattern: /\b(sam|serverless|sls)\s+deploy\b/, reason: 'deploys to AWS' },
+    { pattern: /\bterraform\s+(apply|destroy)\b/, reason: 'changes infrastructure' },
+    { pattern: /\bkubectl\s+(apply|delete|rollout)\b/, reason: 'changes a cluster' },
+    { pattern: /\bdocker\s+push\b/, reason: 'pushes an image' },
+    { pattern: /\baws\s+\w+\s+(delete|put|create|update|remove)/, reason: 'changes AWS resources' },
+    { pattern: /\bmkfs\b|\bdd\s+if=|\bshutdown\b|\breboot\b/, reason: 'affects the whole system' },
+    { pattern: /\bchmod\s+(-R\s+)?777\b/, reason: 'makes files world-writable' },
+    { pattern: /curl[^|]*\|\s*(sudo\s+)?(ba)?sh|wget[^|]*\|\s*(sudo\s+)?(ba)?sh/, reason: 'pipes a download into a shell' },
+    { pattern: /:\(\)\s*\{.*\|.*&.*\}/, reason: 'fork bomb' },
+];
+const SHELL_CHAINING = /[;&|]|\$\(|`|>>|>|<\(/;
+const AGENT_METADATA_DIR = /^\.rivine(\/|$)/;
+export function isAgentMetadataPath(relPath) {
+    return AGENT_METADATA_DIR.test(relPath.replace(/^\.\//, ''));
+}
+export function isNotebookSeedCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed || SHELL_CHAINING.test(trimmed))
+        return false;
+    const tokens = trimmed.split(/\s+/);
+    const head = (tokens[0] ?? '').replace(/^.*\//, '');
+    if (head !== 'mkdir')
+        return false;
+    const args = tokens.slice(1).filter((t) => t !== '-p' && t !== '--' && !t.startsWith('-'));
+    if (args.length === 0)
+        return false;
+    return args.every((p) => {
+        const rel = p.replace(/^\/workspace\/?/, '').replace(/^\.\//, '');
+        return isAgentMetadataPath(rel);
+    });
+}
+export function isSecretPath(relPath) {
+    return SECRET_PATTERNS.some((re) => re.test(relPath));
+}
+export function isReadOnlyCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed || SHELL_CHAINING.test(trimmed))
+        return false;
+    const tokens = trimmed.split(/\s+/);
+    const head = (tokens[0] ?? '').replace(/^.*\//, '');
+    if (READ_ONLY_COMMANDS.has(head))
+        return true;
+    const subcommands = READ_ONLY_SUBCOMMANDS[head];
+    if (subcommands) {
+        const sub = tokens.slice(1).find((t) => !t.startsWith('-'));
+        return sub !== undefined && subcommands.has(sub);
+    }
+    return /^(-v|--version|-V|--help|-h)$/.test(tokens[1] ?? '');
+}
+function dangerousCommand(command) {
+    for (const { pattern, reason } of ALWAYS_ASK_COMMANDS) {
+        if (pattern.test(command))
+            return reason;
+    }
+    return null;
+}
+const ALLOW_OUTSIDE_PROJECT = Boolean(process.env.RIVINE_ALLOW_OUTSIDE_PROJECT);
+export function decide(input) {
+    const { op, mode, relPath, outsideProject, command } = input;
+    if (outsideProject) {
+        if (mode === 'bypass') {
+            return ALLOW_OUTSIDE_PROJECT
+                ? { verdict: 'allow' }
+                : {
+                    verdict: 'deny',
+                    reason: `${relPath ?? 'this path'} is outside the project directory; bypass mode ` +
+                        'does not leave the project (set RIVINE_ALLOW_OUTSIDE_PROJECT=1 if you mean it)',
+                };
+        }
+        return {
+            verdict: 'ask',
+            category: 'outside',
+            reason: `${relPath ?? 'this path'} is outside the project directory`,
+        };
+    }
+    if (mode === 'bypass')
+        return { verdict: 'allow' };
+    if (relPath && isSecretPath(relPath)) {
+        return {
+            verdict: 'ask',
+            category: 'secret',
+            reason: READ_OPS.has(op)
+                ? `${relPath} looks like it holds credentials — reading it would send them to the model`
+                : `${relPath} looks like it holds credentials`,
+        };
+    }
+    if (op === 'mcp_call') {
+        if (mode === 'plan') {
+            return {
+                verdict: 'deny',
+                reason: 'plan mode does not call external tools — press Shift+Tab to change mode',
+            };
+        }
+        return { verdict: 'ask', category: 'mcp', reason: 'calls an external tool on your machine' };
+    }
+    if (op === 'execute') {
+        const cmd = command ?? '';
+        const danger = dangerousCommand(cmd);
+        if (danger)
+            return { verdict: 'ask', category: 'destructive', reason: danger };
+        if (isNotebookSeedCommand(cmd) && mode !== 'plan') {
+            return { verdict: 'allow' };
+        }
+        if (mode === 'acceptEdits' && isReadOnlyCommand(cmd)) {
+            return { verdict: 'allow' };
+        }
+        if (mode === 'plan') {
+            return isReadOnlyCommand(cmd)
+                ? { verdict: 'allow' }
+                : {
+                    verdict: 'deny',
+                    reason: 'plan mode runs read-only commands only — press Shift+Tab to change mode',
+                };
+        }
+        return { verdict: 'ask', category: 'command', reason: 'runs a command on your machine' };
+    }
+    if (READ_OPS.has(op))
+        return { verdict: 'allow' };
+    if (WRITE_OPS.has(op)) {
+        if (mode === 'plan') {
+            return {
+                verdict: 'deny',
+                reason: 'plan mode does not modify files — press Shift+Tab to change mode',
+            };
+        }
+        if (relPath && isAgentMetadataPath(relPath))
+            return { verdict: 'allow' };
+        if (mode === 'acceptEdits')
+            return { verdict: 'allow' };
+        return { verdict: 'ask', category: 'write', reason: `writes ${relPath ?? 'a file'}` };
+    }
+    return { verdict: 'ask', category: 'command', reason: 'unrecognised operation' };
+}
+export function nextMode(current) {
+    const index = CYCLE_MODES.indexOf(current);
+    if (index === -1)
+        return 'default';
+    return CYCLE_MODES[(index + 1) % CYCLE_MODES.length];
+}
+export function describeMode(mode) {
+    switch (mode) {
+        case 'plan':
+            return 'plan · reads only';
+        case 'default':
+            return 'default · asks before changes';
+        case 'acceptEdits':
+            return 'accept edits · writes apply, commands ask';
+        case 'bypass':
+            return 'bypass · no prompts';
+    }
+}

package/dist/protocol/runner.js

@@ -0,0 +1,325 @@
+/*!
+ * 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 { closeSession, openTurn, postFsResult, resumeTurn } from '../api/workspace.js';
+import { apiUrl } from '../config.js';
+import { accessToken } from '../auth/session.js';
+import { classify, execute } from './fsExecutor.js';
+import { isSealedEnvelope, SessionKey } from './sessionKey.js';
+import { selectRelevantTools } from '../mcp/relevance.js';
+import { readTurnStream } from './stream.js';
+const PENDING_POLL_MS = 1200;
+export class TurnRunner {
+    ctx;
+    cb;
+    mcp;
+    seen = new Set();
+    static SEEN_LIMIT = 5000;
+    approvalChain = Promise.resolve();
+    inFlight = new Set();
+    stopped = false;
+    pollTimer = null;
+    constructor(ctx, cb, mcp) {
+        this.ctx = ctx;
+        this.cb = cb;
+        this.mcp = mcp;
+    }
+    shell = null;
+    key = SessionKey.generate();
+    setMode(mode) {
+        this.ctx.mode = mode;
+    }
+    writeToShell(data) {
+        if (!this.shell)
+            return false;
+        this.shell.write(data);
+        return true;
+    }
+    get interactiveShell() {
+        return Boolean(this.shell);
+    }
+    resizeShell(cols, rows) {
+        this.shell?.resize(cols, rows);
+    }
+    killShell() {
+        if (!this.shell)
+            return false;
+        this.shell.kill();
+        return true;
+    }
+    executeHooks(approvedOutside = false) {
+        return {
+            onOutput: (text) => this.cb.onOutput?.(text),
+            onShell: (handle) => {
+                this.shell = handle;
+                this.cb.onShell?.(handle);
+            },
+            approvedOutside,
+        };
+    }
+    setMcpTools(tools) {
+        this.ctx.mcpTools = tools;
+    }
+    async run(message, snapshot) {
+        this.stopped = false;
+        this.startPolling();
+        const selection = selectRelevantTools(message, this.ctx.mcpTools ?? []);
+        if (selection.servers.length) {
+            this.cb.onNotice(`MCP: using ${selection.servers.join(', ')}` +
+                (selection.skipped.length ? ` (not needed: ${selection.skipped.join(', ')})` : ''));
+        }
+        try {
+            const response = await openTurn({
+                workspaceId: this.ctx.workspaceId,
+                chatSpaceId: this.ctx.chatSpaceId,
+                sessionId: this.ctx.sessionId,
+                message,
+                permissionMode: this.ctx.mode,
+                cwdSnapshot: snapshot,
+                mcpTools: selection.tools.map(({ name, description, input_schema }) => ({
+                    name,
+                    description,
+                    input_schema,
+                })),
+                sessionKey: this.key.toBase64(),
+            });
+            return await this.consume(response);
+        }
+        finally {
+            this.stopPolling();
+            await Promise.allSettled([...this.inFlight]);
+        }
+    }
+    async consume(response) {
+        let answer = '';
+        let pendingHitl = null;
+        for await (const event of readTurnStream(response)) {
+            switch (event.type) {
+                case 'token':
+                    answer += event.content ?? '';
+                    this.cb.onToken(event.content ?? '');
+                    break;
+                case 'stage':
+                    this.cb.onStage(String(event.label ?? ''));
+                    break;
+                case 'tool_call_start': {
+                    const e = event;
+                    const detail = e.args?.command ?? e.args?.filename ?? '';
+                    this.cb.onTool(String(e.name ?? 'tool'), String(detail));
+                    break;
+                }
+                case 'code_file': {
+                    const e = event;
+                    this.cb.onFileTouched(String(e.path ?? ''), e.status);
+                    break;
+                }
+                case 'fs_request':
+                    this.dispatch(event);
+                    break;
+                case 'approval_request': {
+                    const e = event;
+                    pendingHitl = {
+                        message: String(e.message ?? 'Approval required.'),
+                        tool: e.tool ? String(e.tool) : undefined,
+                        options: extractOptions(e),
+                        multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
+                        threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
+                    };
+                    break;
+                }
+                case 'final_answer':
+                    answer = String(event.content ?? answer);
+                    break;
+                case 'error': {
+                    const e = event;
+                    return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
+                }
+                case 'done':
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (pendingHitl) {
+            return { answer: await this.settleHitl(pendingHitl), cancelled: false };
+        }
+        return { answer, cancelled: false };
+    }
+    async settleHitl(first) {
+        let current = first;
+        let answer = '';
+        for (let round = 0; current && round < 25; round += 1) {
+            const decision = await this.enqueuePrompt(() => this.cb.requestDecision(current));
+            const body = (await resumeTurn({
+                workspaceId: this.ctx.workspaceId,
+                chatSpaceId: this.ctx.chatSpaceId,
+                threadId: current.threadId,
+                sessionId: this.ctx.sessionId,
+                sessionKey: this.key.toBase64(),
+                approved: decision.approved,
+                feedback: decision.feedback,
+                modifiedArgs: decision.modifiedArgs,
+            }));
+            answer = String(body.response ?? answer);
+            const meta = body.context_metadata ?? {};
+            current = meta.paused
+                ? {
+                    message: String(meta.hitl_prompt ?? body.response ?? 'Approval required.'),
+                    tool: meta.hitl_tool ? String(meta.hitl_tool) : undefined,
+                    options: extractOptions({ ui_schema: meta.hitl_ui_schema, args: meta.hitl_args }),
+                    multi: Boolean(meta.hitl_ui_schema?.multi),
+                    threadId: String(meta.thread_id ?? current.threadId),
+                }
+                : null;
+        }
+        return answer;
+    }
+    dispatch(request) {
+        if (this.stopped || this.seen.has(request.request_id))
+            return;
+        if (this.seen.size >= TurnRunner.SEEN_LIMIT) {
+            const keep = [...this.seen].slice(-TurnRunner.SEEN_LIMIT / 2);
+            this.seen.clear();
+            for (const id of keep)
+                this.seen.add(id);
+        }
+        this.seen.add(request.request_id);
+        const task = (async () => {
+            let outcome;
+            try {
+                if (request.op === 'mcp_call') {
+                    const { approval, refusal } = await classify(this.ctx.root, request, this.ctx.mode);
+                    if (refusal) {
+                        outcome = refusal;
+                    }
+                    else if (approval && !(await this.enqueuePrompt(() => this.cb.requestApproval(approval), false))) {
+                        outcome = { ok: false, error: 'The developer declined this tool call.' };
+                    }
+                    else if (!this.mcp) {
+                        outcome = { ok: false, error: 'No MCP servers are connected in this session.' };
+                    }
+                    else {
+                        const result = await this.mcp.call(String(request.args.tool ?? ''), (request.args.args ?? {}));
+                        outcome = { ok: true, data: { result } };
+                    }
+                    await postFsResult(this.ctx.sessionId, request.request_id, outcome, this.key);
+                    return;
+                }
+                if (request.op === 'ask') {
+                    const question = {
+                        prompt: String(request.args.prompt ?? ''),
+                        options: request.args.options?.filter(Boolean),
+                        multi: Boolean(request.args.multi),
+                    };
+                    const answer = await this.enqueuePrompt(() => this.cb.askQuestion(question), '');
+                    outcome = { ok: true, data: { answer } };
+                    await postFsResult(this.ctx.sessionId, request.request_id, outcome, this.key);
+                    return;
+                }
+                const { approval, refusal } = await classify(this.ctx.root, request, this.ctx.mode);
+                if (refusal) {
+                    outcome = refusal;
+                }
+                else if (approval) {
+                    const allowed = await this.enqueuePrompt(() => this.cb.requestApproval(approval), false);
+                    outcome = allowed
+                        ? await execute(this.ctx.root, request, this.executeHooks(approval.category === 'outside'))
+                        : { ok: false, error: 'The developer declined this operation.' };
+                }
+                else {
+                    outcome = await execute(this.ctx.root, request, this.executeHooks());
+                }
+            }
+            catch (err) {
+                outcome = { ok: false, error: err.message };
+            }
+            try {
+                await postFsResult(this.ctx.sessionId, request.request_id, outcome, this.key);
+            }
+            catch (err) {
+                this.cb.onNotice(`Could not report a file operation: ${err.message}`);
+            }
+        })();
+        this.inFlight.add(task);
+        void task.finally(() => this.inFlight.delete(task));
+    }
+    enqueuePrompt(ask, fallback) {
+        let release;
+        const answered = new Promise((r) => {
+            release = r;
+        });
+        this.approvalChain = this.approvalChain.then(async () => {
+            if (this.stopped) {
+                release(fallback);
+                return;
+            }
+            release(await ask().catch(() => fallback));
+        });
+        return answered;
+    }
+    startPolling() {
+        if (this.pollTimer)
+            return;
+        const tick = async () => {
+            if (this.stopped)
+                return;
+            try {
+                const res = await fetch(`${apiUrl()}/api/cli/sessions/${this.ctx.sessionId}/pending`, { headers: { authorization: `Bearer ${await accessToken()}` } });
+                if (res.ok) {
+                    const body = (await res.json());
+                    for (const request of body.requests ?? []) {
+                        const opened = this.openPending(request);
+                        if (opened)
+                            this.dispatch(opened);
+                    }
+                }
+            }
+            catch {
+            }
+        };
+        this.pollTimer = setInterval(() => void tick(), PENDING_POLL_MS);
+        this.pollTimer.unref?.();
+    }
+    openPending(row) {
+        if (!row.sealed)
+            return row;
+        if (!isSealedEnvelope(row.sealed))
+            return null;
+        try {
+            return { ...row, args: this.key.open(row.sealed) };
+        }
+        catch {
+            this.cb.onNotice('Ignored a file operation that failed its integrity check.');
+            return null;
+        }
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    async shutdown() {
+        this.stopped = true;
+        this.stopPolling();
+        await closeSession(this.ctx.sessionId);
+    }
+}
+function extractOptions(event) {
+    const raw = event?.ui_schema?.options ??
+        event?.ui_schema?.choices ??
+        event?.args?.options ??
+        event?.options;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw
+        .map((item) => (typeof item === 'string' ? item : (item?.label ?? item?.value ?? '')))
+        .filter((label) => label.length > 0);
+}

package/dist/protocol/sessionKey.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 { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+const VERSION = 2;
+const KEY_BYTES = 32;
+const NONCE_BYTES = 12;
+const TAG_BYTES = 16;
+export function isSealedEnvelope(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const e = value;
+    return e.v === VERSION && typeof e.n === 'string' && typeof e.ct === 'string';
+}
+export class SessionKey {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    static generate() {
+        return new SessionKey(randomBytes(KEY_BYTES));
+    }
+    toBase64() {
+        return this.key.toString('base64');
+    }
+    seal(value) {
+        const nonce = randomBytes(NONCE_BYTES);
+        const cipher = createCipheriv('aes-256-gcm', this.key, nonce);
+        const body = Buffer.concat([
+            cipher.update(Buffer.from(JSON.stringify(value), 'utf8')),
+            cipher.final(),
+        ]);
+        return {
+            v: VERSION,
+            n: nonce.toString('base64'),
+            ct: Buffer.concat([body, cipher.getAuthTag()]).toString('base64'),
+        };
+    }
+    open(envelope) {
+        const raw = Buffer.from(envelope.ct, 'base64');
+        if (raw.length < TAG_BYTES)
+            throw new Error('sealed payload is too short to be valid');
+        const body = raw.subarray(0, raw.length - TAG_BYTES);
+        const tag = raw.subarray(raw.length - TAG_BYTES);
+        const decipher = createDecipheriv('aes-256-gcm', this.key, Buffer.from(envelope.n, 'base64'));
+        decipher.setAuthTag(tag);
+        const plain = Buffer.concat([decipher.update(body), decipher.final()]);
+        return JSON.parse(plain.toString('utf8'));
+    }
+}