@praise166/vire 0.1.0

package/.env.example

@@ -0,0 +1,7 @@
+DATABASE_URL=postgres://postgres:password@localhost:5432/vire
+DISCORD_TOKEN=your.discord.token
+VIRE_STATUS_URL=https://your-worker.your-subdomain.workers.dev
+VIRE_DELETE_AFTER_SECONDS=8
+
+# Default is false. When false, Vire blocks watched high-risk commands in server channels.
+VIRE_ALLOW_SERVER_RISKY_COMMANDS=false

package/dist/vire.js

@@ -0,0 +1,562 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { spawn } from 'node:child_process';
+import { access, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { input, password, select } from '@inquirer/prompts';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import ora from 'ora';
+import pg from 'pg';
+const { Client } = pg;
+process.on('warning', warning => {
+    if (warning.message.includes("The SSL modes 'prefer', 'require', and 'verify-ca'") ||
+        warning.code === 'DEP0190') {
+        return;
+    }
+    console.warn(warning);
+});
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const configDir = process.env.VIRE_HOME || join(process.env.APPDATA || process.env.HOME || root, 'vire');
+await mkdir(configDir, { recursive: true });
+await loadConfig();
+const sessionsFile = join(configDir, 'sessions.json');
+const localBuild = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+const bg = '#303030';
+const panelOptions = {
+    borderColor: 'gray',
+    borderStyle: 'round',
+    padding: 1,
+    backgroundColor: bg,
+};
+const state = {
+    user: 'pending',
+    requests: 0,
+    globalAll: process.env.VIRE_ALLOW_SERVER_RISKY_COMMANDS === 'true',
+    last: 'booting',
+};
+function banner() {
+    console.clear();
+    console.log(boxen([
+        `${chalk.hex('#f59e0b')('*')} ${chalk.bold.white('vire.self')}`,
+        '',
+        `${chalk.dim('please enter your credentials below')}`,
+    ].join('\n'), panelOptions));
+    console.log(' /\\_/\\');
+    console.log('( o.o )', chalk.dim('.gg/vire3'));
+    console.log(' > ^ <');
+    console.log();
+}
+function statusLine() {
+    const width = process.stdout.columns || 100;
+    const text = [
+        ' vire.self',
+        `user: ${state.user}`,
+        `requests: ${state.requests}`,
+        `global all: ${state.globalAll}`,
+        `last: ${state.last}`,
+    ].join(' | ');
+    console.log(chalk.bgHex(bg).white(text.padEnd(width)));
+}
+function notice(kind, body) {
+    if (kind === 'dm' && shouldHideDm(body)) {
+        return;
+    }
+    const color = kind === 'blocked' || kind === 'server-alert'
+        ? chalk.red
+        : kind === 'dm'
+            ? chalk.cyan
+            : kind === 'request'
+                ? chalk.green
+                : kind === 'global'
+                    ? chalk.yellow
+                    : chalk.white;
+    const label = kind === 'request' ? formatRequest(body) : body;
+    console.log(`${color('*')} ${chalk.bold(kind)} ${chalk.dim(label)}`);
+    state.last = `${kind}: ${body}`;
+}
+function shouldHideDm(body) {
+    const message = body.split(':').slice(1).join(':').trim();
+    return !message || message.startsWith(',');
+}
+function formatRequest(body) {
+    return body.replace(/\s+used\s+\((\d+)\s+total\)/, ' ($1)');
+}
+function handleBotLine(raw) {
+    const line = raw.trim();
+    if (!line)
+        return;
+    const event = line.match(/^\[vire:([^\]]+)\]\s*(.*)$/);
+    if (event) {
+        const [, kind, body = ''] = event;
+        if (kind === 'request') {
+            const count = body.match(/\((\d+) total\)/);
+            if (count)
+                state.requests = Number(count[1]);
+        }
+        if (kind === 'login') {
+            state.user = body.replace(/\s+is connected$/, '');
+        }
+        if (kind === 'global') {
+            state.globalAll = body.includes('unlocked');
+        }
+        notice(kind, body);
+        return;
+    }
+    if (line.startsWith('+---') ||
+        line.startsWith('user:') ||
+        line.startsWith('requests made:') ||
+        line.startsWith('notifications:') ||
+        line.startsWith('global all:')) {
+        return;
+    }
+    console.log(chalk.dim(line));
+}
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value?.trim()) {
+        throw new Error(`${name} is required in .env`);
+    }
+    return value;
+}
+async function loadConfig() {
+    const userEnv = join(configDir, '.env');
+    const projectEnv = join(root, '.env');
+    let userEnvExists = true;
+    await access(userEnv).catch(() => {
+        userEnvExists = false;
+    });
+    if (!userEnvExists) {
+        await copyFile(projectEnv, userEnv).catch(() => undefined);
+    }
+    dotenv.config({ path: userEnv, override: false });
+}
+async function remoteStatus() {
+    const url = statusUrl();
+    if (!url?.trim()) {
+        throw new Error('vire status url is not configured');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        const body = (await response.json().catch(() => ({})));
+        return {
+            online: response.ok && body.online !== false,
+            auth: response.ok && body.auth !== false,
+            status: String(body.status ?? response.status),
+            message: String(body.message ?? response.statusText),
+            build: body.build ? String(body.build) : undefined,
+            download_url: body.download_url ? String(body.download_url) : undefined,
+            database_url: body.database_url ? String(body.database_url) : undefined,
+            delete_after_seconds: body.delete_after_seconds
+                ? String(body.delete_after_seconds)
+                : undefined,
+            image_api_url: body.image_api_url ? String(body.image_api_url) : undefined,
+            telemetry: body.telemetry === true,
+        };
+    }
+    catch (error) {
+        return {
+            online: false,
+            auth: false,
+            status: 'unreachable',
+            message: error instanceof Error ? error.message : 'status check failed',
+            build: undefined,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function statusUrl() {
+    return process.env.VIRE_STATUS_URL || localBuild.vire?.statusUrl;
+}
+function telemetryUrl() {
+    const url = statusUrl();
+    if (!url?.trim())
+        return undefined;
+    const target = new URL(url);
+    target.pathname = '/telemetry';
+    target.search = '';
+    return target.toString();
+}
+function applyRemoteConfig(status) {
+    if (status.database_url && !process.env.DATABASE_URL) {
+        process.env.DATABASE_URL = status.database_url;
+    }
+    if (status.delete_after_seconds && !process.env.VIRE_DELETE_AFTER_SECONDS) {
+        process.env.VIRE_DELETE_AFTER_SECONDS = status.delete_after_seconds;
+    }
+    if (status.image_api_url && !process.env.VIRE_IMAGE_API_URL) {
+        process.env.VIRE_IMAGE_API_URL = status.image_api_url;
+    }
+    const telemetry = telemetryUrl();
+    if (telemetry && !process.env.VIRE_TELEMETRY_URL) {
+        process.env.VIRE_TELEMETRY_URL = telemetry;
+    }
+}
+async function checkForUpdate(status) {
+    const remoteBuild = status.build?.trim();
+    const currentBuild = localBuild.version ?? '0.0.0';
+    if (!status.download_url) {
+        if (remoteBuild && remoteBuild !== currentBuild) {
+            ora().warn(`new build ${remoteBuild} available, no download url set`);
+        }
+        return null;
+    }
+    if (!remoteBuild) {
+        return downloadRuntime(status.download_url, 'latest');
+    }
+    if (remoteBuild === currentBuild) {
+        const existing = await downloadedRuntimePath(remoteBuild);
+        if (existing)
+            return existing;
+        return downloadRuntime(status.download_url, remoteBuild);
+    }
+    return downloadRuntime(status.download_url, remoteBuild);
+}
+async function downloadRuntime(url, build) {
+    const existing = await downloadedRuntimePath(build);
+    if (existing)
+        return existing;
+    if (!url) {
+        return null;
+    }
+    const spinner = ora(`downloading runtime ${build}`).start();
+    const response = await fetch(url);
+    if (!response.ok) {
+        spinner.fail(`download failed (${response.status})`);
+        return null;
+    }
+    const fileName = runtimeFileName(url, build);
+    const updates = join(root, 'updates');
+    const target = join(updates, fileName);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    await mkdir(updates, { recursive: true });
+    await writeFile(target, bytes);
+    spinner.succeed(`downloaded runtime ${build}`);
+    return target;
+}
+function runtimeFileName(url, build) {
+    void url;
+    void build;
+    return process.platform === 'win32' ? 'vire.exe' : 'vire';
+}
+async function downloadedRuntimePath(build) {
+    const candidates = [
+        process.platform === 'win32' ? 'vire.exe' : 'vire',
+        process.platform === 'win32' ? `vire.self-${build}.exe` : `vire.self-${build}`,
+        process.platform === 'win32' ? 'vire.self.exe' : 'vire.self',
+    ];
+    for (const candidate of candidates) {
+        const path = join(root, 'updates', candidate);
+        let exists = true;
+        await access(path).catch(() => {
+            exists = false;
+        });
+        if (exists)
+            return path;
+    }
+    return null;
+}
+async function offlineScreen(status) {
+    const frames = ['(-.-) zzz', '(-_-) zz ', '(-.-) z  ', '(-_-) zz '];
+    for (let i = 0; i < 16; i += 1) {
+        console.clear();
+        console.log(boxen([
+            `${chalk.hex('#f59e0b')('*')} ${chalk.bold.white('vire.self')}`,
+            '',
+            `${chalk.dim('status:')} ${chalk.red(status.status)}`,
+            `${chalk.dim('message:')} ${status.message}`,
+            '',
+            ' /\\_/\\',
+            ` ${frames[i % frames.length]}`,
+            ' > ^ <',
+        ].join('\n'), { ...panelOptions, borderColor: 'red' }));
+        await new Promise(resolve => setTimeout(resolve, 220));
+    }
+    console.log(chalk.dim('bye bye...'));
+}
+async function postgresLogin() {
+    const databaseUrl = requireEnv('DATABASE_URL');
+    const username = await input({ message: 'username' });
+    const pass = await password({ message: 'password', mask: '*' });
+    const spinner = ora('checking postgres login').start();
+    const client = new Client({ connectionString: databaseUrl });
+    try {
+        await client.connect();
+        await client.query('create extension if not exists pgcrypto with schema public');
+        const result = await client.query('select id from vire_users where username = $1 and password_hash = public.crypt($2::text, password_hash)', [username, pass]);
+        if (result.rowCount !== 1) {
+            spinner.fail('login rejected');
+            throw new Error('invalid username or password');
+        }
+        spinner.succeed(`logged in as ${chalk.bold(username)}`);
+        return { username };
+    }
+    finally {
+        await client.end().catch(() => undefined);
+    }
+}
+async function discordToken() {
+    const sessions = await loadSessions();
+    if (sessions.length > 0) {
+        const choice = await select({
+            message: 'session',
+            choices: [
+                ...sessions.map(session => ({
+                    name: session.username,
+                    value: `resume:${session.id}`,
+                })),
+                { name: 'add token', value: 'add' },
+                { name: 'change token', value: 'change' },
+            ],
+        });
+        if (choice.startsWith('resume:')) {
+            const session = sessions.find(item => item.id === choice.slice('resume:'.length));
+            if (session)
+                return { token: session.token, save: false };
+        }
+        if (choice === 'change') {
+            const id = await select({
+                message: 'change',
+                choices: sessions.map(session => ({
+                    name: session.username,
+                    value: session.id,
+                })),
+            });
+            const token = await password({ message: 'discord token', mask: '*' });
+            await saveSessions(sessions.filter(session => session.id !== id));
+            return { token, save: true };
+        }
+    }
+    if (process.env.DISCORD_TOKEN?.trim()) {
+        return { token: process.env.DISCORD_TOKEN, save: true };
+    }
+    return {
+        token: await password({ message: 'discord token', mask: '*' }),
+        save: true,
+    };
+}
+async function verifyDiscordToken(token) {
+    const response = await fetch('https://discord.com/api/v10/users/@me', {
+        headers: {
+            authorization: token,
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(body || 'discord token was rejected');
+    }
+    const user = (await response.json());
+    const id = user.id ?? user.username ?? 'unknown';
+    const avatarUrl = user.avatar && user.id
+        ? `https://cdn.discordapp.com/avatars/${user.id}/${user.avatar}.png?size=128`
+        : undefined;
+    return {
+        avatarUrl,
+        id,
+        username: user.username ?? user.id ?? 'unknown',
+    };
+}
+async function sendTelemetry(event) {
+    const url = process.env.VIRE_TELEMETRY_URL;
+    if (!url)
+        return;
+    await fetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(event),
+    }).catch(() => undefined);
+}
+async function loadSessions() {
+    return readFile(sessionsFile, 'utf8')
+        .then(content => JSON.parse(content))
+        .catch(() => []);
+}
+async function saveSessions(sessions) {
+    await writeFile(sessionsFile, JSON.stringify(sessions, null, 2));
+}
+async function saveSession(token, user) {
+    const sessions = await loadSessions();
+    const next = sessions.filter(session => session.id !== user.id);
+    next.push({
+        id: user.id,
+        username: user.username,
+        token,
+        updated_at: new Date().toISOString(),
+    });
+    await saveSessions(next);
+}
+async function ensureReleaseBinary(downloadedRuntime) {
+    if (downloadedRuntime)
+        return downloadedRuntime;
+    const exe = process.platform === 'win32' ? 'vire.exe' : 'vire';
+    const binary = join(root, 'target', 'release', exe);
+    let exists = true;
+    await access(binary).catch(() => {
+        exists = false;
+    });
+    if (!exists) {
+        const updateBinary = await newestDownloadedRuntime();
+        if (updateBinary)
+            return updateBinary;
+    }
+    if (!exists) {
+        throw new Error('runtime missing; upload the exe to r2 or place it in updates');
+    }
+    if (process.env.VIRE_FORCE_BUILD === 'true') {
+        const spinner = ora('preparing runtime').start();
+        await run('cargo', ['build', '--release'], spinner);
+    }
+    return binary;
+}
+async function newestDownloadedRuntime() {
+    const candidates = ['vire.exe', 'vire'];
+    for (const candidate of candidates) {
+        const path = join(root, 'updates', candidate);
+        let exists = true;
+        await access(path).catch(() => {
+            exists = false;
+        });
+        if (exists)
+            return path;
+    }
+    return null;
+}
+function run(command, args, spinner) {
+    return new Promise((resolve, reject) => {
+        const [bin, binArgs] = commandForPlatform(command, args);
+        const child = spawn(bin, binArgs, {
+            cwd: root,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', chunk => {
+            stderr += chunk.toString();
+        });
+        child.on('error', error => {
+            spinner.fail(`${command} failed to start`);
+            reject(error);
+        });
+        child.on('exit', code => {
+            if (code === 0) {
+                spinner.succeed(spinner.text);
+                resolve();
+            }
+            else {
+                spinner.fail(`${command} exited with ${code}`);
+                reject(new Error(stderr.trim() || `${command} exited with ${code}`));
+            }
+        });
+    });
+}
+function commandForPlatform(command, args) {
+    if (process.platform !== 'win32') {
+        return [command, args];
+    }
+    return ['cmd.exe', ['/d', '/s', '/c', quoteCommand([command, ...args])]];
+}
+function quoteCommand(parts) {
+    return parts
+        .map(part => {
+        if (/^[a-zA-Z0-9_./:-]+$/.test(part)) {
+            return part;
+        }
+        return `"${part.replace(/"/g, '\\"')}"`;
+    })
+        .join(' ');
+}
+function startBot(binary, token, login) {
+    console.clear();
+    console.log(boxen([
+        `${chalk.bold.green('vire.self is starting')}`,
+        `${chalk.dim('user:')} ${login.username}`,
+        `${chalk.dim('requests:')} 0`,
+        `${chalk.dim('safety:')} use ,global all false to disable autonuke`,
+    ].join('\n'), { ...panelOptions, borderColor: 'cyan' }));
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, [], {
+            cwd: root,
+            shell: false,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                DISCORD_TOKEN: token,
+                VIRE_CLI_WRAPPED: 'true',
+                NO_COLOR: '1',
+            },
+        });
+        ora().succeed('vire.self is running');
+        let started = true;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', chunk => {
+            for (const line of chunk.split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                handleBotLine(line);
+            }
+        });
+        child.stderr.on('data', chunk => {
+            for (const line of chunk.split(/\r?\n/)) {
+                if (line.trim())
+                    console.error(chalk.red(line.trim()));
+            }
+        });
+        child.on('error', error => {
+            reject(error);
+        });
+        child.on('exit', code => {
+            if (!started) {
+                console.log(chalk.red(`vire.self exited before connecting (${code ?? 0})`));
+            }
+            else {
+                console.log(chalk.dim(`vire.self exited with code ${code ?? 0}`));
+            }
+            resolve();
+        });
+    });
+}
+async function main() {
+    banner();
+    try {
+        const status = await remoteStatus();
+        if (!status.online || !status.auth) {
+            await offlineScreen(status);
+            return;
+        }
+        applyRemoteConfig(status);
+        const runtime = await checkForUpdate(status);
+        const login = await postgresLogin();
+        const selection = await discordToken();
+        const discordUser = await verifyDiscordToken(selection.token);
+        state.user = discordUser.username;
+        if (selection.save) {
+            await saveSession(selection.token, discordUser);
+        }
+        await sendTelemetry({
+            type: 'login',
+            service_user: login.username,
+            discord_username: discordUser.username,
+            discord_id: discordUser.id,
+            avatar_url: discordUser.avatarUrl,
+        });
+        console.log(chalk.dim(`logged in as ${discordUser.username}`));
+        const binary = await ensureReleaseBinary(runtime);
+        await startBot(binary, selection.token, login);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`error: ${message}`));
+        process.exitCode = 1;
+    }
+}
+await main();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@praise166/vire",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "vire": "./dist/vire.js",
+    "vire.self": "./dist/vire.js"
+  },
+  "vire": {
+    "statusUrl": "https://vire-self-status.your-subdomain.workers.dev"
+  },
+  "scripts": {
+    "dev": "tsx cli/vire.ts",
+    "start": "tsx cli/vire.ts",
+    "build": "tsc -p tsconfig.json",
+    "global": "npm run build && node scripts/install-global.mjs",
+    "exe": "node scripts/build-exe.mjs",
+    "installer:exe": "cargo build --release --bin vire-installer",
+    "worker:dev": "wrangler dev",
+    "worker:deploy": "wrangler deploy"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.3.2",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "dotenv": "^16.4.7",
+    "ora": "^8.1.1",
+    "pg": "^8.13.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7",
+    "@types/pg": "^8.11.11",
+    "caxa": "^3.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "wrangler": "^4.18.0"
+  },
+  "pkg": {
+    "scripts": [
+      "dist/**/*.js"
+    ],
+    "assets": [
+      "target/release/vire.exe"
+    ]
+  }
+}