@adhdev/ghostty-vt-node 0.7.31

package/CMakeLists.txt

@@ -0,0 +1,77 @@
+cmake_minimum_required(VERSION 3.20)
+project(ghostty_vt_node LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+include(FetchContent)
+
+execute_process(
+  COMMAND node -p "require('node-addon-api').include"
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  OUTPUT_VARIABLE NODE_ADDON_API_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+string(REPLACE "\"" "" NODE_ADDON_API_DIR "${NODE_ADDON_API_DIR}")
+
+set(GHOSTTY_GIT_TAG "d4a38c8661453026bd1b1bb022ba2c37b347adce" CACHE STRING "Ghostty git revision for libghostty-vt")
+
+if(DEFINED ENV{ZIG_EXECUTABLE} AND NOT DEFINED ZIG_EXECUTABLE)
+  set(ZIG_EXECUTABLE "$ENV{ZIG_EXECUTABLE}" CACHE FILEPATH "Path to zig executable")
+endif()
+
+FetchContent_Declare(ghostty
+  GIT_REPOSITORY https://github.com/ghostty-org/ghostty.git
+  GIT_TAG ${GHOSTTY_GIT_TAG}
+)
+FetchContent_MakeAvailable(ghostty)
+
+add_library(${PROJECT_NAME} SHARED
+  src/addon.cc
+  src/ghostty_bridge.c
+)
+
+set(GHOSTTY_VT_RUNTIME_ALIAS "${CMAKE_SHARED_LIBRARY_PREFIX}ghostty-vt${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+  ${CMAKE_JS_INC}
+  ${NODE_ADDON_API_DIR}
+)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE
+  NAPI_DISABLE_CPP_EXCEPTIONS
+  GHOSTTY_STATIC
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+  ${CMAKE_JS_LIB}
+  ghostty-vt
+)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+  PREFIX ""
+  SUFFIX ".node"
+)
+
+if(APPLE)
+  set_target_properties(${PROJECT_NAME} PROPERTIES
+    BUILD_RPATH "@loader_path"
+    INSTALL_RPATH "@loader_path"
+  )
+  target_link_options(${PROJECT_NAME} PRIVATE "-undefined dynamic_lookup")
+elseif(UNIX)
+  set_target_properties(${PROJECT_NAME} PROPERTIES
+    BUILD_RPATH "$ORIGIN"
+    INSTALL_RPATH "$ORIGIN"
+  )
+endif()
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    $<TARGET_FILE:ghostty-vt>
+    $<TARGET_FILE_DIR:${PROJECT_NAME}>/$<TARGET_FILE_NAME:ghostty-vt>
+  COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    $<TARGET_FILE:ghostty-vt>
+    $<TARGET_FILE_DIR:${PROJECT_NAME}>/${GHOSTTY_VT_RUNTIME_ALIAS}
+)

package/index.d.ts

@@ -0,0 +1,18 @@
+export type GhosttyTerminalOptions = {
+  cols: number;
+  rows: number;
+  scrollback: number;
+};
+
+export type GhosttyPlainTextFormatOptions = {
+  trim?: boolean;
+};
+
+export interface GhosttyTerminalHandle {
+  write(data: string | Uint8Array): void;
+  resize(cols: number, rows: number): void;
+  formatPlainText(options?: GhosttyPlainTextFormatOptions): string;
+  dispose(): void;
+}
+
+export function createTerminal(options: GhosttyTerminalOptions): GhosttyTerminalHandle;

package/index.js

@@ -0,0 +1,34 @@
+const path = require('node:path');
+
+function getTriplet() {
+    return `${process.platform}-${process.arch}-node${process.versions.modules}`;
+}
+
+function loadBinding() {
+    const triplet = getTriplet();
+    const explicitPrebuiltDir = process.env.ADHDEV_GHOSTTY_VT_PREBUILT_DIR
+        ? path.resolve(process.env.ADHDEV_GHOSTTY_VT_PREBUILT_DIR)
+        : null;
+    const candidates = [
+        explicitPrebuiltDir ? path.join(explicitPrebuiltDir, triplet, 'ghostty_vt_node.node') : null,
+        explicitPrebuiltDir ? path.join(explicitPrebuiltDir, 'ghostty_vt_node.node') : null,
+        path.join(__dirname, 'prebuilt', triplet, 'ghostty_vt_node.node'),
+        path.join(__dirname, 'build', 'Release', 'ghostty_vt_node.node'),
+        path.join(__dirname, 'build', 'Debug', 'ghostty_vt_node.node'),
+    ].filter(Boolean);
+
+    const errors = [];
+    for (const candidate of candidates) {
+        try {
+            return require(candidate);
+        } catch (error) {
+            errors.push(`${candidate}: ${error && error.message ? error.message : String(error)}`);
+        }
+    }
+
+    throw new Error(
+        `Unable to load @adhdev/ghostty-vt-node native binding for ${triplet}. Provide a prebuilt via ADHDEV_GHOSTTY_VT_PREBUILT_DIR or build it with "npm run build -w packages/ghostty-vt-node". ${errors.join(' | ')}`,
+    );
+}
+
+module.exports = loadBinding();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@adhdev/ghostty-vt-node",
+  "version": "0.7.31",
+  "description": "Native Node binding for libghostty-vt",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "prebuilt",
+    "scripts",
+    "CMakeLists.txt",
+    "src"
+  ],
+  "scripts": {
+    "build": "node ./scripts/build-or-use-prebuilt.mjs",
+    "rebuild": "cmake-js rebuild",
+    "clean": "cmake-js clean"
+  },
+  "author": "vilmire",
+  "dependencies": {
+    "node-addon-api": "^8.7.0"
+  },
+  "devDependencies": {
+    "cmake-js": "^8.0.0"
+  },
+  "license": "AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vilmire/adhdev.git",
+    "directory": "packages/ghostty-vt-node"
+  },
+  "homepage": "https://github.com/vilmire/adhdev#readme"
+}

package/scripts/build-or-use-prebuilt.mjs

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageDir = path.resolve(scriptDir, '..');
+const outputDir = path.join(packageDir, 'build', 'Release');
+const outputFile = path.join(outputDir, 'ghostty_vt_node.node');
+const triplet = `${process.platform}-${process.arch}-node${process.versions.modules}`;
+
+function candidatePrebuiltPaths() {
+  const candidates = [];
+  const explicitDir = process.env.ADHDEV_GHOSTTY_VT_PREBUILT_DIR?.trim();
+  if (explicitDir) {
+    candidates.push(path.join(explicitDir, triplet, 'ghostty_vt_node.node'));
+    candidates.push(path.join(explicitDir, 'ghostty_vt_node.node'));
+  }
+  candidates.push(path.join(packageDir, 'prebuilt', triplet, 'ghostty_vt_node.node'));
+  return candidates;
+}
+
+function installPrebuiltIfPresent() {
+  for (const candidate of candidatePrebuiltPaths()) {
+    if (!fs.existsSync(candidate)) continue;
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.copyFileSync(candidate, outputFile);
+    console.log(`[ghostty-vt-node] using prebuilt native binding from ${candidate}`);
+    return true;
+  }
+  return false;
+}
+
+if (!installPrebuiltIfPresent() && process.env.ADHDEV_SKIP_GHOSTTY_VT_BUILD === '1') {
+  console.log(`[ghostty-vt-node] skipping native build for ${triplet} (ADHDEV_SKIP_GHOSTTY_VT_BUILD=1)`);
+  process.exit(0);
+}
+
+if (installPrebuiltIfPresent()) {
+  process.exit(0);
+}
+
+const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const result = spawnSync(npx, ['cmake-js', 'compile'], {
+  cwd: packageDir,
+  env: process.env,
+  stdio: 'inherit',
+});
+
+process.exit(result.status ?? 1);

package/src/addon.cc

@@ -0,0 +1,170 @@
+#include <algorithm>
+#include <string>
+
+#include <napi.h>
+
+#include "ghostty_bridge.h"
+
+namespace {
+
+struct TerminalBindingState {
+  AdhdevGhosttyTerminal* terminal = nullptr;
+};
+
+std::string BuildGhosttyErrorMessage(const char* context, int result) {
+  return std::string(context) + ": " + adhdev_ghostty_result_message(result);
+}
+
+void ThrowGhosttyError(Napi::Env env, const char* context, int result) {
+  Napi::Error::New(env, BuildGhosttyErrorMessage(context, result)).ThrowAsJavaScriptException();
+}
+
+TerminalBindingState* GetState(const Napi::CallbackInfo& info) {
+  if (!info.Data()) {
+    Napi::Error::New(info.Env(), "missing native terminal state").ThrowAsJavaScriptException();
+    return nullptr;
+  }
+  return static_cast<TerminalBindingState*>(info.Data());
+}
+
+bool EnsureOpen(Napi::Env env, TerminalBindingState* state) {
+  if (!state || !state->terminal) {
+    Napi::Error::New(env, "ghostty terminal already disposed").ThrowAsJavaScriptException();
+    return false;
+  }
+  return true;
+}
+
+void FinalizeState(Napi::Env, TerminalBindingState* state) {
+  if (!state) return;
+  if (state->terminal) {
+    adhdev_ghostty_terminal_destroy(state->terminal);
+    state->terminal = nullptr;
+  }
+  delete state;
+}
+
+Napi::Value Write(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  TerminalBindingState* state = GetState(info);
+  if (!EnsureOpen(env, state)) return env.Undefined();
+  if (info.Length() < 1) return env.Undefined();
+
+  int result = ADHDEV_GHOSTTY_INVALID_VALUE;
+  if (info[0].IsBuffer()) {
+    Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+    result = adhdev_ghostty_terminal_write(state->terminal, buffer.Data(), buffer.Length());
+  } else if (info[0].IsString()) {
+    std::string text = info[0].As<Napi::String>().Utf8Value();
+    result = adhdev_ghostty_terminal_write(
+        state->terminal,
+        reinterpret_cast<const uint8_t*>(text.data()),
+        text.size());
+  } else {
+    Napi::TypeError::New(env, "write expects a string or Uint8Array buffer").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_write", result);
+  }
+  return env.Undefined();
+}
+
+Napi::Value Resize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  TerminalBindingState* state = GetState(info);
+  if (!EnsureOpen(env, state)) return env.Undefined();
+  if (info.Length() < 2 || !info[0].IsNumber() || !info[1].IsNumber()) {
+    Napi::TypeError::New(env, "resize expects cols and rows").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const uint16_t cols = static_cast<uint16_t>(std::max(1, info[0].As<Napi::Number>().Int32Value()));
+  const uint16_t rows = static_cast<uint16_t>(std::max(1, info[1].As<Napi::Number>().Int32Value()));
+  const int result = adhdev_ghostty_terminal_resize(state->terminal, cols, rows);
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_resize", result);
+  }
+  return env.Undefined();
+}
+
+Napi::Value FormatPlainText(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  TerminalBindingState* state = GetState(info);
+  if (!EnsureOpen(env, state)) return env.Null();
+
+  bool trim = false;
+  if (info.Length() >= 1 && info[0].IsObject()) {
+    Napi::Object options = info[0].As<Napi::Object>();
+    if (options.Has("trim")) {
+      trim = options.Get("trim").ToBoolean().Value();
+    }
+  }
+
+  char* text = nullptr;
+  size_t text_len = 0;
+  const int result = adhdev_ghostty_terminal_format_plain_text(
+      state->terminal,
+      trim ? 1 : 0,
+      &text,
+      &text_len);
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_format_plain_text", result);
+    return env.Null();
+  }
+
+  std::string output(text, text_len);
+  adhdev_ghostty_terminal_free_text(text, text_len);
+  return Napi::String::New(env, output);
+}
+
+Napi::Value Dispose(const Napi::CallbackInfo& info) {
+  TerminalBindingState* state = GetState(info);
+  if (state && state->terminal) {
+    adhdev_ghostty_terminal_destroy(state->terminal);
+    state->terminal = nullptr;
+  }
+  return info.Env().Undefined();
+}
+
+Napi::Value CreateTerminal(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "options object is required").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  const Napi::Object options = info[0].As<Napi::Object>();
+  const uint16_t cols = static_cast<uint16_t>(std::max(1, options.Get("cols").ToNumber().Int32Value()));
+  const uint16_t rows = static_cast<uint16_t>(std::max(1, options.Get("rows").ToNumber().Int32Value()));
+  const size_t scrollback = options.Has("scrollback")
+      ? static_cast<size_t>(std::max<int64_t>(0, options.Get("scrollback").ToNumber().Int64Value()))
+      : 2000;
+
+  auto* state = new TerminalBindingState();
+  const int result = adhdev_ghostty_terminal_create(cols, rows, scrollback, &state->terminal);
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    delete state;
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_create", result);
+    return env.Null();
+  }
+
+  Napi::Object object = Napi::Object::New(env);
+  Napi::External<TerminalBindingState> external = Napi::External<TerminalBindingState>::New(env, state, FinalizeState);
+  object.Set("_native", external);
+  object.Set("write", Napi::Function::New(env, Write, "write", state));
+  object.Set("resize", Napi::Function::New(env, Resize, "resize", state));
+  object.Set("formatPlainText", Napi::Function::New(env, FormatPlainText, "formatPlainText", state));
+  object.Set("dispose", Napi::Function::New(env, Dispose, "dispose", state));
+  return object;
+}
+
+}  // namespace
+
+Napi::Object InitAddon(Napi::Env env, Napi::Object exports) {
+  exports.Set("createTerminal", Napi::Function::New(env, CreateTerminal));
+  return exports;
+}
+
+NODE_API_MODULE(ghostty_vt_node, InitAddon)

package/src/ghostty_bridge.c

@@ -0,0 +1,118 @@
+#include "ghostty_bridge.h"
+
+#include <ghostty/vt.h>
+
+struct AdhdevGhosttyTerminal {
+    GhosttyTerminal handle;
+    uint16_t cols;
+    uint16_t rows;
+};
+
+static const uint32_t kCellWidthPx = 8;
+static const uint32_t kCellHeightPx = 16;
+
+int adhdev_ghostty_terminal_create(
+    uint16_t cols,
+    uint16_t rows,
+    size_t scrollback,
+    AdhdevGhosttyTerminal** out_terminal) {
+    if (!out_terminal || cols == 0 || rows == 0) return GHOSTTY_INVALID_VALUE;
+
+    AdhdevGhosttyTerminal* terminal = (AdhdevGhosttyTerminal*)ghostty_alloc(NULL, sizeof(AdhdevGhosttyTerminal));
+    if (!terminal) return GHOSTTY_OUT_OF_MEMORY;
+
+    terminal->cols = cols;
+    terminal->rows = rows;
+    terminal->handle = NULL;
+
+    GhosttyTerminalOptions options = {
+        .cols = cols,
+        .rows = rows,
+        .max_scrollback = scrollback,
+    };
+
+    GhosttyResult result = ghostty_terminal_new(NULL, &terminal->handle, options);
+    if (result != GHOSTTY_SUCCESS) {
+        ghostty_free(NULL, (uint8_t*)terminal, sizeof(AdhdevGhosttyTerminal));
+        return result;
+    }
+
+    *out_terminal = terminal;
+    return GHOSTTY_SUCCESS;
+}
+
+int adhdev_ghostty_terminal_write(
+    AdhdevGhosttyTerminal* terminal,
+    const uint8_t* data,
+    size_t len) {
+    if (!terminal || !terminal->handle || (!data && len > 0)) return GHOSTTY_INVALID_VALUE;
+    ghostty_terminal_vt_write(terminal->handle, data, len);
+    return GHOSTTY_SUCCESS;
+}
+
+int adhdev_ghostty_terminal_resize(
+    AdhdevGhosttyTerminal* terminal,
+    uint16_t cols,
+    uint16_t rows) {
+    if (!terminal || !terminal->handle || cols == 0 || rows == 0) return GHOSTTY_INVALID_VALUE;
+    terminal->cols = cols;
+    terminal->rows = rows;
+    (void)kCellWidthPx;
+    (void)kCellHeightPx;
+    return ghostty_terminal_resize(terminal->handle, cols, rows);
+}
+
+int adhdev_ghostty_terminal_format_plain_text(
+    AdhdevGhosttyTerminal* terminal,
+    int trim,
+    char** out_text,
+    size_t* out_len) {
+    if (!terminal || !terminal->handle || !out_text || !out_len) return GHOSTTY_INVALID_VALUE;
+
+    GhosttyFormatterTerminalOptions options = GHOSTTY_INIT_SIZED(GhosttyFormatterTerminalOptions);
+    options.emit = GHOSTTY_FORMATTER_FORMAT_PLAIN;
+    options.trim = trim != 0;
+
+    GhosttyFormatter formatter = NULL;
+    GhosttyResult result = ghostty_formatter_terminal_new(NULL, &formatter, terminal->handle, options);
+    if (result != GHOSTTY_SUCCESS) return result;
+
+    uint8_t* text = NULL;
+    size_t text_len = 0;
+    result = ghostty_formatter_format_alloc(formatter, NULL, &text, &text_len);
+    ghostty_formatter_free(formatter);
+    if (result != GHOSTTY_SUCCESS) return result;
+
+    *out_text = (char*)text;
+    *out_len = text_len;
+    return GHOSTTY_SUCCESS;
+}
+
+void adhdev_ghostty_terminal_free_text(char* text, size_t len) {
+    if (!text) return;
+    ghostty_free(NULL, (uint8_t*)text, len);
+}
+
+void adhdev_ghostty_terminal_destroy(AdhdevGhosttyTerminal* terminal) {
+    if (!terminal) return;
+    if (terminal->handle) {
+        ghostty_terminal_free(terminal->handle);
+        terminal->handle = NULL;
+    }
+    ghostty_free(NULL, (uint8_t*)terminal, sizeof(AdhdevGhosttyTerminal));
+}
+
+const char* adhdev_ghostty_result_message(int result) {
+    switch (result) {
+        case GHOSTTY_SUCCESS:
+            return "success";
+        case GHOSTTY_OUT_OF_MEMORY:
+            return "out of memory";
+        case GHOSTTY_INVALID_VALUE:
+            return "invalid value";
+        case GHOSTTY_OUT_OF_SPACE:
+            return "out of space";
+        default:
+            return "unknown error";
+    }
+}

package/src/ghostty_bridge.h

@@ -0,0 +1,46 @@
+#ifndef ADHDEV_GHOSTTY_BRIDGE_H
+#define ADHDEV_GHOSTTY_BRIDGE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct AdhdevGhosttyTerminal AdhdevGhosttyTerminal;
+
+#define ADHDEV_GHOSTTY_SUCCESS 0
+#define ADHDEV_GHOSTTY_INVALID_VALUE -2
+
+int adhdev_ghostty_terminal_create(
+    uint16_t cols,
+    uint16_t rows,
+    size_t scrollback,
+    AdhdevGhosttyTerminal** out_terminal);
+
+int adhdev_ghostty_terminal_write(
+    AdhdevGhosttyTerminal* terminal,
+    const uint8_t* data,
+    size_t len);
+
+int adhdev_ghostty_terminal_resize(
+    AdhdevGhosttyTerminal* terminal,
+    uint16_t cols,
+    uint16_t rows);
+
+int adhdev_ghostty_terminal_format_plain_text(
+    AdhdevGhosttyTerminal* terminal,
+    int trim,
+    char** out_text,
+    size_t* out_len);
+
+void adhdev_ghostty_terminal_free_text(char* text, size_t len);
+void adhdev_ghostty_terminal_destroy(AdhdevGhosttyTerminal* terminal);
+const char* adhdev_ghostty_result_message(int result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif