flare-md 0.2.2

package/README.md

@@ -0,0 +1,88 @@
+# Flare
+
+Fast, themeable markdown viewer. Opens `.md` files in a native window with syntax highlighting, a table of contents sidebar, and live reload.
+
+Built with [Tauri v2](https://v2.tauri.app/) and Rust.
+
+## Install
+
+### Installer (Windows)
+
+Download the latest `.msi` or `.exe` installer from [Releases](https://github.com/GBX-Group/flare/releases).
+
+### npm
+
+```bash
+npm install -g github:GBX-Group/flare
+```
+
+Requires read access to the repo. Downloads a pre-built binary automatically.
+
+### Build from source
+
+Requires [Rust](https://rustup.rs/) and the [Tauri prerequisites](https://v2.tauri.app/start/prerequisites/).
+
+```bash
+git clone https://github.com/GBX-Group/flare.git
+cd flare/src-tauri
+cargo build --release
+```
+
+Binary output: `src-tauri/target/release/flare.exe`
+
+## Usage
+
+```
+flare <FILE> [--theme <THEME>]
+```
+
+```bash
+flare README.md
+flare docs/SPEC.md --theme github-light
+```
+
+## Themes
+
+Three built-in themes, switchable from the dropdown in the sidebar:
+
+| Theme | Description |
+|-------|-------------|
+| `github-dark` | GitHub dark mode (default) |
+| `github-light` | GitHub light mode |
+| `tokyo-night` | Tokyo Night color scheme |
+
+Theme selection persists across sessions via localStorage.
+
+## Features
+
+- **Native window** - lightweight Tauri/WebView2 app, not a browser tab
+- **Table of contents** - auto-generated sidebar from headings
+- **Live reload** - file watcher updates the view on save
+- **Theme switching** - three themes, switchable at runtime
+- **Syntax highlighting** - fenced code blocks with language classes
+- **Small binary** - ~3 MB installer
+
+## Project Structure
+
+```
+flare/
+├── src-tauri/           # Tauri + Rust application
+│   ├── src/
+│   │   ├── main.rs      # CLI entry point (clap)
+│   │   ├── lib.rs       # Tauri setup, HTML gen, file watcher
+│   │   ├── markdown.rs  # Markdown-to-HTML renderer (pulldown-cmark)
+│   │   ├── themes.rs    # Embedded CSS themes
+│   │   └── toc.rs       # Table of contents generator
+│   ├── icons/           # App icons (all sizes)
+│   ├── Cargo.toml       # Rust dependencies
+│   └── tauri.conf.json  # Tauri configuration
+├── bin/                 # Node shim for npm install
+├── scripts/             # npm postinstall (binary download)
+├── docs/                # Spec and design docs
+├── package.json         # npm package config
+└── README.md
+```
+
+## License
+
+Unlicensed. Internal use.

package/bin/flare

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+const { spawn } = require("child_process");
+const path = require("path");
+
+const ext = process.platform === "win32" ? ".exe" : "";
+const binary = path.join(__dirname, `flare${ext}`);
+
+const child = spawn(binary, process.argv.slice(2), {
+  detached: true,
+  stdio: "ignore",
+});
+
+child.on("error", (err) => {
+  console.error("flare: failed to launch:", err.message);
+  process.exit(1);
+});
+
+child.unref();

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "flare-md",
+  "version": "0.2.2",
+  "description": "Fast, themeable markdown viewer",
+  "repository": "github:GBX-Group/flare",
+  "license": "UNLICENSED",
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "bin": {
+    "flare": "bin/flare"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,108 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const VERSION = "0.2.2";
+const REPO = "GBX-Group/flare";
+const BIN_DIR = path.join(__dirname, "..", "bin");
+
+const PLATFORM_MAP = {
+  "win32-x64": `Flare_${VERSION}_x64-setup.exe`,
+};
+
+// For now we only support Windows x64 (GBX standard)
+// The installer approach doesn't work well for npm - just download the raw exe
+const BINARY_NAME = process.platform === "win32" ? "flare.exe" : "flare";
+const BINARY_PATH = path.join(BIN_DIR, BINARY_NAME);
+
+function getDownloadUrl() {
+  // Download the raw exe from the release, not the installer
+  return `https://github.com/${REPO}/releases/download/v${VERSION}/flare-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const follow = (url) => {
+      https
+        .get(url, { headers: { "User-Agent": "flare-installer" } }, (res) => {
+          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            follow(res.headers.location);
+            return;
+          }
+          if (res.statusCode !== 200) {
+            reject(new Error(`Download failed: HTTP ${res.statusCode} from ${url}`));
+            return;
+          }
+          const file = fs.createWriteStream(dest);
+          res.pipe(file);
+          file.on("finish", () => {
+            file.close();
+            resolve();
+          });
+        })
+        .on("error", reject);
+    };
+    follow(url);
+  });
+}
+
+async function main() {
+  const assetName = `flare-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
+
+  if (!fs.existsSync(BIN_DIR)) {
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+  }
+
+  // Method 1: gh CLI (handles private repo auth)
+  try {
+    execSync("gh --version", { stdio: "ignore" });
+    console.log(`Flare: downloading binary via gh CLI...`);
+    execSync(
+      `gh release download v${VERSION} --repo ${REPO} --pattern "${assetName}" --output "${BINARY_PATH}" --clobber`,
+      { stdio: "inherit" }
+    );
+    if (process.platform !== "win32") {
+      fs.chmodSync(BINARY_PATH, 0o755);
+    }
+    console.log("Flare: installed successfully!");
+    return;
+  } catch (err) {
+    console.log("Flare: gh CLI download failed, trying direct HTTPS...");
+  }
+
+  // Method 2: Direct HTTPS (works for public repos)
+  try {
+    const releaseUrl = getDownloadUrl();
+    console.log(`Flare: downloading binary for ${process.platform}-${process.arch}...`);
+    await download(releaseUrl, BINARY_PATH);
+    if (process.platform !== "win32") {
+      fs.chmodSync(BINARY_PATH, 0o755);
+    }
+    console.log("Flare: installed successfully!");
+    return;
+  } catch (err) {
+    console.log(`Flare: HTTPS download failed (${err.message})`);
+    console.log("Flare: attempting to build from source...");
+  }
+
+  // Method 3: Build from source
+  try {
+    execSync("cargo --version", { stdio: "ignore" });
+    console.log("Flare: building from source with cargo...");
+    const tauriSrc = path.join(__dirname, "..", "src-tauri");
+    execSync("cargo build --release", { cwd: tauriSrc, stdio: "inherit" });
+    const builtBinary = path.join(tauriSrc, "target", "release", BINARY_NAME);
+    fs.copyFileSync(builtBinary, BINARY_PATH);
+    if (process.platform !== "win32") {
+      fs.chmodSync(BINARY_PATH, 0o755);
+    }
+    console.log("Flare: built and installed successfully!");
+  } catch (e) {
+    console.error("Flare: could not install. Download manually from:");
+    console.error(`  https://github.com/${REPO}/releases/tag/v${VERSION}`);
+    process.exit(1);
+  }
+}
+
+main();