@webinson/peer 0.4.16 → 0.4.18

package/bin/peer.mjs

@@ -2,6 +2,7 @@
 // Peer: shows a team which agent threads its people chose to share, and on what they work.
 // `peer login` signs in once; `/peer` in a Claude Code thread shares that one thread.
 import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -30,11 +31,12 @@ const MARKETPLACE = "webinson-peer";
 
 const HELP = `peer: share chosen agent threads with your team
 
-  peer login [email] [--hub <url>] [--workspace <slug>]
-                    sign in once and set up Claude Code (/peer, /peer stop, /peer-list)
+  peer login [email] [--hub <url>] [--workspace <slug>] [--codex [--client]]
+                    sign in once and set up Claude Code or Codex
   peer list         people in the workspace, their shared threads and what they work on
   peer status       who you are, the workspace and the threads this computer shares
-  peer doctor       why Peer's hook did not answer /peer
+  peer doctor       why Peer's hook did not answer /peer, and whether this repository is in one
+                    Hub project (edits are checked against teammates' there)
   peer team connect <url> --as <member> [--project <id>]
                     connect to the team's memory server (your key on stdin); new threads in the
                     project's repositories then start with teammates' published findings. The
@@ -43,14 +45,15 @@ const HELP = `peer: share chosen agent threads with your team
   peer all [words] [here] [--newest | --oldest] [page N]
                     your own memories in your personal OpenViking, or the ones with these words
                     (full text); here: only this repository's. /peer-all in Claude Code
-  peer install      set up Claude Code again (hooks, the two commands and the thread mark)
-  peer uninstall    remove them from Claude Code
+  peer install [--codex [--client]]
+                    set up the thread mark; --client also builds the Peer Codex terminal
+  peer uninstall [--codex]  remove the integration from Claude Code or Codex
   peer logout       forget the sign-in on this computer
 
 In Claude Code: /peer shares the thread (/peer <message> also sends the message on), /peer stop
 ends it, /peer-list shows the list.
-Only threads where /peer was typed are shared, and only their repository, branch and state:
-never prompts, answers or summaries.`;
+Only threads where /peer was typed are shared, and only their repository, branch, state and the
+paths of the files they edit: never prompts, answers, summaries or file contents.`;
 
 // ---- files ----
 
@@ -133,8 +136,8 @@ function workingOn(cwd) {
   return { repository, branch: branch && branch !== "HEAD" ? branch : undefined, repoKey };
 }
 
-async function report(saved, session, state, cwd) {
-  await call(saved, "PUT", `/workspaces/${saved.workspace}/agents/${session}`, { agent: "claude-code", state, ...workingOn(cwd) }, HUB_TIMEOUT_MS);
+async function report(saved, session, state, cwd, agent = "claude-code", timeoutMs = HUB_TIMEOUT_MS) {
+  await call(saved, "PUT", `/workspaces/${saved.workspace}/agents/${session}`, { agent, state, ...workingOn(cwd) }, timeoutMs);
 }
 
 // ---- the list ----
@@ -235,6 +238,40 @@ function log(line) {
   } catch {}
 }
 
+async function shareThread(saved, session, cwd, working, agent, mode) {
+  const sharedAt = new Date().toISOString();
+  writeJson(markerOf(session), { workspace: saved.workspace, sharedAt, mode });
+  const where = workingOn(cwd);
+  const what = [where.repository, where.branch].filter(Boolean).map(plain).join(" @ ");
+  // Claude Code's thread mark checks each edit against teammates' (`peer collide`); Codex sends no paths.
+  const edits = !agent || agent === "claude-code";
+  let said = `Peer: this thread is shared in ${saved.workspace}${what ? ` as ${what}` : ""}. Teammates see its repository, branch${edits ? ", state and the paths of the files it edits" : " and state"}, nothing of the conversation. /peer stop ends it.`;
+  // The Hub project its edits are checked in, looked up beside the report; `project` in the marker also says
+  // the thread was shared by a version that sends edited paths.
+  const [, project] = await Promise.all([
+    report(saved, session, working ? "working" : "idle", cwd, agent).catch((error) => {
+      said = `Peer: shared, but the hub did not answer yet (${error.message}). The next turn tries again.`;
+    }),
+    edits ? shareProject(saved, where.repoKey) : undefined,
+  ]);
+  if (edits) {
+    writeJson(markerOf(session), { workspace: saved.workspace, sharedAt, mode, project, ...(where.repoKey ? { repoKey: where.repoKey } : {}) });
+    try {
+      environment();
+    } catch {}
+  }
+  return { said, what };
+}
+
+async function stopSharing(saved, session, cwd, agent) {
+  const marker = markerOf(session);
+  const shared = readJson(marker);
+  fs.rmSync(marker, { force: true });
+  if (!shared?.workspace) return "Peer: this thread was not shared.";
+  await report({ ...saved, workspace: shared.workspace }, session, "stopped", cwd, agent).catch(() => {});
+  return "Peer: this thread is no longer shared.";
+}
+
 async function hook(event) {
   const input = await readStdin();
   const session = input.session_id;
@@ -268,19 +305,10 @@ async function hook(event) {
         return block(`Peer: ${error.message}`);
       }
       if (argument === "stop") {
-        fs.rmSync(marker, { force: true });
-        if (!shared) return block("Peer: this thread was not shared.", retitle(input, false));
-        await report(saved, session, "stopped", input.cwd).catch(() => {});
-        return block("Peer: this thread is no longer shared.", retitle(input, false));
+        return block(await stopSharing(saved, session, input.cwd), retitle(input, false));
       }
       // `/peer <message>` shares the thread and lets the message through: the command hands it to the model.
-      writeJson(marker, { workspace: saved.workspace, sharedAt: new Date().toISOString() });
-      const where = workingOn(input.cwd);
-      const what = [where.repository, where.branch].filter(Boolean).join(" @ ");
-      const sharedText = `Peer: this thread is shared in ${saved.workspace}${what ? ` as ${what}` : ""}. Teammates see its repository, branch and state, nothing of the conversation. /peer stop ends it.`;
-      let hubError;
-      await report(saved, session, argument ? "working" : "idle", input.cwd).catch((error) => (hubError = error));
-      const said = hubError ? `Peer: shared, but the hub did not answer yet (${hubError.message}). The next turn tries again.` : sharedText;
+      const { said, what } = await shareThread(saved, session, input.cwd, Boolean(argument));
       const sessionTitle = retitle(input, true, what);
       // A bare /peer reaches the agent too, which confirms in one line: a block would show the person Claude
       // Code's "hook blocked your prompt" warning for what went right.
@@ -319,11 +347,11 @@ function forgetOldThreads() {
 }
 
 // A turn never waits on or fails because of the hub: a report that does not go through is dropped.
-async function reportQuietly(session, state, cwd) {
+async function reportQuietly(session, state, cwd, agent, timeoutMs) {
   const saved = config();
   const marker = readJson(markerOf(session));
   if (!saved?.session || !marker?.workspace) return;
-  await report({ ...saved, workspace: marker.workspace }, session, state, cwd).catch(() => {});
+  await report({ ...saved, workspace: marker.workspace }, session, state, cwd, agent, timeoutMs).catch(() => {});
 }
 
 // ---- Claude Code setup ----
@@ -336,7 +364,7 @@ const SHARED_NOTE = "[Peer's hook ran]";
 // Added when /peer came alone: there is no message to work on, only the confirmation, and its privacy line
 // is a promise the person relies on, so it stays whole.
 const ALONE_NOTE =
-  "The person typed /peer alone. Reply with only that confirmation, in one or two short lines in the person's language: where the thread is shared, that teammates see its repository, branch and state but never the conversation, and that /peer stop ends it. Do nothing else and use no tools.";
+  "The person typed /peer alone. Reply with only that confirmation, in one or two short lines in the person's language: where the thread is shared, that teammates see its repository, branch, state and the paths of the files it edits but never the conversation, and that /peer stop ends it. Do nothing else and use no tools.";
 
 const COMMAND_FILES = {
   "peer.md": `---
@@ -458,6 +486,10 @@ function option(args, name) {
 }
 
 async function login(args) {
+  const forCodex = args.includes("--codex");
+  const client = args.includes("--client");
+  if (client && !forCodex) throw new Error("--client requires --codex");
+  args = args.filter((arg) => arg !== "--codex" && arg !== "--client");
   const hub = (option(args, "--hub") ?? process.env.PEER_HUB ?? config()?.hub ?? DEFAULT_HUB).replace(/\/+$/, "");
   let workspace = option(args, "--workspace");
   const ask = readline.createInterface({ input: process.stdin, output: process.stderr });
@@ -493,7 +525,8 @@ async function login(args) {
   } finally {
     ask.close();
   }
-  install();
+  if (forCodex) (await import("./codex-thread-mark.mjs")).installCodex(codexPeer, { client });
+  else install();
 }
 
 async function logout() {
@@ -589,8 +622,26 @@ async function doctor() {
     }
   }
 
-  const lines = fs.existsSync(HOOK_LOG) ? fs.readFileSync(HOOK_LOG, "utf8").trim().split("\n").slice(-5) : [];
+  // Edits are checked against teammates' only in a repository that one Hub project lists. Reads the manifest only.
+  const repoKey = repositoryPeer(process.cwd());
+  if (saved?.session && saved?.workspace && repoKey) {
+    const project = await shareProject(saved, repoKey);
+    if (project === "failed") bad(`the hub did not answer which project holds ${repoKey}: run \`peer doctor\` again`);
+    else if (project === "none") bad(`no single Hub project in ${saved.workspace} lists ${repoKey}, so edits are not checked against teammates': add the repository to one project`);
+    else ok(`${repoKey} is in Hub project ${project}: edits in shared threads are checked against teammates'`);
+  }
+
+  const all = fs.existsSync(HOOK_LOG) ? fs.readFileSync(HOOK_LOG, "utf8").trim().split("\n") : [];
+  // Edit checks come one per edit: counted by state, so they do not push the other runs out of view.
+  const isCollide = (l) => l.split(" ")[1] === "collide";
+  const lines = all.filter((l) => !isCollide(l)).slice(-5);
   if (lines.length) console.log(`\nLast hook runs (${HOOK_LOG}):\n${lines.map((l) => `  ${l}`).join("\n")}`);
+  const collides = all.filter(isCollide);
+  if (collides.length) {
+    const states = {};
+    for (const l of collides) states[l.split(" ")[2]] = (states[l.split(" ")[2]] ?? 0) + 1;
+    console.log(`Edit checks: ${Object.entries(states).map(([state, n]) => `${n} ${state}`).join(", ")}`);
+  }
   console.log(
     problems
       ? `\n${problems} thing(s) to fix. Then start a new Claude Code session.`
@@ -823,19 +874,20 @@ function threadUses(session, prompts) {
   return uses.slice(-200);
 }
 
-async function threadMemories(session) {
+async function threadMemories(session, codex = false) {
   const ov = readJson(OV_CONF);
   if (!ov?.url) return { connected: false, reason: `no OpenViking client config at ${OV_CONF}` };
-  const base = `viking://user/${ov.user}/sessions/cc-${session}`;
+  const base = `viking://user/${ov.user}/sessions/${codex ? "cx" : "cc"}-${session}`;
+  const uses = (prompts) => codex ? [] : threadUses(session, prompts);
   let archives;
   try {
     archives = await ovRead(ov, `/fs/ls?uri=${encodeURIComponent(`${base}/history`)}`);
   } catch (error) {
-    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: threadUses(session, transcriptPrompts(session)) };
+    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: uses(codex ? [] : transcriptPrompts(session)) };
     throw error;
   }
   const saves = [];
-  const prompts = transcriptPrompts(session);
+  const prompts = codex ? [] : transcriptPrompts(session);
   for (const archive of archives.filter((entry) => entry.isDir)) {
     let diff;
     try {
@@ -872,7 +924,15 @@ async function threadMemories(session) {
     items.forEach((item, index) => (item.body = String(bodies[index] ?? "").slice(0, 3000)));
     saves.push({ at: diff.extracted_at ?? archive.modTime, items });
   }
-  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: threadUses(session, prompts) };
+  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: uses(prompts) };
+}
+
+function threadMemoryText(memories) {
+  if (!memories.connected) return `Peer: ${memories.reason}`;
+  if (!memories.saves.length) return "This thread has not saved anything to memory yet.";
+  return memories.saves.flatMap((save) => [save.at, ...save.items.map((item) =>
+    `  ${item.change} ${item.type} "${item.name}": ${item.lines.join(" / ")}${item.systemText ? "  [holds Claude Code's own text]" : ""}`,
+  )]).join("\n");
 }
 
 // ---- team memory: teammates' published project knowledge at the start of a thread ----
@@ -912,13 +972,14 @@ async function teamCall(team, method, route, body, timeoutMs = 3000) {
   return { status: response.status, value: await response.json().catch(() => ({})) };
 }
 
+const keysOf = (project) => (project.repositories ?? []).map((r) => repositoryKey(r.url ?? "")).filter(Boolean);
+
 // The project is the Hub's: the workspace project whose repositories include this one, with all of its
 // repositories. A repository in no Hub project (or without a sign-in) is a project of its own, named by its key.
 async function teamProject(repo) {
   const saved = config();
   if (!saved?.session || !saved?.workspace) return { project: repo, repos: [repo] };
   const manifest = await call(saved, "GET", `/workspaces/${saved.workspace}/manifest`, undefined, 10000);
-  const keysOf = (project) => (project.repositories ?? []).map((r) => repositoryKey(r.url ?? "")).filter(Boolean);
   const found = (manifest?.projects ?? []).find((project) => keysOf(project).includes(repo));
   return found ? { project: found.id, repos: keysOf(found) } : { project: repo, repos: [repo] };
 }
@@ -973,8 +1034,7 @@ function changesSince(cwd, paths, date) {
   return log ? log.split("\n").filter(Boolean).length : 0;
 }
 
-async function teamHook(event) {
-  const input = await readStdin();
+async function teamHook(event, input) {
   const team = readJson(TEAM_FILE);
   const session = input.session_id;
   if (!team || !validSession(session)) return;
@@ -1033,7 +1093,7 @@ async function teamHook(event) {
     ...entries,
     "</teammates-project-knowledge>",
   ].join("\n");
-  answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: block } });
+  return { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: block } };
 }
 
 // ---- your own memory: what your personal OpenViking remembered, listed and searched ----
@@ -1191,6 +1251,91 @@ async function memoryText(query) {
 
 // ---- main ----
 
+// ---- the collision signal: after an edit in a shared thread, who else was on that file ----
+// The thread-mark mod runs `peer collide` after each edit; the Hub's `intent` records the claim and answers whose
+// other sessions are on the path (claims count 180 s). Only the path leaves the computer, never its contents.
+
+const ENVIRONMENT = path.join(HOME, "environment");
+const COLLIDE_TIMEOUT_MS = 1500;
+
+// The Hub project of a shared thread: the one project listing this repository, `none` for zero or several, `failed`
+// when the Hub does not answer.
+async function shareProject(saved, repoKey) {
+  if (!repoKey) return "none";
+  try {
+    const manifest = await call(saved, "GET", `/workspaces/${saved.workspace}/manifest`, undefined, HUB_TIMEOUT_MS);
+    const found = (manifest?.projects ?? []).filter((project) => keysOf(project).includes(repoKey));
+    return found.length === 1 ? found[0].id : "none";
+  } catch {
+    return "failed";
+  }
+}
+
+// This computer as the Hub's claims name it: made once, kept across sign-ins, so a claim stays this computer's.
+function environment() {
+  try {
+    return fs.readFileSync(ENVIRONMENT, "utf8").trim();
+  } catch {}
+  fs.mkdirSync(HOME, { recursive: true, mode: 0o700 });
+  try {
+    fs.writeFileSync(ENVIRONMENT, crypto.randomUUID(), { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  return fs.readFileSync(ENVIRONMENT, "utf8").trim();
+}
+
+// A path inside the repository as the Hub accepts it: relative, forward slashes, no `..`, no control characters.
+const repositoryFile = (relative) =>
+  relative && !relative.startsWith("/") && !relative.includes(":") && !/[\u0000-\u001f\u007f]/.test(relative) && !relative.split("/").includes("..") && relative.length <= 300;
+
+async function collide(session, toolUseId, file) {
+  const started = Date.now();
+  let relative = null;
+  const done = (state, reason, holders = []) => {
+    log(`collide ${state} ${reason ?? "-"} ${Date.now() - started} ms`);
+    console.log(JSON.stringify({ path: relative, state, ...(reason ? { reason } : {}), holders }));
+  };
+  const saved = config();
+  const marker = validSession(session) ? readJson(markerOf(session)) : null;
+  if (!saved?.session || !marker?.workspace || !marker.project) return done("skipped");
+  if (marker.project === "none") return done("no-project");
+  if (marker.project === "failed") return done("unchecked", "lookup-failed");
+  let real;
+  try {
+    real = fs.realpathSync(String(file ?? ""));
+  } catch {
+    return done("skipped");
+  }
+  const top = git(path.dirname(real), "rev-parse", "--show-toplevel");
+  if (!top || repositoryPeer(path.dirname(real)) !== marker.repoKey) return done("skipped");
+  relative = path.relative(fs.realpathSync(top), real).split(path.sep).join("/");
+  if (!repositoryFile(relative)) {
+    relative = null;
+    return done("skipped");
+  }
+  let answered;
+  try {
+    const body = { environment: environment(), session: `cc-${session}`, paths: [relative], ...(toolUseId ? { op: String(toolUseId).slice(0, 64) } : {}) };
+    answered = await call({ ...saved, workspace: marker.workspace }, "POST", `/workspaces/${marker.workspace}/coord/${encodeURIComponent(marker.project)}/intent`, body, COLLIDE_TIMEOUT_MS);
+  } catch (error) {
+    return done("unchecked", error?.name === "TimeoutError" ? "hub-timeout" : "hub-error");
+  }
+  const verdict = (answered?.verdicts ?? []).find((v) => v.path === relative);
+  if (!verdict) return done("clear");
+  if (!Array.isArray(verdict.holders)) return done("unchecked", "old-hub");
+  const me = String(saved.email ?? "").toLowerCase();
+  const holders = verdict.holders.map((h) => ({ email: String(h.email ?? ""), at: h.at, own: String(h.email ?? "").toLowerCase() === me }));
+  return done(holders.length ? "collision" : "clear", undefined, holders);
+}
+
+const codexPeer = {
+  home: HOME, cli: SELF, mod: MOD_DIR,
+  validSession, readJson, writeJson, markerOf, config, forgetOldThreads,
+  reportQuietly, signedIn, shareThread, stopSharing, listText, memoryQuery, memoryPage, memoryText,
+  threadMemories, threadMemoryText, teamHook,
+};
+
 const [command, ...args] = process.argv.slice(2);
 try {
   switch (command) {
@@ -1211,16 +1356,10 @@ try {
     case "thread": {
       // `peer thread --json <session id>` is for the thread-mark mod's pane.
       const session = args.find((arg) => !arg.startsWith("--"));
-      if (!validSession(session)) throw new Error("usage: peer thread [--json] <claude code session id>");
-      const memories = await threadMemories(session);
+      if (!validSession(session)) throw new Error("usage: peer thread [--json] [--codex] <session id>");
+      const memories = await threadMemories(session, args.includes("--codex"));
       if (args.includes("--json")) console.log(JSON.stringify(memories));
-      else if (!memories.connected) console.log(`Peer: ${memories.reason}`);
-      else if (!memories.saves.length) console.log("This thread has not saved anything to memory yet.");
-      else
-        for (const save of memories.saves) {
-          console.log(save.at);
-          for (const item of save.items) console.log(`  ${item.change} ${item.type} "${item.name}": ${item.lines.join(" / ")}${item.systemText ? "  [holds Claude Code's own text]" : ""}`);
-        }
+      else console.log(threadMemoryText(memories));
       break;
     }
     case "status":
@@ -1231,14 +1370,31 @@ try {
       break;
     case "install":
       signedIn();
-      install();
+      if (args.includes("--codex")) {
+        (await import("./codex-thread-mark.mjs")).installCodex(codexPeer, { client: args.includes("--client") });
+      } else if (args.includes("--client")) throw new Error("--client requires --codex");
+      else install();
       break;
     case "uninstall":
-      uninstall();
+      if (args.includes("--codex")) (await import("./codex-thread-mark.mjs")).uninstallCodex(codexPeer);
+      else uninstall();
+      break;
+    case "codex-control":
+      answer(await (await import("./codex-thread-mark.mjs")).codexControl(await readStdin(), codexPeer));
       break;
     case "hook":
       // A hook never breaks the person's session: whatever goes wrong, it exits 0.
-      await (args[0]?.startsWith("team-") ? teamHook(args[0]) : hook(args[0])).catch((error) => log(`hook ${args[0]} failed: ${error?.message ?? error}`));
+      await (async () => {
+        if (args[0] === "codex") {
+          const { codexHook } = await import("./codex-thread-mark.mjs");
+          const output = await codexHook(await readStdin(), codexPeer);
+          if (output) answer(output);
+        } else if (args[0]?.startsWith("team-")) {
+          const output = await teamHook(args[0], await readStdin());
+          if (output) answer(output);
+        }
+        else await hook(args[0]);
+      })().catch((error) => log(`hook ${args[0]} failed: ${error?.message ?? error}`));
       break;
     case "all": {
       // `peer all --json …` is for the thread-mark mod's pane; without a personal OpenViking it says so.
@@ -1251,6 +1407,12 @@ try {
       }
       break;
     }
+    case "collide": {
+      // `peer collide --json <session> <tool_use_id> <absolute path>` is for the thread-mark mod, after an edit.
+      const [session, toolUseId, file] = args.filter((arg) => arg !== "--json");
+      await collide(session, toolUseId, file);
+      break;
+    }
     case "team":
       if (args[0] === "connect") await teamConnect(args.slice(1));
       else if (args[0] === "status") teamStatus();

package/mod/codex/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "webinson-peer-codex",
+  "interface": { "displayName": "Peer" },
+  "plugins": [
+    {
+      "name": "peer-thread-mark",
+      "source": { "source": "local", "path": "./peer-thread-mark" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

package/mod/codex/client/.gitattributes

@@ -0,0 +1 @@
+*.patch whitespace=-blank-at-eol