@profullstack/qryptchat 0.1.0 → 0.2.0

package/dist/{chunk-9kkxje88.js → chunk-c8qkdept.js}

@@ -822,6 +822,81 @@ async function openKeyBlob(blob, ephemeral) {
   return { keys1024: keys.keys1024, keys768: keys.keys768 };
 }
 
+// src/lib/chat/reactions.js
+var REACTION_TYPE = "reaction";
+var MAX_EMOJI_LENGTH = 32;
+function reactionEnvelope(targetId, emoji, remove = false) {
+  return JSON.stringify({ v: 1, type: REACTION_TYPE, target: String(targetId), emoji: String(emoji), remove: !!remove });
+}
+function parseReaction(content) {
+  try {
+    const d = JSON.parse(content);
+    if (d?.type !== REACTION_TYPE || typeof d.target !== "string" || typeof d.emoji !== "string")
+      return null;
+    if (!d.emoji || d.emoji.length > MAX_EMOJI_LENGTH)
+      return null;
+    return { target: d.target, emoji: d.emoji, remove: !!d.remove };
+  } catch {
+    return null;
+  }
+}
+var senderName = (m) => m?.sender?.display_name || m?.sender?.username || "Someone";
+function snippet(m, max = 90) {
+  if (!m)
+    return "";
+  if (m.message_type === "file" || m.has_attachments)
+    return "\uD83D\uDCCE Attachment";
+  const text = String(m.content ?? "").replace(/\s+/g, " ").trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function foldMessages(messages, myUserId) {
+  const visible = [];
+  const byId = new Map;
+  const picks = new Map;
+  for (const m of messages) {
+    if (m.message_type === REACTION_TYPE) {
+      const r = parseReaction(m.content);
+      if (!r)
+        continue;
+      const forTarget = picks.get(r.target) ?? new Map;
+      const current = forTarget.get(m.sender_id);
+      if (r.remove) {
+        if (current && current.emoji === r.emoji)
+          forTarget.delete(m.sender_id);
+      } else {
+        forTarget.set(m.sender_id, { emoji: r.emoji, name: senderName(m), at: m.created_at });
+      }
+      picks.set(r.target, forTarget);
+      continue;
+    }
+    visible.push(m);
+    byId.set(m.id, m);
+  }
+  return visible.map((m) => {
+    const out = { ...m, reactions: [] };
+    const forTarget = picks.get(m.id);
+    if (forTarget?.size) {
+      const groups = new Map;
+      for (const [senderId, p] of forTarget) {
+        const g = groups.get(p.emoji) ?? { emoji: p.emoji, count: 0, mine: false, names: [], first: p.at };
+        g.count += 1;
+        g.names.push(senderId === myUserId ? "You" : p.name);
+        if (senderId === myUserId)
+          g.mine = true;
+        if (p.at < g.first)
+          g.first = p.at;
+        groups.set(p.emoji, g);
+      }
+      out.reactions = [...groups.values()].sort((a, b) => b.count - a.count || String(a.first).localeCompare(String(b.first)));
+    }
+    if (m.reply_to_id) {
+      const target = byId.get(m.reply_to_id);
+      out.replyTo = target ? { id: target.id, name: target.sender_id === myUserId ? "You" : senderName(target), snippet: snippet(target), missing: false } : { id: m.reply_to_id, name: "", snippet: "Original message not loaded", missing: true };
+    }
+    return out;
+  });
+}
+
 // src/cli/api.js
 class QcError extends Error {
   constructor(message, status) {
@@ -889,34 +964,37 @@ class QcClient {
     const { conversations = [] } = await this.request("/api/conversations/load", { method: "POST", body: {} });
     return conversations.map((c) => ({ ...c, title: conversationTitle(c, this.me) }));
   }
-  async messages(conversationId, { limit = 100, before } = {}) {
+  async messages(conversationId, { limit = 200, before } = {}) {
     const { messages = [], hasMore = false } = await this.request("/api/messages/load", {
       method: "POST",
       body: { conversationId, limit, ...before ? { before } : {} }
     });
-    const out = [];
+    const raw = [];
     for (const m of messages) {
-      let text;
+      let content = m.encrypted_content ? await this.ring.decrypt(m.encrypted_content) : "";
       if (m.message_type === "file" || m.has_attachments) {
-        text = m.encrypted_content ? await this.ring.decrypt(m.encrypted_content) : "";
-        text = `\uD83D\uDCCE ${text && text !== "[File attachment]" ? `${text} ` : ""}(attachment: open qrypt.chat to download)`;
-      } else {
-        text = m.encrypted_content ? await this.ring.decrypt(m.encrypted_content) : "";
+        content = `\uD83D\uDCCE ${content && content !== "[File attachment]" ? `${content} ` : ""}(attachment: open qrypt.chat to download)`;
       }
-      out.push({
-        id: m.id,
-        conversationId: m.conversation_id,
-        senderId: m.sender_id,
-        sender: m.sender?.display_name || m.sender?.username || "unknown",
-        username: m.sender?.username || "",
-        mine: m.sender_id === this.me?.id,
-        text,
-        at: m.created_at
-      });
+      raw.push({ ...m, content });
     }
+    const out = foldMessages(raw, this.me?.id).map((m) => ({
+      id: m.id,
+      conversationId: m.conversation_id,
+      senderId: m.sender_id,
+      sender: m.sender?.display_name || m.sender?.username || "unknown",
+      username: m.sender?.username || "",
+      mine: m.sender_id === this.me?.id,
+      text: m.content,
+      at: m.created_at,
+      reactions: m.reactions.map(({ emoji, count, mine, names }) => ({ emoji, count, mine, names })),
+      ...m.replyTo ? { replyTo: m.replyTo } : {}
+    }));
     return { messages: out, hasMore };
   }
-  async send(conversationId, text) {
+  async react(conversationId, messageId, emoji, remove = false) {
+    return this.send(conversationId, reactionEnvelope(messageId, emoji, remove), { messageType: REACTION_TYPE });
+  }
+  async send(conversationId, text, { replyTo, messageType = "text" } = {}) {
     const { participants = [] } = await this.request(`/api/chat/conversations/${encodeURIComponent(conversationId)}/participants`);
     const userIds = participants.map((p) => p.user_id);
     if (!userIds.length)
@@ -935,7 +1013,7 @@ class QcClient {
       throw new QcError("No participant has a public key yet");
     const { message } = await this.request("/api/messages/send", {
       method: "POST",
-      body: { conversationId, encryptedContents, messageType: "text" }
+      body: { conversationId, encryptedContents, messageType, ...replyTo ? { replyToId: replyTo } : {} }
     });
     return { message, skipped: missing.length };
   }
@@ -1049,10 +1127,32 @@ var TIMEOUT_MS = 5 * 60 * 1000;
 var PAGE = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title>
 <style>body{font:16px system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;background:#0b0d12;color:#e6e8ee}main{max-width:28rem;text-align:center}</style>
 <main><h1>${title}</h1><p>${body}</p></main>`;
+function isRemote({ platform = process.platform, env = process.env } = {}) {
+  if (env.QC_NO_BROWSER)
+    return true;
+  return !!(env.SSH_CONNECTION || env.SSH_TTY) && !env.DISPLAY && !env.WAYLAND_DISPLAY && platform !== "darwin" && platform !== "win32";
+}
+function parsePasted(input, state) {
+  const text = String(input || "").trim();
+  if (!text)
+    return null;
+  if (/^https?:\/\//i.test(text)) {
+    let url;
+    try {
+      url = new URL(text);
+    } catch {
+      return null;
+    }
+    const got = url.searchParams.get("state");
+    if (got && got !== state)
+      throw new Error("That link belongs to a different login. Run qc login again.");
+    return url.searchParams.get("code");
+  }
+  return /^[A-Za-z0-9_-]{20,}$/.test(text) ? text : null;
+}
 function openBrowser(url, { platform = process.platform, env = process.env } = {}) {
-  if (env.QC_NO_BROWSER || (env.SSH_CONNECTION || env.SSH_TTY) && !env.DISPLAY && !env.WAYLAND_DISPLAY && platform === "linux") {
+  if (isRemote({ platform, env }))
     return false;
-  }
   const [cmd, args] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
     const child = spawn(cmd, args, { stdio: "ignore", detached: true });
@@ -1102,7 +1202,8 @@ async function login(options = {}) {
   const ephemeral = await ephemeralKeypair();
   let server;
   let redirectUri = "oob";
-  if (!options.oob) {
+  const oob = options.oob || isRemote({ env });
+  if (!oob) {
     server = createServer();
     await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
     redirectUri = `http://127.0.0.1:${server.address().port}/callback`;
@@ -1124,20 +1225,44 @@ async function login(options = {}) {
   print(`  Confirmation code: ${match}`);
   print("  Check that the browser shows the same code before you approve.");
   print("");
-  const opened = !options.oob && openBrowser(url.toString(), { env });
+  const opened = !oob && openBrowser(url.toString(), { env });
   print(opened ? "  Opened your browser. If it did not, open:" : "  Open this link in a browser where you are signed in to qrypt.chat:");
   print(`  ${url.toString()}`);
   print("");
   let code;
+  let rl;
   try {
     if (server) {
-      code = await waitForCallback(server, state);
+      const waits = [waitForCallback(server, state)];
+      if (process.stdin.isTTY) {
+        rl = createInterface({ input: process.stdin, output: process.stderr });
+        waits.push((async () => {
+          for (;; ) {
+            let line;
+            try {
+              line = await rl.question("  Waiting for the browser… or paste the URL it ended up on: ");
+            } catch {
+              return new Promise(() => {});
+            }
+            const pasted = parsePasted(line, state);
+            if (pasted)
+              return pasted;
+            print("  That is not a qc login code or callback URL.");
+          }
+        })());
+      }
+      code = await Promise.race(waits);
     } else {
-      const rl = createInterface({ input: process.stdin, output: process.stderr });
-      code = (await rl.question("  Paste the code from the browser: ")).trim();
-      rl.close();
+      rl = createInterface({ input: process.stdin, output: process.stderr });
+      for (;; ) {
+        code = parsePasted(await rl.question("  Paste the code (or the URL) from the browser: "), state);
+        if (code)
+          break;
+        print("  That is not a qc login code.");
+      }
     }
   } finally {
+    rl?.close();
     server?.close();
   }
   if (!code)
@@ -1174,7 +1299,8 @@ Usage:
   qc whoami               who this terminal is signed in as
   qc chats                list your chats
   qc read <chat> [-n 20]  print the last messages of a chat
-  qc send <chat> <text>   send a message (text "-" reads stdin)
+  qc send <chat> <text>   send a message (text "-" reads stdin; --reply <message-id> to reply)
+  qc react <chat> <message-id> <emoji> [--remove]   react to a message
   qc listen               print new messages as they arrive (NDJSON with --json)
   qc mcp                  run as an MCP server on stdio (list_chats, read_chat, send_message)
 
@@ -1192,7 +1318,7 @@ function parseArgs2(argv) {
       const [k, v] = a.slice(2).split("=", 2);
       if (v !== undefined)
         args.flags[k] = v;
-      else if (["url", "n", "limit"].includes(k) && argv[i + 1] !== undefined)
+      else if (["url", "n", "limit", "reply"].includes(k) && argv[i + 1] !== undefined)
         args.flags[k] = argv[++i];
       else
         args.flags[k] = true;
@@ -1292,10 +1418,27 @@ async function main2(argv, { version = "0.0.0" } = {}) {
       const last = messages.slice(-Math.max(1, Number(flags.n || flags.limit || 20)));
       if (flags.json)
         return json(last);
-      for (const m of last)
-        out(`[${stamp(m.at)}] ${m.mine ? "you" : m.sender}: ${m.text}`);
+      for (const m of last) {
+        if (m.replyTo)
+          out(`    ┃ ${m.replyTo.name ? `${m.replyTo.name}: ` : ""}${m.replyTo.snippet}`);
+        const reactions = m.reactions?.length ? `  [${m.reactions.map((r) => `${r.emoji}${r.count > 1 ? r.count : ""}`).join(" ")}]` : "";
+        out(`[${stamp(m.at)}] ${m.mine ? "you" : m.sender}: ${m.text}${reactions}  (${m.id.slice(0, 8)})`);
+      }
       return;
     }
+    case "react": {
+      const [chatQuery, messageId, emoji] = rest;
+      if (!chatQuery || !messageId || !emoji)
+        throw new Error("Usage: qc react <chat> <message-id> <emoji> [--remove]");
+      const c = await client(flags);
+      const chat = findChat2(await c.conversations(), chatQuery);
+      const { messages } = await c.messages(chat.id);
+      const target = messages.filter((m) => m.id === messageId || m.id.startsWith(messageId));
+      if (target.length !== 1)
+        throw new Error(target.length ? `"${messageId}" matches ${target.length} messages` : `No message "${messageId}" in ${chat.title}`);
+      await c.react(chat.id, target[0].id, emoji, !!flags.remove);
+      return out(`${flags.remove ? "Removed" : "Reacted"} ${emoji} on ${chat.title}.`);
+    }
     case "send": {
       if (!rest[0] || rest.length < 2)
         throw new Error('Usage: qc send <chat> <text>   (text "-" reads stdin)');
@@ -1304,7 +1447,7 @@ async function main2(argv, { version = "0.0.0" } = {}) {
         throw new Error("Nothing to send.");
       const c = await client(flags);
       const chat = findChat2(await c.conversations(), rest[0]);
-      const { message, skipped } = await c.send(chat.id, text);
+      const { message, skipped } = await c.send(chat.id, text, { replyTo: flags.reply || undefined });
       if (flags.json)
         return json({ id: message?.id, conversation: chat.id, skipped });
       return out(`Sent to ${chat.title}${skipped ? ` (${skipped} participant(s) have no key yet)` : ""}.`);

package/dist/commands.js

@@ -3,7 +3,7 @@ import {
   parseArgs2,
   findChat2,
   main2
-} from "./chunk-9kkxje88.js";
+} from "./chunk-c8qkdept.js";
 export {
   HELP2 as HELP,
   findChat2 as findChat,

package/dist/mcp.js

@@ -1,6 +1,6 @@
 import {
   findChat2
-} from "./chunk-9kkxje88.js";
+} from "./chunk-c8qkdept.js";
 
 // src/cli/mcp.js
 import { createInterface } from "node:readline";
@@ -30,11 +30,27 @@ var TOOLS = [
       type: "object",
       properties: {
         chat: { type: "string", description: "Conversation id or part of its name" },
-        text: { type: "string", description: "The message" }
+        text: { type: "string", description: "The message" },
+        reply_to: { type: "string", description: "Optional: id of the message this replies to (from read_chat)" }
       },
       required: ["chat", "text"],
       additionalProperties: false
     }
+  },
+  {
+    name: "react_to_message",
+    description: "React to a message with an emoji (Signal-style: one reaction per person; a new one replaces yours). End-to-end encrypted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chat: { type: "string", description: "Conversation id or part of its name" },
+        message_id: { type: "string", description: "The message id, from read_chat" },
+        emoji: { type: "string", description: "The emoji, e.g. ❤️" },
+        remove: { type: "boolean", description: "Withdraw this reaction instead" }
+      },
+      required: ["chat", "message_id", "emoji"],
+      additionalProperties: false
+    }
   }
 ];
 async function callTool(client, name, args = {}) {
@@ -46,15 +62,32 @@ async function callTool(client, name, args = {}) {
     const chat = findChat2(await client.conversations(), args.chat);
     const { messages } = await client.messages(chat.id, { limit: 100 });
     const limit = Math.min(100, Math.max(1, Number(args.limit) || 20));
-    return { chat: { id: chat.id, title: chat.title }, messages: messages.slice(-limit).map(({ sender, mine, text, at }) => ({ from: mine ? "me" : sender, text, at })) };
+    return {
+      chat: { id: chat.id, title: chat.title },
+      messages: messages.slice(-limit).map(({ id, sender, mine, text, at, reactions, replyTo }) => ({
+        id,
+        from: mine ? "me" : sender,
+        text,
+        at,
+        ...reactions?.length ? { reactions: reactions.map(({ emoji, count, mine: m }) => ({ emoji, count, mine: m })) } : {},
+        ...replyTo ? { reply_to: { id: replyTo.id, from: replyTo.name, text: replyTo.snippet } } : {}
+      }))
+    };
   }
   if (name === "send_message") {
     if (!args.text || typeof args.text !== "string")
       throw new Error("text is required");
     const chat = findChat2(await client.conversations(), args.chat);
-    const { message, skipped } = await client.send(chat.id, args.text);
+    const { message, skipped } = await client.send(chat.id, args.text, { replyTo: typeof args.reply_to === "string" ? args.reply_to : undefined });
     return { sent: true, id: message?.id, chat: chat.title, skipped };
   }
+  if (name === "react_to_message") {
+    if (!args.emoji || typeof args.emoji !== "string")
+      throw new Error("emoji is required");
+    const chat = findChat2(await client.conversations(), args.chat);
+    await client.react(chat.id, String(args.message_id), args.emoji, !!args.remove);
+    return { reacted: !args.remove, emoji: args.emoji, chat: chat.title };
+  }
   throw new Error(`Unknown tool ${name}`);
 }
 async function handle(client, msg, { version }) {

package/dist/tui.js

@@ -61,11 +61,19 @@ function transcriptLines(messages, width, theme) {
         ]
       });
     }
+    if (m.replyTo) {
+      const who = m.replyTo.name ? `${m.replyTo.name}: ` : "";
+      lines.push({ text: truncate(`  ┃ ${who}${m.replyTo.snippet}`, width), fg: theme.muted });
+    }
     for (const part of String(m.text ?? "").split(`
 `)) {
       for (const line of wrap(part, Math.max(4, width - 2)))
         lines.push({ text: `  ${line}`, fg: theme.foreground });
     }
+    if (m.reactions?.length) {
+      const summary = m.reactions.map((r) => `${r.emoji}${r.count > 1 ? ` ${r.count}` : ""}`).join("  ");
+      lines.push({ text: truncate(`  ${summary}`, width), fg: m.reactions.some((r) => r.mine) ? theme.accent : theme.muted });
+    }
     last = m;
   }
   return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/qryptchat",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "qc: qrypt.chat in your terminal. A full-screen end-to-end encrypted chat client (ML-KEM-1024), plus a scriptable CLI and an MCP server.",
   "type": "module",
   "bin": {