@beunec/rivine 0.1.0

package/dist/mcp/oauth.js

@@ -0,0 +1,234 @@
+/*!
+ * 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 { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { openBrowser } from '../auth/pkce.js';
+import { loadSession, mcpAccount, saveSession } from '../auth/keychain.js';
+const PORTS = [1455, 1456, 1457, 1458, 1459, 1460];
+const FLOW_TIMEOUT_MS = 5 * 60_000;
+const SAFE_SCOPES = new Set([
+    'openid',
+    'profile',
+    'email',
+    'offline_access',
+    'mcp',
+    'mcp:read',
+    'mcp:tools',
+    'tools',
+    'tools:read',
+    'read',
+]);
+const RENEW_MARGIN_MS = 60_000;
+async function freePort() {
+    for (const candidate of PORTS) {
+        const free = await new Promise((resolve) => {
+            const probe = createServer();
+            probe.once('error', () => resolve(false));
+            probe.once('listening', () => probe.close(() => resolve(true)));
+            probe.listen(candidate, '127.0.0.1');
+        });
+        if (free)
+            return candidate;
+    }
+    throw new Error(`Ports ${PORTS[0]}-${PORTS[PORTS.length - 1]} are all in use. Close another sign-in and retry.`);
+}
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+async function discover(serverUrl) {
+    let origin;
+    try {
+        origin = new URL(serverUrl).origin;
+    }
+    catch {
+        return null;
+    }
+    const candidates = [
+        `${origin}/.well-known/oauth-authorization-server`,
+        `${origin}/.well-known/openid-configuration`,
+    ];
+    for (const url of candidates) {
+        try {
+            const res = await fetch(url, { headers: { accept: 'application/json' } });
+            if (!res.ok)
+                continue;
+            const meta = (await res.json());
+            if (meta?.authorization_endpoint && meta?.token_endpoint)
+                return meta;
+        }
+        catch {
+        }
+    }
+    return null;
+}
+async function register(meta, redirectUri) {
+    if (!meta.registration_endpoint)
+        return null;
+    try {
+        const res = await fetch(meta.registration_endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                client_name: 'Rivine Code CLI',
+                redirect_uris: [redirectUri],
+                grant_types: ['authorization_code', 'refresh_token'],
+                response_types: ['code'],
+                token_endpoint_auth_method: 'none',
+            }),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.client_id ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+const PAGE = (rawTitle, rawDetail) => {
+    const title = escapeHtml(rawTitle);
+    const detail = escapeHtml(rawDetail);
+    return `<!doctype html>
+<html><head><meta charset="utf-8"><title>${title}</title></head>
+<body style="font-family:system-ui,sans-serif;display:grid;place-items:center;height:100vh;margin:0;background:#f4f4f0">
+<div style="text-align:center"><h1 style="font-size:17px;margin:0 0 8px">${title}</h1>
+<p style="font-size:13px;color:#555;margin:0">${detail}</p></div></body></html>`;
+};
+export async function loginToServer(serverName, serverUrl, onUrl) {
+    const meta = await discover(serverUrl);
+    if (!meta?.authorization_endpoint || !meta.token_endpoint) {
+        throw new Error(`${serverName} does not advertise an OAuth authorization server. ` +
+            'If it uses a static API key, use: rivine mcp add --token-env <VAR>');
+    }
+    const port = await freePort();
+    const redirectUri = `http://127.0.0.1:${port}/callback`;
+    const existing = (await loadSession(mcpAccount(serverName)));
+    const clientId = existing?.clientId ?? (await register(meta, redirectUri));
+    if (!clientId) {
+        throw new Error(`${serverName} requires a client id and does not support dynamic registration. ` +
+            'Register this CLI with the provider and set the token via --token-env instead.');
+    }
+    const verifier = base64url(randomBytes(32));
+    const challenge = base64url(createHash('sha256').update(verifier).digest());
+    const state = base64url(randomBytes(16));
+    const code = await new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+            if (url.pathname !== '/callback') {
+                res.writeHead(404).end();
+                return;
+            }
+            const finish = (status, page, done) => {
+                res.writeHead(status, { 'content-type': 'text/html; charset=utf-8' }).end(page);
+                res.on('finish', () => {
+                    server.close();
+                    done();
+                });
+            };
+            const error = url.searchParams.get('error');
+            if (error) {
+                const detail = url.searchParams.get('error_description') || error;
+                finish(400, PAGE('Sign-in was cancelled', detail), () => reject(new Error(detail)));
+                return;
+            }
+            const returned = url.searchParams.get('code') ?? '';
+            if (!returned || url.searchParams.get('state') !== state) {
+                finish(400, PAGE('Sign-in could not be verified', 'Please run the command again.'), () => reject(new Error('The sign-in response did not match this terminal.')));
+                return;
+            }
+            finish(200, PAGE(`Connected to ${serverName}`, 'You can close this tab.'), () => resolve(returned));
+        });
+        server.on('error', (err) => reject(err));
+        server.listen(port, '127.0.0.1', () => {
+            const authorize = new URL(meta.authorization_endpoint);
+            authorize.searchParams.set('response_type', 'code');
+            authorize.searchParams.set('client_id', clientId);
+            authorize.searchParams.set('redirect_uri', redirectUri);
+            authorize.searchParams.set('code_challenge', challenge);
+            authorize.searchParams.set('code_challenge_method', 'S256');
+            authorize.searchParams.set('state', state);
+            const scopes = (meta.scopes_supported ?? []).filter((s) => SAFE_SCOPES.has(s));
+            if (scopes.length)
+                authorize.searchParams.set('scope', scopes.join(' '));
+            const href = authorize.toString();
+            onUrl(href);
+            openBrowser(href);
+        });
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Timed out waiting for the browser. Run the command again.'));
+        }, FLOW_TIMEOUT_MS).unref();
+    });
+    const token = await exchange(meta.token_endpoint, {
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: redirectUri,
+        client_id: clientId,
+        code_verifier: verifier,
+    });
+    await saveSession({ ...token, clientId, tokenEndpoint: meta.token_endpoint }, mcpAccount(serverName));
+}
+async function exchange(tokenEndpoint, body) {
+    const res = await fetch(tokenEndpoint, {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+        body: new URLSearchParams(body).toString(),
+    });
+    if (!res.ok) {
+        throw new Error(`The authorization server refused the request (HTTP ${res.status}).`);
+    }
+    const parsed = (await res.json());
+    if (!parsed.access_token)
+        throw new Error('The authorization server returned no access token.');
+    return {
+        accessToken: parsed.access_token,
+        refreshToken: parsed.refresh_token,
+        expiresAt: Date.now() + (parsed.expires_in ?? 3600) * 1000,
+    };
+}
+export async function tokenFor(serverName) {
+    const stored = (await loadSession(mcpAccount(serverName)));
+    if (!stored)
+        return null;
+    if (stored.expiresAt - RENEW_MARGIN_MS > Date.now())
+        return stored.accessToken;
+    if (!stored.refreshToken || !stored.tokenEndpoint || !stored.clientId) {
+        return stored.accessToken;
+    }
+    try {
+        const renewed = await exchange(stored.tokenEndpoint, {
+            grant_type: 'refresh_token',
+            refresh_token: stored.refreshToken,
+            client_id: stored.clientId,
+        });
+        await saveSession({
+            ...renewed,
+            refreshToken: renewed.refreshToken ?? stored.refreshToken,
+            clientId: stored.clientId,
+            tokenEndpoint: stored.tokenEndpoint,
+        }, mcpAccount(serverName));
+        return renewed.accessToken;
+    }
+    catch {
+        return null;
+    }
+}
+export async function isLoggedIn(serverName) {
+    return (await loadSession(mcpAccount(serverName))) !== null;
+}

package/dist/mcp/relevance.js

@@ -0,0 +1,74 @@
+/*!
+ * 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.
+ */
+const MAX_TOOLS_PER_TURN = 24;
+const RELEVANCE_THRESHOLD = 2;
+const NOISE = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'to', 'of', 'in', 'on', 'at', 'for', 'with', 'from',
+    'is', 'are', 'was', 'be', 'been', 'it', 'this', 'that', 'these', 'those', 'as', 'by',
+    'i', 'we', 'you', 'me', 'my', 'our', 'your', 'can', 'please', 'add', 'make', 'use', 'using',
+    'get', 'set', 'new', 'all', 'any', 'if', 'then', 'do', 'does', 'not', 'no', 'yes',
+    'file', 'files', 'code', 'run', 'fix', 'update', 'create', 'write', 'read', 'change',
+    'tool', 'tools', 'server', 'data', 'list', 'name', 'value', 'return', 'returns', 'result',
+]);
+function tokenize(text) {
+    const out = new Set();
+    for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+        if ((raw.length > 2 || raw === 'db') && !NOISE.has(raw))
+            out.add(raw);
+    }
+    return out;
+}
+function serverVocabulary(tools) {
+    const words = new Set();
+    for (const tool of tools) {
+        for (const word of tokenize(tool.name.replace(/^mcp__/, '').replace(/__/g, ' '))) {
+            words.add(word);
+        }
+        for (const word of tokenize(tool.description))
+            words.add(word);
+    }
+    return words;
+}
+export function selectRelevantTools(message, all) {
+    if (all.length === 0)
+        return { tools: [], servers: [], skipped: [] };
+    const byServer = new Map();
+    for (const tool of all) {
+        const list = byServer.get(tool.server) ?? [];
+        list.push(tool);
+        byServer.set(tool.server, list);
+    }
+    const prompt = tokenize(message);
+    const lowered = message.toLowerCase();
+    const scored = [];
+    for (const [server, tools] of byServer) {
+        const named = lowered.includes(server.toLowerCase());
+        let overlap = 0;
+        const vocabulary = serverVocabulary(tools);
+        for (const word of prompt)
+            if (vocabulary.has(word))
+                overlap += 1;
+        scored.push({ server, tools, score: named ? Number.POSITIVE_INFINITY : overlap });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const chosen = [];
+    const servers = [];
+    const skipped = [];
+    for (const entry of scored) {
+        if (entry.score < RELEVANCE_THRESHOLD || chosen.length + entry.tools.length > MAX_TOOLS_PER_TURN) {
+            skipped.push(entry.server);
+            continue;
+        }
+        chosen.push(...entry.tools);
+        servers.push(entry.server);
+    }
+    return { tools: chosen, servers, skipped };
+}

package/dist/protocol/edit.js

@@ -0,0 +1,247 @@
+/*!
+ * 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 { readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { dirname, join } from 'node:path';
+function replaceLiteral(haystack, needle, replacement, all) {
+    if (all)
+        return haystack.split(needle).join(replacement);
+    const at = haystack.indexOf(needle);
+    if (at < 0)
+        return haystack;
+    const body = indentContinuation(haystack, at, needle, replacement);
+    return haystack.slice(0, at) + body + haystack.slice(at + needle.length);
+}
+function indentContinuation(haystack, matchIndex, oldString, newString) {
+    if (!newString.includes('\n'))
+        return newString;
+    if (oldString.includes('\n'))
+        return newString;
+    const lineStart = haystack.lastIndexOf('\n', matchIndex - 1) + 1;
+    const prefix = haystack.slice(lineStart, matchIndex);
+    if (prefix.length > 0 && !/^[ \t]+$/.test(prefix))
+        return newString;
+    const lines = newString.split('\n');
+    return [
+        lines[0],
+        ...lines.slice(1).map((l) => (l.length > 0 ? prefix + l : l)),
+    ].join('\n');
+}
+function countOccurrences(haystack, needle) {
+    if (!needle)
+        return 0;
+    return haystack.split(needle).length - 1;
+}
+function dominantEnding(text) {
+    const crlf = (text.match(/\r\n/g) ?? []).length;
+    const lf = (text.match(/(?<!\r)\n/g) ?? []).length;
+    return crlf > lf ? '\r\n' : '\n';
+}
+function toLf(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+function withEnding(text, ending) {
+    return ending === '\r\n' ? toLf(text).replace(/\n/g, '\r\n') : toLf(text);
+}
+function findIndentedBlock(haystackLines, needleLines) {
+    const wanted = needleLines.map((l) => l.trim());
+    const found = [];
+    for (let i = 0; i + wanted.length <= haystackLines.length; i += 1) {
+        let matches = true;
+        for (let j = 0; j < wanted.length; j += 1) {
+            if (haystackLines[i + j].trim() !== wanted[j]) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches)
+            continue;
+        const firstReal = wanted.findIndex((l) => l.length > 0);
+        if (firstReal < 0)
+            continue;
+        const haveIndent = haystackLines[i + firstReal].match(/^[ \t]*/)[0];
+        const wantIndent = needleLines[firstReal].match(/^[ \t]*/)[0];
+        if (!haveIndent.startsWith(wantIndent) && !wantIndent.startsWith(haveIndent)) {
+            continue;
+        }
+        found.push({ start: i, end: i + wanted.length, haveIndent, wantIndent });
+        if (found.length > 1)
+            return 'ambiguous';
+    }
+    return found[0] ?? null;
+}
+function describeNearMiss(content, oldString) {
+    const needleLines = toLf(oldString).split('\n').filter((l) => l.trim().length > 0);
+    if (needleLines.length === 0)
+        return 'the search text was blank';
+    const anchor = needleLines[0].trim();
+    const lines = toLf(content).split('\n');
+    const exact = lines.findIndex((l) => l.trim() === anchor);
+    if (exact >= 0) {
+        return (`its first line matches at line ${exact + 1}, so the difference is further down — ` +
+            're-read the file around that line and copy the block exactly');
+    }
+    let best = -1;
+    let bestScore = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        const candidate = lines[i].trim();
+        if (!candidate)
+            continue;
+        let shared = 0;
+        while (shared < candidate.length && shared < anchor.length && candidate[shared] === anchor[shared]) {
+            shared += 1;
+        }
+        if (shared > bestScore) {
+            bestScore = shared;
+            best = i;
+        }
+    }
+    if (best >= 0 && bestScore >= Math.min(8, anchor.length / 2)) {
+        return `the closest line is ${best + 1}: ${JSON.stringify(lines[best].trim().slice(0, 120))}`;
+    }
+    return 'nothing in the file resembles it — the path may be wrong, or the file may already have been changed';
+}
+export function planEdit(content, request) {
+    const { oldString, newString, replaceAll } = request;
+    if (!oldString)
+        return { ok: false, error: { kind: 'empty_old_string' } };
+    if (oldString === newString)
+        return { ok: false, error: { kind: 'no_op' } };
+    const exact = countOccurrences(content, oldString);
+    if (exact === 1 || (exact > 1 && replaceAll)) {
+        return {
+            ok: true,
+            value: {
+                content: replaceLiteral(content, oldString, newString, replaceAll),
+                occurrences: exact,
+                strategy: 'exact',
+            },
+        };
+    }
+    if (exact > 1) {
+        return {
+            ok: false,
+            error: {
+                kind: 'ambiguous',
+                occurrences: exact,
+                hint: 'include more surrounding context so the snippet is unique, or pass replace_all',
+            },
+        };
+    }
+    const ending = dominantEnding(content);
+    const normalizedContent = toLf(content);
+    const normalizedOld = toLf(oldString);
+    const viaEndings = countOccurrences(normalizedContent, normalizedOld);
+    if (viaEndings === 1 || (viaEndings > 1 && replaceAll)) {
+        const updated = replaceLiteral(normalizedContent, normalizedOld, toLf(newString), replaceAll);
+        return {
+            ok: true,
+            value: {
+                content: withEnding(updated, ending),
+                occurrences: viaEndings,
+                strategy: 'line-endings',
+            },
+        };
+    }
+    if (viaEndings > 1) {
+        return {
+            ok: false,
+            error: {
+                kind: 'ambiguous',
+                occurrences: viaEndings,
+                hint: 'include more surrounding context so the snippet is unique, or pass replace_all',
+            },
+        };
+    }
+    const contentLines = normalizedContent.split('\n');
+    const needleLines = normalizedOld.split('\n');
+    const block = findIndentedBlock(contentLines, needleLines);
+    if (block === 'ambiguous') {
+        return {
+            ok: false,
+            error: {
+                kind: 'ambiguous',
+                occurrences: 2,
+                hint: 'it appears more than once ignoring indentation — include more surrounding context',
+            },
+        };
+    }
+    if (block) {
+        const replacementLines = toLf(newString)
+            .split('\n')
+            .map((line) => {
+            if (line.length === 0)
+                return line;
+            const body = line.startsWith(block.wantIndent)
+                ? line.slice(block.wantIndent.length)
+                : line.replace(/^[ \t]*/, '');
+            return block.haveIndent + body;
+        });
+        const merged = [
+            ...contentLines.slice(0, block.start),
+            ...replacementLines,
+            ...contentLines.slice(block.end),
+        ].join('\n');
+        return {
+            ok: true,
+            value: { content: withEnding(merged, ending), occurrences: 1, strategy: 'indentation' },
+        };
+    }
+    return {
+        ok: false,
+        error: { kind: 'not_found', hint: describeNearMiss(content, oldString) },
+    };
+}
+export async function writeFileAtomic(path, content) {
+    let mode;
+    try {
+        mode = (await stat(path)).mode;
+    }
+    catch {
+    }
+    const temp = join(dirname(path), `.${randomBytes(6).toString('hex')}.rivine.tmp`);
+    try {
+        await writeFile(temp, content, mode === undefined ? 'utf8' : { encoding: 'utf8', mode });
+        await rename(temp, path);
+    }
+    catch (err) {
+        await unlink(temp).catch(() => { });
+        throw err;
+    }
+}
+export function describeFailure(error) {
+    switch (error.kind) {
+        case 'file_not_found':
+            return 'file_not_found';
+        case 'empty_old_string':
+            return 'empty_old_string — old_string must contain the text to replace';
+        case 'no_op':
+            return 'no_op — old_string and new_string are identical';
+        case 'ambiguous':
+            return `multiple_occurrences (${error.occurrences}) — ${error.hint}`;
+        case 'not_found':
+            return `string_not_found — ${error.hint}`;
+    }
+}
+export async function applyEdit(path, request) {
+    let current;
+    try {
+        current = await readFile(path, 'utf8');
+    }
+    catch {
+        return { ok: false, error: { kind: 'file_not_found' } };
+    }
+    const planned = planEdit(current, request);
+    if (!planned.ok)
+        return planned;
+    await writeFileAtomic(path, planned.value.content);
+    return planned;
+}