@commonlyai/cli 0.1.219 → 0.1.221

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.219",
+  "version": "0.1.221",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/inbox.js

@@ -188,22 +188,58 @@ export const runInboxAck = async (itemId, opts = {}, deps = {}) => {
   }
 };
 
+// `value` is either a 1-based option index (position in the decision's options,
+// shown on refusal) or an option label. The server stores whatever string it is sent, so
+// the label is resolved here against the open queue and only the label is posted:
+// a bare "2" recorded in the ruling would mean nothing to anyone reading it later.
+export const resolveDecisionChoice = (options, value) => {
+  const choices = (Array.isArray(options) ? options : [])
+    .map((option) => String(option?.label ?? '').trim())
+    .filter(Boolean);
+  const listing = choices.map((label, i) => `  ${i + 1}. ${label}`).join('\n');
+  const raw = String(value).trim();
+  if (/^\d+$/.test(raw)) {
+    const index = Number(raw);
+    const labelled = choices.findIndex((label) => label === raw);
+    // A digit-only label is also a position in the list. When the two point at
+    // different options, neither reading is safe to guess, so refuse.
+    if (labelled !== -1 && labelled !== index - 1) {
+      throw new InboxRefusal(`"${raw}" is both option ${labelled + 1}'s label and position ${raw}; refusing to guess. Choose by position (1-${choices.length}) or by a label that is not a number:\n${listing}`);
+    }
+    if (index < 1 || index > choices.length) {
+      throw new InboxRefusal(`option ${raw} is out of range; choose 1-${choices.length}:\n${listing}`);
+    }
+    return choices[index - 1];
+  }
+  const match = choices.find((label) => label.toLocaleLowerCase() === raw.toLocaleLowerCase());
+  if (!match) throw new InboxRefusal(`"${raw}" is not an option; the options are:\n${listing}`);
+  return match;
+};
+
 export const runInboxChoose = async (decisionId, value, opts = {}, deps = {}) => {
   const {
     env = process.env, fetchImpl = fetch, log = console.log, error = console.error, sleep = undefined,
   } = deps;
   try {
-    if (!decisionId) throw new InboxRefusal('a decision id is required: commonly inbox choose <decisionId> <value>');
-    if (value === undefined) throw new InboxRefusal('a value is required: commonly inbox choose <decisionId> <value>');
+    if (!decisionId) throw new InboxRefusal('a decision id is required: commonly inbox choose <decisionId> <n|label>');
+    if (value === undefined) throw new InboxRefusal('a value is required: commonly inbox choose <decisionId> <n|label>');
     const {
       baseUrl, request, account,
     } = await connect(opts, { env, fetchImpl, sleep });
     log(formatAccountLine({ account, baseUrl }));
+    // The options live on the open queue, not on the decision route, so the
+    // choice is resolved against the same queue this account would see in `list`.
+    const { items } = await fetchQueue(request);
+    const open = items.find((item) => String(item?.id) === String(decisionId) && item?.kind === 'decision');
+    if (!open) {
+      throw new InboxRefusal(`decision ${decisionId} is not open on this account's queue; nothing to choose`);
+    }
+    const label = resolveDecisionChoice(open.options, value);
     const result = await request(`/api/activity/decisions/${encodeURIComponent(decisionId)}/choose`, {
       method: 'POST',
-      body: { value },
+      body: { value: label },
     });
-    log(`chose ${decisionId} = ${value}`);
+    log(`chose ${decisionId} = ${label}`);
     log(`-> ${JSON.stringify(result)}`);
     return 0;
   } catch (err) {
@@ -237,7 +273,8 @@ Examples:
   $ commonly inbox list --cursor-file ~/.commonly/inbox/connector-ops.cursor   # only what is new
   $ commonly inbox list --cursor-file ~/.commonly/inbox/c.cursor --window 300  # widen the re-read to 5m
   $ commonly inbox ack <attentionItemId>
-  $ commonly inbox choose <decisionId> 2
+  $ commonly inbox choose <decisionId> 2          # second option of the card, by position
+  $ commonly inbox choose <decisionId> "Ship it"  # or by its label
 
 Cost: with no cursor, \`list\` reads the WHOLE queue, one request per 50 items —
 550 open items is 11 requests. /api/activity is limited to 60 a minute **keyed on
@@ -285,7 +322,7 @@ their attention as runtime events, not from this queue.
 
   inbox
     .command('choose <decisionId> <value>')
-    .description('Rule a decision card (the source= id from `list`)')
+    .description('Rule a decision card (the source= id from `list`). <value> is an option number (1-based) or its label')
     .option('--token-file <path>', INBOX_TOKEN_HELP)
     .option('--instance <url>', 'Target Commonly instance')
     .action(async (decisionId, value, opts) => { process.exit(await runInboxChoose(decisionId, value, opts)); });

package/src/commands/pod.js

@@ -8,6 +8,7 @@
 
 import { createClient } from '../lib/api.js';
 import { getToken, resolveInstanceUrl } from '../lib/config.js';
+import { createTailPoller } from '../lib/pod-tail.js';
 
 export const registerPod = (program) => {
   const pod = program.command('pod').description('Manage pods');
@@ -96,28 +97,16 @@ Commonly instance (see: commonly login --help).
 
       const client = createClient({ instance: resolveInstanceUrl(opts.instance), token });
 
-      let lastId = null;
       console.log(`Watching pod ${podId}... (Ctrl+C to stop)\n`);
 
+      const pollNew = createTailPoller({
+        fetchPage: (limit) => client.get(`/api/messages/${podId}`, { limit }),
+        filter: opts.filter,
+        print: (line) => console.log(line),
+      });
       const poll = async () => {
         try {
-          const data = await client.get(`/api/messages/${podId}`, {
-            limit: 20,
-            after: lastId,
-          });
-          const messages = Array.isArray(data) ? data : data.messages || [];
-
-          messages.forEach((m) => {
-            const isBot = m.isBot || m.sender?.isBot;
-            if (opts.filter === 'agents' && !isBot) return;
-            if (opts.filter === 'humans' && isBot) return;
-
-            const ts = new Date(m.createdAt || m.timestamp).toTimeString().slice(0, 8);
-            const who = m.username || m.sender?.username || '?';
-            const marker = isBot ? '🤖' : '👤';
-            console.log(`[${ts}] ${marker} ${who}: ${m.content}`);
-            lastId = m._id || m.id;
-          });
+          await pollNew();
         } catch (err) {
           console.error(`[poll error] ${err.message}`);
         }

package/src/lib/pod-tail.js

@@ -0,0 +1,68 @@
+/**
+ * Live pod tail for `commonly pod tail`.
+ *
+ * GET /api/messages/:podId takes `before` and `limit` only; it ignores `after`
+ * and returns the newest `limit` rows. Polling it with a cursor therefore
+ * re-serves the same window every tick. The poller keeps the ids it has
+ * already printed and prints only the rest, in the order the page returns
+ * them (oldest first).
+ */
+
+// Ids kept for de-duplication. Old entries fall out first, so a long tail
+// stays bounded in memory.
+export const TAIL_SEEN_MAX = 1000;
+export const TAIL_PAGE_LIMIT = 100;
+
+// Same bot field the v2 chat reads (frontend/src/v2/utils/threadView.ts
+// participantOf): `user.isBot`, falling back to the mapped `userId.isBot`.
+export const isAgentMessage = (m) => {
+  if (typeof m?.user?.isBot === 'boolean') return m.user.isBot;
+  return m?.userId?.isBot === true;
+};
+
+const authorName = (m) => m?.user?.username || m?.userId?.username || m?.username || '?';
+
+const clock = (m) => {
+  const raw = m?.createdAt || m?.timestamp;
+  const date = raw ? new Date(raw) : null;
+  return date && !Number.isNaN(date.getTime()) ? date.toTimeString().slice(0, 8) : '--:--:--';
+};
+
+export const formatTailLine = (m) => {
+  const marker = isAgentMessage(m) ? '🤖' : '👤';
+  return `[${clock(m)}] ${marker} ${authorName(m)}: ${m?.content ?? ''}`;
+};
+
+/**
+ * @param {object} opts
+ * @param {(limit: number) => Promise<object[] | {messages: object[]}>} opts.fetchPage
+ * @param {'all'|'agents'|'humans'} [opts.filter='all']
+ * @param {(line: string) => void} opts.print
+ */
+export const createTailPoller = ({ fetchPage, filter = 'all', print }) => {
+  const seen = new Set();
+  const remember = (id) => {
+    seen.add(id);
+    if (seen.size > TAIL_SEEN_MAX) seen.delete(seen.values().next().value);
+  };
+
+  return async () => {
+    const data = await fetchPage(TAIL_PAGE_LIMIT);
+    const messages = Array.isArray(data) ? data : data?.messages || [];
+    let printed = 0;
+
+    messages.forEach((m) => {
+      const id = String(m?._id || m?.id || '');
+      if (id) {
+        if (seen.has(id)) return;
+        remember(id);
+      }
+      if (filter === 'agents' && !isAgentMessage(m)) return;
+      if (filter === 'humans' && isAgentMessage(m)) return;
+      print(formatTailLine(m));
+      printed += 1;
+    });
+
+    return printed;
+  };
+};