@profullstack/qryptchat 0.1.0

package/dist/chunk-fb6zrz6m.js

@@ -0,0 +1,40 @@
+// src/cli/config.js
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_URL = "https://qrypt.chat";
+function configDir(env = process.env) {
+  if (env.QC_HOME)
+    return env.QC_HOME;
+  return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "qc");
+}
+var sessionPath = (env = process.env) => join(configDir(env), "session.json");
+function baseUrl(session, env = process.env) {
+  return (env.QC_URL || session?.base || DEFAULT_URL).replace(/\/+$/, "");
+}
+function loadSession(env = process.env) {
+  try {
+    const session = JSON.parse(readFileSync(sessionPath(env), "utf8"));
+    return session && session.access_token && session.keys ? session : null;
+  } catch {
+    return null;
+  }
+}
+function saveSession(session, env = process.env) {
+  const dir = configDir(env);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {}
+  const file = sessionPath(env);
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(session, null, 2), { mode: 384 });
+  renameSync(tmp, file);
+}
+function clearSession(env = process.env) {
+  const file = sessionPath(env);
+  if (existsSync(file))
+    rmSync(file);
+}
+
+export { configDir, sessionPath, baseUrl, loadSession, saveSession, clearSession };

package/dist/commands.js

@@ -0,0 +1,12 @@
+import {
+  HELP2,
+  parseArgs2,
+  findChat2,
+  main2
+} from "./chunk-9kkxje88.js";
+export {
+  HELP2 as HELP,
+  findChat2 as findChat,
+  main2 as main,
+  parseArgs2 as parseArgs
+};

package/dist/mcp.js

@@ -0,0 +1,118 @@
+import {
+  findChat2
+} from "./chunk-9kkxje88.js";
+
+// src/cli/mcp.js
+import { createInterface } from "node:readline";
+var TOOLS = [
+  {
+    name: "list_chats",
+    description: "List your qrypt.chat conversations (id, title, participant count), most recent first.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "read_chat",
+    description: "Read the latest decrypted messages of a conversation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chat: { type: "string", description: "Conversation id or part of its name" },
+        limit: { type: "number", description: "How many of the latest messages (default 20, max 100)" }
+      },
+      required: ["chat"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "send_message",
+    description: "Send an end-to-end encrypted message (ML-KEM-1024) to a conversation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chat: { type: "string", description: "Conversation id or part of its name" },
+        text: { type: "string", description: "The message" }
+      },
+      required: ["chat", "text"],
+      additionalProperties: false
+    }
+  }
+];
+async function callTool(client, name, args = {}) {
+  if (name === "list_chats") {
+    const chats = await client.conversations();
+    return chats.map((c) => ({ id: c.id, title: c.title, participants: c.participants?.length ?? 0, updated_at: c.updated_at }));
+  }
+  if (name === "read_chat") {
+    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 })) };
+  }
+  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);
+    return { sent: true, id: message?.id, chat: chat.title, skipped };
+  }
+  throw new Error(`Unknown tool ${name}`);
+}
+async function handle(client, msg, { version }) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case "initialize":
+      return {
+        protocolVersion: params?.protocolVersion ?? "2025-06-18",
+        capabilities: { tools: {} },
+        serverInfo: { name: "qc", title: "qrypt.chat", version }
+      };
+    case "ping":
+      return {};
+    case "tools/list":
+      return { tools: TOOLS };
+    case "tools/call":
+      try {
+        const result = await callTool(client, params?.name, params?.arguments);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], structuredContent: result };
+      } catch (err) {
+        return { content: [{ type: "text", text: err.message }], isError: true };
+      }
+    default:
+      if (id === undefined)
+        return;
+      throw Object.assign(new Error(`Method not found: ${method}`), { code: -32601 });
+  }
+}
+function serveMcp(client, { version = "0.0.0", input = process.stdin, output = process.stdout } = {}) {
+  for (const m of ["log", "info", "debug"])
+    console[m] = (...a) => process.stderr.write(`${a.join(" ")}
+`);
+  const write = (obj) => output.write(`${JSON.stringify(obj)}
+`);
+  const rl = createInterface({ input });
+  rl.on("line", async (line) => {
+    if (!line.trim())
+      return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+    try {
+      const result = await handle(client, msg, { version });
+      if (msg.id !== undefined && result !== undefined)
+        write({ jsonrpc: "2.0", id: msg.id, result });
+    } catch (err) {
+      if (msg.id !== undefined)
+        write({ jsonrpc: "2.0", id: msg.id, error: { code: err.code ?? -32603, message: err.message } });
+    }
+  });
+  return new Promise((resolve) => rl.on("close", resolve));
+}
+export {
+  callTool,
+  handle,
+  serveMcp
+};

package/dist/tui.js

@@ -0,0 +1,426 @@
+import {
+  configDir
+} from "./chunk-fb6zrz6m.js";
+
+// src/cli/tui.js
+import { createApp, editText, emojify, insertText, stringWidth, truncate, widgets, wrap } from "@profullstack/hqtui";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var SIDEBAR = 30;
+function initialState(me) {
+  return {
+    me,
+    conversations: [],
+    selected: 0,
+    activeId: null,
+    messages: {},
+    unread: {},
+    typing: {},
+    focus: "compose",
+    field: { value: "", cursor: 0 },
+    picker: null,
+    recent: [],
+    scrollBack: 0,
+    status: "connecting",
+    notice: "",
+    loading: true
+  };
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+var timeOf = (iso) => {
+  const d = new Date(iso);
+  return `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+};
+var dayOf = (iso) => new Date(iso).toLocaleDateString(undefined, { weekday: "short", day: "numeric", month: "short" });
+function nameColor(theme, key) {
+  const palette = [theme.accent, theme.info, theme.success, theme.warning, theme.secondary, theme.primary];
+  let h = 0;
+  for (const ch of key)
+    h = h * 31 + ch.codePointAt(0) >>> 0;
+  return palette[h % palette.length];
+}
+function transcriptLines(messages, width, theme) {
+  const lines = [];
+  let day = "";
+  let last = null;
+  for (const m of messages) {
+    const d = dayOf(m.at);
+    if (d !== day) {
+      day = d;
+      const label = ` ${d} `;
+      const side = Math.max(2, Math.floor((width - stringWidth(label)) / 2));
+      lines.push({ text: `${"─".repeat(side)}${label}${"─".repeat(Math.max(0, width - side - stringWidth(label)))}`, fg: theme.border });
+      last = null;
+    }
+    const sameRun = last && last.senderId === m.senderId && new Date(m.at) - new Date(last.at) < 5 * 60 * 1000;
+    if (!sameRun) {
+      lines.push({
+        spans: [
+          { text: m.mine ? "you" : m.sender, fg: m.mine ? theme.primary : nameColor(theme, m.senderId || m.sender), bold: true },
+          { text: `  ${timeOf(m.at)}`, 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 });
+    }
+    last = m;
+  }
+  return lines;
+}
+function drawTranscript(surface, state) {
+  const theme = surface.theme;
+  const messages = state.messages[state.activeId] || [];
+  if (!state.activeId) {
+    surface.text(1, 1, state.loading ? "Loading your chats…" : "Pick a chat on the left.", { fg: theme.muted });
+    return;
+  }
+  if (!messages.length) {
+    surface.text(1, 1, "No messages yet. Say hello \uD83D\uDC4B", { fg: theme.muted });
+    return;
+  }
+  const lines = transcriptLines(messages, surface.width, theme);
+  const start = Math.max(0, lines.length - surface.height - state.scrollBack);
+  const top = Math.max(0, surface.height - (lines.length - start));
+  for (let y = top;y < surface.height; y++) {
+    const line = lines[start + y - top];
+    if (!line)
+      break;
+    if (line.spans) {
+      let x = 0;
+      for (const span of line.spans)
+        x += surface.text(x, y, span.text, { fg: span.fg, attrs: span.bold ? 1 : 0 });
+    } else {
+      surface.text(0, y, truncate(line.text, surface.width), { fg: line.fg });
+    }
+  }
+  if (state.scrollBack > 0) {
+    const hint = ` ↓ ${state.scrollBack} more `;
+    surface.text(Math.max(0, surface.width - stringWidth(hint)), surface.height - 1, hint, { fg: theme.background, bg: theme.accent });
+  }
+}
+function render({ ui, width, height, theme }, state, on = {}) {
+  const active = state.conversations.find((c) => c.id === state.activeId);
+  const typingNames = Object.values(state.typing[state.activeId] || {}).map((t) => t.name);
+  ui.row({ size: 1 }, (bar) => {
+    bar.draw((s) => {
+      const t = s.theme;
+      s.fillRect(0, 0, s.width, 1, { bg: t.surface ?? t.background });
+      let x = s.text(0, 0, " \uD83D\uDD12 qrypt.chat ", { fg: t.background, bg: t.primary, attrs: 1 });
+      x += s.text(x, 0, `  @${state.me?.username ?? "?"}`, { fg: t.foreground, bg: t.surface ?? t.background });
+      if (state.notice)
+        s.text(x + 2, 0, truncate(state.notice, Math.max(0, s.width - x - 16)), { fg: t.warning, bg: t.surface ?? t.background });
+      const live = { live: ["●", "live", t.success], connecting: ["◌", "connecting", t.warning], offline: ["○", "offline", t.danger] }[state.status] ?? ["○", state.status, t.muted];
+      const label = `${live[0]} ${live[1]} `;
+      s.text(s.width - stringWidth(label), 0, label, { fg: live[2], bg: t.surface ?? t.background });
+    });
+  });
+  ui.row({ size: "fill" }, (row) => {
+    const listWidth = Math.min(SIDEBAR, Math.max(18, Math.floor(width * 0.3)));
+    row.panel({ title: "Chats", size: listWidth, borderColor: state.focus === "list" ? theme?.borderFocused : undefined }, (p) => {
+      const inner = Math.max(4, listWidth - 5);
+      p.list({
+        items: state.conversations.map((c) => {
+          const unread = state.unread[c.id] || 0;
+          const tag = unread ? ` ●${unread > 99 ? "99+" : unread}` : "";
+          const name = truncate(c.title, inner - stringWidth(tag));
+          return {
+            label: `${name}${" ".repeat(Math.max(0, inner - stringWidth(name) - stringWidth(tag)))}${tag}`,
+            color: unread ? theme?.accent : undefined
+          };
+        }),
+        selected: state.selected,
+        followSelection: true,
+        scrollbar: true,
+        onSelectRow: (i) => on.open?.(i),
+        onActivateRow: (i) => on.open?.(i)
+      });
+    });
+    const people = active?.participants?.length ?? 0;
+    row.panel({
+      title: active?.title ?? "qc",
+      subtitle: active ? `${people} ${people === 1 ? "person" : "people"} · ML-KEM-1024` : "end-to-end encrypted",
+      borderColor: state.focus === "compose" ? theme?.borderFocused : undefined
+    }, (p) => {
+      p.draw((s) => {
+        drawTranscript(s, state);
+        p.ctx.hit({ rect: s.hitRect(), onScroll: (delta) => on.scroll?.(-delta) });
+      }, { size: "fill" });
+      p.label(typingNames.length ? `${typingNames.join(", ")} ${typingNames.length === 1 ? "is" : "are"} typing…` : " ", { size: 1 });
+      p.textInput({
+        value: state.field.value,
+        cursor: state.field.cursor,
+        placeholder: active ? `Message ${active.title}  (Ctrl+E emoji, :rocket: works too)` : "Pick a chat first",
+        focused: state.focus === "compose" && !state.picker,
+        size: 1
+      });
+    });
+  });
+  ui.statusBar({
+    items: [
+      { key: "Enter", label: state.focus === "list" ? "open" : "send" },
+      { key: "Ctrl+E", label: "emoji" },
+      { key: "Tab", label: state.focus === "list" ? "compose" : "chats" },
+      { key: "PgUp", label: "scroll" },
+      { key: "Ctrl+C", label: "quit" }
+    ],
+    size: 1
+  });
+  if (state.picker) {
+    const size = widgets.emojiPickerSize(10, 7);
+    ui.emojiPicker({
+      state: state.picker,
+      recent: state.recent,
+      x: Math.min(Math.max(0, width - size.width - 1), Math.min(SIDEBAR, Math.floor(width * 0.3)) + 1),
+      y: Math.max(0, height - size.height - 3),
+      onChange: (s) => on.pickerChange?.(s),
+      onPick: (e) => on.pick?.(e),
+      onClose: () => on.pickerClose?.()
+    });
+  }
+}
+var recentFile = () => join(configDir(), "recent-emoji.json");
+function loadRecent() {
+  try {
+    const list = JSON.parse(readFileSync(recentFile(), "utf8"));
+    return Array.isArray(list) ? list.filter((c) => typeof c === "string").slice(0, 30) : [];
+  } catch {
+    return [];
+  }
+}
+function saveRecent(list) {
+  try {
+    writeFileSync(recentFile(), JSON.stringify(list), { mode: 384 });
+  } catch {}
+}
+async function runTui(client, { initialChat } = {}) {
+  const state = initialState(client.me);
+  state.recent = loadRecent();
+  const abort = new AbortController;
+  const app = await createApp({ quitKeys: ["ctrl+c"], focusNavigation: false });
+  const redraw = () => app.invalidate();
+  const note = (msg) => {
+    state.notice = msg;
+    redraw();
+    if (msg)
+      setTimeout(() => {
+        if (state.notice === msg) {
+          state.notice = "";
+          redraw();
+        }
+      }, 6000);
+  };
+  for (const m of ["log", "info", "warn", "error", "debug"])
+    console[m] = () => {};
+  async function loadMessages(id) {
+    try {
+      const { messages } = await client.messages(id, { limit: 100 });
+      state.messages[id] = messages;
+      redraw();
+    } catch (err) {
+      note(`Could not load messages: ${err.message}`);
+    }
+  }
+  async function loadConversations() {
+    try {
+      const before = state.activeId;
+      state.conversations = await client.conversations();
+      state.loading = false;
+      if (!state.activeId && state.conversations.length) {
+        const want = initialChat ? state.conversations.findIndex((c) => c.id === initialChat || c.title.toLowerCase().includes(String(initialChat).toLowerCase())) : 0;
+        openAt(Math.max(0, want));
+      } else {
+        state.selected = Math.max(0, state.conversations.findIndex((c) => c.id === before));
+      }
+      redraw();
+      for (const c of state.conversations.slice(0, 40)) {
+        if (c.id !== state.activeId && !state.messages[c.id])
+          await loadMessages(c.id);
+      }
+    } catch (err) {
+      state.loading = false;
+      note(err.status === 401 ? "Session ended: run qc login" : `Could not load chats: ${err.message}`);
+    }
+  }
+  function openAt(i) {
+    const c = state.conversations[i];
+    if (!c)
+      return;
+    state.selected = i;
+    state.activeId = c.id;
+    state.unread[c.id] = 0;
+    state.scrollBack = 0;
+    if (!state.messages[c.id])
+      loadMessages(c.id);
+    redraw();
+  }
+  let typingSent = 0;
+  function typed() {
+    if (!state.activeId)
+      return;
+    const now = Date.now();
+    if (now - typingSent > 3000) {
+      typingSent = now;
+      client.typing(state.activeId, true);
+    }
+  }
+  async function send() {
+    const text = emojify(state.field.value.trim(), { mode: "emoji" });
+    if (!text || !state.activeId)
+      return;
+    const id = state.activeId;
+    state.field = { value: "", cursor: 0 };
+    state.scrollBack = 0;
+    const pending = { id: `pending-${Date.now()}`, senderId: client.me?.id, sender: "you", mine: true, text, at: new Date().toISOString() };
+    state.messages[id] = [...state.messages[id] || [], pending];
+    redraw();
+    try {
+      const { skipped } = await client.send(id, text);
+      if (skipped)
+        note(`${skipped} participant(s) have no key yet and will not see this`);
+      client.typing(id, false);
+      typingSent = 0;
+      await loadMessages(id);
+    } catch (err) {
+      state.messages[id] = (state.messages[id] || []).filter((m) => m !== pending);
+      state.field = { value: text, cursor: text.length };
+      note(`Not sent: ${err.message}`);
+    }
+  }
+  const handlers = {
+    select: (i) => {
+      state.selected = i;
+      redraw();
+    },
+    open: (i) => {
+      openAt(i);
+      state.focus = "compose";
+    },
+    scroll: (delta) => {
+      state.scrollBack = Math.max(0, state.scrollBack + delta * 3);
+      redraw();
+    },
+    pickerChange: (s) => {
+      state.picker = s;
+      redraw();
+    },
+    pick: (e) => {
+      state.field = insertText(state.field, e.char);
+      state.recent = [e.char, ...state.recent.filter((c) => c !== e.char)].slice(0, 30);
+      saveRecent(state.recent);
+      state.picker = null;
+      typed();
+      redraw();
+    },
+    pickerClose: () => {
+      state.picker = null;
+      redraw();
+    }
+  };
+  app.on("key", (event) => {
+    if (state.picker)
+      return;
+    if (event.key === "ctrl+e") {
+      state.picker = widgets.createEmojiPicker(state.recent);
+    } else if (event.key === "tab" || event.key === "shift+tab" || event.key === "escape" && state.focus === "compose") {
+      state.focus = state.focus === "list" ? "compose" : "list";
+    } else if (event.key === "pageup") {
+      handlers.scroll(4);
+    } else if (event.key === "pagedown") {
+      handlers.scroll(-4);
+    } else if (event.key === "ctrl+n" || event.key === "alt+down") {
+      openAt(Math.min(state.conversations.length - 1, state.selected + 1));
+    } else if (event.key === "ctrl+p" || event.key === "alt+up") {
+      openAt(Math.max(0, state.selected - 1));
+    } else if (event.key === "ctrl+r") {
+      loadConversations();
+      if (state.activeId)
+        loadMessages(state.activeId);
+    } else if (state.focus === "list") {
+      if (event.key === "up" || event.key === "k")
+        state.selected = Math.max(0, state.selected - 1);
+      else if (event.key === "down" || event.key === "j")
+        state.selected = Math.min(state.conversations.length - 1, state.selected + 1);
+      else if (event.key === "enter" || event.key === "right" || event.key === "l")
+        handlers.open(state.selected);
+    } else if (event.key === "enter") {
+      send();
+    } else if (event.key === "up" && !state.field.value) {
+      handlers.scroll(1);
+    } else if (event.key === "down" && !state.field.value) {
+      handlers.scroll(-1);
+    } else {
+      const next = editText(state.field, event);
+      if (next) {
+        if (next.value !== state.field.value)
+          typed();
+        state.field = next;
+      }
+    }
+    redraw();
+  });
+  app.on("paste", (event) => {
+    if (state.picker || state.focus !== "compose")
+      return;
+    state.field = insertText(state.field, event.text);
+    redraw();
+  });
+  app.on("exit", () => abort.abort());
+  app.render((args) => render(args, state, handlers));
+  loadConversations();
+  client.events(({ type, data }) => {
+    if (type === "NEW_MESSAGE") {
+      const id = data?.message?.conversation_id;
+      if (!id)
+        return;
+      if (id === state.activeId)
+        loadMessages(id);
+      else {
+        if (data.message.sender_id !== client.me?.id)
+          state.unread[id] = (state.unread[id] || 0) + 1;
+        delete state.messages[id];
+      }
+      const i = state.conversations.findIndex((c) => c.id === id);
+      if (i > 0) {
+        const [c] = state.conversations.splice(i, 1);
+        state.conversations.unshift(c);
+        state.selected = state.conversations.findIndex((x) => x.id === state.activeId);
+      }
+      if (i === -1)
+        loadConversations();
+      if (data.message.sender_id !== client.me?.id)
+        delete (state.typing[id] || {})[data.message.sender_id];
+    } else if (type === "USER_TYPING" && data?.conversationId) {
+      const room = state.typing[data.conversationId] ||= {};
+      if (data.isTyping) {
+        room[data.userId] = { name: data.displayName || data.username || "someone", until: Date.now() + 6000 };
+        setTimeout(() => {
+          if (room[data.userId]?.until <= Date.now()) {
+            delete room[data.userId];
+            redraw();
+          }
+        }, 6100);
+      } else
+        delete room[data.userId];
+    } else if (type === "CONVERSATION_CREATED") {
+      loadConversations();
+    }
+    redraw();
+  }, {
+    signal: abort.signal,
+    onStatus: (s) => {
+      state.status = s;
+      redraw();
+    }
+  }).catch((err) => note(err.message));
+  await app.start();
+  abort.abort();
+}
+export {
+  initialState,
+  render,
+  runTui,
+  transcriptLines
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@profullstack/qryptchat",
+  "version": "0.1.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": {
+    "qc": "./bin/qc.js",
+    "qryptchat": "./bin/qc.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@noble/ciphers": "^2.0.0",
+    "@profullstack/hqtui": "^0.8.0",
+    "mlkem": "^2.5.0"
+  },
+  "keywords": [
+    "qrypt.chat",
+    "chat",
+    "e2ee",
+    "ml-kem",
+    "post-quantum",
+    "tui",
+    "cli",
+    "mcp"
+  ],
+  "homepage": "https://qrypt.chat",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/profullstack/qryptchat-web.git",
+    "directory": "packages/qryptchat"
+  },
+  "license": "MIT",
+  "author": "Profullstack, Inc."
+}