mulmoterminal 4.7.0 → 4.7.2

package/README.md

@@ -567,12 +567,12 @@ CLAUDE_CWD=/Users/you/my-project
 
 ### UI settings (`~/.mulmoterminal/config.json`)
 
-The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/config.json`
+The Settings modal (the gear button) persists per-user UI choices to `~/.mulmoterminal/config.json`
 (read/written via `GET`/`POST /api/config`):
 
 ![The Settings modal — theme, notification sound, PR repos, launch commands, and MCP servers](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/settings.png)
 
-*Open it from the ⚙ button in the toolbar. Pick a **theme**, set the **terminal font size**, **font** and **scroll speed**, set a custom **attention sound**, list the repos the cross-repo **PRs & Issues** view should aggregate, add **launch commands** for grid cells, register your own **MCP servers**, and turn on the switches for what this app writes on your behalf — **issue work comments**, the **PR clone footer**, the **closing summary**, the **decision digest**, the **dev worklog** — no need to hand-edit the config file. Four settings stay with their skill because a form would be the wrong tool for them (`keymap`, `themes`, `providers`, `buttons`/`chips`); Settings shows what each is doing now and launches that skill. Note that **theme, font size and scroll speed are stored per browser** (they're display preferences, so a phone and a desktop keep their own); the rest live in `~/.mulmoterminal/config.json` and are shared by every client.*
+*Open it from the gear button in the toolbar. Under the title, a **Version** row shows what is running: the version from the shipped `package.json`, plus a `commit <sha>` chip on a git checkout — there the version is only whatever was last released, so the commit is what identifies the build. When something newer exists, the row is followed by the header badge's update notice, command included. Pick a **theme**, set the **terminal font size**, **font** and **scroll speed**, set a custom **attention sound**, list the repos the cross-repo **PRs & Issues** view should aggregate, add **launch commands** for grid cells, register your own **MCP servers**, and turn on the switches for what this app writes on your behalf — **issue work comments**, the **PR clone footer**, the **closing summary**, the **decision digest**, the **dev worklog** — no need to hand-edit the config file. Four settings stay with their skill because a form would be the wrong tool for them (`keymap`, `themes`, `providers`, `buttons`/`chips`); Settings shows what each is doing now and launches that skill. Note that **theme, font size and scroll speed are stored per browser** (they're display preferences, so a phone and a desktop keep their own); the rest live in `~/.mulmoterminal/config.json` and are shared by every client.*
 
 | Field        | Meaning |
 | ------------ | ------- |
@@ -847,7 +847,9 @@ In dev, open the Vite URL; its proxy forwards `/ws`, `/ws/pubsub`, and `/api` to
 
 An empty grid cell's launcher sets the **Working directory** by typing, by a preset
 chip, or with the **📁 folder button** (a native OS folder dialog). The preset chips are
-the directories you have launched in; the **workspace** leads them always, labelled
+the directories you have launched in — **worktrees excluded**, since one is a single task's
+branch that is deleted with the task, not a place to launch in again; the
+**workspace** leads them always, labelled
 **WORKSPACE** and marked with an icon, whether or not you have ever launched there — it is
 the one directory where a claude or codex session reaches every GUI tool (agy and grok get
 what the directory registered, there as anywhere — see
@@ -879,7 +881,7 @@ alongside the Claude sessions. Scripts are **per-directory**: the cell reads the
 different projects' scripts.
 
 The same launcher also has an **or launch** row for your configured **launch commands**
-— any interactive command — set in Settings (⚙) → **Launch commands** as
+— any interactive command — set in Settings (the gear button) → **Launch commands** as
 `{ label, command }` (e.g. `htop` → `htop`, `Codex` → `codex`). A plain shell needs no
 entry here: the Agent Picker's **Shell** option already opens `$SHELL`. Unlike
 a one-shot script, a launcher runs as a **persistent terminal in the cell's directory**:
@@ -1170,7 +1172,7 @@ with no schema on disk, so the fields are identified by measurement (see
 rather than a number it is unsure of, so if a future agy release moves those fields, an
 Antigravity cell falls back to showing its model alone — it will not show a wrong percentage.
 
-The **Settings** modal (⚙) shows an **estimated $ cost** — Session / Today / Month — from
+The **Settings** modal (the gear button) shows an **estimated $ cost** — Session / Today / Month — from
 `GET /api/cost`, using a built-in public per-model price table (cache reads billed at
 0.1×, cache writes at 1.25× input). It's an estimate: real billing differs, **flat-plan
 (Max) usage isn't reflected**, and turns on unpriced models are flagged and excluded.
@@ -1611,6 +1613,7 @@ From a shell: `mulmoterminal room read <room>` · `room post <room> <text…> [-
 | `GET /api/sound?kind=` · `/api/dir-sound?cwd=&kind=` · `/api/sound-preset/:id` · `/api/dir-config?cwd=` | Custom / per-directory / preset attention sound + per-dir config. `kind` selects a config entry, never a path. |
 | `GET /api/dir-config-detail?cwd=` | The same per-dir config, **plus** the settings a running terminal doesn't need (`provider`, `model`, `skills`, `addDirs`, header button/chip **labels**), **plus** which keys the file set and how each fared (applied / dropped in validation / not a setting at all). Read-only; backs the Settings modal's **Directory settings** preview. Unlike the other `?cwd=` routes this one does **not** fall back to the default workspace — it reports on the directory it was asked about, so a path that no longer exists comes back as `exists:false`. Sound paths and button commands stay server-side. |
 | `GET /api/launch-options` | The Anthropic-compatible backends this server can reach, each with its models and — when it can't — the reason. Reports the **name** of the env var a key is read from, never the key. |
+| `GET /api/update-status` | What is running and whether anything newer exists: `install` (`npm` / `git`), `version`, `commit` (a checkout's short HEAD sha), `latest` (npm, only when newer) and the one-line `notice`. Backs the header's **Update** badge and the Settings version line. Computed once at startup and served from memory — `ready` is false until that check lands. |
 | `GET /api/notifications`(`/history`) · `POST /api/notifications/:id/clear` | Notification feed. |
 | `POST /api/transcribe`(`/model`…) | Voice-input transcription (Whisper, macOS). |
 | `POST /api/translation` | Runtime UI-string translation. |
@@ -1958,7 +1961,7 @@ src/
     PrsOverlay.vue                           cross-repo PRs & Issues
     Wiki*View.vue, Collections*.vue, AccountingOverlay.vue   workspace views
     TimelineOverlay.vue, ToolsPane.vue, NotificationBell.vue, RemoteHostControl.vue
-    SettingsModal.vue                        ⚙ settings — the dialog shell + section order
+    SettingsModal.vue                        settings — the dialog shell + section order
     settings/                                one file per settings section (theme, sounds,
                                              web push, google, PR repos, launchers, quick
                                              commands, MCP, cost, shortcuts, …), plus the

package/bin/update-check.d.ts

@@ -6,6 +6,16 @@ export interface UpdateNoticeDeps {
   fetchLatest?: () => Promise<string | null>;
 }
 export declare function computeUpdateNotice(pkgDir: string, currentVersion: string, deps?: UpdateNoticeDeps): Promise<string | null>;
+export declare function readInstallInfo(
+  pkgDir: string,
+  currentVersion: string,
+  deps?: UpdateNoticeDeps,
+): Promise<Pick<import("../common/updateStatus.js").UpdateStatus, "install" | "version" | "commit">>;
+export declare function computeUpdateInfo(
+  pkgDir: string,
+  currentVersion: string,
+  deps?: UpdateNoticeDeps,
+): Promise<Omit<import("../common/updateStatus.js").UpdateStatus, "ready">>;
 export declare function isUpdateCheckDisabled(env: Record<string, string | undefined>): boolean;
 export declare function hasNodeModulesSegment(pkgDir: string): boolean;
 export declare function classifyInstall(pkgDir: string, isGitWorkTree: boolean): "npm" | "git";

package/bin/update-check.js

@@ -168,15 +168,12 @@ export function gitUpdateNotice({ localSha, localShort, remoteSha, defaultBranch
 const LS_REMOTE_TIMEOUT_MS = 6000;
 
 // The git branch of the check: local HEAD vs the remote's, read with ls-remote so no fetch is
-// forced. Silent on a dirty tree (can't fast-forward) or any unreadable probe.
-async function gitUpdateNotice_(git) {
+// forced. Silent on a dirty tree (can't fast-forward) or any unreadable probe. `localShort` is
+// passed in because the caller has already read it for the version display.
+async function gitUpdateNotice_(git, localShort) {
   const status = await git(["status", "--porcelain"]);
   if (status === null || isTreeDirtyForUpdate(status)) return null;
-  const [localSha, localShort, lsRemote] = await Promise.all([
-    git(["rev-parse", "HEAD"]),
-    git(["rev-parse", "--short", "HEAD"]),
-    git(["ls-remote", "--symref", "origin", "HEAD"], LS_REMOTE_TIMEOUT_MS),
-  ]);
+  const [localSha, lsRemote] = await Promise.all([git(["rev-parse", "HEAD"]), git(["ls-remote", "--symref", "origin", "HEAD"], LS_REMOTE_TIMEOUT_MS)]);
   return gitUpdateNotice({
     localSha,
     localShort,
@@ -186,14 +183,32 @@ async function gitUpdateNotice_(git) {
   });
 }
 
-// The whole check, front to back: which install this is, then its notice (or null when
-// current). `pkgDir` is where the tool lives — a node_modules dir (→ npm) or a bare checkout
-// (→ git). `deps` lets tests drive it without spawning git or hitting the network; production
-// callers pass nothing and get the real git/registry probes bound to pkgDir.
-export async function computeUpdateNotice(pkgDir, currentVersion, deps = {}) {
+// What is running, without asking the network: the install kind and — for a checkout, where the
+// package.json version is only the last release — the commit that identifies the build. Local
+// probes only, so this is also what the UI gets when the update check is opted out.
+export async function readInstallInfo(pkgDir, currentVersion, deps = {}) {
   const git = deps.runGit ?? ((args, timeout_ms) => runGit(pkgDir, args, timeout_ms));
-  const fetchLatest = deps.fetchLatest ?? fetchLatestVersion;
   const inWorkTree = hasNodeModulesSegment(pkgDir) ? false : (await git(["rev-parse", "--is-inside-work-tree"])) === "true";
-  if (classifyInstall(pkgDir, inWorkTree) === "git") return gitUpdateNotice_(git);
-  return npmUpdateNotice(currentVersion, await fetchLatest());
+  const install = classifyInstall(pkgDir, inWorkTree);
+  return { install, version: currentVersion, commit: install === "git" ? await git(["rev-parse", "--short", "HEAD"]) : null };
+}
+
+// The whole check, front to back: what is running, what is newer, and the one line that says so
+// (null when current). `pkgDir` is where the tool lives — a node_modules dir (→ npm) or a bare
+// checkout (→ git). `deps` lets tests drive it without spawning git or hitting the network;
+// production callers pass nothing and get the real git/registry probes bound to pkgDir.
+export async function computeUpdateInfo(pkgDir, currentVersion, deps = {}) {
+  const git = deps.runGit ?? ((args, timeout_ms) => runGit(pkgDir, args, timeout_ms));
+  const fetchLatest = deps.fetchLatest ?? fetchLatestVersion;
+  const info = await readInstallInfo(pkgDir, currentVersion, { runGit: git });
+  if (info.install === "git") return { ...info, latest: null, notice: await gitUpdateNotice_(git, info.commit) };
+  const latest = await fetchLatest();
+  // `latest` is what the UI OFFERS, so it carries only a version worth moving to — the registry
+  // answering with the version already installed is not news.
+  return { ...info, latest: latest && isNewerVersion(latest, currentVersion) ? latest : null, notice: npmUpdateNotice(currentVersion, latest) };
+}
+
+// The notice alone, for the launcher's console line.
+export async function computeUpdateNotice(pkgDir, currentVersion, deps = {}) {
+  return (await computeUpdateInfo(pkgDir, currentVersion, deps)).notice;
 }

package/common/updateStatus.ts

@@ -0,0 +1,42 @@
+// What GET /api/update-status answers: which install is running, what it is, and what is newer.
+// Shared because both sides decide from it — the server builds it from the startup probe, the
+// header badge and the Settings version line read it.
+
+import { isRecord } from "./isRecord.js";
+
+/** How the tool was installed, which decides what "the running version" even means. */
+export type InstallKind = "npm" | "git";
+
+export interface UpdateStatus {
+  /** False until the startup check has landed; `commit` / `latest` / `notice` are not final yet. */
+  ready: boolean;
+  install: InstallKind;
+  /** The shipped package.json version. For a git checkout this is the last release, not the build. */
+  version: string;
+  /** git installs: short HEAD sha — the only thing that identifies which build is running. */
+  commit: string | null;
+  /** npm installs: the registry's version, present only when it is newer than `version`. */
+  latest: string | null;
+  /** The one-line "update available" rendering both the launcher and the header badge show. */
+  notice: string | null;
+}
+
+const isInstallKind = (value: unknown): value is InstallKind => value === "npm" || value === "git";
+
+const stringOrNull = (value: unknown): string | null => (typeof value === "string" ? value : null);
+
+/**
+ * The response as a status, or null when it is not one. Null rather than a filled-in default: a
+ * body we could not read must leave the version line hidden, not print a version nobody is on.
+ */
+export function parseUpdateStatus(body: unknown): UpdateStatus | null {
+  if (!isRecord(body) || !isInstallKind(body.install) || typeof body.version !== "string") return null;
+  return {
+    ready: body.ready === true,
+    install: body.install,
+    version: body.version,
+    commit: stringOrNull(body.commit),
+    latest: stringOrNull(body.latest),
+    notice: stringOrNull(body.notice),
+  };
+}

package/common/worktreePath.ts

@@ -0,0 +1,62 @@
+// What a managed worktree's path says about it, for the two sides that both have to ask.
+//
+// In `common/` because the launch form and `mulmoterminal init` each decide from it — the browser
+// records the directory a cell launched in, the CLI seeds the same list from Claude's history — and
+// a rule mirrored into `src/` and `server/` is a rule that drifts.
+
+import { dirPathKey } from "./dirPathKey.js";
+
+// A managed worktree lives at <root>/<repo>-<8hex>/<task> (see the server's `worktreesRoot`).
+const MANAGED_DIR = /^(.+)-[0-9a-f]{8}$/;
+
+/**
+ * The repo and task to CALL a worktree path, for a header that would otherwise show a long managed
+ * path. Shape alone, with no idea where the managed root is — which is why it is only ever used to
+ * name something. Getting it wrong shows a label; it decides nothing.
+ */
+export function worktreeLabel(cwd: string | null): { repo: string; task: string } | null {
+  if (!cwd) return null;
+  const parts = cwd.split(/[/\\]/).filter(Boolean);
+  const i = parts.indexOf("worktrees");
+  const dir = parts[i + 1];
+  const task = parts[i + 2];
+  if (i < 0 || !dir || !task) return null;
+  const m = MANAGED_DIR.exec(dir);
+  return m?.[1] === undefined ? null : { repo: m[1], task };
+}
+
+/**
+ * Whether this directory is one WE created — asked before recording it as a working-directory
+ * preset, which a worktree must never become: it is one branch for one task, deleted when the task
+ * is done, and nothing prunes the chip when the directory goes (the close button is the only
+ * remover), so the row filled with paths that no longer exist.
+ *
+ * Anchored on the managed ROOT, not on the shape above. Shape alone matches any
+ * `…/worktrees/<name>-<8hex>/<task>` a person or another tool happens to have, and the cost here is
+ * not a wrong label — it is a real working directory silently missing from the launcher (Codex on
+ * #1543). The root is the same authority the server's own `worktreeTask` uses; the browser is told
+ * it by `/api/config`.
+ *
+ * **An unknown root answers `false`** — record the directory. Before `/api/config` resolves there is
+ * nothing to compare against, and of the two ways to be wrong, an extra chip the user can delete
+ * beats a directory that quietly never appears.
+ *
+ * Lexical containment (`dirPathKey`), because the browser has no filesystem: it folds both
+ * separators, `.`/`..` and a trailing slash, but not a symlink or Windows' case-insensitivity.
+ * Both values come from the same server, so they agree in practice — and a spelling it cannot fold
+ * falls back to "not ours", which is the safe direction above.
+ */
+export function isManagedWorktreePath(cwd: string | null | undefined, worktreesRoot: string | null | undefined): boolean {
+  if (!cwd || !worktreesRoot) return false;
+  const rootKey = dirPathKey(worktreesRoot);
+  if (rootKey === "") return false;
+  const prefix = rootKey.endsWith("/") ? rootKey : `${rootKey}/`;
+  const key = dirPathKey(cwd);
+  if (!key.startsWith(prefix)) return false;
+  const below = key.slice(prefix.length).split("/").filter(Boolean);
+  // `<repo>-<hash>/<task>` at least, and the first segment has to be a name WE mint. The root
+  // holds worktrees but is not one, the per-repo directory above a task is not one either, and a
+  // directory someone put under the root by hand carries no hash — all three are places a person
+  // could reasonably be working, and dropping one loses it from the launcher (Codex on #1543).
+  return below.length >= 2 && MANAGED_DIR.test(below[0] ?? "");
+}

package/dist/assets/{abnfDiagram-VRR7QNED-WSmThe6b-D7o5fw1r.js → abnfDiagram-VRR7QNED-WSmThe6b-DknQ8qLF.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-CvsWqFln-Tc7ZSrRz.js";import{_ as n,g as r}from"./mermaid-parser.core-C1baW7NG-D6V0bamn.js";import"./chunk-WYO6CB5R-nS6zX9ct-CEyECF4F.js";import"./chunk-VAUOI2AC-BKx35BBi-DF4roMbC.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CorQ_Pl1-Bo-W29fw.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};
+import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-CvsWqFln-Tc7ZSrRz.js";import{_ as n,g as r}from"./mermaid-parser.core-C1baW7NG-CX-WYPvl.js";import"./chunk-WYO6CB5R-nS6zX9ct-BCV_YuAf.js";import"./chunk-VAUOI2AC-BKx35BBi-_cGUYYkB.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CorQ_Pl1-BbhhBfNZ.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};

package/dist/assets/architecture-TIHT7OUA-Cqhmai3f-C07fcF9Q.js

@@ -0,0 +1 @@
+import{f as e}from"./mermaid-parser.core-C1baW7NG-CX-WYPvl.js";export{e as createArchitectureServices};