openvibe-desktop 1.2.0

package/dist/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { getInstallDir, checkForUpdate, downloadAndVerify } from './updater.js';
+const VERSION_FILE = join(getInstallDir(), '.version');
+const CACHE_FILE = join(getInstallDir(), '.cache.json');
+async function readCache() {
+    try {
+        const data = await readFile(CACHE_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(data) {
+    await mkdir(getInstallDir(), { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(data, null, 2));
+}
+async function getOrDownloadBinary() {
+    // Check cache first
+    const cache = await readCache();
+    if (cache && existsSync(cache.binaryPath)) {
+        return cache.binaryPath;
+    }
+    // Check version file
+    let currentVersion = '';
+    try {
+        currentVersion = (await readFile(VERSION_FILE, 'utf-8')).trim();
+    }
+    catch {
+        currentVersion = '';
+    }
+    const info = await checkForUpdate(VERSION_FILE);
+    if (!info) {
+        throw new Error('failed to fetch latest release info');
+    }
+    const binaryPath = await downloadAndVerify(info);
+    await writeCache({ version: info.version, binaryPath });
+    return binaryPath;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--version') || args.includes('-v')) {
+        const cache = await readCache();
+        console.log(cache?.version || 'unknown');
+        process.exit(0);
+    }
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`OpenVibe Desktop — open-source agentic coding environment
+
+Usage:
+  openvibe [options]
+
+Options:
+  --version, -v   Show version
+  --help, -h      Show this help
+  --update        Force update check`);
+        process.exit(0);
+    }
+    if (args.includes('--update')) {
+        console.log('Checking for updates...');
+        const info = await checkForUpdate(VERSION_FILE);
+        if (!info) {
+            console.log('No update available or failed to check');
+            process.exit(1);
+        }
+        const cache = await readCache();
+        if (cache?.version === info.version) {
+            console.log(`Already up-to-date (v${info.version})`);
+            process.exit(0);
+        }
+        console.log(`Updating to v${info.version}...`);
+        const binaryPath = await downloadAndVerify(info);
+        console.log(`Updated to v${info.version}`);
+        process.exit(0);
+    }
+    try {
+        const binaryPath = await getOrDownloadBinary();
+        const child = spawn(binaryPath, args, {
+            stdio: 'inherit',
+            env: { ...process.env },
+        });
+        child.on('exit', (code) => {
+            process.exit(code ?? 0);
+        });
+        child.on('error', (err) => {
+            console.error(`Failed to launch OpenVibe: ${err.message}`);
+            process.exit(1);
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+main();

package/dist/updater.js

@@ -0,0 +1,217 @@
+import { createHash } from 'node:crypto';
+import { writeFile, mkdir, unlink } from 'node:fs/promises';
+import { existsSync, createReadStream } from 'node:fs';
+import { join } from 'node:path';
+import { get } from 'node:https';
+import { request as httpGet } from 'node:http';
+import { exec as execCb } from 'node:child_process';
+const GITHUB_REPO = 'nihmadev/OpenVibe';
+const API_BASE = process.env.OPENVIBE_API_URL || `https://api.github.com/repos/${GITHUB_REPO}`;
+export function getPlatform() {
+    const archMap = {
+        x64: 'x64',
+        arm64: 'arm64',
+        ia32: 'x86',
+    };
+    const platformMap = {
+        linux: 'linux',
+        darwin: 'macos',
+        win32: 'windows',
+    };
+    const platform = platformMap[process.platform];
+    const arch = archMap[process.arch];
+    if (!platform)
+        throw new Error(`unsupported platform: ${process.platform}`);
+    if (!arch)
+        throw new Error(`unsupported arch: ${process.arch}`);
+    return { platform, arch };
+}
+export function getInstallDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return join(home, '.openvibe');
+}
+export function getBinDir() {
+    return join(getInstallDir(), 'bin');
+}
+export function getVersionDir(version) {
+    return join(getInstallDir(), 'versions', version);
+}
+function fetchJSON(url) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? get : httpGet;
+        const req = protocol(url, { headers: { 'Accept': 'application/json', 'User-Agent': 'openvibe-desktop' } }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch (e) {
+                        reject(new Error(`invalid JSON: ${data.slice(0, 200)}`));
+                    }
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? get : httpGet;
+        const req = protocol(url, { headers: { 'User-Agent': 'openvibe-desktop' } }, async (res) => {
+            if (!res.statusCode || res.statusCode >= 300) {
+                reject(new Error(`download failed: HTTP ${res.statusCode}`));
+                return;
+            }
+            const chunks = [];
+            for await (const chunk of res)
+                chunks.push(chunk);
+            await mkdir(join(dest, '..'), { recursive: true });
+            await writeFile(dest, Buffer.concat(chunks));
+            resolve();
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+export async function checkForUpdate(versionFile) {
+    const { platform, arch } = getPlatform();
+    try {
+        const baseURL = API_BASE.replace(/\/+$/, '');
+        const url = `${baseURL}/releases/latest`;
+        // Try the Go API first
+        if (!process.env.OPENVIBE_API_URL && baseURL.includes('api.github.com')) {
+            return await checkViaGitHub(platform, arch);
+        }
+        const data = await fetchJSON(`${baseURL}/updates/latest?platform=${platform}&arch=${arch}`);
+        return data;
+    }
+    catch {
+        // Fallback to GitHub API
+        return await checkViaGitHub(platform, arch);
+    }
+}
+async function checkViaGitHub(platform, arch) {
+    const data = await fetchJSON(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`);
+    const version = data.tag_name.replace(/^v/, '');
+    const extMap = {
+        linux: '.AppImage',
+        macos: '.dmg',
+        windows: '.exe',
+    };
+    const ext = extMap[platform];
+    if (!ext)
+        return null;
+    const asset = data.assets.find(a => a.name.endsWith(ext) && a.name.includes(platform));
+    if (!asset)
+        return null;
+    return {
+        version,
+        releaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${data.tag_name}`,
+        platform,
+        arch,
+        url: asset.browser_download_url,
+    };
+}
+export async function downloadAndVerify(info) {
+    const versionDir = getVersionDir(info.version);
+    const binDir = getBinDir();
+    await mkdir(versionDir, { recursive: true });
+    await mkdir(binDir, { recursive: true });
+    const fileName = info.url.split('/').pop() || `openvibe-${info.platform}-${info.arch}`;
+    const filePath = join(versionDir, fileName);
+    if (existsSync(filePath)) {
+        if (info.sha256) {
+            const hash = await sha256File(filePath);
+            if (hash === info.sha256) {
+                return makeExecutableAndLink(filePath, binDir, info);
+            }
+        }
+        else {
+            return makeExecutableAndLink(filePath, binDir, info);
+        }
+    }
+    console.log(`Downloading OpenVibe ${info.version} (${info.platform}-${info.arch})...`);
+    await downloadFile(info.url, filePath);
+    if (info.sha256) {
+        const hash = await sha256File(filePath);
+        if (hash !== info.sha256) {
+            await unlink(filePath);
+            throw new Error(`SHA256 mismatch: expected ${info.sha256}, got ${hash}`);
+        }
+        console.log('SHA256 verified');
+    }
+    return makeExecutableAndLink(filePath, binDir, info);
+}
+async function makeExecutableAndLink(filePath, binDir, info) {
+    // Get the actual binary path (for dmg we need to extract)
+    const { platform } = info;
+    if (platform === 'linux') {
+        await exec(`chmod +x "${filePath}"`);
+        const link = join(binDir, 'openvibe');
+        await writeFile(link.replace(/openvibe$/, '.version'), info.version);
+        // Symlink the binary
+        try {
+            await unlink(link);
+        }
+        catch { /* ignore */ }
+        await exec(`ln -sf "${filePath}" "${link}"`);
+        return link;
+    }
+    if (platform === 'macos') {
+        // Mount dmg, copy .app, detach
+        const mountPoint = `/tmp/openvibe-mount-${Date.now()}`;
+        await exec(`mkdir -p "${mountPoint}"`);
+        await exec(`hdiutil attach "${filePath}" -mountpoint "${mountPoint}" -nobrowse -quiet`);
+        const appPath = join(binDir, 'OpenVibe.app');
+        if (existsSync(appPath)) {
+            await exec(`rm -rf "${appPath}"`);
+        }
+        // Find .app in mounted volume
+        const { stdout } = await exec(`find "${mountPoint}" -name "*.app" -maxdepth 2 -type d | head -1`);
+        const srcApp = stdout.trim();
+        if (srcApp) {
+            await exec(`cp -R "${srcApp}" "${appPath}"`);
+        }
+        await exec(`hdiutil detach "${mountPoint}" -quiet -force`);
+        await exec(`rm -rf "${mountPoint}"`);
+        await writeFile(join(binDir, '.version'), info.version);
+        return join(appPath, 'Contents/MacOS/openvibe');
+    }
+    if (platform === 'windows') {
+        const link = join(binDir, 'openvibe.exe');
+        await writeFile(link.replace(/openvibe\.exe$/, '.version'), info.version);
+        // For exe installer, just symlink
+        try {
+            await unlink(link);
+        }
+        catch { /* ignore */ }
+        await exec(`mklink "${link}" "${filePath}"`, true);
+        return link;
+    }
+    return filePath;
+}
+function sha256File(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filePath);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(hash.digest('hex')));
+        stream.on('error', reject);
+    });
+}
+function exec(cmd, ignoreError = false) {
+    return new Promise((resolve, reject) => {
+        execCb(cmd, (err, stdout, stderr) => {
+            if (err && !ignoreError)
+                reject(err);
+            else
+                resolve({ stdout, stderr });
+        });
+    });
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "openvibe-desktop",
+  "version": "1.2.0",
+  "description": "OpenVibe Desktop — open-source agentic coding environment. Bring your own AI model.",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "mt-studio <lolz@nihmadev.fun>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nihmadev/OpenVibe"
+  },
+  "type": "module",
+  "bin": {
+    "openvibe": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "openvibe",
+    "ai",
+    "coding",
+    "agent",
+    "desktop",
+    "tauri"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}