mulmoterminal 4.26.0 → 4.27.0

package/README.md

@@ -1232,6 +1232,18 @@ The toggle is not the only way in: while a cell is enlarged, **clicking a file p
 printed** opens it here too, rather than in a new tab or full-screen — see
 [Clicking a file path](#clicking-a-file-path).
 
+**Open a file by name instead of walking the tree.** The pane's header has a **search** button
+that opens a finder over it: type part of a file's name or path and it narrows a list of every
+file in the project — fuzzily, so `fpane` finds `src/components/FilesPane.vue`. Arrow keys and
+Enter pick one; it opens in the editor **with the tree expanded down to it**, so the files
+around it are one click away. In a git repository the candidates come from `git ls-files`, so
+everything your `.gitignore` excludes — `node_modules` and the rest — is never offered; outside
+one the tree is walked instead: no ignore file is read, and only a short list of directories
+nobody authors by hand (`node_modules`, virtualenvs, caches) is skipped. The panel says so rather
+than letting you believe an ignore file was applied. There is also a
+[`files-find` shortcut](https://receptron.github.io/mulmoterminal/guide/en/config.html#keymap)
+with no default binding, which opens the pane first if it is closed.
+
 All reads and writes go through `GET/PUT /api/files/browse/*?cwd=&path=`, and every
 `path` is **contained within the project root** (server-side) — `..`/absolute escapes
 are rejected for reads and writes alike, so editing can't reach outside the directory

package/common/collectionRefresh.ts

@@ -0,0 +1,34 @@
+// The `POST /api/collections/:slug/refresh` response. One shape for BOTH arms of that
+// route — a declarative/agent feed's `ingest` re-run and a `googleCalendar` sync — because
+// the collection view reads one result whichever arm answered, and two host-side shapes for
+// one button is how a field ends up set by one arm and never read from the other.
+//
+// It mirrors MulmoClaude's `CollectionRefreshBody` (server/api/routes/collectionCalendarRefresh.ts)
+// so the two hosts over the shared workspace answer the same plugin identically. Re-stated
+// rather than imported, for `collectionPush.ts`'s reason: the plugin ships its
+// `CollectionRefreshResult` from `@mulmoclaude/collection-plugin/vue`, and the server has no
+// business pulling a Vue package in to describe its own response.
+//
+// An absent field is an ABSENT KEY, never an explicit `undefined`. That is what the wire carries
+// either way (JSON.stringify drops an undefined value), and under `exactOptionalPropertyTypes` it
+// is also what makes this assignable to the plugin's own `CollectionRefreshResult` — so the
+// binding in `collectionUi.ts` type-checks the server's shape against the view's expectation
+// instead of both sides describing it separately.
+
+export interface CollectionRefreshResult {
+  /** Always true — "the refresh ran", not "records changed". A refusal is told through
+   *  `errors`, the way the push's `pushed` works. */
+  refreshed: true;
+  written: number;
+  /** Why the refresh did not do what was asked. Read beside the button, so an empty list is
+   *  the only thing that means "it worked". */
+  errors: string[];
+  /** Records a `googleCalendar` sync deleted (the event was cancelled in Google). Sent by the
+   *  calendar arm only: the feed engine counts its own `maxItems` evictions, but the feed arm
+   *  has never reported them and MulmoClaude's does not either. */
+  removed?: number;
+  /** An agent-ingest feed dispatched a worker session instead of writing records itself. */
+  dispatched?: boolean;
+  /** The dispatched session, for the view to navigate to. */
+  chatId?: string;
+}

package/common/keymap.ts

@@ -22,6 +22,7 @@ export const KEYMAP_ACTIONS = [
   "terminal-new-adjacent",
   "terminal-close",
   "terminal-restart",
+  "files-find",
   "copy",
   "paste",
 ] as const;
@@ -49,7 +50,17 @@ export const TERMINAL_SCOPED_ACTIONS: readonly KeymapAction[] = ["copy", "paste"
 // Here rather than beside gridShortcutFor because BOTH sides decide from it: the grid dispatches on
 // it, and validateKeymap has to know that these decline the key — the handler returns WITHOUT
 // stopping the event, so a `send` on the same keystroke fires instead (codex on #1906).
-export const NEEDS_A_CURRENT_TERMINAL: readonly KeymapAction[] = ["zoom-next", "zoom-prev", "terminal-new-adjacent", "terminal-close", "terminal-restart"];
+// `files-find` is here because the pane it opens exists only in the ENLARGED row (see
+// docs/grid-view-modes.md) — a tiled grid has nowhere to put it, so the key declines rather than
+// guessing which of nine terminals was meant.
+export const NEEDS_A_CURRENT_TERMINAL: readonly KeymapAction[] = [
+  "zoom-next",
+  "zoom-prev",
+  "terminal-new-adjacent",
+  "terminal-close",
+  "terminal-restart",
+  "files-find",
+];
 
 // A key that puts BYTES into the focused terminal instead of running an app action (#1005) —
 // Cmd+Right as Ctrl+E for end-of-line, say, or Alt+B for word-back.

package/common/themeColors.ts

@@ -28,3 +28,20 @@ export const THEME_COLOR_KEYS = [
   "brightCyan",
   "brightWhite",
 ] as const;
+
+export type ThemeColorKey = (typeof THEME_COLOR_KEYS)[number];
+
+/** What a palette colour may look like: xterm accepts `#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa`.
+ *  Here rather than in the server schema because BOTH sides check it — the server rejects a config
+ *  on it, and the client re-checks the response before the value reaches a canvas. Two copies of
+ *  this pattern is how one side ends up accepting what the other drops. */
+export const PALETTE_COLOR_RE = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+
+/** STRICT — surrounding whitespace is a reject, not something to trim away. The server's
+ *  `paletteColor` trims before it matches and hands back the trimmed value, so everything this
+ *  predicate legitimately sees has already been normalised; accepting `" #fff "` here would mean
+ *  forwarding that exact string to xterm, which does not trim and cannot parse it. Validate the
+ *  value you are about to pass on, not a cleaned-up version of it. */
+export function isPaletteColor(value: unknown): value is string {
+  return typeof value === "string" && PALETTE_COLOR_RE.test(value);
+}

package/common/themeVars.ts

@@ -4,6 +4,7 @@
 // it, so a key known to one side and not the other would be accepted and then silently ignored.
 
 import { THEME_IDS, type ThemeId } from "./themeIds.js";
+import type { ThemeColorKey } from "./themeColors.js";
 
 // The CSS custom properties one theme sets, mirroring the `:root[data-theme=...]` blocks in
 // src/style.css. A theme with no `extends` has to supply every one of them — a half-painted
@@ -65,6 +66,10 @@ export interface CustomThemeInput {
   /** A built-in theme to start from. Omitted means `colors` must be complete. */
   extends?: ThemeId;
   colors: Partial<ThemeVars>;
+  /** xterm palette entries set outright, for the canvas colours `colors` cannot reach: the
+   *  cursor pair, the selection foreground, the 16 ANSI colours. Wins over what `colors`
+   *  implies (#2097). */
+  term?: Partial<Record<ThemeColorKey, string>>;
 }
 
 /** The full variable set for a theme: the base it extends, with its own colours on top.
@@ -132,11 +137,24 @@ export function isLightTheme(vars: ThemeVars): boolean {
 /** The xterm palette a theme's variables imply. xterm draws on a canvas and cannot read CSS
  *  variables, so the same colours have to reach it as values — derived here rather than asked
  *  for twice, since two copies of one colour is two chances to change only one. The 16 ANSI
- *  colours are NOT derived: they come from the base theme, which is what `extends` is for. */
-export function termThemeFromVars(vars: ThemeVars): { background: string; foreground: string; selectionBackground: string } {
+ *  colours are NOT derived: they come from the base theme, which is what `extends` is for.
+ *
+ *  The cursor pair is derived from the SAME two variables the cell it sits on uses, which makes
+ *  the cursor an inverted cell — so the character under it stays as readable as the characters
+ *  beside it. Inheriting the cursor from the base instead is what made a light theme extending a
+ *  dark one draw a dark block with xterm's default black glyph on top (#2097). */
+export function termThemeFromVars(vars: ThemeVars): {
+  background: string;
+  foreground: string;
+  selectionBackground: string;
+  cursor: string;
+  cursorAccent: string;
+} {
   return {
     background: vars["--bg-base"],
     foreground: vars["--term-fg"],
     selectionBackground: vars["--term-selection"],
+    cursor: vars["--term-fg"],
+    cursorAccent: vars["--bg-base"],
   };
 }