mulmoterminal 4.12.0 → 4.13.0

package/README.md

@@ -1400,7 +1400,11 @@ Favorited collections get their own toolbar buttons.
   grid — so you can flip between "see everything" and "focus on one" in a click. While
   zoomed, keys you bind walk the enlargement along the on-screen order without reaching for
   the mouse — **opt-in, nothing is bound by default**, since any bound key is taken from the
-  terminal underneath. Add a `keymap` to `~/.mulmoterminal/config.json`; see the
+  terminal underneath. Press **Set up shortcuts…** in Settings → **Keyboard shortcuts** and an
+  agent writes the `keymap` for you, checking each binding against your existing ones and the traps
+  a browser or a Mac adds; that section also lists every action and the `send` row whether bound or not, including the
+  [keys sent straight to the terminal](https://receptron.github.io/mulmoterminal/guide/en/config.html#keymap-send).
+  To write it by hand, add a `keymap` to `~/.mulmoterminal/config.json` — see the
   [guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#keymap)
   for the syntax, the action list, and combinations a browser can never bind.
 

package/bin/cli-args.js

@@ -191,6 +191,20 @@ export function launcherUrl(reachHost, port) {
  * TOP-LEVEL visit to the old origin can see it. A URL that has to be stable is therefore cheaper
  * to keep stable than to migrate.
  *
+ * SECOND, INDEPENDENT reason, and the one this comment was missing: Firebase gates
+ * `signInWithPopup` on the CALLING PAGE'S ORIGIN, against the authorized-domain list of the
+ * project — and RemoteHost's Google sign-in is exactly that call
+ * (`src/components/RemoteHostControl.vue`, against `mulmoserver` in `common/firebaseConfig.ts`).
+ * Reported on #1900: that project authorizes `localhost` and NOT `127.0.0.1`, checked in the
+ * console on 2026-08-28, which is why phone pairing could not sign in on 4.11.0 and can on
+ * 4.12.0. Not verified here — this repo cannot read that project's settings.
+ *
+ * It matters because the two reasons fail INDEPENDENTLY. Someone who solves the storage half —
+ * moves the grid layout server-side, say — would read the paragraph above as the whole
+ * justification and be free to change this string, and the first thing to break would be a
+ * feature nothing in `bin/` mentions. Changing the URL means adding the new loopback address to
+ * that authorized-domain list first.
+ *
  * Reachability is not the reason it is safe; #1834 is. `server/infra/loopback-listener.ts` makes
  * this server serve `127.0.0.1` in EVERY configuration — as the primary bind, or as a second
  * listener when the operator widens it — because eight local callers write that address as a
@@ -224,6 +238,13 @@ export function browserUrl(port) {
  * IT, and otherwise say plainly that we stepped aside — including where their layout went, since
  * a silent switch here is #1889 all over again for that one user.
  *
+ * Stepping aside costs more than the layout, and the note says so: on `http://127.0.0.1:<port>`
+ * RemoteHost's Google sign-in is refused as well, because Firebase checks the page's origin
+ * against its authorized domains and that project lists `localhost` only (#1900). This branch is
+ * a real degradation of the app rather than a cosmetic change of address, and the second failure
+ * would otherwise be found only by trying to pair a phone — which is the shape of #1889 again,
+ * one feature further along.
+ *
  * The probe cannot close the window, only narrow it: `::1` is free when asked, and unless the
  * server binds it (a `::1` or `::` bind), a stranger could still take it afterwards. That is the
  * same probe/bind race `isPortFree` already documents and accepts.
@@ -236,7 +257,7 @@ export function launchTarget(reachHost, port, localhostIsUnambiguous) {
     const checked = launcherUrl(reachHost, port);
     return {
       url: checked,
-      note: `Something else is already listening on [::1]:${port}, so the browser is being sent to ${checked} — the address that was checked. If your layout and settings look empty, they are filed under http://localhost:${port}.`,
+      note: `Something else is already listening on [::1]:${port}, so the browser is being sent to ${checked} — the address that was checked. If your layout and settings look empty, they are filed under http://localhost:${port}, and the phone's Google sign-in works only there.`,
     };
   }
   const bound = reachHost === V4_LOOPBACK_CLIENTS_DIAL || reachHost === "::1";

package/bin/mulmoterminal.js

@@ -478,16 +478,23 @@ function runServer(port, probedAddress, localhostIsUnambiguous, noOpen, cwd, onC
     // binding — that is #1876's fix and it stays. The URL asks "where does this user's browser
     // keep its state", and the only answer that does not empty the app is the one it has always
     // been given: see browserUrl.
-    const beginReady = (reachHost) => {
+    // `serverSaysLocalhostIsOurs` is the child's own report and OUTRANKS the probe when present.
+    // The probe ran before the child existed, so it cannot see a process that claimed EITHER
+    // loopback during the boot — only the child knows how its own binds went (Codex, PR #1903).
+    // `undefined` means the child said nothing about it, and then the probe is all there is.
+    const beginReady = (reachHost, serverSaysLocalhostIsOurs) => {
       if (readyStarted) return;
       readyStarted = true;
-      const { url, note } = launchTarget(reachHost, port, localhostIsUnambiguous);
+      const localhostIsOurs = localhostIsUnambiguous && serverSaysLocalhostIsOurs !== false;
+      const { url, note } = launchTarget(reachHost, port, localhostIsOurs);
       cancelReady = waitUntilReady(port, () => announceReady(url, note, noOpen), { host: reachHost });
     };
     server.on("message", (msg) => {
       if (!isRecordLike(msg) || msg.type !== "listening" || typeof msg.address !== "string") return;
       const reported = launcherReachHost(msg.address);
-      if (reported) beginReady(reported);
+      // Absent rather than false when the field is missing, so "an older child said nothing" and
+      // "this child could not take it" stay different answers.
+      if (reported) beginReady(reported, typeof msg.localhostIsOurs === "boolean" ? msg.localhostIsOurs : undefined);
     });
     // The fallback runs ONLY on an address we can name without asking anyone. Guessing from a
     // NAME is what the child's report exists to replace, and a fallback that guessed anyway just
@@ -499,7 +506,8 @@ function runServer(port, probedAddress, localhostIsUnambiguous, noOpen, cwd, onC
     // into something connectable; BIND_HOST is the last resort and returns null for a name.
     const guessed = probedAddress ? launcherReachHost(probedAddress) : launcherReachHost(BIND_HOST);
     const fallbackReady = setTimeout(() => {
-      if (guessed) return beginReady(guessed);
+      // No report, so no v6 answer either — the probe is all this path ever had.
+      if (guessed) return beginReady(guessed, undefined);
       if (!readyStarted)
         log(`Started, but ${BIND_HOST} is a name and the server has not reported which address it bound — not guessing. It may still be starting.`);
     }, REPORTED_ADDRESS_GRACE_MS);

package/common/keymap.ts

@@ -40,6 +40,16 @@ export const isKeymapAction = (value: unknown): value is KeymapAction => typeof
 //     ^C. A handler that has already swallowed the key cannot change its mind.
 export const TERMINAL_SCOPED_ACTIONS: readonly KeymapAction[] = ["copy", "paste"];
 
+// Actions that act ON a terminal and so need one the grid can name. The enlarged cell is the only
+// such state the grid has, so un-zoomed these do nothing rather than guessing which cell was meant.
+// `terminal-new` is exempt (appending needs no subject), and so are `zoom-toggle` / `next-attention`,
+// which pick the cell themselves — that is what makes them the keyboard's way INTO the zoom.
+//
+// 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"];
+
 // 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.
 //
@@ -164,9 +174,17 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
     return [{ action: "keymap", binding: input, reason: "`keymap` must be an object of action -> key binding", fatal: true }];
   }
   const entries = Object.entries(input);
-  // A claim on one keystroke. `rank` is DISPATCH order, so the winner can be named: every action
-  // outranks every send binding, because the grid's handler runs in the capture phase and stops
-  // the event before the terminal — see sendBytesFor.
+  // A claim on one keystroke. `rank` is DISPATCH order, so the winner can be named — with ONE
+  // exception, which is why `kind` is carried alongside it.
+  //
+  // Most actions are claimed by the grid in the capture phase, before the terminal sees the key.
+  // `copy` and `paste` are not (TERMINAL_SCOPED_ACTIONS — gridShortcutFor skips them); they are
+  // decided inside the terminal by clipboardActionFor, which runs ahead of the send handler. So
+  // `paste` still outranks a send.
+  //
+  // `copy` does NOT, unconditionally: clipboardActionFor returns null when nothing is selected —
+  // deliberately, so Ctrl+C stays an interrupt — and the same-key send fires then. Naming `copy`
+  // as the winner there tells the user the opposite of what they will see half the time (#1901).
   const bound = new Map<string, Claim[]>();
   const claim = (parsed: KeyBinding, entry: Claim): void => {
     const key = canonicalBinding(parsed); // as PARSED: "Shift+PageUp" and "shift+pageup" are one keystroke
@@ -182,7 +200,7 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
     if (parsed === null) {
       return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown" or "Shift+PageUp"', fatal: true }];
     }
-    claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action) });
+    claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action), kind: "action" });
     return [];
   });
   return [...problems, ...duplicateWarnings(bound)];
@@ -192,6 +210,9 @@ interface Claim {
   label: string;
   binding: string;
   rank: number;
+  /** Which side of the dispatch this is. `copy` vs a `send` is the one collision whose winner
+   *  depends on runtime state, and that cannot be read back off `label`. */
+  kind: "action" | "send";
 }
 
 // Everything wrong with the `send` list, claiming the keystrokes that are well-formed.
@@ -214,7 +235,7 @@ function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim)
       return [{ action: label, binding: entry.key, reason: "`bytes` is empty — the key would be taken from the terminal and nothing sent", fatal: true }];
     }
     // Ranked after every action, matching who actually wins (see the `bound` comment above).
-    claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i });
+    claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i, kind: "send" });
     return [];
   });
 }
@@ -229,15 +250,55 @@ function duplicateWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
     if (claims.length < 2) return [];
     const [winner, ...losers] = [...claims].sort((a, b) => a.rank - b.rank);
     if (!winner) return []; // unreachable: claims.length >= 2 was checked above
-    return losers.map(({ label, binding }) => ({
-      action: label,
-      binding,
-      reason: `same keystroke as \`${winner.label}\` — only \`${winner.label}\` will fire`,
+    const runnerUp = fallthroughWinner(winner, losers);
+    return losers.map((loser) => ({
+      action: loser.label,
+      binding: loser.binding,
+      reason: collisionReason(winner, runnerUp, loser),
       fatal: false,
     }));
   });
 }
 
+// An action that DECLINES the keystroke in some runtime state, letting it fall through to a `send`
+// binding on the same key. Naming such an action as the sole winner is wrong whenever the user is
+// in the other state, which is the whole of #1901.
+//
+// Two handlers decline, for the same structural reason — each returns WITHOUT stopping the event:
+//
+//   - `copy` with no selection (clipboardActionFor), deliberately, so Ctrl+C stays interrupt.
+//   - NEEDS_A_CURRENT_TERMINAL with nothing enlarged (gridShortcutFor).
+//
+// `acts` and `otherwise` are the two halves of what the user is told.
+interface StandsAside {
+  acts: string;
+  otherwise: string;
+}
+const WHILE_ENLARGED: StandsAside = { acts: "only while a terminal is enlarged", otherwise: "when none is" };
+const standsAside = (label: string): StandsAside | null => {
+  if (label === "copy") return { acts: "only while text is selected", otherwise: "when nothing is" };
+  return NEEDS_A_CURRENT_TERMINAL.some((action) => action === label) ? WHILE_ENLARGED : null;
+};
+
+// The claim that fires when the winner stands aside, or null when the winner takes every state.
+//
+// Only a send can be this one. `actionForKey` returns the lowest-ranked bound action and stops, so
+// a second ACTION on the key is never reached in either state; and `sendBytesFor` takes the FIRST
+// match, so only the first send is. A conditional collision therefore has exactly TWO reachable
+// claims and every later one is unreachable in BOTH states.
+const fallthroughWinner = (winner: Claim, losers: Claim[]): Claim | null =>
+  winner.kind === "action" && standsAside(winner.label) !== null ? (losers.find((claim) => claim.kind === "send") ?? null) : null;
+
+// What the user will actually see, which is not always a single winner.
+const collisionReason = (winner: Claim, runnerUp: Claim | null, loser: Claim): string => {
+  const aside = standsAside(winner.label);
+  if (runnerUp === null || aside === null) return `same keystroke as \`${winner.label}\` — only \`${winner.label}\` will fire`;
+  if (loser === runnerUp) {
+    return `same keystroke as \`${winner.label}\` — \`${winner.label}\` acts ${aside.acts}, and \`${loser.label}\` fires ${aside.otherwise}`;
+  }
+  return `same keystroke as \`${winner.label}\` and \`${runnerUp.label}\` — \`${winner.label}\` acts ${aside.acts} and \`${runnerUp.label}\` fires ${aside.otherwise}, so \`${loser.label}\` never fires`;
+};
+
 // A binding's identity as a keystroke, for spotting two actions that claim the same one.
 const canonicalBinding = (b: KeyBinding): string => `${b.shift ? "S" : ""}${b.alt ? "A" : ""}${b.ctrl ? "C" : ""}${b.meta ? "M" : ""}|${b.key}`;