@heyamiko/amiko-cli 0.14.0-beta.17 → 0.14.0-beta.18

package/README.md

@@ -259,6 +259,7 @@ amiko chat send "Trip planning" "standup in 5 @all" --yes     # @all — notifie
 amiko chat send "Trip planning" "standup in 5" --all --yes    # same, via the explicit flag
 amiko chat send @sophie "look 👀" --image ./cat.png --yes         # attach a local image
 amiko chat send @sophie "made this 🎵" --audio <generated-url> --yes  # attach audio (e.g. from `amiko create`)
+amiko chat receipts <messageId>                  # who read your message + when (id from `chat read`)
 ```
 
 - **`<target>`** for `read`/`send` is a **conversation id** (from `chat list` — use this for groups), a **user id**, an **`@handle`**, or a **name**. Names resolve against your **friends first**, then people search; if ambiguous, the CLI lists candidates instead of guessing. A cuid that isn't one of your conversations is retried as a user id, so pasting a user id "just works".
@@ -266,6 +267,7 @@ amiko chat send @sophie "made this 🎵" --audio <generated-url> --yes  # attach
 - **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL) and `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note). One media block per message (image *or* audio). **Video isn't supported in chat yet.** A local file is uploaded; an Amiko URL (e.g. a generated asset from `amiko create`) attaches directly with no re-upload. (A local *audio* file is sent as a voice note, with your text as a separate message.)
 - **@all in groups**: `--all` prepends an @all mention, and a standalone `@all` word typed in the message converts too — either way **every member** is notified. Group **admins/owners** can always use it; everyone else only after an admin runs `amiko chat group mention-all <group> on`. Without permission, `--all` fails with the fix named, while a typed `@all` is delivered as plain text (with a note). Incoming mention markup renders as plain `@name`/`@all` in `chat read` and `chat list`.
 - `chat send` messages a real person, so it's **gated on `--yes`** in non-interactive shells. Delivery is real-time. `--raw` prints raw JSON on any subcommand.
+- **`chat receipts <messageId>`** shows read receipts for **your own** messages (server-enforced; 403 otherwise): sent time, who read it with each person's first-read time, and who it was delivered to but hasn't read. Reads from before receipts tracking show as "exact time unknown". Read-only, ungated.
 
 ### Group chats
 
@@ -588,6 +590,10 @@ npm publish
 
 ## Changelog
 
+### 0.14.0-beta.18
+
+- **Read receipts: `amiko chat receipts <messageId>`.** Shows when the message was sent, who has read it (per-person first-read time), and who it was delivered to but hasn't read yet. Sender-only, enforced server-side — works for messages sent as the owner (`chat send`); anything else 403s with a clear message. Reader names resolve from the conversation's participant list (short-id fallback). Read-only and ungated, like `chat reactions`; `--raw` prints the API payload. Rows read before receipts tracking existed render as "exact time unknown". Requires the companion amiko-web `feat/chat-read-receipts` deploy (`GET /api/messages/{id}/receipts`).
+
 ### 0.14.0-beta.17
 
 - **@all mentions in group chats + `amiko chat group mention-all <group> <on|off>`.** `chat send` gains `--all`, and a standalone literal `@all` word in the message converts too — both emit the canonical sentinel `@[all](all:all)` (kept in sync with amiko-web `src/utils/mentions.ts`), which amiko-chat expands into a mention notification for every group member. The CLI pre-checks permission client-side, mirroring the web gate plus the server-honored `owner` role (`admin`/`owner`, or the conversation's `allow_everyone_mention_all` flag; `left_at` participants excluded): a denied `--all` exits 1 naming the fix, before the approval gate and before any DM could be created, while a denied literal `@all` degrades to plain text with a note — the server treats an unauthorized token as inert either way. The new `chat group mention-all` toggle PATCHes `/api/conversations/{id}/mention-all-permission` (admin-gated server-side, 403 → admin tip) behind `confirmDestructive`, and the current setting shows in `chat group info` (`@all mentions: everyone | admins only`). Incoming mention markup (`@[Name](id:user|agent)` / `@[all](all:all)`) now renders as plain `@Name`/`@all` in `chat read`, `chat list`, and `chat group list` previews (new `src/lib/mentions.ts`). Requires the companion amiko-web `feat/group-mention-all` deploy.

package/dist/index.js

@@ -23665,8 +23665,8 @@ function readFromFile(path) {
 }
 function readRoutingIdsFromEnv() {
   return {
-    agentId: asString(process.env.AMIKO_AGENT_ID),
-    sessionId: asString(process.env.AMIKO_SESSION_ID)
+    agentId: asString(process.env.OPENHERMIT_AGENT_ID),
+    sessionId: asString(process.env.OPENHERMIT_SESSION_ID)
   };
 }
 function readFromEnv() {
@@ -28111,6 +28111,66 @@ function registerChatCommand(chat) {
       console.log(label(emoji3, `×${count}`) + you);
     }
   });
+  chat.command("receipts <messageId>").description("Show who read your message and when (sender-only). Get the message id from `amiko chat read`.").option("--raw", "Output raw JSON").action(async (messageId, opts) => {
+    const auth = authOrExit();
+    let msg;
+    try {
+      msg = await fetchMessage(auth, messageId);
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Could not load that message"));
+      process.exit(1);
+    }
+    let data;
+    try {
+      data = await amikoWebFetch(auth, `/api/messages/${encodeURIComponent(messageId)}/receipts`, { timeoutMs: 20000 });
+    } catch (e5) {
+      const status = e5.status;
+      console.error(error(status === 403 ? "Read receipts are only available for messages you sent (as the owner)." : e5 instanceof Error ? e5.message : "Failed to load receipts"));
+      process.exit(1);
+    }
+    const reads = data.reads ?? [];
+    const delivered = data.delivered_to ?? [];
+    if (opts.raw) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    const names = new Map;
+    if (msg.conversation_id) {
+      try {
+        const conv = await fetchConversationById(auth, msg.conversation_id);
+        for (const p of conv.participants ?? []) {
+          if (p.participant_type !== "user")
+            continue;
+          const id = normalizeUserId(p.participant_id);
+          names.set(id, p.user?.name ?? p.user?.handle ?? id.slice(0, 8));
+        }
+      } catch {}
+    }
+    const nameFor = (userId) => {
+      const id = normalizeUserId(userId);
+      return names.get(id) ?? id.slice(0, 8);
+    };
+    const fmt = (iso) => iso.slice(0, 19).replace("T", " ");
+    console.log(label("Message", previewText(msg)));
+    console.log(label("Sent", fmt(data.sent_at)));
+    console.log("");
+    console.log(heading(`Read by (${reads.length})`));
+    if (reads.length === 0) {
+      console.log(dim("  No one has read this yet."));
+    } else {
+      for (const r of reads) {
+        const when = r.approximate ? dim("read (exact time unknown)") : fmt(r.read_at);
+        console.log(`  ${label(nameFor(r.user_id), when)}`);
+      }
+    }
+    if (delivered.length > 0) {
+      console.log("");
+      console.log(heading(`Delivered to (${delivered.length})`));
+      for (const userId of delivered) {
+        console.log(`  ${nameFor(userId)}`);
+      }
+    }
+  });
   const group = chat.command("group").description("Group chats — create, list, info, rename, add/remove members, @all permission, leave");
   registerChatGroupCommand(group);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.14.0-beta.17",
+  "version": "0.14.0-beta.18",
   "description": "Amiko CLI — swap tokens, manage credits, bridge cross-chain, and call marketplace agents",
   "type": "module",
   "bin": {

package/skills/SKILL.md

@@ -34,6 +34,7 @@ Call your shell tool (your runtime calls it `bash`, `shell`, `run`, or similar)
 | "search memory for X" | shell → `amiko memory search "X"` |
 | "share the group's invite link" (asked by an admin) | shell → `amiko chat group info "<group>"` (confirm they're admin) → `amiko chat group invite "<group>"` |
 | "react to the latest message from Ava about the team with a heart" | shell → `amiko chat read "Ava"` (find that message, copy its `id`) → `amiko chat react <messageId> ❤️ --yes` |
+| "did Sophie read my message about the demo?" | shell → `amiko chat read "Sophie"` (find the owner's message, copy its `id`) → `amiko chat receipts <messageId>` |
 | "what can amiko do?" | shell → `amiko --help` |
 | "what's my MiniMax / ElevenLabs voice id?" | shell → `amiko info` |
 | "speak with my cloned MiniMax voice" | shell → `amiko info`, quote the cost, obtain explicit approval, then run `amiko create tts "…" --provider minimax --voice <minimax_voice_id> --yes` |
@@ -148,6 +149,7 @@ MiniMax Hailuo is silent — there is no CLI mux step to attach a separate music
 - **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL — e.g. a generated image) and `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note). One media block per message (image XOR audio). **Video is not supported** on chat yet. To share a generated asset, pass its URL from `amiko create status` (no re-upload). A local audio file is sent as a voice note with the text as a separate message.
 - Plain names resolve against the owner's **friends first**, then people search; if ambiguous the CLI errors listing the candidates — ask the owner which one, don't blind-send. A plain name that exactly matches one of the owner's group titles targets that **group**. If a send fails, surface the CLI's error verbatim — don't invent permission explanations or ask the owner to open the chat from the app.
 - **Reactions** — `amiko chat react <messageId> <emoji>`, `amiko chat unreact <messageId>`, `amiko chat reactions <messageId>`. The owner **won't give you a message id** — they'll say something like *"react to the latest Ava message about the team with a heart"*. Get ids from `amiko chat read <target>`: it prints each message's `id` and any existing reactions — match the message by its **content**, then act on that id. `react` adds (or replaces) your reaction — **one per message**, a new emoji replaces the previous one, and re-reacting the same emoji is a no-op (use `unreact` to remove). Pass the **actual emoji character** (`❤️`, `👍`, `😂`). `react`/`unreact` are outward (other people see them), so `--yes` is required in non-interactive shells and the confirmation shows a preview of the target message; `reactions` (read) is ungated. These act **as the owner** (人对人), just like `chat send` — not the twin's own `session_*`.
+- **Read receipts** — `amiko chat receipts <messageId>` shows when the message was sent, who has read it (with each person's first-read time), and who it was delivered to but hasn't read yet. **Only works for messages the owner sent** (server-enforced) — a 403 means it wasn't the owner's message; report that, don't retry. Get the id from `amiko chat read <target>`, matching the message by its **content**. Read-only and ungated, like `reactions`. Rows marked "exact time unknown" were read before receipts tracking existed — never invent a time for them.
 
 ### Group chats — `amiko chat group`