@kamal0808/anytoany 0.1.0 → 0.3.0

package/cli.js

@@ -20,6 +20,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import readline from 'node:readline';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 
 const HOME = process.env.ANY_HOME || path.join(os.homedir(), '.any');
 const CONFIG = path.join(HOME, 'config.json');
@@ -52,13 +55,17 @@ 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 };
+  const key = process.env.ANY_KEY || cfg.key || null;
+  return { user: norm(user), relay: relay.replace(/\/$/, ''), key };
 }
 
 function norm(user) {
   if (!user) return null;
-  return user.startsWith('@') ? user : '@' + user;
+  return user.startsWith('@') ? user.toLowerCase() : '@' + user.toLowerCase();
+}
+
+function validSlug(h) {
+  return /^@[a-z0-9_-]{2,30}$/.test(h);
 }
 
 function die(msg) {
@@ -66,11 +73,28 @@ function die(msg) {
   process.exit(1);
 }
 
+// register (claim a handle, get your own key) — no auth needed
+async function registerWithRelay(relay, handle, displayName) {
+  let res;
+  try {
+    res = await fetch(relay + '/register', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ handle, displayName }),
+    });
+  } catch (e) {
+    die(`can't reach relay at ${relay} (${e.message})`);
+  }
+  const j = await res.json().catch(() => ({}));
+  if (!res.ok) die(j.error || `register failed (${res.status})`);
+  return j; // { handle, key, displayName }
+}
+
 async function api(relay, method, route, body) {
-  const { token } = resolve();
+  const { key } = resolve();
   const headers = {};
   if (body) headers['content-type'] = 'application/json';
-  if (token) headers['authorization'] = `Bearer ${token}`;
+  if (key) headers['authorization'] = `Bearer ${key}`;
   let res;
   try {
     res = await fetch(relay + route, {
@@ -119,12 +143,19 @@ function printMessage(m, { full = false } = {}) {
 // ---- commands ------------------------------------------------------------
 
 async function cmdRegister(args) {
-  const user = norm(args[0]);
-  if (!user) die('usage: any register @you');
+  let handle = norm(args[0]);
+  if (!handle) die('usage: any register @you [Display Name]');
+  if (!validSlug(handle)) die('handle must be 2-30 chars: a-z 0-9 _ - (e.g. @kamal)');
   const cfg = loadConfig();
-  cfg.user = user;
+  const relay = (process.env.ANY_RELAY_URL || cfg.relay || DEFAULT_RELAY).replace(/\/$/, '');
+  const name = args.slice(1).join(' ') || null;
+  const acct = await registerWithRelay(relay, handle, name);
+  cfg.user = acct.handle;
+  cfg.key = acct.key;
+  cfg.relay = relay;
+  if (acct.displayName) cfg.displayName = acct.displayName;
   saveConfig(cfg);
-  console.log(`registered as ${user}`);
+  console.log(`✓ registered as ${acct.handle}${acct.displayName ? ' (' + acct.displayName + ')' : ''}`);
 }
 
 async function cmdRelay(args) {
@@ -136,27 +167,20 @@ async function cmdRelay(args) {
   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)`);
+  const { user, relay, key } = resolve();
+  console.log(`handle: ${user || '(unregistered — run: any setup)'}`);
+  console.log(`relay:  ${relay}`);
+  console.log(`key:    ${key ? 'set' : '(none — run: any setup)'}`);
+  if (key) {
+    const me = await api(relay, 'GET', '/whoami').catch(() => null);
+    if (me) console.log(`status: online as ${me.handle}${me.displayName ? ' (' + me.displayName + ')' : ''}`);
+  }
 }
 
 async function cmdSend(args) {
-  const { user, relay } = resolve();
-  if (!user) die('you are not registered. Run: any register @you');
+  const { key, relay } = resolve();
+  if (!key) die('not registered. Run: any setup');
   const to = norm(args[0]);
   if (!to) die('usage: any send @who <text | file>');
   const rest = args.slice(1);
@@ -172,24 +196,20 @@ async function cmdSend(args) {
     body = rest.join(' ');
   }
 
-  const { id } = await api(relay, 'POST', '/send', { from: user, to, subject, body });
+  const { id } = await api(relay, 'POST', '/send', { 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 { key, relay } = resolve();
+  if (!key) die('not registered. Run: any setup');
   const all = args.includes('--all');
-  const { messages, count } = await api(
-    relay,
-    'GET',
-    `/inbox?user=${encodeURIComponent(user)}${all ? '&all=1' : ''}`,
-  );
+  const { messages, count } = await api(relay, 'GET', `/inbox${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`);
+  console.log(`${count} ${all ? 'message(s)' : 'new message(s)'}:\n`);
   for (const m of messages) {
     printMessage(m);
     console.log('');
@@ -208,34 +228,30 @@ async function cmdRead(args) {
 }
 
 async function cmdReply(args) {
-  const { user, relay } = resolve();
-  if (!user) die('you are not registered. Run: any register @you');
+  const { key, relay } = resolve();
+  if (!key) die('not registered. Run: any setup');
   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 });
+  const { id: newId } = await api(relay, 'POST', '/reply', { id, 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 { key, relay } = resolve();
+  if (!key) die('not registered. Run: any setup');
   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`);
+  console.log(`watching inbox (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`);
+  const first = await api(relay, 'GET', `/inbox?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: [] }));
+    const { messages } = await api(relay, 'GET', `/inbox?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);
@@ -247,13 +263,208 @@ async function cmdWatch(args) {
   setInterval(poll, interval);
 }
 
+// ---- watcher: poke (one tick) + setup (install the background watcher) ----
+
+function deepLink(user, folder) {
+  const prompt =
+    `You are helping me (${user}) with my anytoany messages. Run \`any inbox\` to see new messages, ` +
+    `read the newest with \`any read <id>\`, and help me draft a reply. When I approve, send it with ` +
+    `\`any reply <id> "..."\`. Do not send anything until I confirm.`;
+  let url = `claude://code/new?q=${encodeURIComponent(prompt)}`;
+  if (folder) url += `&folder=${encodeURIComponent(folder)}`;
+  return url;
+}
+
+function fireBanner(m, link) {
+  const preview = (m.body || '').replace(/\s+/g, ' ').slice(0, 120);
+  const title = `📨 ${m.from} → you`;
+  try {
+    execFileSync(
+      'terminal-notifier',
+      ['-title', title, '-subtitle', 'click to read & reply in Claude', '-message', preview, '-execute', `open '${link}'`],
+      { stdio: 'ignore' },
+    );
+    return;
+  } catch {}
+  try {
+    execFileSync('osascript', ['-e', `display notification ${JSON.stringify(preview)} with title ${JSON.stringify(title)}`], { stdio: 'ignore' });
+  } catch {}
+}
+
+// one watch tick: alert on any new unread message. Run by launchd every ~15s.
+async function cmdPoke() {
+  const { user, relay, key: authKey } = resolve();
+  if (!authKey) die('not registered (run: any setup)');
+  const slug = user.replace('@', '');
+  const seenPath = path.join(HOME, `poke-seen-${slug}.txt`);
+  const lockPath = path.join(HOME, `poke-${slug}.lock`);
+  fs.mkdirSync(HOME, { recursive: true });
+  try {
+    fs.mkdirSync(lockPath); // single-flight
+  } catch {
+    return;
+  }
+  try {
+    const { messages } = await api(relay, 'GET', `/inbox`);
+    if (!messages || !messages.length) return;
+    let seen = new Set();
+    try {
+      seen = new Set(fs.readFileSync(seenPath, 'utf8').split('\n').filter(Boolean).map(Number));
+    } catch {}
+    const link = deepLink(user, process.env.ANY_FOLDER || loadConfig().folder || null);
+    for (const m of messages) {
+      if (seen.has(m.id)) continue;
+      fireBanner(m, link);
+      fs.appendFileSync(seenPath, m.id + '\n');
+      console.log(`alerted #${m.id} from ${m.from}`);
+    }
+  } finally {
+    try {
+      fs.rmdirSync(lockPath);
+    } catch {}
+  }
+}
+
+function promptLine(q) {
+  return new Promise((res) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(q, (a) => {
+      rl.close();
+      res(a.trim());
+    });
+  });
+}
+
+function have(cmd) {
+  try {
+    execFileSync('/bin/bash', ['-lc', `command -v ${cmd}`], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// one-command onboarding: claim a handle (get your key) + install the watcher
+async function cmdSetup() {
+  const cfg = loadConfig();
+  const tty = process.stdin.isTTY;
+  const relay = (process.env.ANY_RELAY_URL || cfg.relay || DEFAULT_RELAY).replace(/\/$/, '');
+
+  if (!cfg.key) {
+    // claim a new account
+    let handle = norm(process.env.ANY_USER || cfg.user);
+    if (!handle) {
+      if (!tty) die('no handle — run interactively, or: any register @you first');
+      handle = norm(await promptLine('Pick a handle (e.g. @yash): '));
+    }
+    if (!validSlug(handle)) die('handle must be 2-30 chars: a-z 0-9 _ - (e.g. @kamal)');
+    let name = cfg.displayName || process.env.ANY_NAME || null;
+    if (tty && !name) name = (await promptLine('Display name (optional): ')) || null;
+    const acct = await registerWithRelay(relay, handle, name);
+    cfg.user = acct.handle;
+    cfg.key = acct.key;
+    cfg.relay = relay;
+    if (acct.displayName) cfg.displayName = acct.displayName;
+    saveConfig(cfg);
+    console.log(`✓ registered as ${acct.handle}${acct.displayName ? ' (' + acct.displayName + ')' : ''} → ${relay}`);
+  } else {
+    if (!cfg.relay) {
+      cfg.relay = relay;
+      saveConfig(cfg);
+    }
+    console.log(`✓ already registered as ${cfg.user} → ${cfg.relay}`);
+  }
+  const user = cfg.user;
+
+  const me = await api(cfg.relay, 'GET', '/whoami').catch(() => null);
+  console.log(me ? `✓ connected as ${me.handle}` : '! could not verify with relay (continuing)');
+
+  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> "…"');
+    return;
+  }
+
+  // ensure a stable global install (npx runs from a temp cache the watcher can't rely on)
+  if (!have('any')) {
+    console.log('Installing @kamal0808/anytoany globally…');
+    try {
+      execFileSync('npm', ['install', '-g', '@kamal0808/anytoany'], { stdio: 'inherit' });
+    } catch {}
+  }
+  if (!have('terminal-notifier')) {
+    console.log('Installing terminal-notifier (clickable banners)…');
+    try {
+      execFileSync('brew', ['install', 'terminal-notifier'], { stdio: 'inherit' });
+    } catch {
+      console.log('! could not auto-install — run:  brew install terminal-notifier');
+    }
+  }
+
+  // resolve a stable cli.js path for the LaunchAgent
+  let cliForAgent = fileURLToPath(import.meta.url);
+  try {
+    const anyBin = execFileSync('/bin/bash', ['-lc', 'command -v any'], { encoding: 'utf8' }).trim();
+    if (anyBin) cliForAgent = fs.realpathSync(anyBin);
+  } catch {}
+
+  const key = user.replace('@', '');
+  const label = `com.anytoany.poke.${key}`;
+  const laDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  fs.mkdirSync(laDir, { recursive: true });
+  const plistPath = path.join(laDir, `${label}.plist`);
+  const nodeDir = path.dirname(process.execPath);
+  fs.writeFileSync(
+    plistPath,
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array><string>${process.execPath}</string><string>${cliForAgent}</string><string>poke</string></array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>ANY_USER</key><string>${user}</string>
+    <key>PATH</key><string>${nodeDir}:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+  <key>StartInterval</key><integer>15</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>/tmp/any-poke-${key}.log</string>
+  <key>StandardErrorPath</key><string>/tmp/any-poke-${key}.err</string>
+</dict>
+</plist>
+`,
+  );
+
+  // prime seen-file so existing messages don't all alert at once
+  try {
+    const { messages } = await api(cfg.relay, 'GET', `/inbox?all=1`);
+    fs.writeFileSync(path.join(HOME, `poke-seen-${key}.txt`), (messages || []).map((m) => m.id).join('\n') + '\n');
+  } catch {}
+
+  const uid = process.getuid();
+  try {
+    execFileSync('launchctl', ['bootout', `gui/${uid}/${label}`], { stdio: 'ignore' });
+  } catch {}
+  try {
+    execFileSync('launchctl', ['bootstrap', `gui/${uid}`, plistPath], { stdio: 'ignore' });
+    console.log('✓ background watcher installed');
+  } catch {
+    console.log(`! load the watcher manually:\n    launchctl bootstrap gui/${uid} ${plistPath}`);
+  }
+
+  console.log(`\nDone — you're on the network as ${user}.`);
+  console.log('New message → a banner pops → click it → Claude Desktop opens to read & reply.');
+}
+
 function cmdHelp() {
   console.log(`any — tiny message relay CLI
 
-  any register @you            set your identity
+  any setup                    one-command onboarding (claim @handle + banner watcher)
+  any register @you [Name]     claim a handle (get your key)
   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 whoami                   show your handle + 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)
@@ -271,9 +482,10 @@ Env:     ANY_USER, ANY_RELAY_URL, ANY_HOME
 const [, , cmd, ...args] = process.argv;
 
 const table = {
+  setup: cmdSetup,
+  poke: cmdPoke,
   register: cmdRegister,
   relay: cmdRelay,
-  token: cmdToken,
   whoami: cmdWhoami,
   send: cmdSend,
   inbox: cmdInbox,

package/package.json

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