@supanadit/morse-web 0.2.1 → 0.3.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 supanadit
+Copyright (c) 2026 Supan Adit Pratama
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/server.mjs

@@ -74,7 +74,8 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 15;
+var PROTOCOL_VERSION = 17;
+var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
 // ../protocol/dist/frontend-manifest.js
@@ -96,6 +97,9 @@ function parseFrontendManifest(raw) {
     return void 0;
   }
 }
+function frontendIdentity(manifest) {
+  return manifest ? { name: manifest.name, version: manifest.version } : void 0;
+}
 
 // ../server/src/app.module.ts
 import { Module } from "@nestjs/common";
@@ -121,8 +125,16 @@ var MorseError = class extends Error {
   }
 };
 var AgentUnavailableError = class extends MorseError {
+  /**
+   * The next step, in a form a frontend can render (see `SessionViewState
+   * .agentFailure`). The message stays human-readable on its own; this is the
+   * machine-readable half, and only the layer that knows pi's package name can
+   * fill it in.
+   */
+  remedy;
   constructor(message, options) {
     super(message, "agent-unavailable", options);
+    this.remedy = options?.remedy;
   }
 };
 var AgentProtocolError = class extends MorseError {
@@ -1580,6 +1592,7 @@ ${mentions}` : mentions;
 import { accessSync, constants } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, join } from "node:path";
+var PI_INSTALL_COMMAND = "npm install -g @earendil-works/pi-coding-agent";
 function buildRpcArgs(options) {
   const args = ["--mode", "rpc"];
   if (options.noSession) {
@@ -1611,10 +1624,10 @@ function resolvePi(options = {}) {
   }
   throw new AgentUnavailableError([
     "The pi coding agent was not found.",
-    "Install it (`npm install -g @earendil-works/pi-coding-agent`) or point Morse at it:",
+    `Install it (\`${PI_INSTALL_COMMAND}\`) or point Morse at it:`,
     '- VS Code: setting "morse.pi.path"',
     "- NestJS host: env MORSE_PI_PATH (or MORSE_PI_ENTRY for a bundled rpc-entry.js)"
-  ].join("\n"));
+  ].join("\n"), { remedy: { install: PI_INSTALL_COMMAND } });
 }
 function findOnPath(binary, env = process.env) {
   const pathValue = env.PATH ?? env.Path ?? "";
@@ -1706,27 +1719,71 @@ var PiRpcAgentFactory = class {
 };
 
 // ../adapter-pi-rpc/dist/pi-rpc-session-catalog.js
-import { readdir, readFile, stat, unlink } from "node:fs/promises";
-import { basename, join as join2, resolve, sep } from "node:path";
+import { open, readdir, readFile, stat, unlink } from "node:fs/promises";
+import { join as join2, resolve, sep } from "node:path";
+var TYPE_PREFIX = '{"type":"';
+function typeAt(raw, start, end) {
+  if (!raw.startsWith(TYPE_PREFIX, start)) {
+    return void 0;
+  }
+  const close = raw.indexOf('"', start + TYPE_PREFIX.length);
+  return close === -1 || close > end ? void 0 : raw.slice(start + TYPE_PREFIX.length, close);
+}
 var PiRpcSessionCatalog = class {
   directory;
   maxSessions;
   removeFile;
+  readSummary;
+  /**
+   * Summaries survive between calls, keyed by path and validated by size + mtime.
+   * The list is asked for far more often than sessions change — every reconnect,
+   * every new session, every rename — and re-reading 50 transcripts each time was
+   * the single most expensive thing the host did.
+   */
+  cache = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.directory = resolveSessionDir(options.sessionDir, options.env);
     this.maxSessions = options.maxSessions ?? 50;
     this.removeFile = options.removeFile ?? unlink;
+    this.readSummary = options.readSummary ?? readSessionSummary;
   }
   get sessionDirectory() {
     return this.directory;
   }
+  /**
+   * A list already being built is handed to every caller instead of being started
+   * again: two frontends connecting at the same moment, or a refresh landing while
+   * a push is in flight, used to mean two full scans of the whole catalog.
+   */
+  inFlight;
   async list() {
+    this.inFlight ??= this.buildList().finally(() => {
+      this.inFlight = void 0;
+    });
+    return this.inFlight;
+  }
+  async buildList() {
     const files = await this.collectSessionFiles();
     const summaries = [];
+    const seen = /* @__PURE__ */ new Set();
     for (const file of files.slice(0, this.maxSessions)) {
-      const summary = await readSessionSummary(file.path, file.updatedAt);
-      if (summary) {
-        summaries.push(summary);
+      seen.add(file.path);
+      const cached = this.cache.get(file.path);
+      if (cached !== void 0 && cached.size === file.size && cached.updatedAt === file.updatedAt) {
+        summaries.push(cached.summary);
+        continue;
+      }
+      const scan = await this.readSummary(file.path, file.updatedAt, cached);
+      if (scan === void 0) {
+        this.cache.delete(file.path);
+        continue;
+      }
+      this.cache.set(file.path, { size: file.size, updatedAt: file.updatedAt, ...scan });
+      summaries.push(scan.summary);
+    }
+    for (const path of [...this.cache.keys()]) {
+      if (!seen.has(path)) {
+        this.cache.delete(path);
       }
     }
     return summaries;
@@ -1759,61 +1816,108 @@ var PiRpcSessionCatalog = class {
         }
         const path = join2(bucketPath, entry.name);
         const info = await stat(path).catch(() => void 0);
-        files.push({ path, updatedAt: info?.mtimeMs ?? 0 });
+        files.push({ path, size: info?.size ?? 0, updatedAt: info?.mtimeMs ?? 0 });
       }
     }
     files.sort((left, right) => right.updatedAt - left.updatedAt);
     return files;
   }
 };
-async function readSessionSummary(path, updatedAt) {
-  const raw = await readFile(path, "utf8").catch(() => void 0);
+async function readSessionSummary(path, updatedAt, previous) {
+  let resumable = previous !== void 0 && previous.scanned > 0 && updatedAt >= previous.updatedAt;
+  if (resumable && previous !== void 0) {
+    const info = await stat(path).catch(() => void 0);
+    resumable = info !== void 0 && info.size > previous.scanned;
+  }
+  const from = resumable && previous !== void 0 ? previous.scanned : 0;
+  const raw = resumable ? await readFrom(path, from).catch(() => void 0) : await readFile(path, "utf8").catch(() => void 0);
   if (raw === void 0) {
     return void 0;
   }
-  let id = basename(path, ".jsonl");
-  let cwd = "";
-  let name;
-  let firstUserText;
-  let messageCount = 0;
-  for (const line of raw.split("\n")) {
-    if (!line.startsWith("{")) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const type = entry["type"];
-    if (type === "session" && cwd.length === 0) {
-      id = asString(entry["id"]) ?? id;
-      cwd = asString(entry["cwd"]) ?? "";
-      continue;
-    }
-    if (type === "message") {
-      messageCount += 1;
-      if (!firstUserText) {
-        const message = asRecord(entry["message"]);
-        if (message?.["role"] === "user") {
-          firstUserText = textOf(message["content"]);
+  let cwd = resumable && previous !== void 0 ? previous.summary.cwd : "";
+  let name = resumable && previous !== void 0 ? previous.name : void 0;
+  let firstUserText = resumable && previous !== void 0 ? previous.firstUserText : void 0;
+  let messageCount = resumable && previous !== void 0 ? previous.summary.messageCount : 0;
+  let scanned = from;
+  let consumed = 0;
+  const parseAt = (start, end) => parseLine(raw.slice(start, end));
+  for (let start = 0; start < raw.length; ) {
+    const newline = raw.indexOf("\n", start);
+    const end = newline === -1 ? raw.length : newline;
+    const complete = newline !== -1;
+    let type;
+    if (raw.charCodeAt(start) === 123) {
+      type = complete ? typeAt(raw, start, end) ?? asString(parseAt(start, end)?.["type"]) : asString(parseAt(start, end)?.["type"]);
+      if (type === "message") {
+        messageCount += 1;
+        if (firstUserText === void 0) {
+          const message = asRecord(parseAt(start, end)?.["message"]);
+          if (message?.["role"] === "user") {
+            firstUserText = textOf(message["content"]);
+          }
+        }
+      } else if (type === "session") {
+        if (cwd.length === 0) {
+          cwd = asString(parseAt(start, end)?.["cwd"]) ?? "";
         }
+      } else if ((type === "session_info" || type === "session_name") && !name) {
+        name = asString(parseAt(start, end)?.["name"]);
       }
-      continue;
     }
-    if ((type === "session_info" || type === "session_name") && !name) {
-      name = asString(entry["name"]);
+    if (!complete) {
+      if (type !== void 0) {
+        consumed = raw.length;
+      }
+      break;
     }
+    consumed = newline + 1;
+    start = newline + 1;
+  }
+  if (consumed > 0) {
+    scanned = from + Buffer.byteLength(raw.slice(0, consumed));
   }
   return {
-    id: path,
-    title: name ?? titleFromText(firstUserText) ?? "Untitled session",
-    cwd,
-    updatedAt,
-    messageCount
+    summary: {
+      id: path,
+      title: name ?? titleFromText(firstUserText) ?? "Untitled session",
+      cwd,
+      updatedAt,
+      messageCount
+    },
+    scanned,
+    name,
+    firstUserText
   };
 }
+async function readFrom(path, from) {
+  const handle = await open(path, "r");
+  try {
+    const info = await handle.stat();
+    if (info.size <= from) {
+      return "";
+    }
+    const length = info.size - from;
+    const buffer = Buffer.alloc(length);
+    let filled = 0;
+    while (filled < length) {
+      const { bytesRead } = await handle.read(buffer, filled, length - filled, from + filled);
+      if (bytesRead === 0) {
+        break;
+      }
+      filled += bytesRead;
+    }
+    return buffer.subarray(0, filled).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function parseLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
 function textOf(content) {
   const direct = asString(content);
   if (direct !== void 0) {
@@ -2204,7 +2308,9 @@ var SessionTranscriptStore = class {
           this.emit({
             sessionKey,
             message,
-            items: projector?.snapshot() ?? []
+            get items() {
+              return projector?.snapshot() ?? [];
+            }
           });
         }
       });
@@ -2232,6 +2338,7 @@ function emptySessionViewState(workspace, meta) {
     agentReady: meta.agentReady,
     agentStarting: meta.agentStarting,
     agentError: meta.agentError,
+    agentFailure: meta.agentFailure,
     hasOlderHistory: meta.hasOlderHistory,
     loadingOlderHistory: meta.loadingOlderHistory
   };
@@ -2270,6 +2377,7 @@ function toSessionViewState(state, meta) {
     agentReady: meta.agentReady,
     agentStarting: meta.agentStarting,
     agentError: meta.agentError,
+    agentFailure: meta.agentFailure,
     hasOlderHistory: meta.hasOlderHistory,
     loadingOlderHistory: meta.loadingOlderHistory
   };
@@ -2362,6 +2470,8 @@ var HostSessionController = class {
   agentReady = false;
   agentStarting = false;
   agentError;
+  /** The machine-readable half of `agentError` (see `AgentFailure`). */
+  agentFailure;
   busy = false;
   disposed = false;
   hasOpenedOnce = false;
@@ -2537,7 +2647,16 @@ var HostSessionController = class {
     this.loadingOlderHistory = false;
     this.agentReady = false;
     this.agentStarting = false;
+    this.clearAgentFailure();
+  }
+  /**
+   * Forgets the agent failure, message and all. Called wherever the agent comes
+   * back (a ready event, an adopted session), so a stale screen never outlives
+   * the problem it described.
+   */
+  clearAgentFailure() {
     this.agentError = void 0;
+    this.agentFailure = void 0;
   }
   /** Fills the draft pickers from the registry's session-less probe. */
   async warmDraft() {
@@ -2597,7 +2716,7 @@ var HostSessionController = class {
     this.hasOlderHistory = false;
     this.loadingOlderHistory = false;
     this.agentReady = false;
-    this.agentError = void 0;
+    this.clearAgentFailure();
     const next = this.options.services.registry.hotKeys().at(-1);
     if (next) {
       await this.runSessionChange(() => this.options.services.registry.activate(next));
@@ -2622,6 +2741,7 @@ var HostSessionController = class {
     } catch (error) {
       this.agentReady = false;
       this.agentError = describeError(error);
+      this.agentFailure = describeAgentFailure(error, this.options.agentHint);
       this.options.logger.warn("Could not start the Morse agent", error);
       this.fail(`Could not start the Morse agent: ${this.agentError}`, this.options.agentHint);
     } finally {
@@ -2645,7 +2765,7 @@ var HostSessionController = class {
     this.hasOlderHistory = false;
     this.loadingOlderHistory = false;
     this.agentReady = true;
-    this.agentError = void 0;
+    this.clearAgentFailure();
     this.emitTranscript(opened.key);
     this.emitState();
     void this.publishSessions();
@@ -2932,7 +3052,7 @@ var HostSessionController = class {
     switch (event.type) {
       case "agent/ready":
         this.agentReady = true;
-        this.agentError = void 0;
+        this.clearAgentFailure();
         this.emitState();
         return;
       case "agent/state":
@@ -2948,6 +3068,7 @@ var HostSessionController = class {
       case "agent/fatal":
         this.agentReady = false;
         this.agentError = event.message;
+        this.agentFailure = hintOnly(this.options.agentHint);
         this.options.transcripts.error(sessionKey, event.message, event.detail);
         this.emitState();
         return;
@@ -3098,6 +3219,7 @@ var HostSessionController = class {
       agentReady: this.agentReady,
       agentStarting: this.agentStarting,
       agentError: this.agentError,
+      agentFailure: this.agentFailure,
       busy: this.busy,
       hasOlderHistory: this.hasOlderHistory,
       loadingOlderHistory: this.loadingOlderHistory
@@ -3209,6 +3331,25 @@ function describeError(error) {
   }
   return typeof error === "string" ? error : JSON.stringify(error);
 }
+function describeAgentFailure(error, hint) {
+  const code = agentErrorCode(error);
+  const install = error instanceof AgentUnavailableError ? error.remedy?.install : void 0;
+  const failure = {
+    ...code ? { code } : {},
+    ...install ? { install } : {},
+    ...hint ? { hint } : {}
+  };
+  return Object.keys(failure).length > 0 ? failure : void 0;
+}
+function agentErrorCode(error) {
+  if (!(error instanceof MorseError)) {
+    return void 0;
+  }
+  return error.code === "agent-unavailable" || error.code === "agent-protocol" ? error.code : void 0;
+}
+function hintOnly(hint) {
+  return hint ? { hint } : void 0;
+}
 
 // ../server/src/internal/http/health.controller.ts
 import { Controller, Get } from "@nestjs/common";
@@ -3350,7 +3491,7 @@ import { Inject as Inject3, Injectable as Injectable2 } from "@nestjs/common";
 // ../server/src/internal/uploads/upload-store.ts
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join4, relative, sep as sep3 } from "node:path";
+import { basename, isAbsolute as isAbsolute3, join as join4, relative, sep as sep3 } from "node:path";
 var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
 var DEFAULT_UPLOAD_DIR = ".morse/uploads";
 var UploadError = class extends Error {
@@ -3374,11 +3515,11 @@ async function saveUpload(cwd, request, uploadDir = DEFAULT_UPLOAD_DIR) {
   await mkdir(directory, { recursive: true });
   const target = uniquePath(directory, name);
   await writeFile(target, bytes);
-  return { path: mentionPath(cwd, target), name: basename2(target), bytes: bytes.length };
+  return { path: mentionPath(cwd, target), name: basename(target), bytes: bytes.length };
 }
 function safeFileName(raw) {
   const value = typeof raw === "string" ? raw : "";
-  const base = basename2(value.replace(/\\/g, "/")).trim();
+  const base = basename(value.replace(/\\/g, "/")).trim();
   const cleaned = base.replace(/[\u0000-\u001f<>:"|?*]/g, "_").replace(/^\.+/, "").trim();
   if (cleaned.length === 0) {
     throw new UploadError("That upload had no usable file name.");
@@ -3409,7 +3550,7 @@ function formatMb(bytes) {
 // ../server/src/internal/workspace/directory-browser.ts
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename3, dirname, isAbsolute as isAbsolute4, join as join5, resolve as resolve3 } from "node:path";
+import { basename as basename2, dirname, isAbsolute as isAbsolute4, join as join5, resolve as resolve3 } from "node:path";
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3466,7 +3607,7 @@ function shortcutRoots(options) {
       continue;
     }
     seen.add(path);
-    roots.push({ name: basename3(path) || path, path });
+    roots.push({ name: basename2(path) || path, path });
   }
   return roots;
 }
@@ -3636,7 +3777,11 @@ var MorseSessionFactory = class {
       // pi's fork re-parents the conversation, so a past prompt can be edited.
       editMessage: true,
       // The same fork can branch a new session and hand the prompt back instead.
-      forkMessage: true
+      forkMessage: true,
+      // A page served by this host may ask the registry for the latest release, so
+      // the sidebar can say when a newer Morse is out. A host without it stays
+      // quiet; this one is on unless `MORSE_UPDATE_CHECK=0` says otherwise.
+      updateCheck: this.config.updateCheck
     };
   }
   createFor(emit) {
@@ -3652,6 +3797,8 @@ var MorseSessionFactory = class {
       transcripts: this.transcripts,
       policy: this.policy,
       scope: { kind: "global" },
+      // The bundle this host serves, so the panel can name its own version.
+      ...this.config.frontend ? { frontend: this.config.frontend } : {},
       // The registry outlives this connection on purpose.
       ownsRegistry: false,
       // A page load must not create a session; the first prompt opens one.
@@ -3774,7 +3921,7 @@ MorseGateway = __decorateClass([
 ], MorseGateway);
 
 // ../server/src/app/config.ts
-import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute5, join as join7 } from "node:path";
+import { basename as basename3, dirname as dirname2, isAbsolute as isAbsolute5, join as join7 } from "node:path";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 function loadConfig(env = process.env) {
@@ -3785,11 +3932,13 @@ function loadConfig(env = process.env) {
   const monorepoUiDir = join7(moduleDir, "..", "..", "..", "ui-angular", "dist");
   const defaultUiDir = existsSync2(join7(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
   const defaultHost = "127.0.0.1";
+  const uiDir = configuredUiDir ? isAbsolute5(configuredUiDir) ? configuredUiDir : join7(process.cwd(), configuredUiDir) : defaultUiDir;
   return {
     host: env.MORSE_HOST ?? defaultHost,
     port: parsePositiveInt(env.MORSE_PORT, 4399),
-    uiDir: configuredUiDir ? isAbsolute5(configuredUiDir) ? configuredUiDir : join7(process.cwd(), configuredUiDir) : defaultUiDir,
-    workspace: { cwd: workspacePath, name: basename4(workspacePath) || workspacePath },
+    uiDir,
+    frontend: readFrontendIdentity(uiDir),
+    workspace: { cwd: workspacePath, name: basename3(workspacePath) || workspacePath },
     piPath: env.MORSE_PI_PATH,
     nodeEntryPath: env.MORSE_PI_ENTRY,
     sessionDir: env.MORSE_SESSION_DIR,
@@ -3797,9 +3946,19 @@ function loadConfig(env = process.env) {
     requestTimeoutMs: parsePositiveInt(env.MORSE_REQUEST_TIMEOUT_MS, 3e4),
     hotSessions: parsePositiveInt(env.MORSE_HOT_SESSIONS, 4),
     projects: parseList(env.MORSE_PROJECTS),
-    uploadDir: env.MORSE_UPLOAD_DIR?.trim() || DEFAULT_UPLOAD_DIR
+    uploadDir: env.MORSE_UPLOAD_DIR?.trim() || DEFAULT_UPLOAD_DIR,
+    updateCheck: !isOff(env.MORSE_UPDATE_CHECK)
   };
 }
+function readFrontendIdentity(uiDir) {
+  try {
+    return frontendIdentity(
+      parseFrontendManifest(readFileSync(join7(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
+    );
+  } catch {
+    return void 0;
+  }
+}
 function parsePositiveInt(value, fallback) {
   if (!value) {
     return fallback;
@@ -3807,6 +3966,10 @@ function parsePositiveInt(value, fallback) {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
+function isOff(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "0" || normalized === "false" || normalized === "off";
+}
 function parseList(value) {
   if (!value) {
     return [];