jsmdcui 0.8.0 → 0.9.0

package/src/plugins/js-bridge.js

@@ -4,6 +4,7 @@ import { dirname, join, basename, extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import { tmpdir } from "node:os";
 import { assetPath, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetBytes } from "../runtime/assets.js";
+import { isMdcuiEncoding } from "../runtime/encodings.js";
 import { newMessage, newMessageAtLine, MTError, MTWarning, MTInfo } from "../buffer/message.js";
 import { Loc } from "../buffer/loc.js";
 
@@ -1405,6 +1406,48 @@ export function buildMicroGlobal(jsManager) {
       return app?.buffer?.lines.join("\n") ?? "";
     },
 
+    // Returns the rendered ANSI document when available, otherwise plain text.
+    getAllAnsiText() {
+      const buffer = getApp()?.buffer;
+      return typeof buffer?._mdcuiAnsiText === "string"
+        ? buffer._mdcuiAnsiText
+        : buffer?.lines.join("\n") ?? "";
+    },
+
+    // Activates a 1-based rendered-buffer cell in MDCUI; otherwise falls back to goto.
+    async clickBufferCell(column = 1, line = 1) {
+      const app = getApp();
+      const buffer = app?.buffer;
+      if (!app || !buffer) return false;
+
+      const targetLine = Math.max(1, Math.trunc(Number(line)) || 1);
+      const targetColumn = Math.max(1, Math.trunc(Number(column)) || 1);
+      if (!isMdcuiEncoding(buffer.encoding ?? buffer.Settings?.encoding)) {
+        await app.handleCommand(`goto ${targetLine}:${targetColumn}`);
+        app.render?.();
+        return true;
+      }
+
+      const y = Math.min(targetLine - 1, Math.max(0, buffer.lines.length - 1));
+      const x = Math.min(targetColumn - 1, String(buffer.lines[y] ?? "").length);
+      buffer.cursor = { x, y };
+      const handled = await app.handleMdcuiCellCallback(buffer, y, x, "mouse");
+      app.render?.();
+      return handled;
+    },
+
+    // Sends terminal input through the App's normal parser and event pipeline.
+    async _dispatchRawInput(raw) {
+      const app = getApp();
+      if (!app) return false;
+      const bytes = typeof raw === "string"
+        ? new TextEncoder().encode(raw)
+        : raw;
+      await app._dispatchInput(bytes);
+      app.render?.();
+      return true;
+    },
+
     // Replaces the entire buffer content with text (may contain newlines).
     putAllText(text) {
       const app = getApp();

package/tests/compiled-runtime.test.js

@@ -0,0 +1,8 @@
+import { expect, test } from "bun:test";
+import { isCompiledBinary as isSingleExeCompiled } from "../single-exe/compiled.js";
+
+test("single-exe recognizes Bun compiled virtual paths", () => {
+  expect(isSingleExeCompiled(["bun", "/$bunfs/root/app.js"])).toBe(true);
+  expect(isSingleExeCompiled(["bun", "B:/~BUN/root/app.js"])).toBe(true);
+  expect(isSingleExeCompiled(["bun", "/project/src/index.js"])).toBe(false);
+});

package/tests/demo.test.js

@@ -21,6 +21,7 @@ test("--help describes the non-overwriting demo behavior", () => {
   expect(output.match(/Open it in the TUI and write 5 generated files beside it/g)?.length).toBe(2);
   expect(output).toContain("--demo-imgtool");
   expect(output).toContain("--demo-imgtool-zh");
+  expect(output).toContain("--cdp-maze");
 });
 
 test("--demo-list lists root and automatically discovered demos", () => {
@@ -38,6 +39,27 @@ test("--demo-list lists root and automatically discovered demos", () => {
   expect(output).toContain("--demo-imgtool     --demo-image-processor");
 });
 
+test("--export-cdp-maze writes and overwrites the bundled solver", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-export-cdp-maze-"));
+  const outputPath = join(dir, "cdp-maze.js");
+  try {
+    await writeFile(outputPath, "old solver\n");
+    const result = Bun.spawnSync([bunBin, tui, "--export-cdp-maze"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toContain(`Wrote ${outputPath}`);
+    const exported = await readFile(outputPath, "utf8");
+    expect(exported).toContain("export async function runCdpMaze");
+    expect(exported).not.toContain("old solver");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("--demo writes bundled testapp.md to cwd before opening it", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-"));
   try {
@@ -94,6 +116,24 @@ test("--demo-<filename> automatically loads a matching demos file", async () =>
   }
 });
 
+test("--cdp-maze loads the maze demo", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cdp-maze-"));
+  try {
+    const result = Bun.spawnSync([bunBin, tui, "--cdp-maze", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    const written = await readFile(join(dir, "maze.md"), "utf8");
+    expect(written).toContain("Put the cursor here");
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("Put the cursor here");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("--demo-<filename> preserves an existing local copy", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-generic-existing-"));
   const existing = "# Keep my selector demo\n";

package/tests/kitty-demo.md

@@ -83,7 +83,7 @@ Content before the image, line 10.
 
 ## Image anchor
 
-![img](../demo.resized.jpg)
+![img](../maze.jpg)
 
 ## After image 01
 Content after the image, line 01.

package/src/runtime/compiled.js

@@ -1,25 +0,0 @@
-import { basename, dirname, resolve } from "node:path";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-export function isCompiledBinary(argv = process.argv) {
-  return Boolean(argv?.[1]?.startsWith?.("/$bunfs/"));
-}
-
-export function resolveCompiledBaseDir({ argv = process.argv, execPath = process.execPath } = {}) {
-  const bn = basename(execPath);
-  if (bn.startsWith("ld") || 
-      bn.startsWith("libld") ||
-      bn.startsWith("linker") ) {
-    const realArgv = readFileSync("/proc/self/cmdline", "utf8").match(/[^\0]+/g);
-    return dirname(realArgv?.[1] ?? execPath);
-  }
-  return dirname(execPath) || process.cwd();
-}
-
-export function resolveRepoRoot(importMetaUrl, options = {}) {
-  if (isCompiledBinary(options.argv)) {
-    return resolveCompiledBaseDir(options);
-  }
-  return resolve(dirname(fileURLToPath(importMetaUrl)), "..");
-}