claude-friends 0.4.0 → 0.4.2

package/cli.js

@@ -1,12 +1,12 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings
 
 import { writeFileSync, readFileSync, existsSync, mkdirSync, copyFileSync, readdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { createInterface } from "readline";
 import { getConfig, createConnection } from "./client.js";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import prompts from "prompts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_PATH = join(homedir(), ".claude-friends.json");
@@ -14,6 +14,10 @@ const CONFIG_PATH = join(homedir(), ".claude-friends.json");
 const command = process.argv[2];
 const args = process.argv.slice(3).join(" ").trim();
 
+main().catch((err) => { console.error(err.message); process.exit(1); });
+
+async function main() {
+
 // Helper: connect, send a message, wait for response, print, exit
 function run(messageType, payload, responseType, formatter) {
   const config = getConfig();
@@ -53,25 +57,126 @@ if (command === "setup") {
     process.exit(0);
   }
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (q) => new Promise((res) => rl.question(q, res));
+  // Helper to check username availability
+  async function checkUsername(name) {
+    return new Promise((resolve) => {
+      const ws = createConnection(name);
+      const timer = setTimeout(() => { ws.close(); resolve(true); }, 5000);
+      ws.addEventListener("open", () => {
+        ws.send(JSON.stringify({ type: "check-username", username: name }));
+      });
+      ws.addEventListener("message", (event) => {
+        const msg = JSON.parse(event.data);
+        if (msg.type === "username-available") {
+          clearTimeout(timer);
+          ws.close();
+          resolve(msg.available);
+        }
+      });
+      ws.addEventListener("error", () => { clearTimeout(timer); resolve(true); });
+    });
+  }
+
+  // Helper to add a friend via server
+  async function addFriend(username, friend) {
+    return new Promise((resolve) => {
+      const ws = createConnection(username);
+      const timer = setTimeout(() => { ws.close(); resolve({ type: "error", message: "Timeout connecting to server." }); }, 5000);
+      ws.addEventListener("open", () => {
+        ws.send(JSON.stringify({ type: "add-friend", friend }));
+      });
+      ws.addEventListener("message", (event) => {
+        const msg = JSON.parse(event.data);
+        if (msg.type === "friend-added" || msg.type === "error") {
+          clearTimeout(timer);
+          ws.close();
+          resolve(msg);
+        }
+      });
+    });
+  }
 
+  // --- Step 1: Welcome ---
   console.log(`
 ╔══════════════════════════════════════╗
-║        claude-friends setup          ║
+║      Welcome to claude-friends!      ║
 ╚══════════════════════════════════════╝
+
+See when your friends are coding in Claude Code,
+share status updates, and nudge each other.
+
+Friendship is mutual — you can only see someone
+online if you've BOTH added each other.
 `);
 
-  const username = await ask("Choose a username: ");
+  // --- Step 2: Pick a username ---
+  let username;
+  while (true) {
+    const { value } = await prompts({
+      type: "text",
+      name: "value",
+      message: "Pick a username (this is how friends will find you)",
+    });
+
+    if (!value) { console.log("Setup cancelled."); process.exit(0); }
 
-  if (!username.trim()) {
-    console.log("Username can't be empty.");
-    process.exit(1);
+    const available = await checkUsername(value.trim());
+    if (!available) {
+      console.log(`  "${value.trim()}" is already taken. Try another.\n`);
+      continue;
+    }
+
+    username = value.trim();
+    break;
   }
 
-  writeFileSync(CONFIG_PATH, JSON.stringify({ username: username.trim() }, null, 2));
+  console.log(`\n  You're "${username}"!\n`);
+
+  // Save config
+  writeFileSync(CONFIG_PATH, JSON.stringify({ username }, null, 2));
+
+  // --- Step 3: Add friends ---
+  const { wantFriends } = await prompts({
+    type: "confirm",
+    name: "wantFriends",
+    message: "Want to add some friends now?",
+    initial: true,
+  });
+
+  if (wantFriends) {
+    console.log("\n  Tell your friends to add you back with: claude-friends add " + username + "\n");
+
+    let addMore = true;
+    while (addMore) {
+      const { friend } = await prompts({
+        type: "text",
+        name: "friend",
+        message: "Friend's username",
+      });
+
+      if (!friend || !friend.trim()) break;
+
+      const result = await addFriend(username, friend.trim());
+      if (result.type === "error") {
+        console.log(`  ${result.message}`);
+      } else if (result.mutual) {
+        console.log(`  You and ${friend.trim()} are now friends!`);
+      } else {
+        console.log(`  Added! They need to add you back ("${username}") to see each other online.`);
+      }
 
-  // Install slash commands to ~/.claude/commands/
+      const { more } = await prompts({
+        type: "confirm",
+        name: "more",
+        message: "Add another friend?",
+        initial: false,
+      });
+      addMore = more;
+    }
+  }
+
+  // --- Step 4: Install hooks & commands silently ---
+  // Install slash commands
   const commandsDir = join(homedir(), ".claude", "commands");
   mkdirSync(commandsDir, { recursive: true });
 
@@ -81,95 +186,186 @@ if (command === "setup") {
     for (const file of files) {
       copyFileSync(join(srcCommands, file), join(commandsDir, file));
     }
-    console.log(`\nInstalled slash commands: ${files.map((f) => "/" + f.replace(".md", "")).join(", ")}`);
   }
 
-  // Install token-sharing hook to ~/.claude/settings.json
+  // Install hooks to settings.json
   const settingsPath = join(homedir(), ".claude", "settings.json");
-  const hookCommand = `node ${join(__dirname, "hooks", "update-tokens.js")}`;
   try {
     let settings = {};
     if (existsSync(settingsPath)) {
       settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
     }
     if (!settings.hooks) settings.hooks = {};
-    if (!settings.hooks.Stop) settings.hooks.Stop = [];
 
-    const alreadyInstalled = settings.hooks.Stop.some((h) =>
+    // Token-sharing hook (Stop)
+    if (!settings.hooks.Stop) settings.hooks.Stop = [];
+    const hookCommand = `node ${join(__dirname, "hooks", "update-tokens.js")}`;
+    const tokenHookInstalled = settings.hooks.Stop.some((h) =>
       h.hooks?.some((hk) => hk.command?.includes("update-tokens"))
     );
-
-    if (!alreadyInstalled) {
+    if (!tokenHookInstalled) {
       settings.hooks.Stop.push({
-        hooks: [{
-          type: "command",
-          command: hookCommand,
-          async: true,
-        }],
+        hooks: [{ type: "command", command: hookCommand, async: true }],
       });
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-      console.log("Installed auto token-sharing hook.");
-    }
-  } catch (err) {
-    console.log("Could not install token hook (non-critical):", err.message);
-  }
-
-  // Install statusline + daemon hooks (read settings once)
-  try {
-    const settingsPath2 = join(homedir(), ".claude", "settings.json");
-    let settings = {};
-    if (existsSync(settingsPath2)) {
-      settings = JSON.parse(readFileSync(settingsPath2, "utf-8"));
     }
 
+    // Statusline
     if (!settings.statusLine) {
       settings.statusLine = {
         type: "command",
         command: `node ${join(__dirname, "statusline.js")}`,
       };
-      console.log("Installed status line.");
     }
 
-    // SessionStart hook: spawn daemon to keep user online
-    if (!settings.hooks) settings.hooks = {};
-    const daemonCmd = `node ${join(__dirname, "daemon.js")}`;
-
+    // Presence daemon (SessionStart)
     if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+    const daemonCmd = `node ${join(__dirname, "daemon.js")}`;
     const daemonInstalled = settings.hooks.SessionStart.some((h) =>
       h.hooks?.some((hk) => hk.command?.includes("daemon.js"))
     );
     if (!daemonInstalled) {
       settings.hooks.SessionStart.push({
-        hooks: [{
-          type: "command",
-          command: daemonCmd,
-          async: true,
-        }],
+        hooks: [{ type: "command", command: daemonCmd, async: true }],
       });
-      console.log("Installed presence daemon (keeps you online).");
     }
 
-    writeFileSync(settingsPath2, JSON.stringify(settings, null, 2));
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
   } catch {}
 
+  // --- Step 5: Done ---
   console.log(`
-Done! You're "${username.trim()}".
+You're all set! In Claude Code, try:
 
-In Claude Code:
-  /friend alice       Add a friend
   /friends            See who's online
-  /nudge bob hey!     Nudge someone
-  /status debugging   Set your status
-  /unfriend alice     Remove a friend
+  /friend <name>      Add a friend
+  /nudge <name>       Nudge someone
+  /status <message>   Set your status
 
-Token usage is shared automatically.
+Your friends can add you with: claude-friends add ${username}
 `);
 
-  rl.close();
+} else if (command === "check-username") {
+  // Check if a username is available (for Claude Code slash commands)
+  if (!args) { console.log("Usage: claude-friends check-username <username>"); process.exit(1); }
+  const name = args.trim();
+  const ws = createConnection(name);
+  const timer = setTimeout(() => { ws.close(); console.log("available"); process.exit(0); }, 5000);
+  ws.addEventListener("open", () => {
+    ws.send(JSON.stringify({ type: "check-username", username: name }));
+  });
+  ws.addEventListener("message", (event) => {
+    const msg = JSON.parse(event.data);
+    if (msg.type === "username-available") {
+      clearTimeout(timer);
+      ws.close();
+      console.log(msg.available ? "available" : "taken");
+      process.exit(msg.available ? 0 : 1);
+    }
+  });
+
+} else if (command === "setup-noninteractive") {
+  // Non-interactive setup for use by Claude Code slash commands
+  if (!args) { console.log("Usage: claude-friends setup-noninteractive <username>"); process.exit(1); }
+
+  const username = args.trim();
+
+  // Check if already set up
+  const existing = getConfig();
+  if (existing) {
+    console.log(`Already set up as "${existing.username}".`);
+    process.exit(0);
+  }
+
+  // Check username availability
+  const available = await new Promise((resolve) => {
+    const ws = createConnection(username);
+    const timer = setTimeout(() => { ws.close(); resolve(true); }, 5000);
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify({ type: "check-username", username }));
+    });
+    ws.addEventListener("message", (event) => {
+      const msg = JSON.parse(event.data);
+      if (msg.type === "username-available") {
+        clearTimeout(timer);
+        ws.close();
+        resolve(msg.available);
+      }
+    });
+    ws.addEventListener("error", () => { clearTimeout(timer); resolve(true); });
+  });
+
+  if (!available) {
+    console.log(`Username "${username}" is already taken.`);
+    process.exit(1);
+  }
+
+  // Register on server
+  await new Promise((resolve) => {
+    const ws = createConnection(username);
+    const timer = setTimeout(() => { ws.close(); resolve(); }, 5000);
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify({ type: "register" }));
+    });
+    ws.addEventListener("message", (event) => {
+      const msg = JSON.parse(event.data);
+      if (msg.type === "register-result") {
+        clearTimeout(timer);
+        ws.close();
+        resolve();
+      }
+    });
+  });
+
+  // Save config
+  writeFileSync(CONFIG_PATH, JSON.stringify({ username }, null, 2));
+
+  // Install slash commands
+  const commandsDir = join(homedir(), ".claude", "commands");
+  mkdirSync(commandsDir, { recursive: true });
+  const srcCommands = join(__dirname, "commands");
+  if (existsSync(srcCommands)) {
+    for (const file of readdirSync(srcCommands).filter((f) => f.endsWith(".md"))) {
+      copyFileSync(join(srcCommands, file), join(commandsDir, file));
+    }
+  }
+
+  // Install hooks
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    if (!settings.hooks) settings.hooks = {};
+
+    if (!settings.hooks.Stop) settings.hooks.Stop = [];
+    const hookCommand = `node ${join(__dirname, "hooks", "update-tokens.js")}`;
+    if (!settings.hooks.Stop.some((h) => h.hooks?.some((hk) => hk.command?.includes("update-tokens")))) {
+      settings.hooks.Stop.push({ hooks: [{ type: "command", command: hookCommand, async: true }] });
+    }
+
+    if (!settings.statusLine) {
+      settings.statusLine = { type: "command", command: `node ${join(__dirname, "statusline.js")}` };
+    }
+
+    if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+    const daemonCmd = `node ${join(__dirname, "daemon.js")}`;
+    if (!settings.hooks.SessionStart.some((h) => h.hooks?.some((hk) => hk.command?.includes("daemon.js")))) {
+      settings.hooks.SessionStart.push({ hooks: [{ type: "command", command: daemonCmd, async: true }] });
+    }
+
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  } catch {}
+
+  console.log(`Set up as "${username}".`);
 
 } else if (command === "add") {
   if (!args) { console.log("Usage: claude-friends add <username>"); process.exit(1); }
-  run("add-friend", { friend: args }, "friend-added", () => `Added ${args} as a friend!`);
+  run("add-friend", { friend: args }, "friend-added", (msg) =>
+    msg.mutual
+      ? `You and ${args} are now friends!`
+      : `Added ${args}! They need to add you back to see each other online.`
+  );
 
 } else if (command === "remove") {
   if (!args) { console.log("Usage: claude-friends remove <username>"); process.exit(1); }
@@ -180,21 +376,44 @@ Token usage is shared automatically.
     const friends = msg.friends || [];
     if (friends.length === 0) return "No friends yet. Run: claude-friends add <username>";
 
-    const sorted = [...friends].sort((a, b) => (b.online ? 1 : 0) - (a.online ? 1 : 0));
+    const mutual = friends.filter((f) => f.mutual);
+    const pending = friends.filter((f) => !f.mutual);
+    const sorted = [...mutual].sort((a, b) => (b.online ? 1 : 0) - (a.online ? 1 : 0));
     const onlineCount = sorted.filter((f) => f.online).length;
 
     const lines = sorted.map((f) => {
       const dot = f.online ? "🟢" : "⚫";
       const status = f.status && f.status !== "offline" && f.status !== "unknown" ? ` — ${f.status}` : "";
-      const tokens = f.tokensUsed
-        ? f.tokensUsed >= 1_000_000
-          ? ` [${(f.tokensUsed / 1_000_000).toFixed(1)}M tokens]`
-          : ` [${(f.tokensUsed / 1000).toFixed(1)}K tokens]`
-        : "";
-      return `${dot} ${f.name}${status}${tokens}`;
+      return `${dot} ${f.name}${status}`;
     });
 
-    return `Friends (${onlineCount}/${friends.length} online):\n${lines.join("\n")}`;
+    let output = `Friends (${onlineCount}/${mutual.length} online):\n${lines.join("\n")}`;
+
+    if (pending.length > 0) {
+      output += `\n\nPending (waiting for them to add you back):\n${pending.map((f) => `⏳ ${f.name}`).join("\n")}`;
+    }
+
+    // Token usage graph
+    const withTokens = sorted.filter((f) => f.tokensUsed > 0);
+    if (withTokens.length > 0) {
+      const maxTokens = Math.max(...withTokens.map((f) => f.tokensUsed));
+      const maxNameLen = Math.max(...withTokens.map((f) => f.name.length));
+      const barWidth = 20;
+
+      output += "\n\nToken usage today:";
+      for (const f of withTokens) {
+        const name = f.name.padEnd(maxNameLen);
+        const filled = Math.max(1, Math.round((f.tokensUsed / maxTokens) * barWidth));
+        const bar = "█".repeat(filled);
+        let tokenStr;
+        if (f.tokensUsed >= 1_000_000) tokenStr = `${(f.tokensUsed / 1_000_000).toFixed(1)}M`;
+        else if (f.tokensUsed >= 1_000) tokenStr = `${(f.tokensUsed / 1_000).toFixed(1)}K`;
+        else tokenStr = `${f.tokensUsed}`;
+        output += `\n  ${name} ${bar} ${tokenStr}`;
+      }
+    }
+
+    return output;
   });
 
 } else if (command === "status") {
@@ -248,3 +467,5 @@ In Claude Code:
   /nudge bob hey!
 `);
 }
+
+} // end main

package/commands/friend.md

@@ -1 +1,7 @@
-Run `claude-friends add $ARGUMENTS` and show the output. If no username is provided, ask for one first.
+Add a friend by username.
+
+First, check if claude-friends is set up by running `claude-friends whoami`. If it returns "Not set up", run the onboarding flow described in the /friends command BEFORE doing anything else.
+
+If set up: run `claude-friends add $ARGUMENTS` and show the output. If no username is provided, ask for one using AskUserQuestion.
+
+Remind the user that friendship is mutual — their friend needs to add them back to see each other online.

package/commands/friends.md

@@ -1 +1,32 @@
-Run `claude-friends online` and show the output.
+See who's online.
+
+First, check if claude-friends is set up by running `claude-friends whoami`. If it returns "Not set up", run the onboarding flow below BEFORE doing anything else. If it IS set up, skip to "Show friends".
+
+## Onboarding (only if not set up)
+
+Walk the user through setup using AskUserQuestion:
+
+1. Explain: "claude-friends lets you see when your friends are coding in Claude Code. Friendship is mutual — you can only see each other online if you've BOTH added each other."
+
+2. Before asking the user to pick a username, generate 2-3 suggestions based on their system username (e.g. first name, initials, short nickname). Run `claude-friends check-username <name>` for EACH suggestion IN PARALLEL to check availability. Only include suggestions that return "available" as options in the AskUserQuestion. This way every option shown is guaranteed available. If the user types their own via "Other", run the check after — if taken, tell them immediately and re-ask.
+
+3. Run `claude-friends setup-noninteractive <username>` to register the chosen username. 
+
+4. Ask "Want to add some friends?" (Yes / No). If yes, go DIRECTLY to asking for a username — do NOT show an intermediate screen. Use AskUserQuestion with two options like "Skip" and "Done adding" so the user types their friend's username via "Other". After each add:
+   - Run `claude-friends add <friend>` and show the result
+   - Ask "Add another?" (Yes / No) — repeat until they say no
+   - Remind them: "Tell your friends to add you back with: claude-friends add <their-username>"
+
+5. Say "You're all set!" and continue to Show friends below.
+
+## Show friends
+
+Run `claude-friends online` and show the output.
+
+If any friends have token usage data, also show a bar chart comparing their usage. Use block characters (█) to draw horizontal bars, scaled relative to the highest usage. Example:
+
+```
+tej   ██████████████████ 245.3K
+alice ████████ 102.1K
+bob   ███ 38.5K
+```

package/daemon.js

@@ -2,23 +2,56 @@
 
 // Background daemon that keeps you online in claude-friends.
 // Runs as a persistent WebSocket connection.
-// Started automatically by the SessionStart hook.
+// Also periodically writes friend status to a cache file
+// so the statusline can read it synchronously.
 
+import { writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import { getConfig, createConnection } from "./client.js";
 
 const config = getConfig();
 if (!config) process.exit(0);
 
+const CACHE_PATH = join(homedir(), ".claude-friends-online.json");
 const ws = createConnection(config.username);
 
+function updateCache(friends) {
+  const onlineNames = friends.filter((f) => f.online).map((f) => f.name);
+  try {
+    writeFileSync(CACHE_PATH, JSON.stringify({
+      onlineCount: onlineNames.length,
+      onlineNames,
+      lastUpdate: Date.now(),
+    }));
+  } catch {}
+}
+
 ws.addEventListener("open", () => {
-  // Silently connected — we're online
+  // Request friends list immediately and periodically
+  ws.send(JSON.stringify({ type: "get-friends" }));
 });
 
-ws.addEventListener("close", () => {
-  // Reconnect after a delay (partysocket handles this automatically)
+ws.addEventListener("message", (event) => {
+  try {
+    const msg = JSON.parse(event.data);
+    if (msg.type === "friends-list") {
+      updateCache(msg.friends || []);
+    }
+    // Also update on presence changes
+    if (msg.type === "presence" || msg.type === "state") {
+      ws.send(JSON.stringify({ type: "get-friends" }));
+    }
+  } catch {}
 });
 
+// Poll friends every 15 seconds
+setInterval(() => {
+  if (ws.readyState === 1) {
+    ws.send(JSON.stringify({ type: "get-friends" }));
+  }
+}, 15000);
+
 // Keep process alive
 setInterval(() => {}, 60000);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-friends",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "See who's online in Claude Code. Add friends, share status, nudge each other.",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   "main": "mcp-server.js",
   "scripts": {
     "dev": "npx partykit dev",
-    "deploy": "npx partykit deploy"
+    "deploy": "npx partykit deploy",
+    "postinstall": "claude-friends setup"
   },
   "files": [
     "cli.js",
@@ -22,7 +23,9 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "ccstatusline": "^2.2.7",
     "partysocket": "^1.0.3",
+    "prompts": "^2.4.2",
     "zod": "^3.24.4"
   },
   "devDependencies": {

package/statusline.js

@@ -11,7 +11,7 @@ if (!config) {
 try {
   const friends = await queryFriends(config.username, 3000);
   const online = friends.filter((f) => f.online);
-  const dot = online.length > 0 ? "●" : "○";
+  const dot = online.length > 0 ? "🟢" : "⚫";
   const names = online.slice(0, 3).map((f) => f.name).join(", ");
   const suffix = online.length > 3 ? "…" : "";
   const nameStr = names ? ` (${names}${suffix})` : "";

package/commands/nudge.md

@@ -1 +0,0 @@
-Run `claude-friends nudge $ARGUMENTS` and show the output. If no username is provided, ask for one first.

package/commands/status.md

@@ -1 +0,0 @@
-Run `claude-friends status $ARGUMENTS` and show the output. If no status message is provided, ask for one first.

package/commands/unfriend.md

@@ -1 +0,0 @@
-Run `claude-friends remove $ARGUMENTS` and show the output. If no username is provided, ask for one first.