@hienlh/ppm 0.18.9 → 0.18.11

package/.spike/cdp-client.ts

@@ -0,0 +1,116 @@
+// Minimal Chrome DevTools Protocol client over the browser WebSocket endpoint.
+// Spike helper only (untracked). Flattened sessions: one WS, per-target sessionId.
+
+export interface CdpTarget {
+  targetId: string;
+  type: string;
+  title: string;
+  url: string;
+  attached: boolean;
+}
+
+type Pending = { resolve: (v: any) => void; reject: (e: Error) => void; method: string };
+
+export class CdpClient {
+  private ws!: WebSocket;
+  private nextId = 1;
+  private pending = new Map<number, Pending>();
+  private listeners: Array<(msg: any) => void> = [];
+
+  static async connect(port: number): Promise<CdpClient> {
+    const res = await fetch(`http://127.0.0.1:${port}/json/version`);
+    const info = (await res.json()) as { webSocketDebuggerUrl: string };
+    const client = new CdpClient();
+    await client.open(info.webSocketDebuggerUrl);
+    return client;
+  }
+
+  private open(url: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => resolve();
+      this.ws.onerror = (e) => reject(new Error(`ws error ${String(e)}`));
+      this.ws.onmessage = (ev) => {
+        const msg = JSON.parse(String(ev.data));
+        if (msg.id && this.pending.has(msg.id)) {
+          const p = this.pending.get(msg.id)!;
+          this.pending.delete(msg.id);
+          if (msg.error) p.reject(new Error(`${p.method}: ${msg.error.message} ${msg.error.data ?? ""}`));
+          else p.resolve(msg.result);
+        } else {
+          for (const l of this.listeners) l(msg);
+        }
+      };
+    });
+  }
+
+  onEvent(fn: (msg: any) => void) {
+    this.listeners.push(fn);
+  }
+
+  send(method: string, params: Record<string, unknown> = {}, sessionId?: string): Promise<any> {
+    const id = this.nextId++;
+    const payload: Record<string, unknown> = { id, method, params };
+    if (sessionId) payload.sessionId = sessionId;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, method });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+
+  async targets(): Promise<CdpTarget[]> {
+    const r = await this.send("Target.getTargets");
+    return r.targetInfos as CdpTarget[];
+  }
+
+  async attach(targetId: string): Promise<string> {
+    const r = await this.send("Target.attachToTarget", { targetId, flatten: true });
+    return r.sessionId as string;
+  }
+
+  /** Runtime.evaluate with awaitPromise + returnByValue; throws on JS exception. */
+  async eval<T = unknown>(sessionId: string, expression: string): Promise<T> {
+    const r = await this.send(
+      "Runtime.evaluate",
+      { expression, awaitPromise: true, returnByValue: true, userGesture: false },
+      sessionId,
+    );
+    if (r.exceptionDetails) {
+      const d = r.exceptionDetails;
+      throw new Error(`JS exception: ${d.exception?.description ?? d.text}`);
+    }
+    return r.result?.value as T;
+  }
+
+  async click(sessionId: string, x: number, y: number) {
+    const base = { x, y, button: "left", clickCount: 1 };
+    await this.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y }, sessionId);
+    await this.send("Input.dispatchMouseEvent", { ...base, type: "mousePressed" }, sessionId);
+    await this.send("Input.dispatchMouseEvent", { ...base, type: "mouseReleased" }, sessionId);
+  }
+
+  /** Type printable text as trusted key events (one keyDown/keyUp per char). */
+  async typeText(sessionId: string, text: string) {
+    for (const ch of text) {
+      await this.send("Input.dispatchKeyEvent", { type: "keyDown", text: ch, key: ch, unmodifiedText: ch }, sessionId);
+      await this.send("Input.dispatchKeyEvent", { type: "keyUp", key: ch }, sessionId);
+    }
+  }
+
+  async pressKey(sessionId: string, key: string, code: string, vk: number, text?: string, modifiers = 0) {
+    const common = { key, code, windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk, modifiers };
+    await this.send("Input.dispatchKeyEvent", { type: text ? "keyDown" : "rawKeyDown", ...common, ...(text ? { text, unmodifiedText: text } : {}) }, sessionId);
+    await this.send("Input.dispatchKeyEvent", { type: "keyUp", ...common }, sessionId);
+  }
+
+  async screenshot(sessionId: string, path: string) {
+    const r = await this.send("Page.captureScreenshot", { format: "png" }, sessionId);
+    await Bun.write(path, Buffer.from(r.data, "base64"));
+  }
+
+  close() {
+    this.ws.close();
+  }
+}
+
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

package/.spike/cleanup-ppm-workspace.mjs

@@ -0,0 +1,44 @@
+// One-off: remove the duplicate `terminal:1@panel-*` tabs an earlier smoke run left in the
+// real `ppm` project workspace. Prints before/after; makes no other change.
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+const API = "http://127.0.0.1:8099";
+const db = new Database(join(homedir(), ".ppm", "ppm.dev.db"), { readonly: true });
+const TOKEN = JSON.parse(db.query("SELECT value FROM config WHERE key='auth'").get().value).token;
+db.close();
+
+const H = { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" };
+const res = await fetch(`${API}/api/project/ppm/workspace`, { headers: H });
+const json = await res.json();
+if (!json.ok || !json.data) {
+  console.log("no server workspace for ppm:", JSON.stringify(json).slice(0, 300));
+  process.exit(0);
+}
+const layout = json.data.layout;
+const dump = (l) =>
+  JSON.stringify(Object.fromEntries(Object.entries(l.panels).map(([k, v]) => [k, v.tabs.map((t) => t.id)])));
+console.log("before:", dump(layout));
+
+const BAD = /^terminal:1@panel-/;
+let removed = 0;
+for (const panel of Object.values(layout.panels)) {
+  const keep = panel.tabs.filter((t) => !BAD.test(t.id));
+  removed += panel.tabs.length - keep.length;
+  const ids = new Set(keep.map((t) => t.id));
+  panel.tabs = keep;
+  panel.tabHistory = (panel.tabHistory ?? []).filter((id) => ids.has(id));
+  if (panel.activeTabId && !ids.has(panel.activeTabId)) {
+    panel.activeTabId = panel.tabHistory.at(-1) ?? keep.at(-1)?.id ?? null;
+  }
+}
+console.log("after: ", dump(layout), `removed=${removed}`);
+if (removed === 0) process.exit(0);
+
+const put = await fetch(`${API}/api/project/ppm/workspace`, {
+  method: "PUT",
+  headers: H,
+  body: JSON.stringify({ layout }),
+});
+console.log("PUT:", put.status, JSON.stringify(await put.json()).slice(0, 200));

package/.spike/group-protected-probe.ts

@@ -0,0 +1,21 @@
+// How many groups would the whole-app kill button be enabled for, per the live snapshot?
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { isGroupProtected } from "../src/web/components/system/build-kill-request.ts";
+
+const db = new Database(resolve(homedir(), ".ppm", "ppm.dev.db"), { readonly: true });
+const row = db.query("SELECT value FROM config WHERE key = 'auth'").get() as { value: string } | null;
+const token = row ? JSON.parse(row.value)?.token : undefined;
+const res = await fetch("http://localhost:8081/api/system/resources?processes=1", { headers: token ? { Authorization: `Bearer ${token}` } : {} });
+const snap = (await res.json()).data;
+const byPid = new Map(snap.processes.map((p: any) => [p.pid, p]));
+let enabled = 0, disabled = 0;
+const protectedNames = new Map<string, number>();
+for (const g of snap.groups) {
+  const members = g.pids.map((pid: number) => byPid.get(pid)).filter(Boolean);
+  if (isGroupProtected(members)) { disabled++; for (const m of members) if (m.protected) protectedNames.set(m.name, (protectedNames.get(m.name) ?? 0) + 1); }
+  else enabled++;
+}
+console.log({ groups: snap.groups.length, enabled, disabled, processes: snap.processes.length, protectedProcs: snap.processes.filter((p: any) => p.protected).length });
+console.log("protected names in disabled groups:", [...protectedNames].slice(0, 12));

package/.spike/pip-eval.ts

@@ -0,0 +1,17 @@
+// Ad-hoc: evaluate a JS expression in the spike Chrome's app page. Usage: bun pip-eval.ts "<expr>" [--shot path]
+import { CdpClient } from "./cdp-client";
+const expr = process.argv[2] ?? "location.href";
+const shotIdx = process.argv.indexOf("--shot");
+const cdp = await CdpClient.connect(9333);
+const targets = await cdp.targets();
+const page = targets.find((t) => t.type === "page" && t.url.startsWith("http://localhost:5173"));
+if (!page) throw new Error("no page: " + JSON.stringify(targets));
+const sid = await cdp.attach(page.targetId);
+try {
+  const v = await cdp.eval(sid, expr);
+  console.log(typeof v === "string" ? v : JSON.stringify(v, null, 2));
+} catch (e) {
+  console.error(String(e));
+}
+if (shotIdx > 0) await cdp.screenshot(sid, process.argv[shotIdx + 1]!);
+cdp.close();

package/.spike/pip-page-helpers.js

@@ -0,0 +1,119 @@
+// Injected into the PPM page via Runtime.evaluate. Defines window.__spike helpers.
+// Spike helper only (untracked). Plain JS, no bundling.
+(() => {
+  const S = (window.__spike = window.__spike || { log: [], results: {} });
+  S.note = (m) => { S.log.push(`${new Date().toISOString().slice(11, 23)} ${m}`); console.log("[spike]", m); };
+
+  // ---- React fiber walk: find xterm Terminal instance owned by a tab wrapper ----
+  S.fiberOf = (el) => {
+    const k = Object.keys(el).find((k) => k.startsWith("__reactFiber$"));
+    return k ? el[k] : null;
+  };
+  S.findTerminal = (wrapper) => {
+    const container = wrapper.querySelector(".xterm")?.parentElement;
+    if (!container) return null;
+    let f = S.fiberOf(container);
+    for (let depth = 0; f && depth < 40; depth++, f = f.return) {
+      let hook = f.memoizedState;
+      for (let i = 0; hook && i < 200; i++, hook = hook.next) {
+        const cur = hook.memoizedState && hook.memoizedState.current;
+        if (cur && typeof cur.getSelection === "function" && cur.buffer && typeof cur.rows === "number") return cur;
+      }
+    }
+    return null;
+  };
+  S.termText = (term, lastN = 60) => {
+    const buf = term.buffer.active;
+    const out = [];
+    for (let i = Math.max(0, buf.length - lastN); i < buf.length; i++) out.push(buf.getLine(i)?.translateToString(true) ?? "");
+    return out.join("\n");
+  };
+
+  // ---- Monaco editor instance owned by a wrapper ----
+  S.findEditor = (wrapper) => {
+    const m = window.monaco;
+    if (!m) return null;
+    return m.editor.getEditors().find((e) => wrapper.contains(e.getDomNode())) ?? null;
+  };
+
+  // ---- Style copy into PiP document ----
+  S.copyStyles = (pipDoc) => {
+    const stats = { inlineSheets: 0, clonedLinks: 0, failed: 0, rules: 0 };
+    for (const sheet of document.styleSheets) {
+      try {
+        const rules = [...sheet.cssRules];
+        const style = pipDoc.createElement("style");
+        style.textContent = rules.map((r) => r.cssText).join("\n");
+        pipDoc.head.append(style);
+        stats.inlineSheets++; stats.rules += rules.length;
+      } catch (e) {
+        if (sheet.href) {
+          const link = pipDoc.createElement("link");
+          link.rel = "stylesheet"; link.href = sheet.href;
+          pipDoc.head.append(link); stats.clonedLinks++;
+        } else stats.failed++;
+      }
+    }
+    // Theme lives on <html class="dark|light" style="--token: ...">
+    pipDoc.documentElement.className = document.documentElement.className;
+    pipDoc.documentElement.style.cssText = document.documentElement.style.cssText;
+    pipDoc.body.className = document.body.className;
+    pipDoc.body.style.cssText = "margin:0;width:100vw;height:100vh;overflow:hidden;position:relative;";
+    return stats;
+  };
+
+  // ---- Move / return ----
+  S.moveToPip = (pip, wrapper) => {
+    const slot = wrapper.parentElement;
+    S.origin = { slot, next: wrapper.nextSibling, display: wrapper.style.display, cssText: wrapper.style.cssText };
+    pip.document.body.append(wrapper); // adopts node into pip document
+    wrapper.style.position = "relative"; wrapper.style.inset = ""; wrapper.style.width = "100%"; wrapper.style.height = "100%";
+    return { adopted: wrapper.ownerDocument === pip.document, slotTag: slot.tagName, slotHasWrapper: slot.contains(wrapper) };
+  };
+  // Spike-only: stop ReparentingTab's layout effect (slot.appendChild(wrapper) on every render) from pulling the wrapper back.
+  S.pinToPip = (wrapper) => {
+    const slot = S.origin.slot; S.pinned = wrapper; S.pullbackAttempts = 0;
+    if (!slot.__spikePatched) {
+      const orig = slot.appendChild.bind(slot);
+      slot.appendChild = (n) => { if (n === S.pinned) { S.pullbackAttempts++; return n; } return orig(n); };
+      slot.__spikePatched = true;
+    }
+  };
+  S.unpin = () => { S.pinned = null; };
+  S.moveBack = (wrapper) => {
+    const { slot, cssText } = S.origin;
+    S.unpin();
+    slot.append(wrapper);
+    wrapper.style.cssText = cssText;
+    return { back: wrapper.ownerDocument === document && wrapper.parentElement === slot };
+  };
+
+  // ---- Trusted-gesture button: onclick runs the async fn, stores result ----
+  S.installButton = (id, fn) => {
+    document.getElementById(id)?.remove();
+    const b = document.createElement("button");
+    b.id = id; b.textContent = id;
+    b.style.cssText = "position:fixed;left:8px;bottom:8px;z-index:2147483647;padding:8px 12px;background:#e11;color:#fff;font:14px sans-serif;";
+    b.onclick = async () => {
+      S.results[id] = { phase: "running" };
+      try { S.results[id] = { phase: "done", value: await fn() }; }
+      catch (e) { S.results[id] = { phase: "error", error: String(e && e.stack || e) }; S.note(`button ${id} error: ${e}`); }
+    };
+    document.body.append(b);
+    const r = b.getBoundingClientRect();
+    return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+  };
+
+  // ---- Event probes (native listeners in main doc + pip doc + on wrapper) ----
+  S.installClickProbes = (pip, wrapper) => {
+    S.probe = { mainDocClick: 0, pipDocClick: 0, wrapperClick: 0, reactRootClick: 0 };
+    document.addEventListener("click", () => S.probe.mainDocClick++, true);
+    pip.document.addEventListener("click", () => S.probe.pipDocClick++, true);
+    wrapper.addEventListener("click", () => S.probe.wrapperClick++, true);
+    document.getElementById("root")?.addEventListener("click", () => S.probe.reactRootClick++, true);
+  };
+
+  S.toastText = () => [...document.querySelectorAll("[data-sonner-toast]")].map((t) => t.textContent).join(" | ");
+  S.note("helpers installed");
+  return "ok";
+})();

package/.spike/pip-results-editor-glue.json

@@ -0,0 +1,105 @@
+{
+  "mainState": {
+    "layout": [
+      1395,
+      814
+    ],
+    "slot": [
+      1033,
+      655
+    ],
+    "editContextOpt": true,
+    "nativeEditContextEl": true,
+    "editContextApi": true,
+    "minimapEnabled": false
+  },
+  "layoutFixInMain": [
+    1033,
+    627
+  ],
+  "move": {
+    "phase": "done",
+    "value": {
+      "pipSize": [
+        1395,
+        842
+      ],
+      "layoutBeforeExplicit": [
+        1033,
+        627
+      ],
+      "layoutAfterExplicit": [
+        1395,
+        814
+      ],
+      "wrapper": [
+        1395,
+        842
+      ]
+    }
+  },
+  "pipFocusTarget": {
+    "focused": "native-edit-context",
+    "hasEditContext": true
+  },
+  "typingEditContext": {
+    "line2": "EC export const spikeLine1 = \"one\";",
+    "pass": true
+  },
+  "insertTextEditContext": {
+    "line2": "EC IT export const spikeLine1 = \"one\";",
+    "pass": true
+  },
+  "switchToTextarea": {
+    "editContextOpt": false,
+    "textarea": true,
+    "nec": false
+  },
+  "typingTextarea": {
+    "line2": "TA EC IT export const spikeLine1 = \"one\";",
+    "pass": true
+  },
+  "suggestWidget": {
+    "inWrapper": true,
+    "visible": true,
+    "inMainDoc": false,
+    "items": 12
+  },
+  "resizeGlue": {
+    "pipResizes": 2,
+    "layout": [
+      684,
+      408
+    ],
+    "pip": [
+      684,
+      408
+    ]
+  },
+  "back": {
+    "back": true,
+    "layoutStaleAfterReturn": [
+      684,
+      408
+    ],
+    "layoutAfterExplicit": [
+      1033,
+      627
+    ],
+    "slot": [
+      1033,
+      655
+    ]
+  },
+  "undoAfterReturn": {
+    "steps": [
+      "TA EC IT export const spikeLine1 = \"one\"; || L8=",
+      "TAEC IT export const spikeLine1 = \"one\"; || L8=",
+      "EC ITexport const spikeLine1 = \"one\"; || L8=",
+      "ECexport const spikeLine1 = \"one\"; || L8=",
+      "export const spikeLine1 = \"one\"; || L8=",
+      "export const spikeLine1 = \"one\"; || L8="
+    ],
+    "line2Restored": true
+  }
+}

package/.spike/pip-results-editor.json

@@ -0,0 +1,158 @@
+{
+  "baseline": {
+    "line1": "MAIN1 MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+    "layoutW": 1395,
+    "layoutH": 814,
+    "wordWrap": "off",
+    "minimapCanvases": 2
+  },
+  "move": {
+    "phase": "done",
+    "value": {
+      "styles": {
+        "inlineSheets": 11,
+        "clonedLinks": 2,
+        "failed": 0,
+        "rules": 1477
+      },
+      "moved": {
+        "adopted": true,
+        "slotTag": "DIV",
+        "slotHasWrapper": false
+      },
+      "pipSize": [
+        1395,
+        842
+      ],
+      "viewLines": 8,
+      "firstLineText": "MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+      "layout": [
+        1395,
+        814
+      ],
+      "minimap": {
+        "w": 0,
+        "h": 814
+      },
+      "editorRect": [
+        1395,
+        814
+      ],
+      "monacoTheme": "rgb(21, 22, 28)",
+      "mainBg": "rgb(21, 22, 28)"
+    }
+  },
+  "pipAttached": true,
+  "shotInPip": "C:/Users/PC/ppm/plans/reports/screenshots/spike-02-editor-in-pip.png",
+  "mouseInPip": {
+    "clickedLineText": "export const spikeLine3 = \"three\";",
+    "positionAfterClick": [
+      4,
+      7
+    ],
+    "dragSelection": "xport const spikeLine2",
+    "dragPass": true
+  },
+  "typingInPip": {
+    "line1": "MAIN1 MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+    "pass": false
+  },
+  "shotTyped": "C:/Users/PC/ppm/plans/reports/screenshots/spike-02c-editor-in-pip-typed.png",
+  "resizeViaStyle": {
+    "before": [
+      1395,
+      814
+    ],
+    "after": [
+      1395,
+      814
+    ],
+    "restored": [
+      1395,
+      814
+    ],
+    "relayout": false
+  },
+  "resizeViaWindow": {
+    "before": [
+      1395,
+      814
+    ],
+    "samples": [
+      {
+        "afterMs": 300,
+        "layout": [
+          1395,
+          814
+        ],
+        "pip": [
+          684,
+          408
+        ]
+      },
+      {
+        "afterMs": 1000,
+        "layout": [
+          1395,
+          814
+        ],
+        "pip": [
+          684,
+          408
+        ]
+      },
+      {
+        "afterMs": 3000,
+        "layout": [
+          1395,
+          814
+        ],
+        "pip": [
+          684,
+          408
+        ]
+      }
+    ]
+  },
+  "shotResized": "C:/Users/PC/ppm/plans/reports/screenshots/spike-02d-editor-in-pip-resized.png",
+  "reactClickInPip": {
+    "wordWrapBefore": "off",
+    "wordWrapAfter": "off",
+    "probe": {
+      "mainDocClick": 0,
+      "pipDocClick": 1,
+      "wrapperClick": 3,
+      "reactRootClick": 0
+    }
+  },
+  "suggestWidget": {
+    "inWrapper": false,
+    "visible": null,
+    "inMainDoc": false,
+    "overflowContainer": true,
+    "fixedOverflow": false
+  },
+  "pullbackAttemptsWhileInPip": {
+    "attempts": 0,
+    "stillInPip": true
+  },
+  "back": {
+    "back": true,
+    "layout": [
+      1395,
+      814
+    ],
+    "line1": "MAIN1 MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete."
+  },
+  "afterReturn": {
+    "afterUndo1": "MAIN1MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+    "afterUndo2": "MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+    "undoPass": false,
+    "line1AfterTyping": "BACK3 MAIN1 MAIN1 // Scratch file for the Document PiP spike. Monaco autosaves edits here; safe to delete.",
+    "typingPass": true,
+    "reactWrapToggle": {
+      "before": "off",
+      "after": "on"
+    }
+  }
+}

package/.spike/pip-results-input-isolation.json

@@ -0,0 +1,28 @@
+{
+  "inputApiRoundTripped": {
+    "dataLog": [
+      "echo VIA-INPUT-API\r"
+    ],
+    "echoed": true,
+    "tail": "\n\n",
+    "rows": 44,
+    "cols": 147,
+    "visible": 660
+  },
+  "freshTerminalTrustedKeys": {
+    "id": "terminal:2@panel-8281c2e3",
+    "dataLog": "\u001b[Iecho FRESH-TERM\r",
+    "echoed": true,
+    "tail": "\n\n",
+    "rows": 44,
+    "cols": 147
+  },
+  "roundTrippedTrustedKeys": {
+    "dataLog": "",
+    "echoed": false,
+    "tail": "\n\n",
+    "textareaIsTermTextarea": true,
+    "textareaDoc": true,
+    "elementDoc": true
+  }
+}

package/.spike/pip-results-key-probe.json

@@ -0,0 +1,58 @@
+{
+  "noEmulation": {
+    "hasFocus": true,
+    "vis": "hidden",
+    "active": "xterm-helper-textarea",
+    "keyLog": [
+      "keydown:a:true",
+      "keypress:a:true",
+      "beforeinput:a:true",
+      "input:a:true",
+      "keyup:a:true",
+      "keydown:b:true",
+      "keypress:b:true",
+      "beforeinput:b:true",
+      "input:b:true",
+      "keyup:b:true"
+    ],
+    "dataLog": []
+  },
+  "afterBringToFront": {
+    "hasFocus": true,
+    "vis": "hidden",
+    "active": "xterm-helper-textarea",
+    "keyLog": [
+      "keydown:a:true",
+      "keypress:a:true",
+      "beforeinput:a:true",
+      "input:a:true",
+      "keyup:a:true",
+      "keydown:b:true",
+      "keypress:b:true",
+      "beforeinput:b:true",
+      "input:b:true",
+      "keyup:b:true"
+    ],
+    "dataLog": []
+  },
+  "withFocusEmulation": {
+    "hasFocus": true,
+    "vis": "visible",
+    "active": "xterm-helper-textarea",
+    "keyLog": [
+      "keydown:a:true",
+      "keypress:a:true",
+      "beforeinput:a:true",
+      "input:a:true",
+      "keyup:a:true",
+      "keydown:b:true",
+      "keypress:b:true",
+      "beforeinput:b:true",
+      "input:b:true",
+      "keyup:b:true"
+    ],
+    "dataLog": [
+      "\u001b[O"
+    ]
+  }
+}