@supanadit/morse-web 0.9.4 → 0.10.0

package/dist/server.mjs

@@ -1706,11 +1706,11 @@ function promptDescription(raw) {
     }
     body = raw.slice(frontmatter[0].length);
   }
-  const firstLine = body.split("\n").find((line) => line.trim().length > 0);
-  if (firstLine === void 0) {
+  const firstLine2 = body.split("\n").find((line) => line.trim().length > 0);
+  if (firstLine2 === void 0) {
     return void 0;
   }
-  const trimmed = firstLine.trim();
+  const trimmed = firstLine2.trim();
   return trimmed.length > 60 ? `${trimmed.slice(0, 60)}...` : trimmed;
 }
 function unquote(value) {
@@ -2383,6 +2383,11 @@ var SessionTranscriptStore = class {
   projectors = /* @__PURE__ */ new Map();
   cursors = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
+  /**
+   * Agent events already projected, by instance (see `apply`). A weak set, so
+   * a projected record never keeps itself alive after it has been fanned out.
+   */
+  applied = /* @__PURE__ */ new WeakSet();
   subscribe(listener) {
     this.listeners.add(listener);
     return () => {
@@ -2402,7 +2407,25 @@ var SessionTranscriptStore = class {
   setHistoryCursor(sessionKey, cursor) {
     this.cursors.set(sessionKey, cursor);
   }
+  /**
+   * Feeds one agent event in. Idempotent per event *instance*: the registry
+   * fans a single tagged event out to every subscribed controller, and each of
+   * them writes it here, so a host with more than one connected client would
+   * otherwise project the same stream once per connection. The symptoms are
+   * unmistakable — a delta doubled into "therethere", a second `message_end`
+   * creating a duplicate prose row, and a second `tool-start` re-binding the
+   * call id so the first tool item never receives its `tool-end` and stays
+   * `running` forever ("Working for …" never settling).
+   *
+   * Identity is the right key because `SessionRegistry.emit` passes the same
+   * event object to every listener: the first writer projects it, the rest are
+   * no-ops, whatever the connection count.
+   */
   apply(sessionKey, event) {
+    if (this.applied.has(event)) {
+      return;
+    }
+    this.applied.add(event);
     this.projectorFor(sessionKey).apply(event);
   }
   /** Replays a resumed session's history into an empty transcript. */
@@ -3253,7 +3276,7 @@ var HostSessionController = class {
         this.agentReady = false;
         this.agentError = event.message;
         this.agentFailure = hintOnly(this.options.agentHint);
-        this.options.transcripts.error(sessionKey, event.message, event.detail);
+        this.options.transcripts.apply(sessionKey, event);
         this.emitState();
         return;
       default:
@@ -3936,6 +3959,169 @@ async function readGitDiff(cwd, requested) {
   );
   return { path: rel, diff: diff ?? "" };
 }
+async function readCommitFiles(cwd, requested) {
+  const hash = requested.trim();
+  if (!isCommitHash(hash)) {
+    return { isRepo: false, hash, files: [] };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, hash, files: [] };
+  }
+  const raw = await gitText(
+    ["show", "--name-status", "--format=", "-z", "--find-renames", "--relative", hash],
+    cwd
+  );
+  return { isRepo: true, hash, files: parseNameStatus(raw ?? "") };
+}
+async function readCommitDiff(cwd, hash, requested) {
+  const rel = toPosix2(relative3(cwd, resolveWithin(cwd, requested)));
+  if (!isCommitHash(hash.trim())) {
+    return { path: rel, diff: "" };
+  }
+  const diff = await gitText(
+    ["show", "--format=", "--no-color", "--no-ext-diff", "-U3", "--relative", hash.trim(), "--", rel],
+    cwd
+  );
+  return { path: rel, diff: diff ?? "" };
+}
+function isCommitHash(hash) {
+  return /^[0-9a-fA-F]{4,40}$/.test(hash);
+}
+function parseNameStatus(raw) {
+  const tokens = raw.split("\0");
+  const files = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const status = tokens[index];
+    if (!status) {
+      continue;
+    }
+    const letter = status[0] ?? "";
+    const rename = letter === "R" || letter === "C";
+    const path = tokens[index + (rename ? 2 : 1)];
+    index += rename ? 2 : 1;
+    if (path) {
+      files.push({ path: toPosix2(path), status: `${letter} ` });
+    }
+  }
+  return files;
+}
+async function stageGitPaths(cwd, requested) {
+  const paths = resolvePaths(cwd, requested);
+  if (paths.length > 0) {
+    await gitRun(["add", "--", ...paths], cwd);
+  }
+  return readGitStatus(cwd);
+}
+async function unstageGitPaths(cwd, requested) {
+  const paths = resolvePaths(cwd, requested);
+  if (paths.length > 0) {
+    const reset = await gitRun(["reset", "--quiet", "HEAD", "--", ...paths], cwd);
+    if (!reset) {
+      await gitRun(["rm", "--cached", "--quiet", "--", ...paths], cwd);
+    }
+  }
+  return readGitStatus(cwd);
+}
+async function readGitSync(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, ahead: 0, behind: 0 };
+  }
+  const [branch, upstream] = await Promise.all([
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], cwd)
+  ]);
+  const name = branch?.trim() || void 0;
+  const tracked = upstream?.trim() || void 0;
+  if (tracked === void 0) {
+    return { isRepo: true, branch: name, ahead: 0, behind: 0 };
+  }
+  const counts = await gitText(
+    ["rev-list", "--left-right", "--count", `${tracked}...HEAD`],
+    cwd
+  );
+  const [behind, ahead] = parseCounts(counts ?? "");
+  return { isRepo: true, branch: name, upstream: tracked, ahead, behind };
+}
+async function pullGit(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() === "true") {
+    await gitRun(["pull", "--no-edit"], cwd, 18e4);
+  }
+  return readGitSync(cwd);
+}
+async function pushGit(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() === "true") {
+    await gitRun(["push", "--follow-tags"], cwd, 18e4);
+  }
+  return readGitSync(cwd);
+}
+async function readGitBranches(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, local: [], remote: [], tags: [] };
+  }
+  const [current, local, remote, tags] = await Promise.all([
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/remotes"], cwd),
+    gitText(["for-each-ref", "--format=%(refname:short)", "refs/tags"], cwd)
+  ]);
+  return {
+    isRepo: true,
+    current: current?.trim() || void 0,
+    local: nonEmptyLines(local),
+    remote: nonEmptyLines(remote).filter((name) => !name.endsWith("/HEAD")),
+    tags: nonEmptyLines(tags)
+  };
+}
+async function commitGit(cwd, message) {
+  const text = message.trim();
+  if (text.length === 0) {
+    return { ok: false, message: "A commit needs a message." };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { ok: false, message: "This project is not a git repository." };
+  }
+  const result = await gitExec(["commit", "-m", text], cwd, 6e4);
+  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+}
+async function checkoutGit(cwd, branch, create) {
+  const name = branch.trim();
+  if (!isBranchName(name)) {
+    return { ok: false, message: "That is not a usable branch name." };
+  }
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { ok: false, message: "This project is not a git repository." };
+  }
+  const result = await gitExec(
+    create ? ["checkout", "-b", name] : ["checkout", name],
+    cwd,
+    6e4
+  );
+  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+}
+function isBranchName(name) {
+  return name.length > 0 && !name.startsWith("-") && !name.includes("..") && !name.includes("@{") && !name.endsWith("/") && !/\s/.test(name) && !/[~^:?*\[\\]/.test(name);
+}
+function firstLine(output) {
+  const line = output.split("\n").find((candidate) => candidate.trim().length > 0)?.trim();
+  if (line === void 0) {
+    return void 0;
+  }
+  return line.length > 200 ? `${line.slice(0, 197)}\u2026` : line;
+}
+function nonEmptyLines(output) {
+  return (output ?? "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function parseCounts(raw) {
+  const [behind, ahead] = raw.trim().split(/\s+/).map((value) => Number.parseInt(value, 10));
+  return [Number.isFinite(behind) ? behind : 0, Number.isFinite(ahead) ? ahead : 0];
+}
 function toPosix2(path) {
   return path.split("\\").join("/");
 }
@@ -3983,6 +4169,37 @@ function gitText(args, cwd) {
     );
   });
 }
+function resolvePaths(cwd, requested) {
+  return requested.filter((path) => typeof path === "string" && path.length > 0).map((path) => toPosix2(relative3(cwd, resolveWithin(cwd, path))));
+}
+async function gitRun(args, cwd, timeout = 5e3) {
+  return (await gitExec(args, cwd, timeout)).ok;
+}
+function gitExec(args, cwd, timeout = 5e3) {
+  return new Promise((resolve6) => {
+    execFile(
+      "git",
+      args,
+      {
+        cwd,
+        timeout,
+        maxBuffer: 8 * 1024 * 1024,
+        windowsHide: true,
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_EDITOR: "true",
+          GIT_MERGE_AUTOEDIT: "no"
+        }
+      },
+      (error, stdout, stderr) => {
+        resolve6(
+          error === null ? { ok: true, output: stdout.trim() } : { ok: false, output: (stderr || error.message || "").trim() }
+        );
+      }
+    );
+  });
+}
 
 // ../server/src/internal/workspace/workspace-index.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -4242,6 +4459,54 @@ var MorseSessionFactory = class {
         }
         return readGitDiff(cwd, path);
       }
+      case "gitStage": {
+        const cwd = this.requireWritableCwd(context);
+        return stageGitPaths(cwd, gitPaths(args));
+      }
+      case "gitUnstage": {
+        const cwd = this.requireWritableCwd(context);
+        return unstageGitPaths(cwd, gitPaths(args));
+      }
+      case "gitCommitFiles": {
+        const cwd = this.requireWritableCwd(context);
+        const hash = typeof args?.hash === "string" ? args.hash : "";
+        return readCommitFiles(cwd, hash);
+      }
+      case "gitCommitDiff": {
+        const cwd = this.requireWritableCwd(context);
+        const hash = typeof args?.hash === "string" ? args.hash : "";
+        const path = typeof args?.path === "string" ? args.path : "";
+        if (path.length === 0) {
+          throw new UnsupportedByHostError('gitCommitDiff needs a "path" argument.');
+        }
+        return readCommitDiff(cwd, hash, path);
+      }
+      case "gitSync": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitSync(cwd);
+      }
+      case "gitPull": {
+        const cwd = this.requireWritableCwd(context);
+        return pullGit(cwd);
+      }
+      case "gitPush": {
+        const cwd = this.requireWritableCwd(context);
+        return pushGit(cwd);
+      }
+      case "gitCommit": {
+        const cwd = this.requireWritableCwd(context);
+        const message = typeof args?.message === "string" ? args.message : "";
+        return commitGit(cwd, message);
+      }
+      case "gitBranches": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitBranches(cwd);
+      }
+      case "gitCheckout": {
+        const cwd = this.requireWritableCwd(context);
+        const branch = typeof args?.branch === "string" ? args.branch : "";
+        return checkoutGit(cwd, branch, args?.create === true);
+      }
       default:
         throw new UnsupportedByHostError(`This host does not support "${command}".`);
     }
@@ -4276,6 +4541,13 @@ MorseSessionFactory = __decorateClass([
   __decorateParam(3, Inject3(MORSE_LOGGER)),
   __decorateParam(4, Inject3(MORSE_CONFIG))
 ], MorseSessionFactory);
+function gitPaths(args) {
+  const paths = args?.paths;
+  if (!Array.isArray(paths)) {
+    return [];
+  }
+  return paths.filter((path) => typeof path === "string" && path.length > 0);
+}
 
 // ../server/src/internal/ws/morse.gateway.ts
 var MorseGateway = class {