@adhdev/ghostty-vt-node 0.7.35 → 0.7.43

package/index.d.ts

@@ -12,6 +12,8 @@ export interface GhosttyTerminalHandle {
   write(data: string | Uint8Array): void;
   resize(cols: number, rows: number): void;
   formatPlainText(options?: GhosttyPlainTextFormatOptions): string;
+  formatVT(): string;
+  getCursorPosition(): { col: number; row: number };
   dispose(): void;
 }
 

package/index.js

@@ -12,9 +12,9 @@ function loadBinding() {
     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'),
+        path.join(__dirname, 'prebuilt', triplet, 'ghostty_vt_node.node'),
     ].filter(Boolean);
 
     const errors = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/ghostty-vt-node",
-  "version": "0.7.35",
+  "version": "0.7.43",
   "description": "Native Node binding for libghostty-vt",
   "main": "index.js",
   "types": "index.d.ts",

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

@@ -8,6 +8,24 @@ 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}`;
+const sourceInputs = [
+  path.join(packageDir, 'CMakeLists.txt'),
+  path.join(packageDir, 'src', 'addon.cc'),
+  path.join(packageDir, 'src', 'ghostty_bridge.c'),
+  path.join(packageDir, 'src', 'ghostty_bridge.h'),
+];
+
+function safeMtime(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function latestSourceMtime() {
+  return sourceInputs.reduce((latest, filePath) => Math.max(latest, safeMtime(filePath)), 0);
+}
 
 function candidatePrebuiltPaths() {
   const candidates = [];
@@ -20,9 +38,10 @@ function candidatePrebuiltPaths() {
   return candidates;
 }
 
-function installPrebuiltIfPresent() {
+function installPrebuiltIfPresent(minMtime = 0) {
   for (const candidate of candidatePrebuiltPaths()) {
     if (!fs.existsSync(candidate)) continue;
+    if (safeMtime(candidate) < minMtime) continue;
     fs.mkdirSync(outputDir, { recursive: true });
     fs.copyFileSync(candidate, outputFile);
     console.log(`[ghostty-vt-node] using prebuilt native binding from ${candidate}`);
@@ -31,12 +50,20 @@ function installPrebuiltIfPresent() {
   return false;
 }
 
-if (!installPrebuiltIfPresent() && process.env.ADHDEV_SKIP_GHOSTTY_VT_BUILD === '1') {
+const sourceMtime = latestSourceMtime();
+const outputMtime = safeMtime(outputFile);
+
+if (outputMtime >= sourceMtime && outputMtime > 0) {
+  console.log(`[ghostty-vt-node] keeping existing local build at ${outputFile}`);
+  process.exit(0);
+}
+
+if (!installPrebuiltIfPresent(sourceMtime) && 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()) {
+if (installPrebuiltIfPresent(sourceMtime)) {
   process.exit(0);
 }
 

package/src/addon.cc

@@ -119,6 +119,49 @@ Napi::Value FormatPlainText(const Napi::CallbackInfo& info) {
   return Napi::String::New(env, output);
 }
 
+Napi::Value FormatVT(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  TerminalBindingState* state = GetState(info);
+  if (!EnsureOpen(env, state)) return env.Null();
+
+  char* text = nullptr;
+  size_t text_len = 0;
+  const int result = adhdev_ghostty_terminal_format_vt(
+      state->terminal,
+      &text,
+      &text_len);
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_format_vt", 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 GetCursorPosition(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  TerminalBindingState* state = GetState(info);
+  if (!EnsureOpen(env, state)) return env.Null();
+
+  uint16_t col = 0;
+  uint16_t row = 0;
+  const int result = adhdev_ghostty_terminal_cursor_position(
+      state->terminal,
+      &col,
+      &row);
+  if (result != ADHDEV_GHOSTTY_SUCCESS) {
+    ThrowGhosttyError(env, "adhdev_ghostty_terminal_cursor_position", result);
+    return env.Null();
+  }
+
+  Napi::Object output = Napi::Object::New(env);
+  output.Set("col", Napi::Number::New(env, col));
+  output.Set("row", Napi::Number::New(env, row));
+  return output;
+}
+
 Napi::Value Dispose(const Napi::CallbackInfo& info) {
   TerminalBindingState* state = GetState(info);
   if (state && state->terminal) {
@@ -156,6 +199,8 @@ Napi::Value CreateTerminal(const Napi::CallbackInfo& info) {
   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("formatVT", Napi::Function::New(env, FormatVT, "formatVT", state));
+  object.Set("getCursorPosition", Napi::Function::New(env, GetCursorPosition, "getCursorPosition", state));
   object.Set("dispose", Napi::Function::New(env, Dispose, "dispose", state));
   return object;
 }

package/src/ghostty_bridge.c

@@ -88,6 +88,64 @@ int adhdev_ghostty_terminal_format_plain_text(
     return GHOSTTY_SUCCESS;
 }
 
+int adhdev_ghostty_terminal_format_vt(
+    AdhdevGhosttyTerminal* terminal,
+    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_VT;
+    options.unwrap = false;
+    options.trim = false;
+    options.extra.palette = true;
+    options.extra.modes = true;
+    options.extra.scrolling_region = true;
+    options.extra.tabstops = true;
+    options.extra.keyboard = true;
+    options.extra.screen.cursor = true;
+    options.extra.screen.style = true;
+    options.extra.screen.hyperlink = true;
+    options.extra.screen.protection = true;
+    options.extra.screen.kitty_keyboard = true;
+    options.extra.screen.charsets = true;
+
+    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;
+}
+
+int adhdev_ghostty_terminal_cursor_position(
+    AdhdevGhosttyTerminal* terminal,
+    uint16_t* out_col,
+    uint16_t* out_row) {
+    if (!terminal || !terminal->handle || !out_col || !out_row) return GHOSTTY_INVALID_VALUE;
+
+    GhosttyResult result = ghostty_terminal_get(
+        terminal->handle,
+        GHOSTTY_TERMINAL_DATA_CURSOR_X,
+        out_col);
+    if (result != GHOSTTY_SUCCESS) return result;
+
+    result = ghostty_terminal_get(
+        terminal->handle,
+        GHOSTTY_TERMINAL_DATA_CURSOR_Y,
+        out_row);
+    if (result != GHOSTTY_SUCCESS) return result;
+
+    return GHOSTTY_SUCCESS;
+}
+
 void adhdev_ghostty_terminal_free_text(char* text, size_t len) {
     if (!text) return;
     ghostty_free(NULL, (uint8_t*)text, len);

package/src/ghostty_bridge.h

@@ -35,6 +35,16 @@ int adhdev_ghostty_terminal_format_plain_text(
     char** out_text,
     size_t* out_len);
 
+int adhdev_ghostty_terminal_format_vt(
+    AdhdevGhosttyTerminal* terminal,
+    char** out_text,
+    size_t* out_len);
+
+int adhdev_ghostty_terminal_cursor_position(
+    AdhdevGhosttyTerminal* terminal,
+    uint16_t* out_col,
+    uint16_t* out_row);
+
 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);