@kamal0808/anytoany 0.1.0

package/README.md

@@ -0,0 +1,92 @@
+# `any` — Milestone 1
+
+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**.
+
+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 …)
+```
+
+Identity is auto-detected from hostname (`mac-mini` → `@yash`,
+`macbook-air` → `@kamal`). To be explicit:
+
+```bash
+any register @kamal          # on the MacBook Air
+any register @yash           # on the Mac Mini
+```
+
+## Run the relay (on the Mac Mini — it's always on)
+
+```bash
+cd any
+node relay.js                # listens on 0.0.0.0:4747
+```
+
+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`

package/cli.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+/**
+ * any — the CLI (Milestone 1)
+ *
+ * Five(ish) commands, no auth, hardcoded-friendly identity.
+ *
+ *   any register @kamal          set who you are (writes ~/.any/config.json)
+ *   any relay <url>              point at the relay server
+ *   any whoami                   show current identity + relay
+ *   any send @yash <text|file>   send a message (file -> subject+body)
+ *   any inbox [--all]            list messages addressed to you
+ *   any read <id>                show one message (marks it read)
+ *   any reply <id> <text>        reply to a message
+ *   any watch [--interval 5]     poll inbox, print new messages as they land
+ *
+ * Config resolution (highest wins):
+ *   env ANY_USER / ANY_RELAY_URL  >  ~/.any/config.json  >  hostname default
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const HOME = process.env.ANY_HOME || path.join(os.homedir(), '.any');
+const CONFIG = path.join(HOME, 'config.json');
+
+// Sensible defaults for this specific two-Mac setup. Override anytime with
+// `any register` / `any relay`, or the ANY_USER / ANY_RELAY_URL env vars.
+const DEFAULT_RELAY = 'https://anytoany-relay.kamalkhatwani69.workers.dev'; // hosted relay (Cloudflare Worker + D1)
+
+function hostnameUser() {
+  const h = os.hostname().toLowerCase();
+  if (h.includes('mac-mini') || h.includes('macmini')) return '@yash';
+  if (h.includes('macbook-air') || h.includes('air')) return '@kamal';
+  return null;
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(HOME, { recursive: true });
+  fs.writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
+}
+
+function resolve() {
+  const cfg = loadConfig();
+  const user = process.env.ANY_USER || cfg.user || hostnameUser();
+  const relay = process.env.ANY_RELAY_URL || cfg.relay || DEFAULT_RELAY;
+  const token = process.env.ANY_TOKEN || cfg.token || null;
+  return { user: norm(user), relay: relay.replace(/\/$/, ''), token };
+}
+
+function norm(user) {
+  if (!user) return null;
+  return user.startsWith('@') ? user : '@' + user;
+}
+
+function die(msg) {
+  console.error(`error: ${msg}`);
+  process.exit(1);
+}
+
+async function api(relay, method, route, body) {
+  const { token } = resolve();
+  const headers = {};
+  if (body) headers['content-type'] = 'application/json';
+  if (token) headers['authorization'] = `Bearer ${token}`;
+  let res;
+  try {
+    res = await fetch(relay + route, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  } catch (e) {
+    die(`can't reach relay at ${relay} (${e.message}). Is it running? Try: any relay <url>`);
+  }
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    json = { raw: text };
+  }
+  if (!res.ok) die(json.error || `relay returned ${res.status}`);
+  return json;
+}
+
+function fmtTime(ts) {
+  const d = new Date(ts);
+  return d.toLocaleString();
+}
+
+function printMessage(m, { full = false } = {}) {
+  const flag = m.read ? '  ' : '📨';
+  const subj = m.subject ? m.subject : '(no subject)';
+  console.log(`${flag} #${m.id}  from ${m.from}  ${fmtTime(m.ts)}`);
+  console.log(`    ${subj}`);
+  if (full) {
+    console.log('');
+    console.log(
+      m.body
+        .split('\n')
+        .map((l) => '    ' + l)
+        .join('\n'),
+    );
+  } else {
+    const preview = m.body.replace(/\s+/g, ' ').slice(0, 72);
+    if (preview) console.log(`    ${preview}${m.body.length > 72 ? '…' : ''}`);
+  }
+}
+
+// ---- commands ------------------------------------------------------------
+
+async function cmdRegister(args) {
+  const user = norm(args[0]);
+  if (!user) die('usage: any register @you');
+  const cfg = loadConfig();
+  cfg.user = user;
+  saveConfig(cfg);
+  console.log(`registered as ${user}`);
+}
+
+async function cmdRelay(args) {
+  const url = args[0];
+  if (!url) die('usage: any relay <url>');
+  const cfg = loadConfig();
+  cfg.relay = url.replace(/\/$/, '');
+  saveConfig(cfg);
+  console.log(`relay set to ${cfg.relay}`);
+}
+
+async function cmdToken(args) {
+  const t = args[0];
+  if (!t) die('usage: any token <shared-secret>');
+  const cfg = loadConfig();
+  cfg.token = t;
+  saveConfig(cfg);
+  console.log('token saved');
+}
+
+async function cmdWhoami() {
+  const { user, relay, token } = resolve();
+  console.log(`user:  ${user || '(unset — run: any register @you)'}`);
+  console.log(`relay: ${relay}`);
+  console.log(`token: ${token ? 'set' : '(none)'}`);
+  const health = await api(relay, 'GET', '/health').catch(() => null);
+  if (health) console.log(`relay: online (${health.messages} messages stored)`);
+}
+
+async function cmdSend(args) {
+  const { user, relay } = resolve();
+  if (!user) die('you are not registered. Run: any register @you');
+  const to = norm(args[0]);
+  if (!to) die('usage: any send @who <text | file>');
+  const rest = args.slice(1);
+  if (rest.length === 0) die('nothing to send');
+
+  let subject = null;
+  let body;
+  // If the single remaining arg is a readable file, send its contents.
+  if (rest.length === 1 && fs.existsSync(rest[0]) && fs.statSync(rest[0]).isFile()) {
+    body = fs.readFileSync(rest[0], 'utf8');
+    subject = path.basename(rest[0]);
+  } else {
+    body = rest.join(' ');
+  }
+
+  const { id } = await api(relay, 'POST', '/send', { from: user, to, subject, body });
+  console.log(`sent → ${to}  (#${id})`);
+}
+
+async function cmdInbox(args) {
+  const { user, relay } = resolve();
+  if (!user) die('you are not registered. Run: any register @you');
+  const all = args.includes('--all');
+  const { messages, count } = await api(
+    relay,
+    'GET',
+    `/inbox?user=${encodeURIComponent(user)}${all ? '&all=1' : ''}`,
+  );
+  if (count === 0) {
+    console.log(all ? 'inbox empty' : 'no new messages');
+    return;
+  }
+  console.log(`${count} ${all ? 'message(s)' : 'new message(s)'} for ${user}:\n`);
+  for (const m of messages) {
+    printMessage(m);
+    console.log('');
+  }
+  if (!all) console.log('read one with:  any read <id>');
+}
+
+async function cmdRead(args) {
+  const { relay } = resolve();
+  const id = Number(args[0]);
+  if (!id) die('usage: any read <id>');
+  const m = await api(relay, 'GET', `/message/${id}`);
+  printMessage(m, { full: true });
+  await api(relay, 'POST', '/mark-read', { id });
+  console.log(`\nreply with:  any reply ${id} "your message"`);
+}
+
+async function cmdReply(args) {
+  const { user, relay } = resolve();
+  if (!user) die('you are not registered. Run: any register @you');
+  const id = Number(args[0]);
+  if (!id) die('usage: any reply <id> <text>');
+  const body = args.slice(1).join(' ');
+  if (!body) die('nothing to reply with');
+  const { id: newId } = await api(relay, 'POST', '/reply', { id, from: user, body });
+  console.log(`replied to #${id}  (#${newId})`);
+}
+
+async function cmdWatch(args) {
+  const { user, relay } = resolve();
+  if (!user) die('you are not registered. Run: any register @you');
+  const i = args.indexOf('--interval');
+  const interval = (i >= 0 ? Number(args[i + 1]) : 5) * 1000;
+  const seen = new Set();
+  console.log(`watching inbox for ${user} (every ${interval / 1000}s). Ctrl-C to stop.\n`);
+  // Prime with existing unread so we only announce genuinely new arrivals.
+  const first = await api(relay, 'GET', `/inbox?user=${encodeURIComponent(user)}&all=1`);
+  for (const m of first.messages) seen.add(m.id);
+  if (first.messages.length) console.log(`(${first.messages.length} existing message(s), waiting for new ones)\n`);
+
+  async function poll() {
+    const { messages } = await api(
+      relay,
+      'GET',
+      `/inbox?user=${encodeURIComponent(user)}&all=1`,
+    ).catch(() => ({ messages: [] }));
+    for (const m of messages.sort((a, b) => a.ts - b.ts)) {
+      if (seen.has(m.id)) continue;
+      seen.add(m.id);
+      console.log('─'.repeat(50));
+      printMessage(m, { full: true });
+      console.log('─'.repeat(50) + '\n');
+    }
+  }
+  setInterval(poll, interval);
+}
+
+function cmdHelp() {
+  console.log(`any — tiny message relay CLI
+
+  any register @you            set your identity
+  any relay <url>              point at the relay server
+  any token <secret>           set the shared secret (for a hosted relay)
+  any whoami                   show identity + relay status
+
+  any send @who <text|file>    send a message (a file becomes subject+body)
+  any inbox [--all]            list messages for you (default: unread only)
+  any read <id>                show a message in full (marks read)
+  any reply <id> <text>        reply to a message
+  any watch [--interval 5]     live-poll the inbox for new messages
+
+Config:  ${CONFIG}
+Env:     ANY_USER, ANY_RELAY_URL, ANY_HOME
+`);
+}
+
+// ---- dispatch ------------------------------------------------------------
+
+const [, , cmd, ...args] = process.argv;
+
+const table = {
+  register: cmdRegister,
+  relay: cmdRelay,
+  token: cmdToken,
+  whoami: cmdWhoami,
+  send: cmdSend,
+  inbox: cmdInbox,
+  read: cmdRead,
+  reply: cmdReply,
+  watch: cmdWatch,
+  help: cmdHelp,
+  '--help': cmdHelp,
+  '-h': cmdHelp,
+};
+
+const fn = table[cmd];
+if (!fn) {
+  if (cmd) console.error(`unknown command: ${cmd}\n`);
+  cmdHelp();
+  process.exit(cmd ? 1 : 0);
+}
+
+Promise.resolve(fn(args)).catch((e) => die(e.message || String(e)));

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@kamal0808/anytoany",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Tiny CLI to send/inbox/reply messages between Claude Code sessions via the anytoany relay",
+  "bin": {
+    "any": "cli.js"
+  },
+  "files": [
+    "cli.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cli",
+    "messaging",
+    "claude",
+    "ai",
+    "inbox"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kamal0808/anytoany.git"
+  }
+}