@supanadit/morse-web 0.6.0 → 0.8.0

package/dist/server.mjs

@@ -75,7 +75,7 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 17;
+var PROTOCOL_VERSION = 19;
 var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
@@ -1108,14 +1108,14 @@ var PiRpcClient = class {
       throw this.failed ?? new AgentUnavailableError("The pi agent is not running.");
     }
     const id = `morse-${this.nextId++}`;
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new AgentProtocolError(`pi did not answer "${command.type}" within ${timeoutMs} ms.`));
       }, timeoutMs);
       this.pending.set(id, {
         command: command.type,
-        resolve: (data) => resolve5(data),
+        resolve: (data) => resolve6(data),
         reject,
         timer
       });
@@ -1134,14 +1134,14 @@ var PiRpcClient = class {
       return;
     }
     let exited = false;
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       const finish = () => {
         exited = true;
-        resolve5();
+        resolve6();
       };
       child.once("exit", finish);
       child.stdin.end();
-      setTimeout(resolve5, SHUTDOWN_GRACE_MS).unref?.();
+      setTimeout(resolve6, SHUTDOWN_GRACE_MS).unref?.();
     });
     if (!exited) {
       child.kill();
@@ -2612,6 +2612,7 @@ function noticeMessage(level, text, at) {
 
 // ../host-runtime/dist/session-controller.js
 var HISTORY_PAGE_SIZE = 50;
+var UNTITLED_SESSION = "New session";
 var HostSessionController = class {
   options;
   summaries = /* @__PURE__ */ new Map();
@@ -3322,7 +3323,7 @@ var HostSessionController = class {
         }
         sessions.push({
           id: key,
-          title: state?.sessionTitle ?? this.derivedTitle(key) ?? "New session",
+          title: state?.sessionTitle ?? this.derivedTitle(key) ?? UNTITLED_SESSION,
           cwd,
           updatedAt: Date.now(),
           messageCount: 0
@@ -3409,7 +3410,12 @@ var HostSessionController = class {
     };
     const state = this.activeKey === void 0 ? void 0 : this.options.services.registry.stateOf(this.activeKey);
     if (state) {
-      return toSessionViewState(state, meta);
+      const view = toSessionViewState(state, meta);
+      if (view.sessionTitle === void 0 && this.activeKey !== void 0) {
+        const catalog = this.summaries.get(this.activeKey)?.title;
+        view.sessionTitle = catalog !== void 0 && catalog !== UNTITLED_SESSION ? catalog : this.derivedTitle(this.activeKey);
+      }
+      return view;
     }
     return draftSessionViewState(this.draftWorkspace ?? this.options.services.registry.defaultWorkspace, meta, this.draftCatalog, this.draftModel, this.draftThinking);
   }
@@ -3798,10 +3804,190 @@ function shortcutRoots(options) {
   return roots;
 }
 
-// ../server/src/internal/workspace/workspace-index.ts
+// ../server/src/internal/workspace/file-store.ts
+import { open as open2, stat as stat4 } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative2, resolve as resolve5 } from "node:path";
+var MAX_PREVIEW_BYTES = 512 * 1024;
+var SNIFF_BYTES = 8 * 1024;
+async function readWorkspaceFile(cwd, requested) {
+  const target = resolveWithin(cwd, requested);
+  const info = await stat4(target).catch(() => void 0);
+  if (info === void 0) {
+    throw new UnsupportedByHostError(`No such file: ${requested}`);
+  }
+  if (info.isDirectory()) {
+    throw new UnsupportedByHostError(`${requested} is a directory, not a file.`);
+  }
+  const handle = await open2(target, "r");
+  try {
+    const length = Math.min(info.size, MAX_PREVIEW_BYTES);
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, 0);
+    const slice = buffer.subarray(0, bytesRead);
+    const binary = slice.subarray(0, Math.min(bytesRead, SNIFF_BYTES)).includes(0);
+    return {
+      path: toPosix(relative2(cwd, target)),
+      content: binary ? "" : slice.toString("utf8"),
+      size: info.size,
+      truncated: info.size > bytesRead,
+      binary
+    };
+  } finally {
+    await handle.close();
+  }
+}
+function resolveWithin(cwd, requested) {
+  if (isAbsolute5(requested)) {
+    throw new UnsupportedByHostError("A preview only opens files inside the project.");
+  }
+  const target = resolve5(cwd, requested);
+  const rel = relative2(cwd, target);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute5(rel)) {
+    throw new UnsupportedByHostError("A preview only opens files inside the project.");
+  }
+  return target;
+}
+function toPosix(path) {
+  return path.split("\\").join("/");
+}
+
+// ../server/src/internal/workspace/git-log.ts
 import { execFile } from "node:child_process";
+import { relative as relative3 } from "node:path";
+var DEFAULT_MAX_COMMITS = 250;
+var HARD_MAX_COMMITS = 500;
+var FIELD = "";
+var RECORD = "";
+var PRETTY_FORMAT = ["%H", "%h", "%P", "%D", "%an", "%aI", "%s"].join(FIELD) + RECORD;
+async function readGitLog(cwd, requestedMax, requestedSkip) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, commits: [] };
+  }
+  const max = clampMax(requestedMax);
+  const skip = clampSkip(requestedSkip);
+  const [root, branch, raw] = await Promise.all([
+    gitText(["rev-parse", "--show-toplevel"], cwd),
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(
+      [
+        "log",
+        "--all",
+        "--date-order",
+        `--skip=${skip}`,
+        `--max-count=${max}`,
+        `--pretty=format:${PRETTY_FORMAT}`
+      ],
+      cwd
+    )
+  ]);
+  return {
+    isRepo: true,
+    root: root?.trim() || cwd,
+    branch: branch?.trim() || void 0,
+    commits: parseCommits(raw ?? "")
+  };
+}
+function clampMax(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) {
+    return DEFAULT_MAX_COMMITS;
+  }
+  return Math.max(1, Math.min(HARD_MAX_COMMITS, Math.floor(requested)));
+}
+async function readGitStatus(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, files: [] };
+  }
+  const [prefix, raw] = await Promise.all([
+    gitText(["rev-parse", "--show-prefix"], cwd),
+    gitText(["status", "--porcelain=v1", "-z", "--untracked-files=all"], cwd)
+  ]);
+  return { isRepo: true, files: parseStatus(raw ?? "", prefix?.trim() ?? "") };
+}
+function parseStatus(raw, root) {
+  const records = raw.split("\0");
+  const files = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record || record.length < 4) {
+      continue;
+    }
+    const status = record.slice(0, 2);
+    if (status[0] === "R" || status[0] === "C") {
+      index += 1;
+    }
+    const full = record.slice(3);
+    if (root.length > 0 && !full.startsWith(root)) {
+      continue;
+    }
+    const path = full.slice(root.length);
+    if (path.length > 0) {
+      files.push({ path: toPosix2(path), status });
+    }
+  }
+  return files;
+}
+async function readGitDiff(cwd, requested) {
+  const rel = toPosix2(relative3(cwd, resolveWithin(cwd, requested)));
+  const diff = await gitText(
+    ["diff", "--no-color", "--no-ext-diff", "-U3", "HEAD", "--", rel],
+    cwd
+  );
+  return { path: rel, diff: diff ?? "" };
+}
+function toPosix2(path) {
+  return path.split("\\").join("/");
+}
+function clampSkip(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(requested));
+}
+function parseCommits(raw) {
+  const commits = [];
+  for (const record of raw.split(RECORD)) {
+    const line = record.replace(/^\n+/, "");
+    if (line.trim().length === 0) {
+      continue;
+    }
+    const fields = line.split(FIELD);
+    const [hash, shortHash, parents, refs, author, date, subject] = fields;
+    if (!hash || !shortHash || !date) {
+      continue;
+    }
+    commits.push({
+      hash,
+      shortHash,
+      parents: (parents ?? "").split(" ").filter((parent) => parent.length > 0),
+      refs: parseRefs(refs ?? ""),
+      author: author ?? "",
+      date,
+      subject: subject ?? ""
+    });
+  }
+  return commits;
+}
+function parseRefs(raw) {
+  const refs = raw.split(",").map((ref) => ref.trim()).filter((ref) => ref.length > 0);
+  return refs;
+}
+function gitText(args, cwd) {
+  return new Promise((resolve6) => {
+    execFile(
+      "git",
+      args,
+      { cwd, timeout: 5e3, maxBuffer: 16 * 1024 * 1024, windowsHide: true },
+      (error, stdout) => resolve6(error ? void 0 : stdout)
+    );
+  });
+}
+
+// ../server/src/internal/workspace/workspace-index.ts
+import { execFile as execFile2 } from "node:child_process";
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join7, relative as relative2 } from "node:path";
+import { join as join7, relative as relative4 } from "node:path";
 var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3822,15 +4008,15 @@ var MAX_INDEXED_FILES = 5e3;
 var INDEX_TTL_MS = 6e4;
 var indexes = /* @__PURE__ */ new Map();
 var inFlight = /* @__PURE__ */ new Map();
-async function workspaceFiles(cwd, logger) {
-  const { files, source } = await cachedIndex(cwd);
+async function workspaceFiles(cwd, logger, options = {}) {
+  const { files, source } = await cachedIndex(cwd, options.fresh === true);
   logger.info(`File picker: ${files.length} entries via ${source} in ${cwd}`);
   return files;
 }
-async function cachedIndex(cwd) {
+async function cachedIndex(cwd, fresh) {
   const now = Date.now();
   const cached = indexes.get(cwd);
-  if (cached && now - cached.at < INDEX_TTL_MS) {
+  if (!fresh && cached && now - cached.at < INDEX_TTL_MS) {
     return cached;
   }
   const pending = inFlight.get(cwd);
@@ -3885,12 +4071,12 @@ async function gitFileList(cwd) {
   }
 }
 function runGit(args, cwd) {
-  return new Promise((resolve5) => {
-    execFile(
+  return new Promise((resolve6) => {
+    execFile2(
       "git",
       args,
       { cwd, timeout: 5e3, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
-      (error, stdout) => resolve5(error ? void 0 : stdout)
+      (error, stdout) => resolve6(error ? void 0 : stdout)
     );
   });
 }
@@ -3921,11 +4107,11 @@ async function walk(root, directory, files) {
       continue;
     }
     if (entry.isFile() || entry.isSymbolicLink()) {
-      files.push(toPosix(relative2(root, full)));
+      files.push(toPosix3(relative4(root, full)));
     }
   }
 }
-function toPosix(path) {
+function toPosix3(path) {
   return path.split("\\").join("/");
 }
 
@@ -3952,6 +4138,12 @@ var MorseSessionFactory = class {
       // The server can walk the active session's directory, so the composer's
       // `@` picker works here too — the same list VS Code offers for a workspace.
       filePicker: true,
+      // A browser has no editor of its own, so this host reads files for the
+      // frontend's Explorer and preview tabs. VS Code keeps its native ones.
+      filePreview: true,
+      // The same reasoning for history: VS Code has Source Control, so the
+      // browser host is the one that answers `gitLog` for its own git panel.
+      gitPanel: true,
       // A browser cannot hand a dragged file's path to pi, so the host takes the
       // bytes and writes them next to the session; the frontend then `@mentions`
       // the path it gets back.
@@ -4015,15 +4207,41 @@ var MorseSessionFactory = class {
       }
       case "listFiles": {
         const cwd = this.requireWritableCwd(context);
-        const files = await workspaceFiles(cwd, this.logger);
+        const files = await workspaceFiles(cwd, this.logger, { fresh: args?.fresh === true });
         return { files };
       }
+      case "readFile": {
+        const cwd = this.requireWritableCwd(context);
+        const path = typeof args?.path === "string" ? args.path : "";
+        if (path.length === 0) {
+          throw new UnsupportedByHostError('readFile needs a "path" argument.');
+        }
+        return readWorkspaceFile(cwd, path);
+      }
       case "uploadFile": {
         const cwd = this.requireWritableCwd(context);
         const saved = await saveUpload(cwd, args ?? {}, this.config.uploadDir);
         this.logger.info(`Upload stored: ${saved.path} (${saved.bytes} bytes)`);
         return saved;
       }
+      case "gitLog": {
+        const cwd = this.requireWritableCwd(context);
+        const max = typeof args?.max === "number" ? args.max : void 0;
+        const skip = typeof args?.skip === "number" ? args.skip : void 0;
+        return readGitLog(cwd, max, skip);
+      }
+      case "gitStatus": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitStatus(cwd);
+      }
+      case "gitDiff": {
+        const cwd = this.requireWritableCwd(context);
+        const path = typeof args?.path === "string" ? args.path : "";
+        if (path.length === 0) {
+          throw new UnsupportedByHostError('gitDiff needs a "path" argument.');
+        }
+        return readGitDiff(cwd, path);
+      }
       default:
         throw new UnsupportedByHostError(`This host does not support "${command}".`);
     }
@@ -4107,7 +4325,7 @@ MorseGateway = __decorateClass([
 ], MorseGateway);
 
 // ../server/src/app/config.ts
-import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute5, join as join8 } from "node:path";
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute6, join as join8 } from "node:path";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 function loadConfig(env = process.env) {
@@ -4118,7 +4336,7 @@ function loadConfig(env = process.env) {
   const monorepoUiDir = join8(moduleDir, "..", "..", "..", "ui-angular", "dist");
   const defaultUiDir = existsSync2(join8(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
   const defaultHost = "127.0.0.1";
-  const uiDir = configuredUiDir ? isAbsolute5(configuredUiDir) ? configuredUiDir : join8(process.cwd(), configuredUiDir) : defaultUiDir;
+  const uiDir = configuredUiDir ? isAbsolute6(configuredUiDir) ? configuredUiDir : join8(process.cwd(), configuredUiDir) : defaultUiDir;
   return {
     host: env.MORSE_HOST ?? defaultHost,
     port: parsePositiveInt(env.MORSE_PORT, 4399),