@kamal0808/anytoany 0.3.0 → 0.3.1

package/README.md

@@ -1,92 +1,70 @@
-# `any` — Milestone 1
+# `any` — message people from inside Claude
 
-A deliberately tiny message relay + CLI so two machines (each running a Claude
-Code session) can **send / inbox / reply** — and, once that feels magical,
-**delegate tasks**.
+Send a message to a friend and it lands **inside their Claude Desktop** — a
+banner pops, they click it, a Claude Code session opens that reads the message
+and helps them reply. AI-mediated messaging, human-in-the-loop.
 
-No auth. No websockets. No database. One ~180-line HTTP server over a JSON file,
-and one CLI. Zero dependencies (Node ≥ 18 for global `fetch`; you have 25).
-
-```
-MacBook Air (@kamal)                 Mac Mini (@yash)
-   any CLI  ─────────┐          ┌───────  any CLI
-                     ▼          ▼
-              relay.js on the Mac Mini (Tailscale 100.92.24.17:4747)
-                     └─ data/messages.json
 ```
-
-## Setup (once per machine)
-
-Requires **Node ≥ 18** (for global `fetch`). Note the `any` shim runs whatever
-`node` is first on your `PATH` — if a shell defaults to an old Node (e.g. nvm
-pinned to 14), bare `any` will crash. Fix per machine with `nvm use` (an
-`.nvmrc` pinning 22 is included) or, to make it stick for every shell:
-`nvm alias default 22`.
-
-From the repo root on **each** Mac:
-
-```bash
-cd any
-npm link          # puts `any` on your PATH   (or just use: node any/cli.js …)
+you: any send @friend "hey"
+        → hosted relay (Cloudflare Worker + D1)
+        → friend's machine: watcher polls (cheap, 0 tokens idle)
+        → 🔔 clickable macOS banner
+        → click → claude://code/new opens a Claude Code session IN Claude Desktop
+        → runs `any inbox` → reads → drafts → friend approves → any reply → back to you
 ```
 
-Identity is auto-detected from hostname (`mac-mini` → `@yash`,
-`macbook-air` → `@kamal`). To be explicit:
+## Install (anyone, one command)
 
 ```bash
-any register @kamal          # on the MacBook Air
-any register @yash           # on the Mac Mini
+npx @kamal0808/anytoany@latest setup
 ```
+Pick a unique `@handle` (+ optional display name). No token, no secrets. It
+registers you, installs a background banner watcher, and you're on the network.
+macOS + Node 18+ + Claude Desktop.
 
-## Run the relay (on the Mac Mini — it's always on)
+## Use
 
 ```bash
-cd any
-node relay.js                # listens on 0.0.0.0:4747
+any send @handle "text"    # message anyone by their handle
+any inbox                  # your new messages
+any read <id>              # open one
+any reply <id> "text"      # reply
+any whoami                 # your handle + status
 ```
 
-The default relay URL baked into the CLI is the Mac Mini's Tailscale IP
-(`http://100.92.24.17:4747`), so both Macs already point at it. Override with:
-
-```bash
-any relay http://100.92.24.17:4747
-# or:  export ANY_RELAY_URL=...
-```
-
-Check it from either machine:
-
-```bash
-any whoami                   # shows identity + "relay: online"
-```
-
-## The five commands
-
-```bash
-any send @yash transcript.md          # a file becomes subject + body
-any send @yash "quick question…"       # or send plain text
-any inbox                              # unread messages for you
-any read 3                             # show #3 in full (marks it read)
-any reply 3 "Looks good. Ship it."     # reply goes back to the sender
-any watch                              # live-poll the inbox (agent mode)
-```
-
-## The 60-second demo
-
-1. **Mac Mini:** `node any/relay.js` (leave it running).
-2. **MacBook Air:** `any send @yash transcript.md`
-3. **Mac Mini:** `any inbox` → `any read 1` → `any reply 1 "Looks good. Ship it."`
-4. **MacBook Air:** `any inbox` → the reply is there.
-
-That's the illusion. If it feels magical, it's worth showing to someone.
-
-## Milestone 3 — delegation (the actual point)
-
-The Mac Mini already has a Claude Code session. Paste `OPERATOR-YASH.md` into it
-once. From then on it runs `any watch`, and when a task arrives it executes it in
-Claude Code and replies with the result — autonomously. See that file.
-
-## Config & env
-
-- Config file: `~/.any/config.json` (`{ user, relay }`)
-- Env overrides: `ANY_USER`, `ANY_RELAY_URL`, `ANY_HOME`
-- Relay env: `ANY_PORT`, `ANY_HOST`, `ANY_DATA_DIR`
+## How it works
+
+- **Accounts:** each person claims a unique `@handle` and gets their own key.
+  `from` is server-verified (no spoofing); you can only read your own inbox.
+  Registration is open (anyone can claim a handle and DM anyone by handle).
+- **Relay:** a Cloudflare Worker + D1 (`worker/`) — always-on, edge, durable.
+  URL: `https://anytoany-relay.kamalkhatwani69.workers.dev`.
+- **CLI:** `cli.js` — published to npm as `@kamal0808/anytoany` (bin `any`).
+- **Watcher → banner → Desktop:** `any poke` (run by a launchd agent every ~15s)
+  fires a `terminal-notifier` banner whose click opens
+  `claude://code/new?q=…` — a *tool-capable* Claude Code session inside Claude
+  Desktop (it can run `any`). Set up automatically by `any setup`. macOS-only.
+
+## Layout
+
+| Path | What |
+|---|---|
+| `cli.js` | the `any` CLI (published to npm) |
+| `worker/` | the relay: Cloudflare Worker (`worker.js`) + D1 schema (`schema.sql`) |
+| `relay.js` | legacy standalone Node relay (superseded by the Worker) |
+| `SETUP-YASH.md` | copy-paste onboarding to send a friend |
+| `CLAUDE.md` | operator notes for maintaining/deploying this |
+
+## Maintaining it
+
+- **Deploy the relay:** `cd worker && npx wrangler deploy` (needs `wrangler login`).
+- **Publish the CLI:** bump `version` in `package.json`, then
+  `npm publish --access public` (needs npm login + 2FA).
+- See `CLAUDE.md` for the full operator playbook and known rough edges.
+
+## Not built yet
+
+- One persistent Claude thread for all messaging (deep links only open new
+  sessions; would need the MCP-connector + fixed-chat approach).
+- A dedicated `~/anytoany` folder per install (groups sessions, path-independent).
+- Spam/abuse controls (blocking, invite-only, rate limits) — registration is open.

package/cli.js

@@ -302,8 +302,22 @@ async function cmdPoke() {
   try {
     fs.mkdirSync(lockPath); // single-flight
   } catch {
-    return;
+    // lock exists — break it if stale (a killed tick / network die() can leak it)
+    try {
+      if (Date.now() - fs.statSync(lockPath).mtimeMs > 60000) {
+        fs.rmdirSync(lockPath);
+        fs.mkdirSync(lockPath);
+      } else return;
+    } catch {
+      return;
+    }
   }
+  // release the lock even if a later die()/process.exit() skips the finally block
+  process.on('exit', () => {
+    try {
+      fs.rmdirSync(lockPath);
+    } catch {}
+  });
   try {
     const { messages } = await api(relay, 'GET', `/inbox`);
     if (!messages || !messages.length) return;
@@ -344,6 +358,57 @@ function have(cmd) {
   }
 }
 
+// the anytoany skill — teaches any Claude Code session how to use `any`
+function skillMd(handle) {
+  return `---
+name: anytoany
+description: Message people from the terminal via the \`any\` CLI (anytoany messaging). Use whenever the user wants to send or DM a message (or the current conversation) to a person or @handle, check their anytoany inbox, or reply to a message they received. Needs a shell (Claude Code / Cowork session).
+---
+
+# anytoany — messaging via the \`any\` CLI
+
+\`any\` sends messages between people through a hosted relay; a message lands in the
+recipient's Claude Desktop as a banner they click to read & reply.
+
+**On this machine you are \`${handle}\`.** Run the \`any\` CLI in the shell to act.
+
+## Commands
+| Intent | Command |
+|---|---|
+| Send a message | \`any send @handle "message text"\` |
+| Check new messages | \`any inbox\`  (or \`any inbox --all\`) |
+| Read one (marks read) | \`any read <id>\` |
+| Reply to one | \`any reply <id> "text"\` |
+| Who am I / status | \`any whoami\` |
+
+## Common asks
+- "send X to @bob" → \`any send @bob "X"\`
+- "send this thread to @bob" → summarize the conversation, show me, then on my ok: \`any send @bob "<summary>"\`
+- "anything new?" → \`any inbox\`, then offer to read/reply
+- "reply to #<id>" → draft it, then \`any reply <id> "<reply>"\`
+
+## Contacts
+Use the \`@handle\` the person gave you. Add friends here as you learn them
+(e.g. \`@pulkit\` — Pulkit). If you don't know someone's handle, ask.
+
+## Rules
+- Handles are lowercase slugs \`a-z 0-9 _ -\`, no spaces.
+- **Always confirm the exact message text with me before sending.**
+- Needs a terminal — works in a Claude Code / Cowork session, not a plain chat.
+`;
+}
+
+function installSkill(handle) {
+  try {
+    const dir = path.join(os.homedir(), '.claude', 'skills', 'anytoany');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), skillMd(handle));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // one-command onboarding: claim a handle (get your key) + install the watcher
 async function cmdSetup() {
   const cfg = loadConfig();
@@ -379,6 +444,9 @@ async function cmdSetup() {
   const me = await api(cfg.relay, 'GET', '/whoami').catch(() => null);
   console.log(me ? `✓ connected as ${me.handle}` : '! could not verify with relay (continuing)');
 
+  // install the skill so any Claude Code session knows how to use `any`
+  console.log(installSkill(user) ? '✓ anytoany skill installed (Claude now knows how to message)' : '! could not install skill');
+
   if (process.platform !== 'darwin') {
     console.log('\nThe background banner watcher is macOS-only for now.');
     console.log('You can still use:  any inbox  /  any read <id>  /  any reply <id> "…"');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamal0808/anytoany",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Tiny CLI to send/inbox/reply messages between Claude Code sessions via the anytoany relay",
   "bin": {