overleaf-review 0.1.2 → 0.2.1

package/README.md

@@ -36,7 +36,9 @@ workflow and carries the review layer Git can't represent.
   (`.overleaf/reviews.md` + `.json`), so your tools have every co-author note in context.
 - 📤 **`push`** — turn local edits into **tracked-change suggestions**, mapping files to Overleaf
   docs by path (one file, or every changed `.tex` at once). `--dry-run` previews the exact ops.
-- 💬 **`comment` / `resolve`** — anchor a comment on any text, and resolve/reopen threads.
+- 💬 **`comment` / `reply` / `resolve` / `delete-comment` / `delete-message`** — full comment
+  control: start a thread, reply, resolve/reopen, delete a whole thread or a single message.
+- ✅ **`accept` / `reject`** — act on your collaborators' tracked changes from the CLI.
 - 🔑 **`login`** — validated auth stored outside your repo (chmod 600); `--browser` mode is
   institutional-SSO friendly.
 
@@ -73,7 +75,14 @@ overleaf-review resolve --thread <id>       # thread ids come from `pull`
 | `pull [--out <dir>]` | Read comments + tracked changes into a sidecar |
 | `push [--file <f>] [--doc <name>] [--dry-run]` | Send local edits as tracked-change suggestions (all changed `.tex` if no `--file`) |
 | `comment --anchor <text> --message <text> [--doc <name>] [--nth <n>]` | Add a comment anchored on the given text |
+| `reply --thread <id> --message <text>` | Reply to an existing comment thread |
 | `resolve --thread <id> [--reopen]` | Resolve (or reopen) a comment thread |
+| `delete-comment --thread <id>` | Delete a whole comment thread |
+| `delete-message --message-id <id> [--thread <id>]` | Delete a single message within a thread |
+| `accept --change <id> …` | Accept collaborators' tracked change(s) |
+| `reject --change <id> …` | Reject collaborators' tracked change(s) |
+
+Thread and change ids are listed by `pull` (in `.overleaf/reviews.md`).
 
 ## 🧠 How it works
 
@@ -96,10 +105,13 @@ own account and projects. Use at your own risk.
 
 ## 🗺️ Roadmap
 
-- Reply-to-thread and delete-comment
 - A `pull` that also writes doc content (not just the review sidecar)
 - Trusted-publishing CI
 
+## 📝 Changelog
+
+Version history and notes are on the [Releases page](https://github.com/michu5696/overleaf-review/releases).
+
 ## 📄 License
 
 MIT © [Miguel Castellano](https://github.com/michu5696)

package/dist/cli.js

@@ -149,15 +149,15 @@ var OverleafSocket = class {
     const wsUrl = `${this.baseUrl.replace(/^http/, "ws")}/socket.io/1/websocket/${sid}`;
     if (this.debug) console.log(`[socket] transports=${transports}; ws=${wsUrl}`);
     this.ws = new WebSocket(wsUrl, { headers: this.browserHeaders });
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve2, reject2) => {
       this.ws.once("open", () => resolve2());
-      this.ws.once("error", reject);
+      this.ws.once("error", reject2);
       this.ws.once("unexpected-response", (_req, response) => {
         let errBody = "";
         response.on("data", (chunk) => errBody += chunk.toString());
         response.on(
           "end",
-          () => reject(
+          () => reject2(
             new Error(
               `ws upgrade rejected: ${response.statusCode} ${response.statusMessage}
   headers: ${JSON.stringify(response.headers)}
@@ -175,10 +175,10 @@ var OverleafSocket = class {
   /** Emit an event and resolve with the server's ack payload (array of args). */
   emit(name, args, timeoutMs = 15e3) {
     const id = this.ackId++;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve2, reject2) => {
       const timer = setTimeout(() => {
         this.pendingAcks.delete(id);
-        reject(new Error(`emit('${name}') timed out after ${timeoutMs}ms with no ack`));
+        reject2(new Error(`emit('${name}') timed out after ${timeoutMs}ms with no ack`));
       }, timeoutMs);
       this.pendingAcks.set(id, (payload) => {
         clearTimeout(timer);
@@ -315,6 +315,34 @@ async function setThreadResolved(docId, threadId, reopen, csrf) {
   }
   return res.status;
 }
+async function acceptChanges(docId, changeIds, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/changes/accept`,
+    {
+      method: "POST",
+      headers: headers({ "X-CSRF-Token": csrf, "Content-Type": "application/json" }),
+      body: JSON.stringify({ change_ids: changeIds })
+    }
+  );
+  if (!res.ok) throw new Error(`acceptChanges ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
+async function deleteMessage(threadId, messageId, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages/${messageId}`,
+    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
+  );
+  if (!res.ok) throw new Error(`deleteMessage ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
+async function deleteThread(docId, threadId, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/thread/${threadId}`,
+    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
+  );
+  if (!res.ok) throw new Error(`deleteThread ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
 async function validateSession(baseUrl, session2) {
   const res = await fetch(`${baseUrl}/project`, {
     headers: { Cookie: `overleaf_session2=${session2}`, "User-Agent": UA },
@@ -379,6 +407,7 @@ async function pull(outDir = ".overleaf") {
         context: lineContext(state.lines, line),
         resolved: Boolean(thread.resolved),
         messages: (thread.messages ?? []).map((m) => ({
+          id: m.id,
           author: m.user?.first_name ?? members[m.user_id] ?? m.user_id,
           email: m.user?.email,
           content: m.content,
@@ -391,6 +420,7 @@ async function pull(outDir = ".overleaf") {
       const line = offsetToLine(state.lines, ch.op.p);
       changes.push({
         doc: doc.path,
+        id: ch.id,
         type: isInsert ? "insert" : "delete",
         text: isInsert ? ch.op.i : ch.op.d,
         line: line + 1,
@@ -418,6 +448,10 @@ function renderMarkdown(d) {
   L.push(`# Overleaf review \u2014 ${d.project}`, "");
   L.push(`_Pulled ${d.pulledAt} from project \`${d.projectId}\`._`, "");
   L.push(`**${d.comments.length}** comment(s), **${d.changes.length}** tracked change(s).`, "");
+  L.push(
+    "_Act on these:_ `reply --thread <id> --message <text>` \xB7 `resolve --thread <id>` \xB7 `delete-comment --thread <id>` \xB7 `delete-message --message-id <id>` \xB7 `accept --change <id>` \xB7 `reject --change <id>`.",
+    ""
+  );
   const byDoc = (items) => {
     const m = /* @__PURE__ */ new Map();
     for (const it of items) (m.get(it.doc) ?? m.set(it.doc, []).get(it.doc)).push(it);
@@ -430,9 +464,10 @@ function renderMarkdown(d) {
       for (const c of items) {
         const flag = c.resolved ? " \u2014 \u2705 resolved" : "";
         L.push(`#### \u{1F4AC} \u201C${c.anchor}\u201D \xB7 line ${c.line}${flag}`);
+        L.push(`\`thread ${c.threadId}\``);
         L.push("```", c.context, "```");
         for (const m of c.messages) {
-          L.push(`- **${m.author}**: ${m.content}`);
+          L.push(`- **${m.author}**: ${m.content}  \`msg ${m.id}\``);
         }
         if (!c.messages.length) L.push("- _(no message text)_");
         L.push("");
@@ -445,7 +480,9 @@ function renderMarkdown(d) {
       L.push(`### ${doc}`, "");
       for (const ch of items) {
         const verb = ch.type === "insert" ? "inserted" : "deleted";
-        L.push(`- **${verb}** at line ${ch.line} by ${ch.author}: \`${ch.text.replace(/\n/g, "\u23CE")}\``);
+        L.push(
+          `- **${verb}** at line ${ch.line} by ${ch.author} \xB7 \`change ${ch.id}\`: \`${ch.text.replace(/\n/g, "\u23CE")}\``
+        );
         L.push("  ```", ch.context.replace(/^/gm, "  "), "  ```");
       }
       L.push("");
@@ -603,6 +640,13 @@ async function comment(opts) {
   console.log(`\u2705 Commented on "${opts.anchor}" in ${doc.name}  (thread ${threadId})`);
 }
 
+// src/commands/reply.ts
+async function reply(threadId, message) {
+  const csrf = await getCsrfToken();
+  await postThreadMessage(threadId, message, csrf);
+  console.log(`\u2705 Replied to thread ${threadId}`);
+}
+
 // src/commands/resolve.ts
 async function resolve(threadId, reopen = false) {
   const { socket, docs } = await openProject();
@@ -625,6 +669,95 @@ async function resolve(threadId, reopen = false) {
   console.log(`\u2705 Thread ${threadId} ${reopen ? "reopened" : "resolved"}`);
 }
 
+// src/commands/delete-comment.ts
+async function deleteComment(threadId) {
+  const { socket, docs } = await openProject();
+  let docId;
+  for (const doc of docs) {
+    const state = await joinDoc(socket, doc._id);
+    if ((state.ranges.comments ?? []).some((c) => c.op?.t === threadId)) {
+      docId = doc._id;
+      break;
+    }
+  }
+  socket.close();
+  if (!docId) throw new Error(`thread ${threadId} not found in any doc's comments`);
+  const csrf = await getCsrfToken();
+  await deleteThread(docId, threadId, csrf);
+  console.log(`\u2705 Deleted comment thread ${threadId}`);
+}
+
+// src/commands/delete-message.ts
+async function deleteThreadMessage(messageId, threadId) {
+  const csrf = await getCsrfToken();
+  let tid = threadId;
+  if (!tid) {
+    const threads = await getThreads();
+    for (const [t, v] of Object.entries(threads)) {
+      if (v.messages?.some((m) => m.id === messageId)) {
+        tid = t;
+        break;
+      }
+    }
+  }
+  if (!tid) throw new Error(`message ${messageId} not found in any thread`);
+  await deleteMessage(tid, messageId, csrf);
+  console.log(`\u2705 Deleted message ${messageId} from thread ${tid}`);
+}
+
+// src/commands/accept.ts
+async function accept(changeIds) {
+  const { socket, docs } = await openProject();
+  const byDoc = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    const state = await joinDoc(socket, doc._id);
+    const here = (state.ranges.changes ?? []).filter((c) => changeIds.includes(c.id)).map((c) => c.id);
+    if (here.length) byDoc.set(doc._id, here);
+  }
+  socket.close();
+  const found = [...byDoc.values()].flat();
+  const missing = changeIds.filter((id) => !found.includes(id));
+  if (missing.length) console.log(`\u26A0\uFE0F  not found (already accepted/rejected?): ${missing.join(", ")}`);
+  if (!found.length) throw new Error("no matching tracked changes found");
+  const csrf = await getCsrfToken();
+  for (const [docId, ids] of byDoc) await acceptChanges(docId, ids, csrf);
+  console.log(`\u2705 Accepted ${found.length} tracked change(s)`);
+}
+
+// src/commands/reject.ts
+async function reject(changeIds) {
+  const { socket, docs } = await openProject();
+  const docOf = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    const state = await joinDoc(socket, doc._id);
+    for (const c of state.ranges.changes ?? []) {
+      if (changeIds.includes(c.id)) docOf.set(c.id, doc._id);
+    }
+  }
+  let rejected = 0;
+  for (const id of changeIds) {
+    const docId = docOf.get(id);
+    if (!docId) {
+      console.log(`\u26A0\uFE0F  not found (already accepted/rejected?): ${id}`);
+      continue;
+    }
+    const state = await joinDoc(socket, docId);
+    const c = (state.ranges.changes ?? []).find((x) => x.id === id);
+    if (!c) continue;
+    const op = typeof c.op?.i === "string" ? { p: c.op.p, d: c.op.i } : { p: c.op.p, i: c.op.d };
+    const update = { doc: docId, op: [op], v: state.version, meta: {} };
+    const ack = await socket.emit("applyOtUpdate", [docId, update], 15e3);
+    if (ack?.[0]) {
+      socket.close();
+      throw new Error(`Overleaf rejected the inverse op for ${id}: ${JSON.stringify(ack[0])}`);
+    }
+    rejected++;
+  }
+  socket.close();
+  if (!rejected) throw new Error("no matching tracked changes found");
+  console.log(`\u2705 Rejected ${rejected} tracked change(s)`);
+}
+
 // src/commands/login.ts
 import { createInterface } from "readline/promises";
 async function login(opts) {
@@ -684,40 +817,45 @@ function getFlag(name) {
   const i = process.argv.indexOf(`--${name}`);
   return i >= 0 ? process.argv[i + 1] : void 0;
 }
+function getAll(name) {
+  const out = [];
+  process.argv.forEach((a, i) => {
+    if (a === `--${name}` && process.argv[i + 1]) out.push(process.argv[i + 1]);
+  });
+  return out.flatMap((v) => v.split(",")).map((s) => s.trim()).filter(Boolean);
+}
 function usage() {
   console.log("overleaf-review \u2014 sync Overleaf review data with git\n");
   console.log("Setup:");
-  console.log("  overleaf-review login [--cookie <val>] [--browser]");
-  console.log("      Authenticate and store your session (--browser is SSO-friendly)");
-  console.log("  overleaf-review link --project <id>");
-  console.log("      Link this repo to an Overleaf project (writes .overleaf/config.json)\n");
-  console.log("Review:");
-  console.log("  overleaf-review pull [--out <dir>]");
-  console.log("      Read comments + tracked changes into a sidecar (.overleaf/)");
-  console.log("  overleaf-review push [--file <f>] [--doc <name>] [--dry-run]");
-  console.log("      Send local edits as tracked-change suggestions (all changed .tex if no --file)");
-  console.log("  overleaf-review comment --anchor <text> --message <text> [--doc <name>] [--nth <n>]");
-  console.log("      Add a comment anchored on the given text");
-  console.log("  overleaf-review resolve --thread <id> [--reopen]");
-  console.log("      Resolve (or reopen) a comment thread (ids come from `pull`)");
+  console.log("  login [--cookie <val>] [--browser]        Authenticate (SSO-friendly --browser)");
+  console.log("  link --project <id>                       Link this repo to an Overleaf project\n");
+  console.log("Read:");
+  console.log("  pull [--out <dir>]                        Comments + tracked changes \u2192 sidecar\n");
+  console.log("Comments:");
+  console.log("  comment --anchor <text> --message <text> [--doc <name>] [--nth <n>]");
+  console.log("  reply --thread <id> --message <text>      Reply to an existing thread");
+  console.log("  resolve --thread <id> [--reopen]          Resolve/reopen a thread");
+  console.log("  delete-comment --thread <id>              Delete a whole thread");
+  console.log("  delete-message --message-id <id>          Delete a single message\n");
+  console.log("Tracked changes:");
+  console.log("  push [--file <f>] [--doc <name>] [--dry-run]   Send local edits as suggestions");
+  console.log("  accept --change <id> [--change <id> \u2026]    Accept collaborators\u2019 changes");
+  console.log("  reject --change <id> [--change <id> \u2026]    Reject collaborators\u2019 changes");
+  console.log("\n(thread/change ids come from `pull`; --change accepts comma-separated lists too)");
 }
 async function main() {
   const cmd = process.argv[2];
   switch (cmd) {
-    case "login": {
+    case "login":
       await login({
         cookie: getFlag("cookie"),
         baseUrl: getFlag("base-url"),
         browser: process.argv.includes("--browser")
       });
       break;
-    }
     case "link": {
       const project = getFlag("project");
-      if (!project) {
-        console.error("link requires --project <id>");
-        process.exit(1);
-      }
+      if (!project) fail("link requires --project <id>");
       link(project, getFlag("base-url"));
       break;
     }
@@ -729,40 +867,63 @@ async function main() {
       );
       break;
     }
-    case "push": {
+    case "push":
       await push({ file: getFlag("file"), docName: getFlag("doc"), dryRun: process.argv.includes("--dry-run") });
       break;
-    }
     case "comment": {
       const anchor = getFlag("anchor");
       const message = getFlag("message");
-      if (!anchor || !message) {
-        console.error("comment requires --anchor <text> and --message <text>");
-        process.exit(1);
-      }
+      if (!anchor || !message) fail("comment requires --anchor <text> and --message <text>");
       const nthRaw = getFlag("nth");
-      await comment({
-        docName: getFlag("doc"),
-        anchor,
-        message,
-        occurrence: nthRaw ? Number(nthRaw) : void 0
-      });
+      await comment({ docName: getFlag("doc"), anchor, message, occurrence: nthRaw ? Number(nthRaw) : void 0 });
+      break;
+    }
+    case "reply": {
+      const thread = getFlag("thread");
+      const message = getFlag("message");
+      if (!thread || !message) fail("reply requires --thread <id> and --message <text>");
+      await reply(thread, message);
       break;
     }
     case "resolve": {
       const thread = getFlag("thread");
-      if (!thread) {
-        console.error("resolve requires --thread <id>");
-        process.exit(1);
-      }
+      if (!thread) fail("resolve requires --thread <id>");
       await resolve(thread, process.argv.includes("--reopen"));
       break;
     }
+    case "delete-comment": {
+      const thread = getFlag("thread");
+      if (!thread) fail("delete-comment requires --thread <id>");
+      await deleteComment(thread);
+      break;
+    }
+    case "delete-message": {
+      const messageId = getFlag("message-id");
+      if (!messageId) fail("delete-message requires --message-id <id>");
+      await deleteThreadMessage(messageId, getFlag("thread"));
+      break;
+    }
+    case "accept": {
+      const ids = getAll("change");
+      if (!ids.length) fail("accept requires --change <id>");
+      await accept(ids);
+      break;
+    }
+    case "reject": {
+      const ids = getAll("change");
+      if (!ids.length) fail("reject requires --change <id>");
+      await reject(ids);
+      break;
+    }
     default:
       usage();
       process.exit(cmd ? 1 : 0);
   }
 }
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
 main().then(() => process.exit(0)).catch((e) => {
   console.error(e instanceof Error ? e.message : e);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overleaf-review",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "The missing review layer for Overleaf's Git bridge — sync comments and tracked changes between Overleaf and your local repo.",
   "type": "module",
   "license": "MIT",