@beunec/rivine 0.1.0

package/dist/index.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/*!
+ * 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 { readFileSync } from 'node:fs';
+import { dirname, join, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { render } from 'ink';
+import React from 'react';
+import { Command } from 'commander';
+import { App } from './ui/App.js';
+import { runHeadless } from './runHeadless.js';
+import { isInteractiveTerminal, installTeardown } from './ui/headless.js';
+import { login, logout, status } from './auth/session.js';
+import { openBrowser } from './auth/pkce.js';
+import { apiUrl, siteUrl } from './config.js';
+import { describeServer, loadServers, removeServer, saveServer } from './mcp/config.js';
+import { McpManager } from './mcp/manager.js';
+import { loginToServer } from './mcp/oauth.js';
+import { clearSession, mcpAccount } from './auth/keychain.js';
+import { PERMISSION_MODES } from './protocol/permissions.js';
+const program = new Command();
+function readPackageVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8'));
+        return String(pkg.version ?? '0.0.0');
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+program
+    .name('rivine')
+    .description('Rivine Code in your terminal — edits the files you already have open.')
+    .version(readPackageVersion());
+function resolveMode(options) {
+    if (options.bypass)
+        return 'bypass';
+    if (options.plan)
+        return 'plan';
+    const requested = options.mode;
+    if (requested && PERMISSION_MODES.includes(requested))
+        return requested;
+    return 'default';
+}
+program
+    .command('login', { isDefault: false })
+    .description('Sign in to Beunec')
+    .option('--device', 'use a device code instead of a browser redirect (headless machines)')
+    .action(async (options) => {
+    try {
+        await login({
+            device: options.device,
+            onUrl: (url) => {
+                console.log('\n  Opening your browser to sign in.');
+                console.log(`  If it did not open, visit:\n    ${url}\n`);
+            },
+            onDeviceCode: (code, url) => {
+                console.log(`\n  Visit ${url}`);
+                console.log(`  and enter the code:  ${code}\n`);
+            },
+            onNoRefreshToken: (hours) => {
+                console.log(`  Note: this session cannot renew itself and ends in ~${hours}h.\n` +
+                    `  (This deployment does not issue refresh tokens.)\n`);
+            },
+        });
+        console.log('  Signed in. Run `rivine` in a project to start.\n');
+    }
+    catch (err) {
+        console.error(`\n  ${err.message}\n`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('logout')
+    .description('Remove stored credentials from this machine')
+    .action(async () => {
+    await logout();
+    console.log('  Signed out.\n');
+});
+program
+    .command('status')
+    .description('Show sign-in state and where this client points')
+    .action(async () => {
+    const state = await status();
+    const where = state.storage === 'environment'
+        ? 'RIVINE_TOKEN environment variable'
+        : state.storage === 'keychain'
+            ? 'your OS keychain'
+            : '~/.rivine/credentials.json (file, mode 600)';
+    console.log('');
+    console.log(`  Signed in:  ${state.signedIn ? 'yes' : 'no'}`);
+    console.log(`  Stored in:  ${where}`);
+    if (state.expiresAt) {
+        const minutes = Math.round((state.expiresAt - Date.now()) / 60000);
+        const life = minutes > 0
+            ? `valid for ${minutes} min`
+            : state.canRenew
+                ? 'expired (renews on next use)'
+                : 'expired — run `rivine login`';
+        console.log(`  Token:      ${life}`);
+        console.log(`  Renews:     ${state.canRenew ? 'yes' : 'no — sign in again when it expires'}`);
+    }
+    console.log(`  API:        ${apiUrl()}`);
+    console.log(`  Site:       ${siteUrl()}`);
+    console.log('');
+});
+program
+    .command('credits')
+    .description('Open the credits page in your browser')
+    .action(() => {
+    const url = `${siteUrl()}/credits`;
+    openBrowser(url);
+    console.log(`  Opened ${url}\n`);
+});
+const mcp = program.command('mcp').description('manage MCP servers this terminal hosts');
+mcp
+    .command('add <name> [commandAndArgs...]')
+    .description('add an MCP server (stdio by default, or --transport http|sse with --url)')
+    .option('-t, --transport <kind>', 'stdio | http | sse', 'stdio')
+    .option('-u, --url <url>', 'endpoint for http/sse transports')
+    .option('-e, --env <KEY=VALUE...>', 'environment for a stdio server; use $VAR to reference, never a literal secret', collect, [])
+    .option('--token-env <VAR>', 'name of the env var holding a bearer token (http/sse)')
+    .option('--user', 'save to ~/.rivine/mcp.json instead of this project')
+    .action(async (name, commandAndArgs, options) => {
+    const scope = options.user ? 'user' : 'project';
+    const transport = String(options.transport);
+    const config = { transport: transport };
+    if (transport === 'stdio') {
+        if (commandAndArgs.length === 0) {
+            console.error('\n  A stdio server needs a command, e.g.\n    rivine mcp add playwright npx @playwright/mcp@latest\n');
+            process.exitCode = 1;
+            return;
+        }
+        config.command = commandAndArgs[0];
+        config.args = commandAndArgs.slice(1);
+        const env = {};
+        for (const pair of options.env) {
+            const at = pair.indexOf('=');
+            if (at > 0)
+                env[pair.slice(0, at)] = pair.slice(at + 1);
+        }
+        if (Object.keys(env).length)
+            config.env = env;
+    }
+    else {
+        if (!options.url) {
+            console.error(`\n  A ${transport} server needs --url.\n`);
+            process.exitCode = 1;
+            return;
+        }
+        config.url = String(options.url);
+        if (options.tokenEnv)
+            config.bearerTokenEnvVar = String(options.tokenEnv);
+    }
+    const path = await saveServer(scope, process.cwd(), name, config);
+    console.log(`\n  Added "${name}" to ${path}`);
+    console.log(`  Check it works:  rivine mcp test\n`);
+});
+mcp
+    .command('list')
+    .description('show configured servers and where they came from')
+    .action(async () => {
+    const servers = await loadServers(process.cwd());
+    if (servers.length === 0) {
+        console.log('\n  No MCP servers configured.');
+        console.log('  Add one:  rivine mcp add playwright npx @playwright/mcp@latest\n');
+        return;
+    }
+    console.log('');
+    for (const s of servers) {
+        console.log(`  ${s.name.padEnd(18)} ${s.transport.padEnd(6)} ${s.scope.padEnd(8)} ${describeServer(s)}`);
+    }
+    console.log('');
+});
+mcp
+    .command('remove <name>')
+    .description('remove a server')
+    .option('--user', 'remove from ~/.rivine/mcp.json instead of this project')
+    .action(async (name, options) => {
+    const scope = options.user ? 'user' : 'project';
+    const removed = await removeServer(scope, process.cwd(), name);
+    console.log(removed ? `\n  Removed "${name}".\n` : `\n  No ${scope} server named "${name}".\n`);
+});
+mcp
+    .command('test')
+    .description('connect to every server and list the tools it offers')
+    .action(async () => {
+    const manager = new McpManager();
+    console.log('\n  Connecting…\n');
+    const reports = await manager.connectAll(process.cwd());
+    if (reports.length === 0) {
+        console.log('  No MCP servers configured.\n');
+        return;
+    }
+    for (const r of reports) {
+        const mark = r.ok ? 'ok  ' : 'FAIL';
+        console.log(`  ${mark} ${r.name.padEnd(18)} ${r.ok ? `${r.toolCount} tool(s)` : r.error}`);
+    }
+    const tools = manager.listTools();
+    if (tools.length) {
+        console.log('\n  Tools Rivine will be offered:');
+        for (const t of tools.slice(0, 40)) {
+            console.log(`    ${t.name}`);
+        }
+        if (tools.length > 40)
+            console.log(`    …and ${tools.length - 40} more`);
+    }
+    console.log('');
+    await manager.closeAll();
+});
+mcp
+    .command('login <name>')
+    .description('sign in to a remote MCP server in your browser')
+    .action(async (name) => {
+    const servers = await loadServers(process.cwd());
+    const server = servers.find((s) => s.name === name);
+    if (!server) {
+        console.error(`\n  No MCP server named "${name}". Run: rivine mcp list\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (server.transport === 'stdio' || !server.url) {
+        console.error(`\n  ${name} is a local (stdio) server — it runs as your own user and needs no sign-in.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        await loginToServer(name, server.url, (url) => {
+            console.log(`\n  If your browser did not open:\n  ${url}\n`);
+        });
+        console.log(`  Signed in to ${name}. The token is in your keychain, not in any config file.\n`);
+    }
+    catch (err) {
+        console.error(`\n  ${err.message}\n`);
+        process.exitCode = 1;
+    }
+});
+mcp
+    .command('logout <name>')
+    .description('forget the stored credentials for a remote MCP server')
+    .action(async (name) => {
+    await clearSession(mcpAccount(name));
+    console.log(`\n  Forgot the stored credentials for ${name}.\n`);
+});
+function collect(value, previous) {
+    return [...previous, value];
+}
+program
+    .argument('[prompt...]', 'send one prompt and exit')
+    .option('-p, --print <prompt>', 'send one prompt, print the answer, and exit')
+    .option('-m, --mode <mode>', `permission mode: ${PERMISSION_MODES.join(' | ')}`)
+    .option('--plan', 'start in plan mode (reads only)')
+    .option('--bypass', 'never ask for approval — for CI only, on a machine you are willing to have changed')
+    .option('-C, --cwd <dir>', 'run against a different directory')
+    .option('--output-format <format>', 'text | json — json puts one object on stdout and everything else on stderr', 'text')
+    .action(async (prompt, options) => {
+    const cwd = options.cwd ? resolvePath(options.cwd) : process.cwd();
+    const oneShot = options.print ?? (prompt.length ? prompt.join(' ') : undefined);
+    const mode = resolveMode(options);
+    const format = options.outputFormat === 'json' ? 'json' : 'text';
+    if (!isInteractiveTerminal()) {
+        if (!oneShot) {
+            console.error('\n  No interactive terminal detected.\n' +
+                '  Pass a prompt to run once: rivine -p "add tests for auth.ts"\n');
+            process.exitCode = 2;
+            return;
+        }
+        process.exitCode = await runHeadless({ cwd, mode, prompt: oneShot, format });
+        return;
+    }
+    if (format === 'json' && oneShot) {
+        process.exitCode = await runHeadless({ cwd, mode, prompt: oneShot, format });
+        return;
+    }
+    const { waitUntilExit } = render(React.createElement(App, {
+        cwd,
+        initialMode: mode,
+        oneShot,
+    }), { exitOnCtrlC: false });
+    const removeTeardown = installTeardown(() => { });
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        removeTeardown();
+    }
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error(`\n  ${err.message}\n`);
+    process.exitCode = 1;
+});

package/dist/mcp/config.js

@@ -0,0 +1,73 @@
+/*!
+ * 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 { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export const userConfigPath = () => join(homedir(), '.rivine', 'mcp.json');
+export const projectConfigPath = (root) => join(root, '.rivine', 'mcp.json');
+async function readConfig(path) {
+    const raw = await readFile(path, 'utf8').catch(() => null);
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`${path} is not valid JSON: ${err.message}`);
+    }
+}
+export async function loadServers(root) {
+    const [user, project] = await Promise.all([
+        readConfig(userConfigPath()),
+        readConfig(projectConfigPath(root)),
+    ]);
+    const merged = new Map();
+    for (const [name, config] of Object.entries(user.mcpServers ?? {})) {
+        merged.set(name, { ...config, name, scope: 'user' });
+    }
+    for (const [name, config] of Object.entries(project.mcpServers ?? {})) {
+        merged.set(name, { ...config, name, scope: 'project' });
+    }
+    return [...merged.values()].filter((s) => s.enabled !== false);
+}
+export async function saveServer(scope, root, name, config) {
+    const path = scope === 'user' ? userConfigPath() : projectConfigPath(root);
+    const existing = await readConfig(path);
+    const next = {
+        ...existing,
+        mcpServers: { ...(existing.mcpServers ?? {}), [name]: config },
+    };
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+    return path;
+}
+export async function removeServer(scope, root, name) {
+    const path = scope === 'user' ? userConfigPath() : projectConfigPath(root);
+    const existing = await readConfig(path);
+    if (!existing.mcpServers?.[name])
+        return false;
+    delete existing.mcpServers[name];
+    await writeFile(path, `${JSON.stringify(existing, null, 2)}\n`, 'utf8');
+    return true;
+}
+export function resolveEnv(env) {
+    const out = {};
+    for (const [key, value] of Object.entries(env ?? {})) {
+        out[key] = value.replace(/\$\{?([A-Z0-9_]+)\}?/gi, (_, name) => process.env[name] ?? '');
+    }
+    return out;
+}
+export function describeServer(server) {
+    if (server.transport === 'stdio') {
+        return `${server.command ?? '?'} ${(server.args ?? []).join(' ')}`.trim();
+    }
+    return server.url ?? '?';
+}

package/dist/mcp/manager.js

@@ -0,0 +1,154 @@
+/*!
+ * 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 { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { loadServers, resolveEnv } from './config.js';
+import { tokenFor } from './oauth.js';
+const CONNECT_TIMEOUT_MS = 20_000;
+const CALL_TIMEOUT_MS = 120_000;
+export function toolName(server, tool) {
+    return `mcp__${server}__${tool}`;
+}
+function parseToolName(qualified) {
+    const match = /^mcp__([^_]+(?:_[^_]+)*?)__(.+)$/.exec(qualified);
+    return match ? { server: match[1], tool: match[2] } : null;
+}
+export class McpManager {
+    clients = new Map();
+    tools = [];
+    reports = [];
+    async connectAll(root) {
+        let servers;
+        try {
+            servers = await loadServers(root);
+        }
+        catch (err) {
+            this.reports.push({ name: 'config', scope: '-', ok: false, toolCount: 0, error: err.message });
+            return this.reports;
+        }
+        await Promise.all(servers.map((server) => this.connectOne(server)));
+        return this.reports;
+    }
+    async connectOne(server) {
+        const client = new Client({ name: 'rivine-cli', version: '1.0.0' }, { capabilities: {} });
+        try {
+            const transport = await this.buildTransport(server);
+            await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, 'connect');
+            const listed = await withTimeout(client.listTools(), CONNECT_TIMEOUT_MS, 'listTools');
+            for (const tool of listed.tools ?? []) {
+                this.tools.push({
+                    name: toolName(server.name, tool.name),
+                    description: String(tool.description ?? tool.name).slice(0, 1024),
+                    input_schema: tool.inputSchema ?? {
+                        type: 'object',
+                        properties: {},
+                    },
+                    server: server.name,
+                });
+            }
+            this.clients.set(server.name, client);
+            this.reports.push({
+                name: server.name,
+                scope: server.scope,
+                ok: true,
+                toolCount: listed.tools?.length ?? 0,
+            });
+        }
+        catch (err) {
+            await client.close().catch(() => { });
+            this.reports.push({
+                name: server.name,
+                scope: server.scope,
+                ok: false,
+                toolCount: 0,
+                error: err.message,
+            });
+        }
+    }
+    async buildTransport(server) {
+        if (server.transport === 'stdio') {
+            if (!server.command)
+                throw new Error('stdio server has no `command`');
+            return new StdioClientTransport({
+                command: server.command,
+                args: server.args ?? [],
+                env: { ...process.env, ...resolveEnv(server.env) },
+            });
+        }
+        if (!server.url)
+            throw new Error(`${server.transport} server has no \`url\``);
+        const url = new URL(server.url);
+        const token = server.bearerTokenEnvVar
+            ? process.env[server.bearerTokenEnvVar]
+            : ((await tokenFor(server.name)) ?? undefined);
+        const requestInit = token ? { headers: { authorization: `Bearer ${token}` } } : undefined;
+        return server.transport === 'sse'
+            ? new SSEClientTransport(url, requestInit ? { requestInit } : undefined)
+            : new StreamableHTTPClientTransport(url, requestInit ? { requestInit } : undefined);
+    }
+    listTools() {
+        return [...this.tools];
+    }
+    getReports() {
+        return [...this.reports];
+    }
+    hasTool(qualified) {
+        return this.tools.some((t) => t.name === qualified);
+    }
+    async call(qualified, args) {
+        const parsed = parseToolName(qualified);
+        if (!parsed)
+            return `Error: ${qualified} is not an MCP tool name.`;
+        const client = this.clients.get(parsed.server);
+        if (!client)
+            return `Error: MCP server "${parsed.server}" is not connected.`;
+        try {
+            const result = await withTimeout(client.callTool({ name: parsed.tool, arguments: args }), CALL_TIMEOUT_MS, parsed.tool);
+            return renderToolResult(result);
+        }
+        catch (err) {
+            return `Error calling ${qualified}: ${err.message}`;
+        }
+    }
+    async closeAll() {
+        await Promise.allSettled([...this.clients.values()].map((c) => c.close()));
+        this.clients.clear();
+    }
+}
+function renderToolResult(result) {
+    const content = result?.content;
+    if (!Array.isArray(content))
+        return JSON.stringify(result ?? {}).slice(0, 20_000);
+    const parts = [];
+    for (const item of content) {
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string')
+            parts.push(block.text);
+        else if (block.type === 'image')
+            parts.push(`[image: ${block.mimeType ?? 'unknown'}]`);
+        else if (block.type === 'resource')
+            parts.push(`[resource: ${JSON.stringify(block.resource).slice(0, 500)}]`);
+        else
+            parts.push(JSON.stringify(block).slice(0, 2000));
+    }
+    const text = parts.join('\n').trim();
+    return text.length > 40_000
+        ? `${text.slice(0, 40_000)}\n…[${text.length - 40_000} more characters]`
+        : text || '(empty result)';
+}
+function withTimeout(promise, ms, what) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`${what} timed out after ${ms / 1000}s`)), ms).unref?.()),
+    ]);
+}