@andespindola/brainlink 1.0.5 → 1.0.6

package/dist/cli/commands/write/server-commands.js

@@ -0,0 +1,553 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { platform, tmpdir } from 'node:os';
+import { spawn, spawnSync } from 'node:child_process';
+import { startServer } from '../../../application/start-server.js';
+import { isBucketVaultPath } from '../../../infrastructure/file-system-vault.js';
+import { startRemoteMcpServer } from '../../../mcp/http-server.js';
+import { parsePositiveInteger, print, resolveOptions } from '../../runtime.js';
+const spawnDetached = (command, args, envOverrides) => {
+    try {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            env: envOverrides ? { ...process.env, ...envOverrides } : process.env
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const nativeGuiSwiftScriptPath = join(tmpdir(), 'brainlink-native-gui.swift');
+const nativeGuiPowershellScriptPath = join(tmpdir(), 'brainlink-native-gui.ps1');
+const nativeGuiLinuxScriptPath = join(tmpdir(), 'brainlink-native-gui-linux.py');
+const nativeGuiSwiftScript = `import Foundation
+import AppKit
+import WebKit
+import Darwin
+
+final class BrainlinkAppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
+  private let targetUrl: URL
+  private let parentPid: Int32
+  private var window: NSWindow?
+  private var webView: WKWebView?
+  private var monitorTimer: Timer?
+
+  init(targetUrl: URL, parentPid: Int32) {
+    self.targetUrl = targetUrl
+    self.parentPid = parentPid
+  }
+
+  func applicationDidFinishLaunching(_ notification: Notification) {
+    let window = NSWindow(
+      contentRect: NSRect(x: 0, y: 0, width: 1320, height: 860),
+      styleMask: [.titled, .closable, .miniaturizable, .resizable],
+      backing: .buffered,
+      defer: false
+    )
+    window.title = "Brainlink Graph"
+    window.center()
+    window.isReleasedWhenClosed = false
+    window.delegate = self
+
+    let webView = WKWebView(frame: window.contentView?.bounds ?? .zero)
+    webView.autoresizingMask = [.width, .height]
+    webView.allowsBackForwardNavigationGestures = true
+    webView.load(URLRequest(url: targetUrl))
+    window.contentView?.addSubview(webView)
+
+    self.window = window
+    self.webView = webView
+
+    if parentPid > 0 {
+      monitorTimer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
+        if kill(self.parentPid, 0) != 0 {
+          NSApp.terminate(nil)
+        }
+      }
+    }
+
+    window.makeKeyAndOrderFront(nil)
+    NSApp.activate(ignoringOtherApps: true)
+  }
+
+  func windowWillClose(_ notification: Notification) {
+    monitorTimer?.invalidate()
+    NSApp.terminate(nil)
+  }
+}
+
+let args = Array(CommandLine.arguments.dropFirst())
+let rawTarget = args.indices.contains(0) ? args[0] : "http://127.0.0.1:4321"
+let parentPid: Int32 = args.indices.contains(1) ? (Int32(args[1]) ?? 0) : 0
+
+guard let targetUrl = URL(string: rawTarget) else {
+  fputs("Invalid URL for Brainlink GUI: \\(rawTarget)\\n", stderr)
+  exit(1)
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.regular)
+let delegate = BrainlinkAppDelegate(targetUrl: targetUrl, parentPid: parentPid)
+app.delegate = delegate
+app.run()
+`;
+const nativeGuiPowershellScript = `param(
+  [string]$TargetUrl = "http://127.0.0.1:4321",
+  [int]$ParentPid = 0
+)
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+[System.Windows.Forms.Application]::EnableVisualStyles()
+
+$form = New-Object System.Windows.Forms.Form
+$form.Text = "Brainlink Graph"
+$form.Width = 1320
+$form.Height = 860
+$form.StartPosition = "CenterScreen"
+
+$browser = New-Object System.Windows.Forms.WebBrowser
+$browser.Dock = [System.Windows.Forms.DockStyle]::Fill
+$browser.ScriptErrorsSuppressed = $true
+$browser.Navigate($TargetUrl)
+
+$form.Controls.Add($browser)
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 1000
+$timer.Add_Tick({
+  if ($ParentPid -le 0) {
+    return
+  }
+  try {
+    Get-Process -Id $ParentPid -ErrorAction Stop | Out-Null
+  } catch {
+    $timer.Stop()
+    $form.Close()
+  }
+})
+$form.Add_FormClosed({
+  $timer.Stop()
+})
+$timer.Start()
+[void]$form.ShowDialog()
+`;
+const nativeGuiLinuxPythonScript = `#!/usr/bin/env python3
+import sys
+
+def run() -> int:
+    try:
+        import gi
+        gi.require_version("Gtk", "3.0")
+        try:
+            gi.require_version("WebKit2", "4.1")
+        except ValueError:
+            gi.require_version("WebKit2", "4.0")
+        from gi.repository import Gtk, WebKit2, GLib
+    except Exception:
+        return 1
+
+    target_url = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:4321"
+    parent_pid = int(sys.argv[2]) if len(sys.argv) > 2 else 0
+
+    window = Gtk.Window(title="Brainlink Graph")
+    window.set_default_size(1320, 860)
+    window.connect("destroy", Gtk.main_quit)
+
+    webview = WebKit2.WebView()
+    webview.load_uri(target_url)
+    window.add(webview)
+    window.show_all()
+
+    if parent_pid > 0:
+        def _watch_parent() -> bool:
+            try:
+                import os
+                os.kill(parent_pid, 0)
+            except Exception:
+                Gtk.main_quit()
+                return False
+            return True
+
+        GLib.timeout_add(1000, _watch_parent)
+
+    Gtk.main()
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(run())
+`;
+const commandExists = (command) => {
+    try {
+        const probe = platform() === 'win32'
+            ? spawnSync('where', [command], { stdio: 'ignore' })
+            : spawnSync('which', [command], { stdio: 'ignore' });
+        return probe.status === 0;
+    }
+    catch {
+        return false;
+    }
+};
+const readLinuxDefaultBrowserDesktopEntry = () => {
+    try {
+        const preferred = spawnSync('xdg-settings', ['get', 'default-web-browser'], { encoding: 'utf8' });
+        const rawPreferred = preferred.status === 0 ? preferred.stdout.trim() : '';
+        if (rawPreferred.length > 0) {
+            return rawPreferred;
+        }
+    }
+    catch {
+        // fallback below
+    }
+    try {
+        const fallback = spawnSync('xdg-mime', ['query', 'default', 'x-scheme-handler/https'], { encoding: 'utf8' });
+        const rawFallback = fallback.status === 0 ? fallback.stdout.trim() : '';
+        return rawFallback.length > 0 ? rawFallback : null;
+    }
+    catch {
+        return null;
+    }
+};
+const toLinuxDefaultBrowserCommands = (desktopEntry) => {
+    if (!desktopEntry) {
+        return [];
+    }
+    const normalized = desktopEntry.toLowerCase().trim();
+    if (normalized.includes('firefox')) {
+        return ['firefox'];
+    }
+    if (normalized.includes('edge')) {
+        return ['microsoft-edge', 'microsoft-edge-stable'];
+    }
+    if (normalized.includes('brave')) {
+        return ['brave-browser'];
+    }
+    if (normalized.includes('chromium')) {
+        return ['chromium', 'chromium-browser'];
+    }
+    if (normalized.includes('chrome')) {
+        return ['google-chrome', 'google-chrome-stable'];
+    }
+    return [];
+};
+const readBrowserEnvCommands = () => {
+    const value = process.env.BROWSER?.trim();
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(':')
+        .map((entry) => entry.trim().split(/\s+/)[0] ?? '')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+};
+const prioritizeLinuxBrowserCandidates = (candidates) => {
+    const preferredCommands = toLinuxDefaultBrowserCommands(readLinuxDefaultBrowserDesktopEntry());
+    if (preferredCommands.length === 0) {
+        return candidates;
+    }
+    const priorityMap = new Map(preferredCommands.map((command, index) => [command, index]));
+    return [...candidates].sort((left, right) => {
+        const leftPriority = priorityMap.get(left[0]);
+        const rightPriority = priorityMap.get(right[0]);
+        const leftScore = leftPriority == null ? Number.POSITIVE_INFINITY : leftPriority;
+        const rightScore = rightPriority == null ? Number.POSITIVE_INFINITY : rightPriority;
+        return leftScore - rightScore;
+    });
+};
+const envFlagEnabled = (name) => process.env[name] === '1' || process.env[name] === 'true';
+const spawnAnyDetached = (candidates) => candidates.some(([command, args]) => spawnDetached(command, args));
+const spawnAnyDetachedWithEnv = (candidates) => candidates.some(([command, args, env]) => spawnDetached(command, args, env));
+const windowsStartCandidates = (program, args = []) => [
+    ['cmd', ['/c', 'start', '', program, ...args]]
+];
+const resolveSwiftExecutable = () => {
+    const directSwift = '/usr/bin/swift';
+    if (existsSync(directSwift)) {
+        return directSwift;
+    }
+    try {
+        const probe = spawnSync('xcrun', ['--find', 'swift'], { encoding: 'utf8' });
+        const swiftPath = probe.status === 0 ? probe.stdout.trim() : '';
+        return swiftPath.length > 0 ? swiftPath : null;
+    }
+    catch {
+        return null;
+    }
+};
+const openGraphInMacNativeGui = (url, parentPid) => {
+    const swiftBinary = resolveSwiftExecutable();
+    if (!swiftBinary) {
+        return false;
+    }
+    try {
+        writeFileSync(nativeGuiSwiftScriptPath, nativeGuiSwiftScript, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    return spawnDetached(swiftBinary, [nativeGuiSwiftScriptPath, url, String(parentPid)]);
+};
+const resolveWindowsPowershellExecutable = () => {
+    if (commandExists('powershell')) {
+        return 'powershell';
+    }
+    if (commandExists('pwsh')) {
+        return 'pwsh';
+    }
+    return null;
+};
+const openGraphInWindowsNativeGui = (url, parentPid) => {
+    const powershell = resolveWindowsPowershellExecutable();
+    if (!powershell) {
+        return false;
+    }
+    try {
+        writeFileSync(nativeGuiPowershellScriptPath, nativeGuiPowershellScript, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    return spawnDetached(powershell, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-STA', '-File', nativeGuiPowershellScriptPath, url, String(parentPid)]);
+};
+const openGraphInLinuxNativeGui = (url, parentPid) => {
+    if (!commandExists('python3')) {
+        return false;
+    }
+    try {
+        writeFileSync(nativeGuiLinuxScriptPath, nativeGuiLinuxPythonScript, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    return spawnDetached('python3', [nativeGuiLinuxScriptPath, url, String(parentPid)]);
+};
+const openGraphInNativeGui = (url, parentPid) => {
+    if (platform() === 'darwin') {
+        return openGraphInMacNativeGui(url, parentPid);
+    }
+    if (platform() === 'win32') {
+        return openGraphInWindowsNativeGui(url, parentPid);
+    }
+    return openGraphInLinuxNativeGui(url, parentPid);
+};
+const openGraphInAppWindow = (url) => {
+    if (platform() === 'darwin') {
+        const macCandidates = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+        ]
+            .filter((candidate) => existsSync(candidate))
+            .map((binary) => ({ binary, args: [`--app=${url}`, '--new-window'] }));
+        for (const candidate of macCandidates) {
+            if (spawnDetached(candidate.binary, candidate.args)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (platform() === 'win32') {
+        const appArgument = `--app=${url}`;
+        return spawnAnyDetached([
+            ...windowsStartCandidates('msedge', [appArgument, '--new-window']),
+            ...windowsStartCandidates('chrome', [appArgument, '--new-window']),
+            ...windowsStartCandidates('chromium', [appArgument, '--new-window']),
+            ...windowsStartCandidates('brave', [appArgument, '--new-window'])
+        ]);
+    }
+    const appArgument = `--app=${url}`;
+    const linuxAppWindowEnabled = envFlagEnabled('BRAINLINK_LINUX_APP_WINDOW');
+    if (!linuxAppWindowEnabled) {
+        return false;
+    }
+    const linuxChromiumStableFlags = [
+        '--ozone-platform=x11',
+        '--ozone-platform-hint=x11',
+        '--disable-gpu',
+        '--disable-vulkan',
+        '--use-gl=swiftshader',
+        '--disable-features=Vulkan,VaapiVideoDecoder',
+        '--disable-background-networking'
+    ];
+    const linuxChromiumEnv = {
+        GDK_BACKEND: 'x11',
+        OZONE_PLATFORM: 'x11'
+    };
+    const linuxAppWindowCandidates = [
+        'microsoft-edge',
+        'microsoft-edge-stable',
+        'google-chrome',
+        'google-chrome-stable',
+        'chromium',
+        'chromium-browser',
+        'brave-browser'
+    ].filter((candidate) => commandExists(candidate));
+    return spawnAnyDetachedWithEnv(linuxAppWindowCandidates.map((command) => [
+        command,
+        [...linuxChromiumStableFlags, appArgument, '--new-window'],
+        linuxChromiumEnv
+    ]));
+};
+const openGraphInDetectedBrowser = (url) => {
+    if (platform() === 'win32') {
+        return spawnAnyDetached([
+            ...windowsStartCandidates('msedge', [url]),
+            ...windowsStartCandidates('chrome', [url]),
+            ...windowsStartCandidates('firefox', ['-new-window', url]),
+            ...windowsStartCandidates('chromium', [url]),
+            ...windowsStartCandidates('brave', [url])
+        ]);
+    }
+    const linuxChromiumStableFlags = [
+        '--ozone-platform=x11',
+        '--ozone-platform-hint=x11',
+        '--disable-gpu',
+        '--disable-vulkan',
+        '--use-gl=swiftshader',
+        '--disable-features=Vulkan,VaapiVideoDecoder',
+        '--disable-background-networking'
+    ];
+    const linuxChromiumEnv = {
+        GDK_BACKEND: 'x11',
+        OZONE_PLATFORM: 'x11'
+    };
+    const envBrowserCandidates = readBrowserEnvCommands()
+        .map((command) => command.includes('firefox')
+        ? [command, ['-new-window', url], undefined]
+        : [command, [url], undefined])
+        .filter(([command]) => commandExists(command));
+    if (envBrowserCandidates.length > 0 && spawnAnyDetachedWithEnv(envBrowserCandidates)) {
+        return true;
+    }
+    const linuxBrowserCandidates = [
+        ['firefox', ['-new-window', url], undefined],
+        ['microsoft-edge', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['microsoft-edge-stable', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['google-chrome', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['google-chrome-stable', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['brave-browser', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['chromium', [...linuxChromiumStableFlags, url], linuxChromiumEnv],
+        ['chromium-browser', [...linuxChromiumStableFlags, url], linuxChromiumEnv]
+    ];
+    const available = prioritizeLinuxBrowserCandidates(linuxBrowserCandidates.filter(([command]) => commandExists(command)));
+    return spawnAnyDetachedWithEnv(available);
+};
+const openUrlInUi = (url, parentPid) => {
+    const openDisabled = process.env.BRAINLINK_NO_BROWSER === '1' ||
+        process.env.BRAINLINK_NO_BROWSER === 'true' ||
+        process.env.CI === 'true';
+    if (openDisabled) {
+        return { opened: false, mode: 'none' };
+    }
+    const currentPlatform = platform();
+    const nativeGuiEnabled = !envFlagEnabled('BRAINLINK_NO_NATIVE_GUI') &&
+        (currentPlatform !== 'linux' || envFlagEnabled('BRAINLINK_LINUX_NATIVE_GUI') || envFlagEnabled('BRAINLINK_FORCE_NATIVE_GUI'));
+    if (nativeGuiEnabled && openGraphInNativeGui(url, parentPid)) {
+        return { opened: true, mode: 'native-gui' };
+    }
+    if (platform() === 'linux') {
+        if (spawnDetached('xdg-open', [url])) {
+            return { opened: true, mode: 'browser' };
+        }
+        if (openGraphInDetectedBrowser(url)) {
+            return { opened: true, mode: 'browser' };
+        }
+        if (openGraphInAppWindow(url)) {
+            return { opened: true, mode: 'app-window' };
+        }
+        return { opened: false, mode: 'none' };
+    }
+    if (openGraphInAppWindow(url)) {
+        return { opened: true, mode: 'app-window' };
+    }
+    try {
+        if (platform() === 'darwin') {
+            return { opened: spawnDetached('open', [url]), mode: 'browser' };
+        }
+        if (openGraphInDetectedBrowser(url)) {
+            return { opened: true, mode: 'browser' };
+        }
+        if (platform() === 'win32') {
+            return { opened: spawnDetached('cmd', ['/c', 'start', '', url]), mode: 'browser' };
+        }
+        return { opened: spawnDetached('xdg-open', [url]), mode: 'browser' };
+    }
+    catch {
+        return { opened: false, mode: 'none' };
+    }
+};
+export const registerServerCommands = (program) => {
+    program
+        .command('server')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('-h, --host <host>', 'server host', '127.0.0.1')
+        .option('-p, --port <port>', 'server port', '4321')
+        .option('--no-index', 'skip indexing before starting the server')
+        .option('--no-open', 'do not open the graph UI automatically')
+        .option('-w, --watch', 'watch markdown files and reindex on changes', true)
+        .option('--no-watch', 'disable markdown file watching')
+        .option('--json', 'print machine-readable JSON')
+        .description('start a local web UI for the knowledge graph')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const shouldWatch = options.watch !== false && !isBucketVaultPath(resolved.vault);
+        const server = await startServer({
+            vaultPath: resolved.vault,
+            host: options.host ?? resolved.config.host,
+            port: parsePositiveInteger(options.port ?? String(resolved.config.port), resolved.config.port),
+            shouldIndex: options.index,
+            shouldWatch
+        });
+        const openResult = options.open !== false ? openUrlInUi(server.url, process.pid) : { opened: false, mode: 'none' };
+        print(options.json, {
+            url: server.url,
+            watch: shouldWatch,
+            readonly: true,
+            openedUi: openResult.opened,
+            openMode: openResult.mode
+        }, () => `Brainlink graph server running at ${server.url} (${shouldWatch ? 'watching for changes' : 'watch disabled'})${openResult.opened
+            ? openResult.mode === 'native-gui'
+                ? ' (opened in native desktop GUI)'
+                : openResult.mode === 'app-window'
+                    ? ' (opened in dedicated app window)'
+                    : ' (opened in browser)'
+            : options.open === false
+                ? ' (auto-open disabled)'
+                : ''}`);
+    });
+    program
+        .command('mcp-server')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('-a, --agent <agent>', 'agent memory namespace')
+        .option('-h, --host <host>', 'remote MCP server host', '0.0.0.0')
+        .option('-p, --port <port>', 'remote MCP server port', '3333')
+        .option('--path <path>', 'remote MCP endpoint path', '/mcp')
+        .option('--token <token>', 'bearer token required for MCP requests')
+        .option('--no-index', 'skip indexing before starting the MCP server')
+        .option('--json', 'print machine-readable JSON')
+        .description('start a remote MCP server for centralized cluster access')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const token = options.token ?? process.env.BRAINLINK_MCP_TOKEN;
+        const server = await startRemoteMcpServer({
+            vaultPath: resolved.vault,
+            agent: resolved.agent,
+            host: options.host ?? '0.0.0.0',
+            port: parsePositiveInteger(options.port ?? '3333', 3333),
+            path: options.path ?? '/mcp',
+            token,
+            shouldIndex: options.index
+        });
+        print(options.json, {
+            url: server.url,
+            healthUrl: server.healthUrl,
+            readyUrl: server.readyUrl,
+            vault: resolved.vault,
+            agent: resolved.agent ?? '*',
+            auth: token === undefined ? 'disabled' : 'bearer'
+        }, () => `Brainlink remote MCP server running at ${server.url} (health: ${server.healthUrl}, readiness: ${server.readyUrl})`);
+    });
+};

package/dist/cli/commands/write/shared.js

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+export const resolveAddContent = (options) => {
+    if (options.content != null && options.content.trim().length > 0) {
+        return options.content;
+    }
+    if (options.contentFile == null || options.contentFile.trim().length === 0) {
+        throw new Error('Use --content or --content-file to provide note content.');
+    }
+    return readFileSync(options.contentFile, 'utf8');
+};
+export const parseScore = (value, fallback) => {
+    if (value == null) {
+        return fallback;
+    }
+    const parsed = Number.parseFloat(value);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new Error(`Invalid score value: ${value}. Expected a number between 0 and 1.`);
+    }
+    return parsed;
+};
+export const formatBytes = (bytes) => {
+    if (!Number.isFinite(bytes) || bytes == null) {
+        return 'n/a';
+    }
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value.toFixed(value >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+};