buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/testapp.md

@@ -0,0 +1,78 @@
+# jsmdcui
+# hello
+- world
+- 你好 世界 😅
+- Bun JavaScript
+- [example](https://example.com)
+- [Hello! Click Me](javascript:alert('world'))
+- [myfunc 請按我](javascript:myfunc())
+- [Print process.argv](javascript:pav())
+- [Calculator🧮計算機](javascript:calc())
+  * Use cos sin PI directly
+- [Show ↓ text](javascript:alert($('text').val()))
+
+```text
+Text edit. TUI: Click ↙ to inc lines ↖ to dec
+可編輯文字框 TUI：按↙擴充行數 ↖減少行數
+```
+## Question 問題
+- What is 1+2+3+4+..+..+∞
+
+```text#ans
+-1/12
+```
+- [Submit 提交](javascript:checkAns())
+
+## Task list
+- [X] task1
+- [ ] task2
+
+```js front
+export async function myfunc()
+{
+  let yn=confirm('😃 Are you happy? 你開心嗎？')
+  alert(
+    yn ? 'Great 太棒了':
+         'Sorry to hear that. 很遺憾聽到你這麼說'
+  );
+}
+
+export async function pav()
+{
+  let r=await rpc.getArgv();
+  alert(r)
+}
+
+export async function calc()
+{
+  let s = prompt('Enter an expression 輸入運算式：')
+  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+  const result = await new AsyncFunction('rpc',...Object.getOwnPropertyNames(Math),
+    `return await (${s});` 
+  )(rpc,...Object.getOwnPropertyNames(Math).map(i=>Math[i]))
+  alert(
+  
+    'Result 結果：'+
+    result
+    
+  );
+}
+
+export function checkAns()
+{
+  if($('#ans').val().trim()=='-1/12')
+    $('#ans').val('答對🥳Right!');
+  else
+    $('#ans').val('答錯😫Wrong!');
+}
+
+```
+
+
+```js back
+
+export function getArgv()
+{
+  return process.argv ;
+}
+```

package/initramfs/buninu/apps/jsmdcui/tests/assets-helper.test.js

@@ -0,0 +1,150 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  buildHtmlBundleImageMap,
+  canonicalHtmlBundleImageHref,
+  decodeHtmlAttribute,
+  findHtmlBundleAsset,
+  findHtmlBundleImageAsset,
+  htmlBundleImageAssetPath,
+  readAssetBytes,
+  readAssetText,
+} from "../single-exe/assetsHelper.js";
+
+const homepage = {
+  files: [
+    {
+      input: "../../images/pixel.png",
+      path: "/$bunfs/root/pixel-abc123.png",
+      loader: "file",
+      headers: { "content-type": "image/png" },
+    },
+    {
+      input: "scripts/app.js",
+      path: "/$bunfs/root/app-test.js",
+      loader: "file",
+      headers: { "content-type": "text/javascript" },
+    },
+  ],
+};
+
+test("readAssetText prefers internal text and falls back under REPO_ROOT", async () => {
+  const previousAssets = globalThis.internalAssets;
+  try {
+    globalThis.internalAssets = new Map([
+      ["virtual-only.txt", new TextEncoder().encode("embedded")],
+    ]);
+    expect(await readAssetText("virtual-only.txt")).toBe("embedded");
+
+    globalThis.internalAssets = null;
+    expect(await readAssetText("package.json"))
+      .toContain('"name"');
+  } finally {
+    globalThis.internalAssets = previousAssets;
+  }
+});
+
+test("readAssetBytes prefers internal bytes and falls back under REPO_ROOT", async () => {
+  const previousAssets = globalThis.internalAssets;
+  try {
+    globalThis.internalAssets = new Map([
+      ["virtual-only.bin", Uint8Array.from([1, 2, 3])],
+    ]);
+    expect([...await readAssetBytes("virtual-only.bin")]).toEqual([1, 2, 3]);
+
+    globalThis.internalAssets = null;
+    const bytes = await readAssetBytes("package.json");
+    expect(new TextDecoder().decode(bytes)).toContain('"name"');
+  } finally {
+    globalThis.internalAssets = previousAssets;
+  }
+});
+
+test("HTML bundle asset lookup matches the compiled public asset path", () => {
+  expect(findHtmlBundleAsset(homepage, "/pixel-abc123.png"))
+    .toBe(homepage.files[0]);
+  expect(htmlBundleImageAssetPath(homepage, "/pixel-abc123.png?version=2"))
+    .toBe("/$bunfs/root/pixel-abc123.png");
+});
+
+test("HTML bundle image lookup rejects non-images and unavailable development bundles", () => {
+  expect(findHtmlBundleImageAsset(homepage, "/app-test.js")).toBeNull();
+  expect(findHtmlBundleAsset({}, "/pixel-abc123.png")).toBeNull();
+  expect(findHtmlBundleAsset(null, "/pixel-abc123.png")).toBeNull();
+});
+
+test("HTML bundle image map joins preserved Markdown hrefs to compiled bunfs assets", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "jsmdcui-html-assets-"));
+  const htmlPath = join(directory, "app.html");
+  await writeFile(htmlPath, [
+    '<img src="/dms-ajghf5bd.jpg" data-mdcui-src="jsmdcui/single-exe/dms.jpg">',
+    '<img src="/unicode-xyz.png" data-mdcui-src="%E5%9C%96%E7%89%87/%E6%B8%AC%E8%A9%A6%20%E5%9C%96.png">',
+    '<img src="/query-qwe.png" data-mdcui-src="./query.png?x=1&amp;y=2#preview">',
+  ].join("\n"));
+  const compiledHomepage = {
+    index: htmlPath,
+    files: [
+      {
+        input: "dms.jpg",
+        path: "/$bunfs/root/dms-ajghf5bd.jpg",
+        loader: "file",
+        headers: { "content-type": "image/jpeg" },
+      },
+      {
+        input: "../../unicode.png",
+        path: "/$bunfs/root/unicode-xyz.png",
+        loader: "file",
+        headers: { "content-type": "image/png" },
+      },
+      {
+        input: "../query.png",
+        path: "/$bunfs/root/query-qwe.png",
+        loader: "file",
+        headers: { "content-type": "image/png" },
+      },
+    ],
+  };
+
+  const images = await buildHtmlBundleImageMap(compiledHomepage);
+  expect(images.get("jsmdcui/single-exe/dms.jpg"))
+    .toBe("/$bunfs/root/dms-ajghf5bd.jpg");
+  expect(images.get("圖片/測試 圖.png"))
+    .toBe("/$bunfs/root/unicode-xyz.png");
+  expect(images.get("./query.png?x=1&y=2#preview"))
+    .toBe("/$bunfs/root/query-qwe.png");
+});
+
+test("HTML bundle href canonicalization decodes serialization without resolving paths", () => {
+  expect(decodeHtmlAttribute("./a.png?x=1&amp;y=2")).toBe("./a.png?x=1&y=2");
+  expect(canonicalHtmlBundleImageHref("%E5%9C%96%E7%89%87/a%20b.png"))
+    .toBe("圖片/a b.png");
+  expect(canonicalHtmlBundleImageHref("./a.png?x=1&amp;y=2", { htmlAttribute: true }))
+    .toBe("./a.png?x=1&y=2");
+});
+
+test("HTML bundle image map accepts a custom source attribute", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "jsmdcui-html-assets-custom-"));
+  const htmlPath = join(directory, "custom.html");
+  await writeFile(
+    htmlPath,
+    '<img src="/photo-custom123.jpg" data-original-image="./photos/a.jpg">',
+  );
+  const customHomepage = {
+    index: htmlPath,
+    files: [{
+      input: "../../photos/a.jpg",
+      path: "/$bunfs/root/photo-custom123.jpg",
+      loader: "file",
+      headers: { "content-type": "image/jpeg" },
+    }],
+  };
+
+  const images = await buildHtmlBundleImageMap(
+    customHomepage,
+    "data-original-image",
+  );
+  expect(images.get("./photos/a.jpg"))
+    .toBe("/$bunfs/root/photo-custom123.jpg");
+});

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

@@ -0,0 +1,158 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  BACKUP_SUFFIX,
+  applyBackup,
+  determineBackupPath,
+  removeBackup,
+  writeBackup,
+} from "../src/buffer/backup.js";
+
+const cleanup = [];
+
+afterEach(async () => {
+  await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function tempDir() {
+  const path = await mkdtemp(join(tmpdir(), "bunmicro-backup-"));
+  cleanup.push(path);
+  return path;
+}
+
+function buffer(path, text = "changed") {
+  return {
+    path,
+    AbsPath: path,
+    type: "default",
+    lines: text.split("\n"),
+    Settings: { backup: true, backupdir: "", permbackup: false },
+    _savedSerial: 0,
+    setModified(value) { this.modified = Boolean(value); },
+  };
+}
+
+describe("go-micro compatible backup paths", () => {
+  test("uses Go url.QueryEscape-compatible names", async () => {
+    const dir = await tempDir();
+    const result = determineBackupPath(dir, "/tmp/a b%~!'()*.txt");
+    expect(result).toEqual({
+      name: join(dir, "%2Ftmp%2Fa+b%25~%21%27%28%29%2A.txt"),
+      resolveName: null,
+    });
+  });
+
+  test("prefers an existing legacy name", async () => {
+    const dir = await tempDir();
+    const legacy = join(dir, "%tmp%legacy.txt");
+    await writeFile(legacy, "legacy");
+    expect(determineBackupPath(dir, "/tmp/legacy.txt").name).toBe(legacy);
+  });
+
+  test("uses Go's full MD5 hash and .path sidecar for long names", async () => {
+    const dir = await tempDir();
+    const path = "/" + "x".repeat(300);
+    const hash = createHash("md5").update(path).digest("hex");
+    expect(determineBackupPath(dir, path)).toEqual({
+      name: join(dir, hash),
+      resolveName: join(dir, hash + ".path"),
+    });
+  });
+});
+
+describe("backup lifecycle", () => {
+  test("writes atomically using the Go backup suffix", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt", "one\ntwo");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    expect(await writeBackup(buf, root)).toBe(true);
+    expect(await readFile(target.name, "utf8")).toBe("one\ntwo");
+    expect(existsSync(target.name + BACKUP_SUFFIX)).toBe(false);
+  });
+
+  test("recover keeps the backup and marks a distinct dirty baseline", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt", "disk");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "recovered");
+
+    expect(await applyBackup(buf, root, async () => "recover")).toEqual({ recovered: true, abort: false });
+    expect(buf.lines).toEqual(["recovered"]);
+    expect(buf.modified).toBe(true);
+    expect(buf._savedSerial).toBe(-1);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("ignore removes the backup", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "ignored");
+
+    expect(await applyBackup(buf, root, async () => "ignore")).toEqual({ recovered: false, abort: false });
+    expect(existsSync(target.name)).toBe(false);
+  });
+
+  test("permanent backups survive removal", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.permbackup = true;
+    await writeBackup(buf, root);
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    removeBackup(buf, root);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("forced safe-write backups work when periodic backups are disabled", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.backup = false;
+
+    expect(await writeBackup(buf, root)).toBe(false);
+    expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(true);
+    expect(existsSync(determineBackupPath(backupDir, buf.AbsPath).name)).toBe(true);
+  });
+
+  test("mdcui buffers never write, recover, or remove backups", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.md", "rendered markdown");
+    buf.Settings.backupdir = backupDir;
+    buf.encoding = "mdcui";
+    buf.Settings.encoding = "mdcui";
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    expect(await writeBackup(buf, root)).toBe(false);
+    expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(false);
+    expect(existsSync(target.name)).toBe(false);
+
+    await writeFile(target.name, "utf8 editor recovery");
+    let prompted = false;
+    expect(await applyBackup(buf, root, async () => { prompted = true; return "recover"; }))
+      .toEqual({ recovered: false, abort: false });
+    expect(prompted).toBe(false);
+    expect(buf.lines).toEqual(["rendered markdown"]);
+
+    removeBackup(buf, root);
+    expect(existsSync(target.name)).toBe(true);
+  });
+});

package/initramfs/buninu/apps/jsmdcui/tests/cat-markdown.test.js

@@ -0,0 +1,139 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tui = join(import.meta.dir, "..", "tui");
+const bunBin = Bun.which("bun") || process.argv0;
+
+test("cat renders .md files once with the implicit mdcui encoding", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n- one\n- two\n");
+
+  try {
+    const implicit = Bun.spawnSync([bunBin, tui, "-cat", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const explicit = Bun.spawnSync([bunBin, tui, "-cat", "-encoding", "mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(implicit.exitCode).toBe(0);
+    expect(explicit.exitCode).toBe(0);
+    expect(implicit.stdout.toString()).toBe(explicit.stdout.toString());
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("an explicit utf8 encoding overrides the .md mdcui default", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-utf8-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n```js front\nalert('kept')\n```\n");
+
+  try {
+    const result = Bun.spawnSync([bunBin, tui, "-cat", "-encoding", "utf8", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("alert('kept')");
+    expect(existsSync(markdownPath + ".front.js")).toBe(false);
+    expect(existsSync(markdownPath + ".html")).toBe(false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--edit overrides the .md mdcui default with utf8", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-edit-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n```js front\nalert('editable')\n```\n");
+
+  try {
+    const edit = Bun.spawnSync([bunBin, tui, "-cat", "--edit", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const utf8 = Bun.spawnSync([bunBin, tui, "-cat", "-encoding", "utf8", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(edit.exitCode).toBe(0);
+    expect(edit.stdout.toString()).toBe(utf8.stdout.toString());
+    expect(Bun.stripANSI(edit.stdout.toString())).toContain("alert('editable')");
+    expect(existsSync(markdownPath + ".front.js")).toBe(false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--mdcui and --tui are equivalent to -encoding mdcui", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-mdcui-"));
+  const markdownPath = join(dir, "sample.md");
+  await writeFile(markdownPath, "# Heading\n\n- one\n- two\n");
+
+  try {
+    const flag = Bun.spawnSync([bunBin, tui, "-cat", "--mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const encoding = Bun.spawnSync([bunBin, tui, "-cat", "-encoding", "mdcui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const tuiFlag = Bun.spawnSync([bunBin, tui, "-cat", "--tui", markdownPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(flag.exitCode).toBe(0);
+    expect(encoding.exitCode).toBe(0);
+    expect(tuiFlag.exitCode).toBe(0);
+    expect(flag.stdout.toString()).toBe(encoding.stdout.toString());
+    expect(tuiFlag.stdout.toString()).toBe(encoding.stdout.toString());
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("-filetype forces syntax highlighting independently of the filename", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cat-filetype-"));
+  const textPath = join(dir, "sample.txt");
+  await writeFile(textPath, "const answer = 42;\n");
+
+  try {
+    const automatic = Bun.spawnSync([bunBin, tui, "-cat", textPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const javascript = Bun.spawnSync([bunBin, tui, "-cat", "-filetype", "javascript", textPath], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(automatic.exitCode).toBe(0);
+    expect(javascript.exitCode).toBe(0);
+    expect(automatic.stdout.toString()).not.toContain("\x1b[");
+    expect(javascript.stdout.toString()).toContain("\x1b[");
+    expect(Bun.stripANSI(javascript.stdout.toString()).trimEnd()).toBe("const answer = 42;");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/initramfs/buninu/apps/jsmdcui/tests/cdp-security.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isOriginAllowed,
+  isSafeHostHeader,
+  parseAllowedOrigins,
+} from "../runtime/jsplugins/cdp/cdp-server.js";
+
+describe("Chromium-compatible CDP request checks", () => {
+  test("rejects browser origins by default but permits clients without Origin", () => {
+    expect(isOriginAllowed(null)).toBe(true);
+    expect(isOriginAllowed(undefined)).toBe(true);
+    expect(isOriginAllowed("http://localhost:8000")).toBe(false);
+    expect(isOriginAllowed("null")).toBe(false);
+  });
+
+  test("allows only explicitly configured origins or wildcard", () => {
+    const exact = parseAllowedOrigins("http://localhost:8000, HTTPS://EXAMPLE.COM");
+    expect(isOriginAllowed("http://localhost:8000", exact)).toBe(true);
+    expect(isOriginAllowed("https://example.com", exact)).toBe(true);
+    expect(isOriginAllowed("http://127.0.0.1:8000", exact)).toBe(false);
+    expect(isOriginAllowed("https://evil.example", parseAllowedOrigins("*"))).toBe(true);
+  });
+
+  test("accepts IP and localhost Host headers but rejects DNS names", () => {
+    expect(isSafeHostHeader("127.0.0.1:9222")).toBe(true);
+    expect(isSafeHostHeader("[::1]:9222")).toBe(true);
+    expect(isSafeHostHeader("localhost:9222")).toBe(true);
+    expect(isSafeHostHeader("devtools.localhost:9222")).toBe(true);
+    expect(isSafeHostHeader("attacker.example:9222")).toBe(false);
+    expect(isSafeHostHeader("127.0.0.999:9222")).toBe(false);
+  });
+});

package/initramfs/buninu/apps/jsmdcui/tests/cdp-websocket-test.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>jsmdcui CDP WebSocket test</title>
+
+<button id="test">Try CDP connection</button>
+<pre id="status">Ready.</pre>
+
+<script>
+  const status = document.querySelector("#status");
+  const endpoint = "ws://127.0.0.1:9222/devtools/browser/cdp-server";
+
+  function log(message) {
+    status.textContent += `\n${message}`;
+  }
+
+  function testCdp() {
+    status.textContent = `Connecting to ${endpoint}`;
+    const socket = new WebSocket(endpoint);
+
+    socket.addEventListener("open", () => {
+      log("WebSocket connected. Sending Input.insertText...");
+
+      socket.send(JSON.stringify({
+        id: 1,
+        method: "Input.insertText",
+        params: { text: "hello from web page" },
+      }));
+    });
+
+    socket.addEventListener("message", (event) => {
+      log(`CDP response: ${event.data}`);
+      socket.close();
+    });
+
+    socket.addEventListener("error", () => {
+      log("WebSocket error or browser blocked the connection.");
+    });
+
+    socket.addEventListener("close", (event) => {
+      log(`WebSocket closed (code ${event.code}).`);
+    });
+  }
+
+  document.querySelector("#test").addEventListener("click", testCdp);
+  testCdp();
+</script>