buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/tests/tui-links.test.js

@@ -0,0 +1,298 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildTuiLinkIndex,
+  indexedTuiLinkAtPosition,
+  refreshTuiLinkIndex,
+  tuiLinkActivationContext,
+} from "../src/cui/tui-links.mjs";
+import { navigateTuiHeadingFragment } from "../src/plugins/js-bridge.js";
+
+function markdownBuffer(markdown, columns) {
+  const ansi = String(Bun.markdown.ansi(markdown, {
+    hyperlinks: true,
+    columns,
+  }));
+  return {
+    encoding: "mdcui",
+    lines: Bun.stripANSI(ansi).split("\n"),
+    _mdcuiAnsiText: ansi,
+    _mdcuiSourceText: markdown,
+    _mdcuiTuiSourceText: markdown,
+  };
+}
+
+describe("TUI OSC 8 link index", () => {
+  test("activates every wrapped row and retains the complete rich label", () => {
+    const markdown =
+      'Before [Inspect **very rich label**](javascript:inspect("hello")) after';
+    const buffer = markdownBuffer(markdown, 8);
+    const index = buildTuiLinkIndex(
+      buffer._mdcuiAnsiText,
+      buffer._mdcuiTuiSourceText,
+    );
+    const link = index.links[0];
+
+    expect(link.segments.length).toBeGreaterThan(2);
+    expect(link.href).toBe('javascript:inspect("hello")');
+    expect(link.textContent).toBe("Inspect very rich label");
+    expect(link.innerHTML).toBe(
+      "Inspect <strong>very rich label</strong>",
+    );
+
+    for (const segment of link.segments) {
+      for (let column = segment.start; column < segment.end; column++) {
+        const hit = indexedTuiLinkAtPosition(buffer, segment.row, column);
+        expect(hit?.href).toBe('javascript:inspect("hello")');
+        expect(hit?.textContent).toBe("Inspect very rich label");
+        expect(hit?.innerHTML).toBe(
+          "Inspect <strong>very rich label</strong>",
+        );
+      }
+      if (segment.start > 0) {
+        expect(
+          indexedTuiLinkAtPosition(buffer, segment.row, segment.start - 1),
+        ).toBeNull();
+      }
+      expect(
+        indexedTuiLinkAtPosition(buffer, segment.row, segment.end),
+      ).toBeNull();
+    }
+
+    const html = String(Bun.markdown.html(markdown));
+    expect(html).toContain(
+      '<a href="javascript:inspect(%22hello%22)">Inspect <strong>very rich label</strong></a>',
+    );
+    const payload = {
+      trigger: "enter",
+      link: link.href,
+      linkText: link.textContent,
+      linkHtml: link.innerHTML,
+      linkParent: { row: 1, col: 2 },
+    };
+    const { event, target } = tuiLinkActivationContext(payload);
+    expect(target.href).toBe('javascript:inspect("hello")');
+    expect(target.textContent).toBe("Inspect very rich label");
+    expect(target.innerHTML).toBe(
+      "Inspect <strong>very rich label</strong>",
+    );
+    expect(event.target).toBe(target);
+    expect(event.key).toBe("Enter");
+    expect(target.parent()).toBe(payload.linkParent);
+  });
+
+  test("matches repeated hrefs in order without letting images shift metadata", () => {
+    const markdown =
+      "![decoy](same) [first **rich**](same) [second *rich*](same)";
+    const buffer = markdownBuffer(markdown, 12);
+    const index = buildTuiLinkIndex(
+      buffer._mdcuiAnsiText,
+      buffer._mdcuiTuiSourceText,
+    );
+
+    expect(index.links.map(link => ({
+      href: link.href,
+      text: link.textContent,
+      html: link.innerHTML,
+    }))).toEqual([
+      { href: "same", text: "📷 decoy", html: null },
+      {
+        href: "same",
+        text: "first rich",
+        html: "first <strong>rich</strong>",
+      },
+      {
+        href: "same",
+        text: "second rich",
+        html: "second <em>rich</em>",
+      },
+    ]);
+
+    for (const expected of index.links) {
+      const segment = expected.segments[0];
+      const hit = indexedTuiLinkAtPosition(
+        buffer,
+        segment.row,
+        segment.start,
+      );
+      expect(hit?.textContent).toBe(expected.textContent);
+      expect(hit?.innerHTML).toBe(expected.innerHTML);
+    }
+  });
+
+  test("does not borrow a later rich label after a same-href mismatch", () => {
+    const markdown = [
+      "[first <kbd>**rich**</kbd>](same)",
+      "[first &lt;kbd&gt;rich&lt;/kbd&gt;](same)",
+    ].join(" ");
+    const buffer = markdownBuffer(markdown, 80);
+    const index = buildTuiLinkIndex(
+      buffer._mdcuiAnsiText,
+      buffer._mdcuiTuiSourceText,
+    );
+
+    expect(index.links.map(link => ({
+      text: link.textContent,
+      html: link.innerHTML,
+      order: link.metadataOrder,
+    }))).toEqual([
+      {
+        text: "first <kbd>rich</kbd>",
+        html: null,
+        order: 0,
+      },
+      {
+        text: "first <kbd>rich</kbd>",
+        html: "first &lt;kbd&gt;rich&lt;/kbd&gt;",
+        order: 1,
+      },
+    ]);
+  });
+
+  test("ignores wrapped blockquote prefixes when matching rich metadata", () => {
+    const markdown =
+      '> [Inspect **very rich label words**](javascript:inspect("quoted"))';
+    const buffer = markdownBuffer(markdown, 12);
+    const index = buildTuiLinkIndex(
+      buffer._mdcuiAnsiText,
+      buffer._mdcuiTuiSourceText,
+    );
+    const link = index.links[0];
+
+    expect(link.segments.length).toBeGreaterThan(2);
+    expect(link.textContent).toBe("Inspect very rich label words");
+    expect(link.innerHTML).toBe(
+      "Inspect <strong>very rich label words</strong>",
+    );
+    for (const segment of link.segments) {
+      expect(
+        indexedTuiLinkAtPosition(buffer, segment.row, segment.start)?.innerHTML,
+      ).toBe("Inspect <strong>very rich label words</strong>");
+    }
+  });
+
+  test("keeps source ordinals when hidden rows remove an identical href and label", () => {
+    const markdown = [
+      "[**same**](javascript:repeat())",
+      "",
+      "[*same*](javascript:repeat())",
+    ].join("\n");
+    const buffer = markdownBuffer(markdown, 80);
+    const full = refreshTuiLinkIndex(buffer, { resetCatalog: true });
+    expect(full.links.map(link => link.innerHTML)).toEqual([
+      "<strong>same</strong>",
+      "<em>same</em>",
+    ]);
+
+    const second = full.links[1];
+    const ansiLines = buffer._mdcuiAnsiText.split("\n");
+    const keptAnsi = ansiLines.slice(second.segments[0].row).join("\n");
+    buffer._mdcuiAnsiText = keptAnsi;
+    buffer.lines = Bun.stripANSI(keptAnsi).split("\n");
+
+    const hit = indexedTuiLinkAtPosition(buffer, 0, 0);
+    expect(hit?.href).toBe("javascript:repeat()");
+    expect(hit?.textContent).toBe("same");
+    expect(hit?.innerHTML).toBe("<em>same</em>");
+  });
+
+  test("matches Bun HTML encoding without decoding existing javascript percents", () => {
+    const markdown =
+      '[Inspect **rich**](javascript:inspect("a%20b",`raw`))';
+    const buffer = markdownBuffer(markdown, 80);
+    const hit = indexedTuiLinkAtPosition(buffer, 0, 0);
+
+    expect(hit?.href).toBe('javascript:inspect("a%20b",`raw`)');
+    expect(hit?.textContent).toBe("Inspect rich");
+    expect(hit?.innerHTML).toBe("Inspect <strong>rich</strong>");
+    expect(String(Bun.markdown.html(markdown))).toContain(
+      'href="javascript:inspect(%22a%20b%22,%60raw%60)"',
+    );
+  });
+
+  test("falls back to the complete displayed text when source metadata is missing", () => {
+    const ansi =
+      "\x1b]8;;javascript:raw%22value\x1b\\" +
+      "\x1b[4mfirst row\nsecond row\x1b[24m" +
+      "\x1b]8;;\x1b\\";
+    const buffer = {
+      lines: Bun.stripANSI(ansi).split("\n"),
+      _mdcuiAnsiText: ansi,
+      _mdcuiTuiSourceText: null,
+    };
+
+    const first = indexedTuiLinkAtPosition(buffer, 0, 0);
+    const second = indexedTuiLinkAtPosition(buffer, 1, 0);
+    expect(first?.href).toBe("javascript:raw%22value");
+    expect(second?.href).toBe("javascript:raw%22value");
+    expect(first?.textContent).toBe("first row\nsecond row");
+    expect(second?.textContent).toBe("first row\nsecond row");
+    expect(first?.innerHTML).toBeNull();
+
+    const { target } = tuiLinkActivationContext({
+      trigger: "mouse",
+      link: second.href,
+      linkText: second.textContent,
+      linkHtml: second.innerHTML,
+    });
+    expect(target.href).toBe("javascript:raw%22value");
+    expect(target.textContent).toBe("first row\nsecond row");
+    expect(target.innerHTML).toBe("first row\nsecond row");
+  });
+
+  test("rebuilds a buffer index after rerender replaces ANSI and source", () => {
+    const buffer = markdownBuffer("[old](javascript:old())", 80);
+    expect(indexedTuiLinkAtPosition(buffer, 0, 0)?.textContent).toBe("old");
+
+    const replacement = markdownBuffer(
+      "[new **rich**](javascript:new())",
+      80,
+    );
+    buffer.lines = replacement.lines;
+    buffer._mdcuiAnsiText = replacement._mdcuiAnsiText;
+    buffer._mdcuiSourceText = replacement._mdcuiSourceText;
+    buffer._mdcuiTuiSourceText = replacement._mdcuiTuiSourceText;
+
+    const hit = indexedTuiLinkAtPosition(buffer, 0, 0);
+    expect(hit?.href).toBe("javascript:new()");
+    expect(hit?.textContent).toBe("new rich");
+    expect(hit?.innerHTML).toBe("new <strong>rich</strong>");
+  });
+
+  test("same-document fragments move to the rendered heading toggle", () => {
+    const markdown = [
+      "[Jump](#%E4%B8%AD%E6%96%87-%E8%A8%AD%E5%AE%9A)",
+      "",
+      "# Root",
+      "",
+      "> ## 中文 設定！",
+    ].join("\n");
+    const buffer = markdownBuffer(markdown, 80);
+    let ensureCursorCalls = 0;
+    buffer.cursor = { x: 0, y: 0 };
+    buffer.scroll = { x: 0, y: 0, row: 0 };
+    buffer.ensureCursor = () => { ensureCursorCalls++; };
+
+    const link = indexedTuiLinkAtPosition(buffer, 0, 0);
+    expect(link?.href).toBe(
+      "#%E4%B8%AD%E6%96%87-%E8%A8%AD%E5%AE%9A",
+    );
+    expect(navigateTuiHeadingFragment(buffer, link.href)).toBeTrue();
+    expect(buffer.lines[buffer.cursor.y]).toContain("中文 設定");
+    expect(buffer.cursor.x).toBeGreaterThan(0);
+    expect(buffer.allowCursorOffscreen).toBeFalse();
+    expect(ensureCursorCalls).toBe(1);
+  });
+
+  test("fragment navigation ignores missing, empty, and malformed IDs", () => {
+    const buffer = markdownBuffer("# Existing", 80);
+    buffer.cursor = { x: 0, y: 0 };
+    buffer.ensureCursor = () => {
+      throw new Error("missing fragments must not move the cursor");
+    };
+
+    expect(navigateTuiHeadingFragment(buffer, "#missing")).toBeFalse();
+    expect(navigateTuiHeadingFragment(buffer, "#")).toBeFalse();
+    expect(navigateTuiHeadingFragment(buffer, "#%ZZ")).toBeFalse();
+    expect(buffer.cursor).toEqual({ x: 0, y: 0 });
+  });
+});

package/initramfs/buninu/apps/jsmdcui/tests/wui-responsive-images.test.js

@@ -0,0 +1,60 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createWui, extractJs } from "../runmd.mjs";
+
+const temporaryDirectories = [];
+
+afterEach(() => {
+  for (const directory of temporaryDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("createWui constrains images to their content width", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "jsmdcui-wui-image-"));
+  temporaryDirectories.push(directory);
+  const markdownPath = join(directory, "image.md");
+  const html = await createWui("![wide](wide.png)", markdownPath);
+
+  expect(html).toContain("img {\n  max-width: 100%;\n  height: auto;\n}");
+  expect(html).toContain("table {\n  border-collapse: collapse;\n}");
+  expect(html).toContain("th, td {\n  border: 1px solid black;");
+  expect(html).toContain("tr:hover {\n  background: #ddddee;\n}");
+  expect(html).toContain('src="wide.png" alt="wide" data-mdcui-src="wide.png"');
+  expect(html.match(/max-width: 100%/g)).toHaveLength(1);
+  expect(html.match(/image\.md\.front\.js/g)).toHaveLength(1);
+});
+
+test("createWui injects the image rule into an existing document head", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "jsmdcui-wui-document-"));
+  temporaryDirectories.push(directory);
+  const markdownPath = join(directory, "document.md");
+  const source = "<!doctype html><html><head><title>x</title></head><body><img src=\"wide.png\"></body></html>";
+  const html = await createWui(source, markdownPath);
+
+  expect(html.indexOf("max-width: 100%")).toBeLessThan(html.indexOf("</head>"));
+  expect(html).toContain('src="wide.png" data-mdcui-src="wide.png"');
+  expect(html.match(/document\.md\.front\.js/g)).toHaveLength(1);
+});
+
+test("bundling mode creates a browser-only front entry", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "jsmdcui-wui-bundling-"));
+  temporaryDirectories.push(directory);
+  const markdownPath = join(directory, "bundle.md");
+  const source = "```js front\nexport function pav() { return rpc }\n```";
+  const markdown = await extractJs(source, markdownPath, { bundling: true });
+  const html = await createWui(markdown, markdownPath, { bundling: true });
+  const frontSource = readFileSync(`${markdownPath}.tmpfs.js`, "utf8");
+  const installerSource = readFileSync(`${markdownPath}.tmpfi.js`, "utf8");
+
+  expect(frontSource).toContain("const rpc = wuiRpcClient");
+  expect(frontSource).not.toContain("globalThis.process");
+  expect(frontSource).not.toContain('import("./bundle.md.front.js")');
+  expect(installerSource).toContain('import * as frontMod from "./bundle.md.tmpfs.js"');
+  expect(installerSource).toContain("Object.assign(window, frontMod)");
+  expect(installerSource).toContain("await runWebMdcuiLoad(window, frontMod)");
+  expect(html).toContain('src="./bundle.md.tmpfi.js"');
+  expect(html).not.toContain("bundle.md.front.js");
+});

package/initramfs/buninu/apps/jsmdcui/tests/wui.test.js

@@ -0,0 +1,108 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  convertWuiTableCheckboxes,
+  readMarkdownInput,
+  writeRuntimeFiles,
+} from "../runmd.mjs";
+
+const indexEntry = join(import.meta.dir, "..", "src", "index.js");
+const bunBin = Bun.which("bun") || process.argv0;
+
+test("WUI table cell prefixes become interactive checkbox inputs", () => {
+  const html =
+    "<table><tr><th> [ ] Header</th><td>[x] checked</td>"
+    + "<td>text [ ] unchanged</td><td>[X] upper</td></tr></table>";
+  expect(convertWuiTableCheckboxes(html)).toBe(
+    '<table contenteditable="true"><tr><th> <input type="checkbox"> Header</th>'
+    + '<td><input type="checkbox" checked> checked</td>'
+    + "<td>text [ ] unchanged</td>"
+    + '<td><input type="checkbox" checked> upper</td></tr></table>',
+  );
+});
+
+test("WUI tables become editable once without changing outside HTML cells", () => {
+  const html =
+    '<td>outside</td><table><tr><td class="value">inside</td>'
+    + '<th contenteditable="false">fixed</th></tr></table>';
+  expect(convertWuiTableCheckboxes(html)).toBe(
+    '<td>outside</td><table contenteditable="true"><tr>'
+    + '<td class="value">inside</td>'
+    + '<th contenteditable="false">fixed</th></tr></table>',
+  );
+  expect(convertWuiTableCheckboxes(
+    '<table contenteditable="false"><tr><td>fixed</td></tr></table>',
+  )).toBe(
+    '<table contenteditable="false"><tr><td>fixed</td></tr></table>',
+  );
+});
+
+test("WUI writes the bundled testapp.md when it is missing", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-"));
+  const mdpath = join(dir, "testapp.md");
+  try {
+    const source = await readMarkdownInput(mdpath);
+    expect(source).toContain("# jsmdcui");
+    expect(await readFile(mdpath, "utf8")).toBe(source);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("WUI preserves an existing testapp.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-existing-"));
+  const mdpath = join(dir, "testapp.md");
+  const existing = "# Keep my WUI demo\n";
+  try {
+    await writeFile(mdpath, existing);
+    expect(await readMarkdownInput(mdpath)).toBe(existing);
+    expect(await readFile(mdpath, "utf8")).toBe(existing);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("generated WUI server falls back to a system port when 3000 is occupied", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-port-"));
+  const mdpath = join(dir, "app.md");
+  try {
+    await writeRuntimeFiles(mdpath);
+    const source = await readFile(`${mdpath}-server.js`, "utf8");
+    expect(source).toContain('error?.code === "EADDRINUSE"');
+    expect(source).toContain('serverOptions.port !== 3000 || !addressInUse');
+    expect(source).toContain('Bun.serve({ ...serverOptions, port: 0 })');
+    expect(source).toContain('localhost:${server.port}');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("WUI reports an external server before starting it", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-source-report-"));
+  const mdpath = join(dir, "external.md");
+  const preloadPath = join(dir, "mock-serve.mjs");
+  try {
+    await writeFile(mdpath, "# External WUI\n");
+    await writeFile(
+      preloadPath,
+      `Bun.serve = () => ({ port: 34567, stop() {} });\n`,
+    );
+    const result = Bun.spawnSync(
+      [bunBin, "--preload", preloadPath, indexEntry, "--wui", mdpath],
+      {
+        cwd: dir,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+
+    expect(result.exitCode).toBe(0);
+    const stderr = Bun.stripANSI(result.stderr.toString());
+    expect(stderr).toContain("[mdcui] Starting external WUI server:");
+    expect(stderr).toContain(`${mdpath}-server.js`);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/initramfs/buninu/apps/jsmdcui/tests/wv-client.js

@@ -0,0 +1,96 @@
+const cdpUrl = Bun.argv[2] ?? "ws://127.0.0.1:9222";
+
+const view = new Bun.WebView({
+  backend: {
+    type: "chrome",
+    url: cdpUrl,
+  },
+});
+
+view.onNavigated = (url, title) => {
+  console.log(`[navigated] ${title || "(no title)"} — ${url.slice(0, 80)}`);
+};
+
+const delay = Bun.sleep
+
+try {
+
+  await delay(2000);
+  
+  // 1. navigate to first page
+  console.log("\n--- navigate: https://example.com ---");
+  await view.navigate("https://example.com");
+  await delay(2000);
+
+
+  // 2. navigate to second page
+  console.log("\n--- evaluate: micro.cmd.tab() ---");
+  await view.evaluate("micro.cmd.tab()");
+  await delay(500);
+  
+  console.log("\n--- navigate: github bunmicro hlw.md ---");
+  await view.navigate("https://raw.githubusercontent.com/jjtseng93/bunmicro/refs/heads/main/hlw.md");
+  await delay(2000);
+
+
+  // 3. navigate to third page
+  console.log("\n--- evaluate: micro.cmd.tab() ---");
+  await view.evaluate("micro.cmd.tab()");
+  await delay(500);
+  
+  console.log("\n--- navigate: https://bun.sh/docs dns ---");
+  await view.navigate("https://bun.com/docs/runtime/networking/dns");
+  await delay(2000);
+
+
+  // 4. go back twice
+  console.log("\n--- goBack (dns → hlw) ---");
+  await view.goBack();
+  await delay(2000);
+
+  console.log("\n--- goBack (hlw → example.com) ---");
+  await view.goBack();
+  await delay(2000);
+
+
+  // 5. go forward
+  console.log("\n--- goForward (example.com → hlw) ---");
+  await view.goForward();
+  await delay(2000);
+
+
+  // 6. type before # hello & click
+  console.log("\n--- click #hello to focus ---");
+  await view.scrollTo("#hello");
+  await view.evaluate('micro.action.StartOfLine()');
+  await delay(2000);
+
+  console.log("\n--- type: '# Bun is great' ---");
+  await view.type("# Bun is great");
+  await delay(2000);
+  
+
+  console.log("\n--- press Enter ---");
+  await view.press("Enter");
+  await delay(2000);
+  
+  
+  console.log("\n--- Click 3,3 ---");  
+  await view.click(3,3); //點33
+  await delay(2000);
+
+
+  // 7. resize
+  console.log("\n--- resize 1280x720 ---");
+  await view.resize(1280, 720);
+  await delay(2000);
+
+  // 8. go forward to dns
+  console.log("\n--- goForward (hlw → dns) ---");
+  await view.goForward();
+  await delay(2000);
+
+  console.log("\nAll done.");
+} finally {
+  view.close();
+}

package/initramfs/buninu/apps/jsmdcui/tui

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+':' //; sd=$(dirname "$(realpath "$0")")
+
+':' //; exec bun "$sd"/src/index.js "$@"
+
+await import('./src/index.js')

package/initramfs/buninu/apps/jsmdcui/wui

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+':' //; sd=$(dirname "$(realpath "$0")")
+
+':' //; exec bun "$sd"/src/index.js --wui "$@"
+
+process.argv.splice(2,0,'--wui')
+
+await import('./src/index.js')