@webinson/peer 0.4.0 → 0.4.2

package/README.md

@@ -16,7 +16,11 @@ In a Claude Code thread:
 
 - `/peer` shares this thread in your workspace.
 - `/peer <message>` shares it and passes the message on to the agent as your prompt.
-- `/peer stop` ends sharing. Ending the session ends it too.
+- `/peer stop` ends sharing. Quitting or restarting Claude Code only pauses it: the thread shows as stopped and
+  is shared again when the session is resumed. `/clear` and signing out of Claude Code end it.
+- In a shared thread a band above the prompt says `Peer <workspace>` with `/peer stop` to click; after a stop it
+  turns gray with `/peer start`. It is a Claude Code plugin in this package (`mod/`) that `peer install` adds;
+  the desktop app draws it only while you type or a turn runs.
 - A shared thread's title starts with `● Peer · `, so it stands out in Claude Code's session list; the mark comes
   back if Claude Code renames the thread, and `/peer stop` takes it off.
 - `/peer-list` lists the shared threads by repository, then by person, with each thread's branch and
@@ -42,7 +46,8 @@ branch name, say) and is data, not instructions. An agent that reads it must not
 - **active**: the thread reported in the last 15 minutes, working or waiting for its person.
 - **silent**: nothing for 15 minutes. The session may have crashed or the laptop closed. An agent
   reports only around its turns, so an open thread nobody uses goes silent too.
-- **stopped**: the session ended, `/peer stop` was typed, or the thread was silent for 2 hours.
+- **stopped**: the session ended or closed (until it is resumed), `/peer stop` was typed, or the thread was silent
+  for 2 hours.
   Stopped threads stay in the list for 8 hours.
 
 ## How it works

package/bin/peer.mjs

@@ -21,6 +21,12 @@ const HOOK_TIMEOUT_S = 10;
 const HUB_TIMEOUT_MS = 3000;
 // Why a hook did what it did, without any prompt text: `peer doctor` shows the end of it.
 const HOOK_LOG = path.join(HOME, "hook.log");
+// The thread mark: a Claude Code plugin shipped in this package (mod/), a marketplace of one plugin read
+// from that folder, so updating the package updates it.
+const CLAUDE_BIN = process.env.PEER_CLAUDE || "claude";
+const MOD_DIR = path.join(path.dirname(SELF), "..", "mod");
+const MOD = "peer-thread-mark";
+const MARKETPLACE = "webinson-peer";
 
 const HELP = `peer: share chosen agent threads with your team
 
@@ -33,7 +39,7 @@ const HELP = `peer: share chosen agent threads with your team
                     connect to the team's memory server (your key on stdin); new threads in the
                     project's repositories then start with teammates' published findings
   peer team status  the team server, project and the last recalls
-  peer install      set up Claude Code again (hooks and the two commands)
+  peer install      set up Claude Code again (hooks, the two commands and the thread mark)
   peer uninstall    remove them from Claude Code
   peer logout       forget the sign-in on this computer
 
@@ -278,14 +284,29 @@ async function hook(event) {
     if (sessionTitle) answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", sessionTitle } });
     return;
   }
+  if (event === "start") forgetOldThreads();
   if (!shared) return;
   if (event === "stop") await reportQuietly(session, "idle", input.cwd);
+  // A thread comes back with its session: a restart, a quit or /exit leaves it shared, and resuming it
+  // reports it again. /clear and signing out of Claude Code end it for good.
+  if (event === "start" && input.source === "resume") await reportQuietly(session, "idle", input.cwd);
   if (event === "end") {
     await reportQuietly(session, "stopped", input.cwd);
-    fs.rmSync(marker, { force: true });
+    if (input.reason === "clear" || input.reason === "logout") fs.rmSync(marker, { force: true });
   }
 }
 
+// Threads not resumed for a month are forgotten, so a session resumed much later starts unshared.
+const FORGET_AFTER_MS = 30 * 24 * 60 * 60 * 1000;
+function forgetOldThreads() {
+  try {
+    for (const name of fs.readdirSync(SESSIONS)) {
+      const file = path.join(SESSIONS, name);
+      if (Date.now() - fs.statSync(file).mtimeMs > FORGET_AFTER_MS) fs.rmSync(file, { force: true });
+    }
+  } catch {}
+}
+
 // 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) {
   const saved = config();
@@ -346,7 +367,7 @@ function install() {
   }
   const settings = withoutOurHooks(readJson(SETTINGS) ?? {});
   settings.hooks ??= {};
-  const events = [["UserPromptSubmit", "prompt"], ["Stop", "stop"], ["SessionEnd", "end"]];
+  const events = [["UserPromptSubmit", "prompt"], ["Stop", "stop"], ["SessionEnd", "end"], ["SessionStart", "start"]];
   // Team memory hooks only once this computer is connected to a team server (peer team connect).
   if (fs.existsSync(TEAM_FILE)) events.push(["UserPromptSubmit", "team-prompt"], ["SessionStart", "team-start"]);
   for (const [event, name] of events) {
@@ -357,13 +378,49 @@ function install() {
   fs.mkdirSync(COMMANDS, { recursive: true });
   for (const [name, text] of Object.entries(COMMAND_FILES)) fs.writeFileSync(path.join(COMMANDS, name), text);
   console.log(`Claude Code: hooks in ${SETTINGS}, /peer and /peer-list in ${COMMANDS}. Sessions started from now on have them.`);
+  installMark();
+}
+
+function claudeCli(args) {
+  return execFileSync(CLAUDE_BIN, args, { encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+// The band above the prompt in shared threads. Optional: /peer works without it, so a failure only says so.
+function installMark() {
+  if (!fs.existsSync(path.join(MOD_DIR, ".claude-plugin", "marketplace.json"))) return;
+  const install = () => claudeCli(["plugin", "install", MOD, "--marketplace", MOD_DIR, "--scope", "user"]);
+  try {
+    try {
+      install();
+    } catch {
+      // A marketplace of that name added from an older place (another install of this package) is replaced.
+      try {
+        claudeCli(["plugin", "marketplace", "remove", MARKETPLACE]);
+      } catch {}
+      install();
+    }
+    console.log(`Claude Code: the thread mark (${MOD}), a band above the prompt in shared threads, from ${MOD_DIR}.`);
+  } catch (error) {
+    const reason = String(error.stderr || error.message).trim().split("\n").pop();
+    console.log(`Claude Code: the thread mark was not installed (${reason}); /peer works without it.`);
+    console.log(`  To add it later: claude plugin install ${MOD} --marketplace "${MOD_DIR}"`);
+  }
+}
+
+function uninstallMark() {
+  for (const args of [["plugin", "uninstall", `${MOD}@${MARKETPLACE}`], ["plugin", "marketplace", "remove", MARKETPLACE]]) {
+    try {
+      claudeCli(args);
+    } catch {}
+  }
 }
 
 function uninstall() {
   const settings = readJson(SETTINGS);
   if (settings) writeJson(SETTINGS, withoutOurHooks(settings), 0o644);
   for (const name of Object.keys(COMMAND_FILES)) fs.rmSync(path.join(COMMANDS, name), { force: true });
-  console.log("Claude Code: Peer's hooks and commands removed.");
+  uninstallMark();
+  console.log("Claude Code: Peer's hooks, commands and thread mark removed.");
 }
 
 // ---- signing in ----
@@ -455,8 +512,11 @@ async function doctor() {
   }
 
   try {
-    const version = execFileSync("claude", ["--version"], { encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const version = execFileSync(CLAUDE_BIN, ["--version"], { encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "ignore"] }).trim();
     ok(`Claude Code ${version} (Peer is tested with 2.1.316)`);
+    const mark = JSON.parse(claudeCli(["plugin", "list", "--json"])).find((p) => p.id === `${MOD}@${MARKETPLACE}`);
+    if (mark?.enabled) ok(`the thread mark (${MOD}) is installed`);
+    else console.log(`  --    the thread mark (${MOD}, a band above the prompt) is ${mark ? "turned off" : "not installed"}: \`peer install\` adds it`);
   } catch {
     console.log("  ?     `claude` is not on this terminal's PATH, so its version is unknown");
   }
@@ -466,8 +526,10 @@ async function doctor() {
   for (const [event, groups] of Object.entries(settings?.hooks ?? {})) {
     for (const group of groups) for (const h of group.hooks ?? []) if (String(h.command ?? "").includes(HOOK_TAG)) ours.push({ event, ...h });
   }
-  const events = ["UserPromptSubmit", "Stop", "SessionEnd"];
-  const missing = events.filter((e) => !ours.some((h) => h.event === e));
+  const events = { prompt: "UserPromptSubmit", stop: "Stop", end: "SessionEnd", start: "SessionStart" };
+  const missing = Object.entries(events)
+    .filter(([name, event]) => !ours.some((h) => h.event === event && String(h.command).includes(`hook ${name} `)))
+    .map(([, event]) => event);
   if (!settings) bad(`no ${SETTINGS}: run \`peer install\``);
   else if (missing.length) bad(`${SETTINGS} lacks Peer's ${missing.join(", ")} hook: run \`peer install\``);
   else ok(`hooks in ${SETTINGS}`);

package/mod/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "webinson-peer",
+  "owner": { "name": "Webinson" },
+  "plugins": [
+    {
+      "name": "peer-thread-mark",
+      "source": "./peer-thread-mark",
+      "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt"
+    }
+  ]
+}

package/mod/peer-thread-mark/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "peer-thread-mark",
+  "version": "0.4.2",
+  "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt, with /peer stop and /peer start",
+  "license": "MIT",
+  "types": "./types/index.d.ts"
+}

package/mod/peer-thread-mark/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/mod/peer-thread-mark/hooks/register.tsx

@@ -0,0 +1,115 @@
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { Shared } from '../types'
+
+// The peer CLI's hook writes ~/.peer/sessions/<session id> on `/peer` and removes it on `/peer stop`;
+// that file alone says whether this thread is shared, and in which workspace.
+const shared = atom({ plugin: 'peer-thread-mark', key: 'shared' } as const, null)
+
+async function peerHome($: EngineInterface) {
+  return (await $.env.get('PEER_HOME')) || `${await $.env.get('HOME')}/.peer`
+}
+
+async function refresh($: EngineInterface) {
+  const home = await peerHome($)
+  const before = await read($, shared)
+  let now: Shared
+  try {
+    const marker = JSON.parse(await $.fs.read(`${home}/sessions/${await $.session.id()}`))
+    now = { workspace: String(marker.workspace ?? 'Peer'), isShared: true }
+  } catch {
+    // Not shared, or not readable: keep the band and the workspace it last showed, so stop and start differ
+    // only in state. A thread never shared on a computer without Peer stays without a band.
+    now = before ? { workspace: before.workspace, isShared: false } : null
+  }
+  if (before?.workspace !== now?.workspace || before?.isShared !== now?.isShared) {
+    await update($, shared, () => now)
+  }
+}
+
+// The prompt hook exactly as `peer install` put it in Claude Code's settings, split into its arguments.
+async function promptHook($: EngineInterface): Promise<string[] | undefined> {
+  const claude = (await $.env.get('CLAUDE_CONFIG_DIR')) || `${await $.env.get('HOME')}/.claude`
+  const settings = JSON.parse(await $.fs.read(`${claude}/settings.json`))
+  for (const group of settings.hooks?.UserPromptSubmit ?? []) {
+    for (const hook of group.hooks ?? []) {
+      const command = String(hook.command ?? '')
+      if (!command.includes('# peer-hook') || !/\bhook prompt\b/.test(command)) continue
+      return [...command.split('#')[0].matchAll(/"([^"]*)"|(\S+)/g)].map(m => m[1] ?? m[2])
+    }
+  }
+  return undefined
+}
+
+// A press does what typing the command does: the CLI's own hook shares or stops the thread and says so.
+// (A plugin may not submit a prompt that starts with `/`, so the hook is run directly.)
+async function send($: EngineInterface, prompt: string) {
+  try {
+    const argv = await promptHook($)
+    if (!argv) {
+      $.ui.toast('Peer: no prompt hook in Claude Code settings; run `peer install`')
+      return
+    }
+    const input = { session_id: await $.session.id(), cwd: await $.env.get('PWD'), prompt }
+    const { stdout } = await $.process.run(argv, { stdin: JSON.stringify(input), timeoutMs: 10_000 })
+    const reason = JSON.parse(stdout.trim().split('\n').pop() || '{}').reason
+    if (reason) $.ui.toast(String(reason))
+  } catch (error) {
+    $.ui.toast(`Peer: ${error instanceof Error ? error.message : String(error)}`)
+  }
+  await refresh($)
+}
+
+export const register: Register = on => {
+  // A session that loaded the mod after it started (/reload-plugins, an install) has no state yet: the first
+  // drawing looks once, so the band shows without waiting for the next prompt.
+  let looked = false
+  on('session.start', async ($, e, next) => {
+    const result = await next(e)
+    // Nothing under the prompt: clear the line an earlier version pinned there.
+    $.ui.status(undefined)
+    await refresh($).catch(() => {})
+    return result
+  })
+
+  // The CLI's prompt hook writes or removes the marker while a typed command goes in, so look after it.
+  on('prompt.submit', async ($, e, next) => {
+    const result = await next(e)
+    await refresh($).catch(() => {})
+    return result
+  })
+
+  on('turn.complete', async ($, e, next) => {
+    await refresh($).catch(() => {})
+    return next(e)
+  })
+
+  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    if (!looked) {
+      looked = true
+      await refresh($).catch(() => {})
+    }
+    const now = await read($, shared)
+    if (e.props.hasSurvey || now === null) return next(e)
+
+    const { Box, Button, Text } = $.ui.resolve(e)
+    // One band in both states: the label's own surface says the state (accent when shared, gray when not),
+    // and the one control changes in place, stop to start and back.
+    return (
+      <Box>
+        <Text backgroundColor={now.isShared ? 'suggestion' : 'inactive'} color="inverseText" bold>
+          {' Peer '}
+        </Text>
+        <Text bold={now.isShared} dimColor={!now.isShared}>{now.workspace ? ` ${now.workspace}  ` : '  '}</Text>
+        <Button
+          key="toggle"
+          label={now.isShared ? '/peer stop' : '/peer start'}
+          plain
+          dimColor
+          onPress={() => send($, now.isShared ? '/peer stop' : '/peer')}
+        />
+      </Box>
+    )
+  })
+}

package/mod/peer-thread-mark/types/index.d.ts

@@ -0,0 +1,9 @@
+// Whether this thread is shared, in which Peer workspace; null when Peer is not signed in on this computer
+// (the band then draws nothing).
+export type Shared = { workspace: string; isShared: boolean } | null
+
+declare module 'claude-code' {
+  interface PluginState {
+    'peer-thread-mark': { shared: Shared }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Share chosen Claude Code threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "files": [
     "bin",
+    "mod",
     "README.md"
   ],
   "engines": {