ompchamber 3.5.0 → 3.6.0

package/src/shared/lib/markdown/katex.ts

@@ -62,7 +62,17 @@ export function preloadKatex(): void {
  * like every other model-authored fragment in this pipeline.
  */
 function renderPlaceholder(el: HTMLElement, katex: KatexModule['default']): void {
-  const tex = el.dataset.math ?? '';
+  // `marked.ts` percent-encodes the payload, the way a mermaid block carries
+  // its source: the TeX must survive the HTML attribute round-trip untouched,
+  // and escaping it as HTML double-encoded every formula the prose escaper had
+  // already touched. A malformed payload degrades to the raw attribute.
+  const encoded = el.dataset.math ?? '';
+  let tex = encoded;
+  try {
+    tex = decodeURIComponent(encoded);
+  } catch {
+    // Leave `tex` as the literal attribute text.
+  }
   const displayMode = el.dataset.mathDisplay === '1';
   try {
     el.innerHTML = sanitizeKatexHtml(katex.renderToString(tex, { throwOnError: false, displayMode }));

package/src/shared/lib/markdown/marked.ts

@@ -11,7 +11,15 @@
  *   2. marked  — GFM true, breaks true, autolink via linkify-it (CJK
  *      punctuation is not swallowed into URLs, and a match carrying a backtick
  *      is left to the code-span rule — see autolink.ts), plus a KaTeX
- *      extension for \(...\) inline, \[...\] block, and $$...$$ display math
+ *      extension for \(...\) inline, \[...\] block, $$...$$ display and
+ *      $...$ inline math
+ *
+ * remend heals BLOCK math (`$$…$$`) only. Its inline healer must stay off
+ * (`inlineKatex: false`): it closes an unmatched `$` by appending one to the
+ * END OF THE TEXT, so any message with an odd `$` count — every lone `$HOME`,
+ * `$PATH`, `$1` — became one giant formula from that `$` to the end of the
+ * message, and a `$` landing on a closing ``` fence swallowed the rest of the
+ * document into that code block. `$…$` is left to marked's own flanking rules.
  *
  * The resulting HTML is NOT sanitized here — run the output through
  * DOMPurify (see sanitize.ts) before injecting. What the source's own HTML
@@ -35,19 +43,44 @@ function escapeHtml(value: string): string {
     .replace(/'/g, ''');
 }
 
+/**
+ * True while `renderMarkdown` parses prose it escaped itself. Set around the
+ * `marked.parse` call, read by `renderMathPlaceholder`. Synchronous by
+ * construction: `marked.parse` never awaits, so no nested `renderMarkdown`
+ * can observe the flag mid-parse.
+ */
+let proseEscaped = false;
+
 /**
  * Emit a math placeholder instead of rendering KaTeX inline.
  *
  * `katex` is ~522 kB of JS worth loading only when a message contains math, so
  * it is not imported here. The placeholder carries the TeX source and the
  * display flag; `katex.ts` swaps it for real markup once the library lands
- * (see `hydrateMathBlocks`). Both attributes are HTML-escaped, and escaping
- * `&` first keeps the entity encoding intact through the attribute round-trip.
+ * (see `hydrateMathBlocks`).
+ *
+ * Two things happen to the captured source here, and both exist because this
+ * renderer is the one place all four math extensions funnel through:
+ *
+ * 1. **Entities are reversed** when `renderMarkdown` escaped the prose itself
+ *    (`proseEscaped`). `escapeHtmlOutsideCode` rewrites the source BEFORE
+ *    marked sees it, so a tokenizer captures `x &lt; y` rather than `x < y` and
+ *    KaTeX reports a syntax error for a perfectly good formula. Only the three
+ *    entities that escaper emits are reversed, and only when it ran — a
+ *    document (`allowHtml`) whose own text legitimately holds `&amp;` is left
+ *    alone.
+ * 2. **The result is percent-encoded**, the way a mermaid block carries its
+ *    source. HTML-escaping the payload instead re-escapes what step 1 just
+ *    restored, and the attribute round-trip hides the extra layer from both
+ *    ends. An encoded payload holds no HTML-special character, so nothing
+ *    between here and `renderPlaceholder` can alter it.
  */
 function renderMathPlaceholder(tex: string, displayMode: boolean): string {
-  const escaped = escapeHtml(tex);
+  const restored = proseEscaped
+    ? tex.replace(/&(amp|lt|gt);/g, (_, name: string) => (name === 'amp' ? '&' : name === 'lt' ? '<' : '>'))
+    : tex;
   const display = displayMode ? ' data-math-display="1"' : '';
-  const span = `<span class="${MATH_PENDING_CLASS}" data-math="${escaped}"${display}></span>`;
+  const span = `<span class="${MATH_PENDING_CLASS}" data-math="${encodeURIComponent(restored)}"${display}></span>`;
   // Block math must stay inside a block element: DOMPurify drops a bare
   // `<span>` that sits at the top level of the fragment, which silently deleted
   // every `$$…$$` formula. KaTeX's own output is inline-level too, so the old
@@ -178,11 +211,25 @@ marked.use({
         return renderMathPlaceholder(token.text ?? '', true);
       },
     },
-    // $ ... $ inline math, per remark-math flanking rules: the opening $ must
-    // follow start/whitespace/punctuation (never a word char, so "$5 each" and
-    // "a$b" read as text) and must not be followed by $ or whitespace; the
-    // closing $ must not be preceded by whitespace and not be followed by $
-    // or a digit (so "$n$ =" still works but "cost $5$" does not).
+    // $ ... $ inline math. The flanking rules are the whole defence: a single
+    // `$` is the one delimiter that collides with ordinary text, and this
+    // pipeline renders shell output, currency, SQL and awk programs all day.
+    //
+    //   opening $  — not preceded by a word char (checked in `start`, the only
+    //                place the preceding character is visible), and not
+    //                followed by a digit, `$` or `{`. The digit guard is what
+    //                makes `$5`, `$1` and `$10` text; `{` keeps `${HOME}` out.
+    //   closing $  — not preceded by whitespace, and not followed by a WORD
+    //                char or `$`. That trailing guard is load-bearing twice
+    //                over: it rejects `PATH=$PATH:$HOME` (closer followed by
+    //                `H`) and `a$b$c` (followed by `c`), and it is the reason
+    //                the rule no longer depends on where `start` happened to
+    //                land — the tokenizer is anchored at `^` and cannot see
+    //                the preceding character, so `a$b$c` was math while
+    //                `ax$b$c` was text on the identical rule.
+    //
+    // `$n$ = 3` and `$x^2$ benar` still parse: a space after the closer is not
+    // a word char.
     {
       name: 'inlineMathDollar',
       level: 'inline',
@@ -191,7 +238,7 @@ marked.use({
         return match ? match.index + (match[1]?.length ?? 0) : undefined;
       },
       tokenizer(src: string) {
-        const match = /^\$(?!\$)(?!\s)((?:\\\$|[^$])*?)(?<!\s)\$(?!\$)(?!\d)/.exec(src);
+        const match = /^\$(?![\d${])((?:\\\$|[^$])*?)(?<!\s)\$(?![\w$])/.exec(src);
         return match
           ? { type: 'inlineMathDollar', raw: match[0], text: match[1] }
           : undefined;
@@ -241,9 +288,17 @@ export interface RenderMarkdownOptions {
  */
 export function renderMarkdown(markdown: string, options: RenderMarkdownOptions = {}): string {
   const source = options.allowHtml ? markdown : escapeHtmlOutsideCode(markdown);
-  const healed = remend(source, { katex: true, inlineKatex: true })
+  const healed = remend(source, { katex: true, inlineKatex: false })
     .replace(INCOMPLETE_LINK_RE, (_, text: string) => `<span class="md-incomplete-link">${text}</span>`);
-  return (marked.parse(healed) as string).trim();
+  // The math renderers need to know the prose was escaped, so they can hand
+  // KaTeX the source the author wrote instead of `x &lt; y`. `marked.parse`
+  // never awaits, so no nested render can observe this mid-parse.
+  proseEscaped = !options.allowHtml;
+  try {
+    return (marked.parse(healed) as string).trim();
+  } finally {
+    proseEscaped = false;
+  }
 }
 
 export { marked };

package/src/shared/lib/markdown/math.test.ts

@@ -78,7 +78,9 @@ describe('lazy math rendering', () => {
 
     const placeholder = host.querySelector('.math-pending');
     expect(placeholder).not.toBeNull();
-    expect(placeholder?.getAttribute('data-math')).toBe('E = mc^2');
+    // The payload travels percent-encoded (see `renderMathPlaceholder`), so the
+    // assertion decodes rather than reading the attribute raw.
+    expect(decodeURIComponent(placeholder?.getAttribute('data-math') ?? '')).toBe('E = mc^2');
 
     expect(await hydrateMathBlocks(host)).toEqual({ rendered: 1, failed: 0 });
 
@@ -123,4 +125,54 @@ describe('lazy math rendering', () => {
     const html = renderMarkdown('a $x" onmouseover="alert(1)$ b');
     expect(html).not.toContain('onmouseover="alert');
   });
+
+  // A lone `$` is the delimiter most likely to appear in ordinary text this
+  // app renders all day — shell output, currency, SQL placeholders, awk
+  // programs. Each of these was a formula before the flanking rules and the
+  // remend inline healer were fixed, and the failure was not cosmetic: an odd
+  // `$` count made the formula run to the END of the message.
+  test('a single $ is text, never math', () => {
+    for (const source of [
+      'Hasil: $HOME',
+      '$HOME',
+      'Path ada di $HOME.',
+      'Biaya $5.',
+      'Pakai ${HOME}/bin',
+      'SELECT * FROM t WHERE id = $1',
+      "awk '{print $1, $2}' file",
+      'PATH=$PATH:$HOME',
+      'a$b$c',
+    ]) {
+      const host = mount(source);
+      expect(host.querySelectorAll('.math-pending').length).toBe(0);
+      expect(host.textContent).toBe(source);
+    }
+  });
+
+  test('an unmatched $ does not run to the end of the message', () => {
+    // remend's inline healer used to close the `$` at the very end of the
+    // text, turning everything after it into one formula.
+    const source = 'Hasil: $HOME lalu baris kedua biasa';
+    const host = mount(source);
+    expect(host.querySelectorAll('.math-pending').length).toBe(0);
+    expect(host.textContent).toBe(source);
+  });
+
+  test('a $ in a fenced block leaves the closing fence intact', () => {
+    const host = mount('```\necho $HOME\n```');
+    const code = host.querySelector('pre code');
+    expect(code?.textContent).toBe('echo $HOME');
+    expect(host.querySelectorAll('.math-pending').length).toBe(0);
+  });
+
+  // `escapeHtmlOutsideCode` rewrites the source before marked parses it, so a
+  // formula reached KaTeX as `x < y` and rendered as a syntax error.
+  test('entities in a formula reach KaTeX as the author wrote them', async () => {
+    const host = mount('rumus $x < y$ dan $a \\& b$ benar');
+    expect(host.querySelectorAll('.math-pending').length).toBe(2);
+
+    await hydrateMathBlocks(host);
+    expect(host.querySelectorAll('.katex-error').length).toBe(0);
+    expect(host.querySelectorAll('.katex').length).toBe(2);
+  });
 });

package/src/shared/lib/updates/progress.test.ts

@@ -0,0 +1,54 @@
+/**
+ * The update log fold. Output arrives in chunks that do not respect line
+ * boundaries, so the two properties that matter are: a line is never rendered
+ * in halves, and a long log keeps its tail.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { appendUpdateLog, UPDATE_LOG_LIMIT, updateLogText, type UpdateLogState } from '@/shared/lib/updates/progress';
+
+function empty(): UpdateLogState {
+  return { lines: [], pending: '', truncated: false };
+}
+
+describe('appendUpdateLog', () => {
+  test('a chunk split mid-line is held until its newline arrives', () => {
+    const first = appendUpdateLog(empty(), 'Installing ompcha');
+    // Nothing complete yet: the partial line is carried, not rendered as a line.
+    expect(first.lines).toEqual([]);
+    expect(updateLogText(first)).toBe('Installing ompcha');
+
+    const second = appendUpdateLog(first, 'mber@0.7.1\n');
+    expect(second.lines).toEqual(['Installing ompchamber@0.7.1']);
+    expect(second.pending).toBe('');
+  });
+
+  test('several lines in one chunk each become their own line', () => {
+    const state = appendUpdateLog(empty(), 'one\ntwo\nthree');
+    expect(state.lines).toEqual(['one', 'two']);
+    expect(state.pending).toBe('three');
+    expect(updateLogText(state)).toBe('one\ntwo\nthree');
+  });
+
+  test('an empty chunk does not add a line', () => {
+    const state = appendUpdateLog(appendUpdateLog(empty(), 'x\n'), '');
+    expect(state.lines).toEqual(['x']);
+  });
+
+  test('a log past the limit keeps the newest lines and reports the trim', () => {
+    const chunk = `${'a'.repeat(1000)}\n`.repeat(30);
+    const state = appendUpdateLog(empty(), chunk);
+
+    expect(state.truncated).toBe(true);
+    const length = state.lines.reduce((total, line) => total + line.length + 1, 0);
+    expect(length).toBeLessThanOrEqual(UPDATE_LOG_LIMIT);
+    // The tail is what survives: a failing step reports at the end.
+    expect(state.lines.length).toBeLessThan(30);
+    expect(state.lines.at(-1)).toBe('a'.repeat(1000));
+  });
+
+  test('a log under the limit is not marked truncated', () => {
+    expect(appendUpdateLog(empty(), 'short\n').truncated).toBe(false);
+  });
+});

package/src/shared/lib/updates/progress.ts

@@ -0,0 +1,50 @@
+/**
+ * The log fold behind the update stream.
+ *
+ * Command output arrives in arbitrary chunks, so the state has to hold a
+ * partial trailing line across frames — rendering a half-line as if it were
+ * finished makes the log flicker between two spellings of the same line. The
+ * fold lives here, apart from the hook, so it is unit-testable without a
+ * process or a network.
+ */
+
+/** Cap on retained output; the tail is what matters when a step fails. */
+export const UPDATE_LOG_LIMIT = 20_000;
+
+export interface UpdateLogState {
+  /** Lines complete enough to show. */
+  lines: string[];
+  /** Carried across frames: a chunk boundary can fall mid-line. */
+  pending: string;
+  /** Bytes were dropped from the head once the log passed the limit. */
+  truncated: boolean;
+}
+
+/** Fold one streamed chunk into the log. */
+export function appendUpdateLog(state: UpdateLogState, chunk: string): UpdateLogState {
+  const parts = (state.pending + chunk).split('\n');
+  const pending = parts.pop() ?? '';
+  if (parts.length === 0) return { ...state, pending };
+
+  let lines = [...state.lines, ...parts];
+  let truncated = state.truncated;
+  let length = lines.reduce((total, line) => total + line.length + 1, 0);
+  let start = 0;
+  // Keep the newest lines: a failing step reports at the end, and the head of a
+  // long install log is the least useful thing on screen.
+  while (length > UPDATE_LOG_LIMIT && start < lines.length - 1) {
+    length -= (lines[start]?.length ?? 0) + 1;
+    start += 1;
+  }
+  if (start > 0) {
+    lines = lines.slice(start);
+    truncated = true;
+  }
+
+  return { lines, pending, truncated };
+}
+
+/** The text to show: complete lines, then whatever partial line is in flight. */
+export function updateLogText(state: UpdateLogState): string {
+  return (state.pending ? [...state.lines, state.pending] : state.lines).join('\n');
+}

package/src/shared/types/settings/command.ts

@@ -12,10 +12,23 @@ export interface CommandItem {
   name: string;
   description: string;
   scope: CommandScope;
-  overrideAgent?: string;
-  overrideModel?: string;
+  /**
+   * Markdown template. For a command backed by a file this is the file body
+   * (`$ARGUMENTS`, `` !`shell` `` and `@file` are expanded by omp at run time);
+   * for a builtin it is the literal `/name` token.
+   */
   template: string;
   isBuiltIn?: boolean;
+  /** Absolute path of the markdown command file backing this command, when it
+   *  is one. Absent for a builtin, a skill, or an extension command. */
+  filePath?: string;
+  /** omp's discovery source: `builtin`, `skill`, `custom`, `extension`, `file`. */
+  source?: string;
+  /** True only for a markdown file under a root the chamber owns
+   *  (`~/.omp/agent/commands`, `<workspace>/.omp/commands`). Everything else —
+   *  a builtin, a `.claude` command, an extension command — renders read-only
+   *  and cannot be deleted through the chamber. */
+  managed?: boolean;
   /** oh-my-pi aliases (`/models` for `/model`); live agent commands only. */
   aliases?: string[];
   /** Declarative subcommands; live agent commands only. */

package/src/shared/types/settings/skill.ts

@@ -7,8 +7,21 @@ export interface SkillItem {
   location: SkillLocation;
   locationLabel?: string;
   group?: string;
+  /**
+   * The SKILL.md body for a skill the chamber owns (`managed`), or the file
+   * path for a read-only one — where the settings pane shows the source
+   * location instead of an editor it must not save through.
+   */
   instructions: string;
   project: string;
+  /** Absolute path of the SKILL.md backing this skill. */
+  filePath?: string;
+  /** omp's discovery source, e.g. `native:user`, `agents:project`. */
+  source?: string;
+  /** Chamber-owned: editable and deletable through the settings pane. */
+  managed?: boolean;
+  /** Excluded from the model's `<skills>` listing (`hide` / disableModelInvocation). */
+  hidden?: boolean;
   isInstalledFromCatalog?: boolean;
   catalogSource?: string;
 }