@fresh-editor/fresh-editor 0.1.32 → 0.1.42

package/CHANGELOG.md

@@ -1,6 +1,61 @@
 # Release Notes
 
-## 0.1.28 - Unreleased
+## 0.1.40
+
+### Features
+
+* **Switch Project Command**: New "Switch Project" command (renamed from "Open Folder") to change project root with full context switch. Sessions are automatically saved and restored when switching projects, preserving open files, cursor positions, and split layouts.
+
+* **Nested Submenu Support**: Menus now support nested submenus with proper arrow indicators and positioning.
+
+* **Select Keybinding Map Command**: New popup selector to choose between different keybinding schemes.
+
+* **Double-Click in File Dialog**: Can now double-click to open files in the file open dialog.
+
+* **File Explorer UX Improvements**:
+  - Ctrl+E now focuses the file explorer instead of toggling it
+  - File explorer automatically focuses when closing the last tab
+  - Menu checkboxes properly sync with file explorer visibility state
+
+* **Split Auto-Close**: Closing the last tab in a split now automatically closes the split.
+
+### Bug Fixes
+
+* **Mouse Click Below Last Line**: Fixed mouse click below the last line incorrectly jumping to position 0,0.
+
+* **Menu Checkbox Sync**: Fixed View menu checkboxes not syncing with file explorer visibility state.
+
+* **Duplicate Buffer on Project Switch**: Fixed duplicate buffer creation when switching projects.
+
+* **Wrong Upgrade Tip**: Fixed incorrect upgrade tip message (#293).
+
+### Infrastructure
+
+* **Build System Overhaul**: Replaced cargo-dist with direct cargo builds and custom packaging for more control over the release process.
+
+* **npm OIDC Publishing**: Improved npm publish workflow with OIDC trusted publishing and provenance attestations.
+
+* **GitHub Actions Updates**: Bumped actions/checkout to v6, actions/upload-artifact to v5, actions/download-artifact to v6, and actions/setup-node to v6.
+
+* **Test Improvements**: Many test reliability improvements including Windows compatibility fixes, flaky test fixes, and better test isolation for session persistence tests.
+
+---
+
+## 0.1.35
+
+### Features
+
+* **XDG Config Paths**: Support standard XDG config paths for user configuration. On macOS, `~/.config/fresh/config.json` is now prioritized if it exists, in addition to the system default path. (@Yousa-Mirage)
+
+### Packaging
+
+* **cargo-binstall**: Added cargo-binstall as an installation method in documentation. (@dvchd)
+
+* **npm OIDC Publishing**: Switched npm publish to OIDC trusted publishing with provenance attestations.
+
+---
+
+## 0.1.28
 
 ### Features
 

package/README.md

@@ -43,7 +43,9 @@ Fresh is engineered for speed. It delivers a low-latency experience, with text a
 | Fedora/RHEL | [.rpm](#fedorarhelopensuse-rpm) |
 | All platforms | [Pre-built binaries](#pre-built-binaries) |
 | npm | [npm / npx](#npm) |
+| Rust users (Fast) | [cargo-binstall](#using-cargo-binstall) |
 | Rust users | [crates.io](#from-cratesio) |
+| Nix | [Nix flakes](#nix-flakes) |
 | Developers | [From source](#from-source) |
 
 ### macOS (Homebrew)
@@ -95,6 +97,34 @@ Or try it without installing:
 npx @fresh-editor/fresh-editor
 ```
 
+### Using cargo-binstall
+
+To install the binary directly without compiling (much faster than crates.io):
+
+First, install cargo-binstall if you haven't already
+
+```bash
+cargo install cargo-binstall
+```
+
+Then install fresh
+
+```bash
+cargo binstall fresh-editor
+```
+
+### Nix flakes
+
+Run without installing:
+```bash
+nix run github:sinelaw/fresh
+```
+
+Or install to your profile:
+```bash
+nix profile install github:sinelaw/fresh
+```
+
 ### From crates.io
 
 ```bash

package/binary-install.js

@@ -1,212 +1,62 @@
-const { createWriteStream, existsSync, mkdirSync, mkdtemp } = require("fs");
-const { join, sep } = require("path");
-const { spawnSync } = require("child_process");
-const { tmpdir } = require("os");
-
-const axios = require("axios");
-const rimraf = require("rimraf");
-const tmpDir = tmpdir();
-
-const error = (msg) => {
-  console.error(msg);
-  process.exit(1);
-};
-
-class Package {
-  constructor(platform, name, url, filename, zipExt, binaries) {
-    let errors = [];
-    if (typeof url !== "string") {
-      errors.push("url must be a string");
-    } else {
-      try {
-        new URL(url);
-      } catch (e) {
-        errors.push(e);
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { getBinaryInfo } = require('./binary');
+
+const VERSION = require('./package.json').version;
+const REPO = 'sinelaw/fresh';
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        download(response.headers.location, dest).then(resolve).catch(reject);
+        return;
       }
-    }
-    if (name && typeof name !== "string") {
-      errors.push("package name must be a string");
-    }
-    if (!name) {
-      errors.push("You must specify the name of your package");
-    }
-    if (binaries && typeof binaries !== "object") {
-      errors.push("binaries must be a string => string map");
-    }
-    if (!binaries) {
-      errors.push("You must specify the binaries in the package");
-    }
-
-    if (errors.length > 0) {
-      let errorMsg =
-        "One or more of the parameters you passed to the Binary constructor are invalid:\n";
-      errors.forEach((error) => {
-        errorMsg += error;
-      });
-      errorMsg +=
-        '\n\nCorrect usage: new Package("my-binary", "https://example.com/binary/download.tar.gz", {"my-binary": "my-binary"})';
-      error(errorMsg);
-    }
-
-    this.platform = platform;
-    this.url = url;
-    this.name = name;
-    this.filename = filename;
-    this.zipExt = zipExt;
-    this.installDirectory = join(__dirname, "node_modules", ".bin_real");
-    this.binaries = binaries;
-
-    if (!existsSync(this.installDirectory)) {
-      mkdirSync(this.installDirectory, { recursive: true });
-    }
-  }
-
-  exists() {
-    for (const binaryName in this.binaries) {
-      const binRelPath = this.binaries[binaryName];
-      const binPath = join(this.installDirectory, binRelPath);
-      if (!existsSync(binPath)) {
-        return false;
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
       }
-    }
-    return true;
-  }
+      response.pipe(file);
+      file.on('finish', () => { file.close(); resolve(); });
+    }).on('error', reject);
+  });
+}
 
-  install(fetchOptions, suppressLogs = false) {
-    if (this.exists()) {
-      if (!suppressLogs) {
-        console.error(
-          `${this.name} is already installed, skipping installation.`,
-        );
+async function install() {
+  const info = getBinaryInfo();
+  const archiveName = `fresh-editor-${info.target}.${info.ext}`;
+  const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`;
+  const archivePath = path.join(__dirname, archiveName);
+  const binDir = path.join(__dirname, 'bin');
+
+  console.log(`Downloading ${url}...`);
+  await download(url, archivePath);
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  if (info.ext === 'tar.xz') {
+    execSync(`tar -xJf "${archivePath}" -C "${binDir}" --strip-components=1`, { stdio: 'inherit' });
+  } else if (info.ext === 'zip') {
+    if (process.platform === 'win32') {
+      execSync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${binDir}' -Force"`, { stdio: 'inherit' });
+      // Move files from nested directory
+      const nested = path.join(binDir, `fresh-editor-${info.target}`);
+      if (fs.existsSync(nested)) {
+        fs.readdirSync(nested).forEach(f => {
+          fs.renameSync(path.join(nested, f), path.join(binDir, f));
+        });
+        fs.rmdirSync(nested);
       }
-      return Promise.resolve();
-    }
-
-    if (existsSync(this.installDirectory)) {
-      rimraf.sync(this.installDirectory);
-    }
-
-    mkdirSync(this.installDirectory, { recursive: true });
-
-    if (!suppressLogs) {
-      console.error(`Downloading release from ${this.url}`);
+    } else {
+      execSync(`unzip -o "${archivePath}" -d "${binDir}"`, { stdio: 'inherit' });
     }
-
-    return axios({ ...fetchOptions, url: this.url, responseType: "stream" })
-      .then((res) => {
-        return new Promise((resolve, reject) => {
-          mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
-            let tempFile = join(directory, this.filename);
-            const sink = res.data.pipe(createWriteStream(tempFile));
-            sink.on("error", (err) => reject(err));
-            sink.on("close", () => {
-              if (/\.tar\.*/.test(this.zipExt)) {
-                const result = spawnSync("tar", [
-                  "xf",
-                  tempFile,
-                  // The tarballs are stored with a leading directory
-                  // component; we strip one component in the
-                  // shell installers too.
-                  "--strip-components",
-                  "1",
-                  "-C",
-                  this.installDirectory,
-                ]);
-                if (result.status == 0) {
-                  resolve();
-                } else if (result.error) {
-                  reject(result.error);
-                } else {
-                  reject(
-                    new Error(
-                      `An error occurred untarring the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
-                    ),
-                  );
-                }
-              } else if (this.zipExt == ".zip") {
-                let result;
-                if (this.platform.artifactName.includes("windows")) {
-                  // Windows does not have "unzip" by default on many installations, instead
-                  // we use Expand-Archive from powershell
-                  result = spawnSync("powershell.exe", [
-                    "-NoProfile",
-                    "-NonInteractive",
-                    "-Command",
-                    `& {
-                        param([string]$LiteralPath, [string]$DestinationPath)
-                        Expand-Archive -LiteralPath $LiteralPath -DestinationPath $DestinationPath -Force
-                    }`,
-                    tempFile,
-                    this.installDirectory,
-                  ]);
-                } else {
-                  result = spawnSync("unzip", [
-                    "-q",
-                    tempFile,
-                    "-d",
-                    this.installDirectory,
-                  ]);
-                }
-
-                if (result.status == 0) {
-                  resolve();
-                } else if (result.error) {
-                  reject(result.error);
-                } else {
-                  reject(
-                    new Error(
-                      `An error occurred unzipping the artifact: stdout: ${result.stdout}; stderr: ${result.stderr}`,
-                    ),
-                  );
-                }
-              } else {
-                reject(
-                  new Error(`Unrecognized file extension: ${this.zipExt}`),
-                );
-              }
-            });
-          });
-        });
-      })
-      .then(() => {
-        if (!suppressLogs) {
-          console.error(`${this.name} has been installed!`);
-        }
-      })
-      .catch((e) => {
-        error(`Error fetching release: ${e.message}`);
-      });
   }
 
-  run(binaryName, fetchOptions) {
-    const promise = !this.exists()
-      ? this.install(fetchOptions, true)
-      : Promise.resolve();
-
-    promise
-      .then(() => {
-        const [, , ...args] = process.argv;
-
-        const options = { cwd: process.cwd(), stdio: "inherit" };
-
-        const binRelPath = this.binaries[binaryName];
-        if (!binRelPath) {
-          error(`${binaryName} is not a known binary in ${this.name}`);
-        }
-        const binPath = join(this.installDirectory, binRelPath);
-        const result = spawnSync(binPath, args, options);
-
-        if (result.error) {
-          error(result.error);
-        }
-
-        process.exit(result.status);
-      })
-      .catch((e) => {
-        error(e.message);
-        process.exit(1);
-      });
-  }
+  fs.unlinkSync(archivePath);
+  console.log('fresh-editor installed successfully!');
 }
 
-module.exports.Package = Package;
+module.exports = { install };

package/binary.js

@@ -1,126 +1,29 @@
-const { Package } = require("./binary-install");
-const os = require("os");
-const cTable = require("console.table");
-const libc = require("detect-libc");
-const { configureProxy } = require("axios-proxy-builder");
-
-const error = (msg) => {
-  console.error(msg);
-  process.exit(1);
-};
-
-const {
-  name,
-  artifactDownloadUrl,
-  supportedPlatforms,
-  glibcMinimum,
-} = require("./package.json");
-
-const builderGlibcMajorVersion = glibcMinimum.major;
-const builderGlibcMInorVersion = glibcMinimum.series;
-
-const getPlatform = () => {
-  const rawOsType = os.type();
-  const rawArchitecture = os.arch();
-
-  // We want to use rust-style target triples as the canonical key
-  // for a platform, so translate the "os" library's concepts into rust ones
-  let osType = "";
-  switch (rawOsType) {
-    case "Windows_NT":
-      osType = "pc-windows-msvc";
-      break;
-    case "Darwin":
-      osType = "apple-darwin";
-      break;
-    case "Linux":
-      osType = "unknown-linux-gnu";
-      break;
+const os = require('os');
+const path = require('path');
+
+function getBinaryInfo() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const targets = {
+    'darwin-x64': { target: 'x86_64-apple-darwin', ext: 'tar.xz' },
+    'darwin-arm64': { target: 'aarch64-apple-darwin', ext: 'tar.xz' },
+    'linux-x64': { target: 'x86_64-unknown-linux-gnu', ext: 'tar.xz' },
+    'linux-arm64': { target: 'aarch64-unknown-linux-gnu', ext: 'tar.xz' },
+    'win32-x64': { target: 'x86_64-pc-windows-msvc', ext: 'zip' }
+  };
+
+  const key = `${platform}-${arch}`;
+  const info = targets[key];
+
+  if (!info) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
   }
 
-  let arch = "";
-  switch (rawArchitecture) {
-    case "x64":
-      arch = "x86_64";
-      break;
-    case "arm64":
-      arch = "aarch64";
-      break;
-  }
-
-  if (rawOsType === "Linux") {
-    if (libc.familySync() == "musl") {
-      osType = "unknown-linux-musl-dynamic";
-    } else if (libc.isNonGlibcLinuxSync()) {
-      console.warn(
-        "Your libc is neither glibc nor musl; trying static musl binary instead",
-      );
-      osType = "unknown-linux-musl-static";
-    } else {
-      let libcVersion = libc.versionSync();
-      let splitLibcVersion = libcVersion.split(".");
-      let libcMajorVersion = splitLibcVersion[0];
-      let libcMinorVersion = splitLibcVersion[1];
-      if (
-        libcMajorVersion != builderGlibcMajorVersion ||
-        libcMinorVersion < builderGlibcMInorVersion
-      ) {
-        // We can't run the glibc binaries, but we can run the static musl ones
-        // if they exist
-        console.warn(
-          "Your glibc isn't compatible; trying static musl binary instead",
-        );
-        osType = "unknown-linux-musl-static";
-      }
-    }
-  }
-
-  // Assume the above succeeded and build a target triple to look things up with.
-  // If any of it failed, this lookup will fail and we'll handle it like normal.
-  let targetTriple = `${arch}-${osType}`;
-  let platform = supportedPlatforms[targetTriple];
-
-  if (!platform) {
-    error(
-      `Platform with type "${rawOsType}" and architecture "${rawArchitecture}" is not supported by ${name}.\nYour system must be one of the following:\n\n${Object.keys(
-        supportedPlatforms,
-      ).join(",")}`,
-    );
-  }
-
-  return platform;
-};
-
-const getPackage = () => {
-  const platform = getPlatform();
-  const url = `${artifactDownloadUrl}/${platform.artifactName}`;
-  let filename = platform.artifactName;
-  let ext = platform.zipExt;
-  let binary = new Package(platform, name, url, filename, ext, platform.bins);
-
-  return binary;
-};
-
-const install = (suppressLogs) => {
-  if (!artifactDownloadUrl || artifactDownloadUrl.length === 0) {
-    console.warn("in demo mode, not installing binaries");
-    return;
-  }
-  const package = getPackage();
-  const proxy = configureProxy(package.url);
-
-  return package.install(proxy, suppressLogs);
-};
-
-const run = (binaryName) => {
-  const package = getPackage();
-  const proxy = configureProxy(package.url);
-
-  package.run(binaryName, proxy);
-};
+  return {
+    ...info,
+    binaryName: platform === 'win32' ? 'fresh.exe' : 'fresh'
+  };
+}
 
-module.exports = {
-  install,
-  run,
-  getPackage,
-};
+module.exports = { getBinaryInfo };

package/install.js

@@ -1,4 +1,2 @@
-#!/usr/bin/env node
-
-const { install } = require("./binary");
-install(false);
+const { install } = require('./binary-install');
+install().catch(err => { console.error(err); process.exit(1); });

package/package.json

@@ -1,101 +1,32 @@
 {
-  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.32",
-  "author": "Noam Lewis",
+  "name": "@fresh-editor/fresh-editor",
+  "version": "0.1.42",
+  "description": "A modern terminal-based text editor with plugin support",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinelaw/fresh.git"
+  },
+  "license": "Apache-2.0",
   "bin": {
     "fresh": "run-fresh.js"
   },
-  "dependencies": {
-    "axios": "^1.12.2",
-    "axios-proxy-builder": "^0.1.2",
-    "console.table": "^0.10.0",
-    "detect-libc": "^2.1.2",
-    "rimraf": "^6.0.1"
-  },
-  "description": "A lightweight, fast terminal-based text editor with LSP support and TypeScript plugins",
-  "devDependencies": {
-    "prettier": "^3.6.2"
-  },
-  "engines": {
-    "node": ">=14",
-    "npm": ">=6"
-  },
-  "glibcMinimum": {
-    "major": 2,
-    "series": 35
-  },
-  "homepage": "https://sinelaw.github.io/fresh/",
-  "keywords": [
-    "command-line-utilities",
-    "text-editors",
-    "editor",
-    "terminal",
-    "tui",
-    "text-editor",
-    "lsp"
-  ],
-  "license": "GPL-2.0",
-  "name": "@fresh-editor/fresh-editor",
-  "preferUnplugged": true,
-  "repository": "https://github.com/sinelaw/fresh",
   "scripts": {
-    "fmt": "prettier --write **/*.js",
-    "fmt:check": "prettier --check **/*.js",
-    "postinstall": "node ./install.js"
+    "postinstall": "node install.js"
   },
-  "supportedPlatforms": {
-    "aarch64-apple-darwin": {
-      "artifactName": "fresh-editor-aarch64-apple-darwin.tar.xz",
-      "bins": {
-        "fresh": "fresh"
-      },
-      "zipExt": ".tar.xz"
-    },
-    "aarch64-pc-windows-msvc": {
-      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
-      "bins": {
-        "fresh": "fresh.exe"
-      },
-      "zipExt": ".zip"
-    },
-    "aarch64-unknown-linux-gnu": {
-      "artifactName": "fresh-editor-aarch64-unknown-linux-gnu.tar.xz",
-      "bins": {
-        "fresh": "fresh"
-      },
-      "zipExt": ".tar.xz"
-    },
-    "x86_64-apple-darwin": {
-      "artifactName": "fresh-editor-x86_64-apple-darwin.tar.xz",
-      "bins": {
-        "fresh": "fresh"
-      },
-      "zipExt": ".tar.xz"
-    },
-    "x86_64-pc-windows-gnu": {
-      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
-      "bins": {
-        "fresh": "fresh.exe"
-      },
-      "zipExt": ".zip"
-    },
-    "x86_64-pc-windows-msvc": {
-      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
-      "bins": {
-        "fresh": "fresh.exe"
-      },
-      "zipExt": ".zip"
-    },
-    "x86_64-unknown-linux-gnu": {
-      "artifactName": "fresh-editor-x86_64-unknown-linux-gnu.tar.xz",
-      "bins": {
-        "fresh": "fresh"
-      },
-      "zipExt": ".tar.xz"
-    }
-  },
-  "version": "0.1.32",
-  "volta": {
-    "node": "18.14.1",
-    "npm": "9.5.0"
+  "files": [
+    "binary.js",
+    "binary-install.js",
+    "install.js",
+    "run-fresh.js",
+    "plugins/**/*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "os": ["darwin", "linux", "win32"],
+  "cpu": ["x64", "arm64"],
+  "keywords": ["editor", "terminal", "cli", "text-editor", "vim"],
+  "engines": {
+    "node": ">=18"
   }
-}
+}

package/run-fresh.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+const { spawn } = require('child_process');
+const path = require('path');
+const { getBinaryInfo } = require('./binary');
 
-const { run } = require("./binary");
-run("fresh");
+const info = getBinaryInfo();
+const binPath = path.join(__dirname, 'bin', info.binaryName);
+
+const child = spawn(binPath, process.argv.slice(2), { stdio: 'inherit' });
+child.on('exit', (code) => process.exit(code || 0));

package/.gitignore

@@ -1,2 +0,0 @@
-/node_modules
-