@songsid/agend 2.3.5-alpha.4 → 2.3.5-alpha.5

package/dist/ui/hub-button-actions.js

@@ -0,0 +1,65 @@
+/** Hub F's four chat-store hooks. Shared thread markup stays unchanged; the server owns authorization and votes. */
+const SET_ID = /^[a-f0-9]{32}$/;
+const ownStorage = () => { try { return globalThis.sessionStorage || null; } catch { return null; } };
+const indexes = v => Array.isArray(v) && v.length <= 10 && v.every(i => Number.isInteger(i) && i >= 0 && i < 10) && new Set(v).size === v.length;
+
+export function createHubButtonActions(room, { client, entries, refresh, changed = () => {}, storage = ownStorage(), newKey = () => crypto.randomUUID() }) {
+  const roomId = String(room.id), prefix = `agend-hub-buttons:${roomId}:`;
+  const busy = new Set(), votes = new Map(), pending = new Map();
+  let stopped = false;
+  const notify = () => { if (!stopped) { try { changed(); } catch { /* a subscriber does not alter a committed action */ } } };
+  const read = key => { try { return JSON.parse(storage?.getItem(prefix + key) || "null"); } catch { return null; } };
+  const write = (key, value) => { try { if (value === null) storage?.removeItem(prefix + key); else storage?.setItem(prefix + key, JSON.stringify(value)); } catch { /* memory still works when storage is disabled */ } };
+  const mine = id => {
+    if (!votes.has(id)) { const saved = read(`mine:${id}`); votes.set(id, indexes(saved) ? [...saved].sort((a, b) => a - b) : []); }
+    return [...votes.get(id)];
+  };
+  const view = id => (entries() || []).find(e => e.buttons?.id === id)?.buttons;
+  const intent = body => JSON.stringify([body.setId, body.index ?? null, body.options ?? null]);
+  async function post(setId, fields) {
+    if (stopped) return { ok: false, code: "stopped" };
+    if (!room.features?.includes("buttons-v1") || typeof client.chooseButtons !== "function") return { ok: false, code: "unsupported" };
+    if (!SET_ID.test(setId)) return { ok: false, code: "invalid" };
+    const b = view(setId);
+    if (!b || b.state !== "open") return { ok: false, code: "expired" };
+    if (busy.has(setId)) return { ok: false, code: "busy" };
+    const desired = { setId, ...fields };
+    let prior = pending.get(setId) || read(`pending:${setId}`);
+    if (prior && (prior.setId !== setId || typeof prior.idempotencyKey !== "string" || intent(prior) !== intent(desired))) return { ok: false, code: "uncertain" };
+    const body = prior || { ...desired, idempotencyKey: newKey() };
+    pending.set(setId, body); write(`pending:${setId}`, body);
+    busy.add(setId); notify();
+    try {
+      let result;
+      try { result = await client.chooseButtons(roomId, body); } catch { result = { ok: false, status: 0, code: "unreachable" }; }
+      if (stopped) return { ok: false, code: "stopped" };
+      if (result.ok) {
+        pending.delete(setId); write(`pending:${setId}`, null);
+        if (Array.isArray(body.options)) { votes.set(setId, [...body.options]); write(`mine:${setId}`, body.options); }
+        await refresh();
+      } else if (result.status >= 400 && result.status < 500) {
+        // A definitive refusal may be retried as a new intent. Unknown outcomes retain the SAME key and payload.
+        pending.delete(setId); write(`pending:${setId}`, null);
+      }
+      return result;
+    } finally { busy.delete(setId); notify(); }
+  }
+  function vote(setId, options) {
+    const b = view(setId);
+    if (!b?.poll || !indexes(options) || options.some(i => i >= b.labels.length) || !b.poll.multi && options.length !== 1) return Promise.resolve({ ok: false, code: "invalid" });
+    return post(setId, { options: [...options].sort((a, b) => a - b) });
+  }
+  return {
+    clickButton(setId, index) {
+      const b = view(setId);
+      if (!b || !Number.isInteger(index) || index < 0 || index >= b.labels.length) return Promise.resolve({ ok: false, code: "invalid" });
+      if (!b.poll) return post(setId, { index });
+      const before = mine(setId), next = b.poll.multi ? (before.includes(index) ? before.filter(i => i !== index) : [...before, index]) : [index];
+      return vote(setId, next);
+    },
+    vote,
+    busy: setId => busy.has(setId),
+    mine,
+    stop() { stopped = true; busy.clear(); },
+  };
+}

package/dist/ui/hub-chat-store.js

@@ -0,0 +1,158 @@
+// #3226 B: one Hub room's chat as the shared thread (/assets/chat-thread.js) draws it — the room's entries read over the
+// Hub's API (hub-client.js), turned into the fleet thread's messages (hubEntryToMessages, the one mapping D, E and F
+// extend), polled while the room is shown, and the asker's own questions sent.
+//
+// Polling: at most once per POLL_MS (the server paces each session's room at the same rate and answers a faster read
+// with backpressure), one request at a time, paused while the page is hidden. Unanswered entries are read again (from
+// just before the oldest open one); answered history is kept. The messages answer carries the room itself (its state,
+// its grant's end, what its link negotiated: `room.features`), fresh each poll.
+import { hubClient } from "./hub-client.js";
+import { createHubButtonActions } from "./hub-button-actions.js";
+
+export const POLL_MS = 10_000;
+/** The server's page: at most this many entries per read, the oldest first (rooms.read LIMIT 100). */
+export const PAGE = 100;
+/** How often (every n-th read) an open entry older than the tail page is read from its own place (each in turn). */
+export const FAR_EVERY = 6;
+/** Settled for paging: nothing about them changes on a later read ("uncertain" stays so: it is held, never resolved here). */
+const SETTLED = new Set(["answered", "rejected", "cancelled", "failed", "uncertain"]);
+const iso = (ms) => (Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : undefined);
+
+/** A question's stage as the thread's delivery mark: waiting (◷), at the fleet (✓), answered (✓✓), refused (!). */
+export function stageMark(stage) {
+  return stage === "queued" ? "queued" : stage === "delivered" || stage === "consumed" ? "processing" : stage === "answered" ? "delivered"
+    : stage === "uncertain" ? "cancelled" : "failed";
+}
+
+/**
+ * One entry of GET /hub/v1/rooms/:id/messages → the thread's messages: the question (the asker's own, "user"), then the
+ * answer (the agent's, under the exposure's name) or, for a question that was not answered, a status line saying why.
+ * `question`/`answer` are plain strings (an older tab prints them as text); the files, buttons and quote D, E and F add
+ * sit beside them (#3226 seams).
+ */
+export function hubEntryToMessages(entry, room, { me = "", reason = (code) => code || "" } = {}) {
+  if (!entry || !Number.isSafeInteger(entry.sequence)) return [];
+  const stage = entry.receipt ? entry.receipt.stage : "queued", at = entry.receipt ? entry.receipt.at : undefined;
+  const id = entry.sequence * 2, out = [];
+  const files = (list) => (Array.isArray(list) && list.length ? { attachments: list } : {});
+  out.push({ boot: "hub", id, role: "user", sender: me, ts: iso(entry.askedAt) ?? iso(at),
+    text: entry.expired && entry.question === undefined ? "" : String(entry.question ?? ""), delivery: stageMark(stage),
+    ...files(entry.questionFiles), ...(entry.quote ? { quote: entry.quote } : {}) });
+  if (entry.answer !== undefined) {
+    out.push({ boot: "hub", id: id + 1, role: "agent", sender: (room && room.exposureName) || "", ts: iso(at), text: String(entry.answer),
+      ...files(entry.answerFiles), ...(entry.buttons ? { buttons: entry.buttons } : {}) });
+  } else if (stage === "rejected" || stage === "cancelled" || stage === "failed" || stage === "uncertain") {
+    out.push({ boot: "hub", id: id + 1, role: "status", sender: "", ts: iso(at), text: reason(entry.receipt && entry.receipt.reasonCode, stage) });
+  }
+  return out;
+}
+
+/**
+ * The store of one room: `subscribe(fn)` (fn() on any change) → unsubscribe; `messages()`, `room()`, `working()` (the
+ * question being worked on, if any: { since }), `closed()`; `refresh()` (a read now); `send(text, extras)`;
+ * F's `clickButton(setId, index)`, `vote(setId, options)`, `busy(setId)`, `mine(setId)`; `stop()`.
+ */
+export function createHubChatStore(room, { client = hubClient(), me = "", reason, timers = globalThis, doc = typeof document !== "undefined" ? document : null } = {}) {
+  const subs = new Set();
+  const st = { live: true, timer: 0, inflight: false, entries: [], room: { ...room }, closed: false, error: null, pending: [], full: false, reads: 0, farTurn: 0 };
+  const emit = () => { for (const fn of subs) { try { fn(); } catch { /* a subscriber's own failure */ } } };
+  const merge = (got) => {
+    const byId = new Map(st.entries.map((e) => [e.messageId, e]));
+    for (const e of got) {
+      const next = { ...byId.get(e.messageId), ...e };
+      // A returned entry is complete: removed/retained-away controls must not survive in the cache.
+      if (!e.buttons) delete next.buttons;
+      byId.set(e.messageId, next);
+    }
+    st.entries = [...byId.values()].sort((a, b) => a.sequence - b.sequence);
+  };
+  const schedule = (ms) => { timers.clearTimeout(st.timer); if (st.live && !st.closed) st.timer = timers.setTimeout(poll, ms); };
+  async function poll() {
+    if (!st.live || st.inflight || st.closed) return;
+    if (doc && doc.hidden) { schedule(POLL_MS); return; }
+    st.inflight = true;
+    // Unsettled entries are read again (from just before the oldest one) — but a full page means there is more after
+    // it: read on from the last one first, so an old open entry can never pin the read to the same page (#3246 review).
+    const last = st.entries.length ? st.entries[st.entries.length - 1].sequence : 0;
+    // Keep one response slot for an unseen entry: PAGE known rows would hide every newer row behind LIMIT PAGE.
+    const tail = Math.max(0, last - PAGE + 1);
+    const open = st.full ? null : st.entries.find((e) => !SETTLED.has(e.receipt && e.receipt.stage) || e.buttons?.state === "open");
+    // The tail page is always read again (the newest entries' stages move); an open entry older than that is read from
+    // its own place only every FAR_EVERY-th read, so it never holds back the newer ones (#3246 review, residual).
+    // Every FAR_EVERY-th read goes back to one of them, in turn (#3261 review: each old unsettled entry, not only the oldest).
+    st.reads += 1;
+    const old = st.full ? [] : st.entries.filter((e) => e.sequence - 1 < tail && (!SETTLED.has(e.receipt && e.receipt.stage) || e.buttons?.state === "open"));
+    const far = old.length > 0 && st.reads % FAR_EVERY === 0 ? old[(st.farTurn++) % old.length] : null;
+    const after = far ? far.sequence - 1 : open ? Math.max(open.sequence - 1, tail) : last;
+    let r;
+    try { r = await client.read(st.room.id, after); } catch { r = { ok: false, code: "unreachable" }; }
+    st.inflight = false;
+    if (!st.live) return;
+    if (r.ok) {
+      const got = r.entries || [], known = st.entries.length ? st.entries[st.entries.length - 1].sequence : 0;
+      merge(got);
+      // More may follow only when a page came back full AND reached past what was known (a re-read tail page of exactly
+      // PAGE rows is not "more").
+      st.full = got.length >= PAGE && got[got.length - 1].sequence > known;
+      // The room as the server says it now. Its quota is the server's to give: absent means withdrawn (the owner hid it,
+      // the grant is gone), never "unchanged" — a band once shown must not outlive that. An answer with no room at all
+      // (an older Hub) keeps what is known.
+      if (r.room) { st.room = { ...st.room, ...r.room }; if (!Object.prototype.hasOwnProperty.call(r.room, "quota")) delete st.room.quota; }
+      st.pending = st.pending.filter((p) => !st.entries.some((e) => e.messageId === p.messageId));
+      st.error = null; emit(); schedule(POLL_MS); return;
+    }
+    if (r.code === "revoked" || r.code === "not-found") { st.closed = true; emit(); return; }
+    st.error = r.code || "failed"; emit();
+    schedule(r.code === "backpressure" ? Math.max(POLL_MS, (r.retryAfter || 10) * 1000) : POLL_MS);
+  }
+  const onVisible = () => { if (doc && !doc.hidden) schedule(0); };
+  if (doc) doc.addEventListener("visibilitychange", onVisible);
+  poll();
+  const newKey = () => {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+    const b = new Uint8Array(16); crypto.getRandomValues(b); b[6] = (b[6] & 15) | 64; b[8] = (b[8] & 63) | 128;
+    const x = [...b].map((v) => v.toString(16).padStart(2, "0")).join("");
+    return `${x.slice(0, 8)}-${x.slice(8, 12)}-${x.slice(12, 16)}-${x.slice(16, 20)}-${x.slice(20)}`;
+  };
+  const actions = createHubButtonActions({ id: room.id, get features() { return st.closed ? [] : st.room.features; } }, {
+    client, entries: () => st.entries, refresh: () => schedule(0), changed: emit,
+  });
+  return {
+    subscribe(fn) { subs.add(fn); return () => subs.delete(fn); },
+    room: () => st.room,
+    closed: () => st.closed,
+    error: () => st.error,
+    entries: () => st.entries,
+    messages() {
+      const shown = st.entries.flatMap((e) => hubEntryToMessages(e, st.room, { me, reason }));
+      // A question just sent shows at once (the next read brings its entry and replaces it).
+      const last = st.entries.length ? st.entries[st.entries.length - 1].sequence : 0;
+      const pend = st.pending.flatMap((p, i) => hubEntryToMessages({ messageId: p.messageId, sequence: last + 1 + i, askedAt: p.at, receipt: { stage: "queued", at: p.at }, question: p.text }, st.room, { me, reason }));
+      return [...shown, ...pend];
+    },
+    /** The question the agent is working on now (the oldest "consumed" one), with when it started; null when none. */
+    working() {
+      const w = st.entries.find((e) => e.receipt && e.receipt.stage === "consumed");
+      return w ? { since: w.receipt.at } : null;
+    },
+    refresh() { schedule(0); },
+    async send(text, extras = {}) {
+      const q = String(text || "").trim();
+      if (!q || st.closed) return { ok: false, code: "invalid" };
+      let r;
+      try { r = await client.ask(st.room.id, newKey(), q, extras); } catch { r = { ok: false, code: "unreachable" }; }
+      if (!r.ok) { if (r.code === "revoked") { st.closed = true; emit(); } return r; }
+      st.pending.push({ messageId: r.receipt.messageId, text: q, at: r.receipt.at || Date.now() });
+      emit();
+      return r;
+    },
+    clickButton: actions.clickButton,
+    vote: actions.vote,
+    busy: actions.busy,
+    mine: actions.mine,
+    stop() {
+      st.live = false; actions.stop(); timers.clearTimeout(st.timer); subs.clear();
+      if (doc) doc.removeEventListener("visibilitychange", onVisible);
+    },
+  };
+}

package/dist/ui/hub-chat-strings.js

@@ -0,0 +1,77 @@
+// #3226 B: the Hub chat's own words (the conversation list, the room, the right-hand panel, the menu), en and zh-TW, and
+// its stylesheet. A module of its own (a tab opened before an upgrade holds an older hub-strings.js without these words,
+// and an older hub.css without these rules). The thread's own words are the fleet chat's (/assets/chat-strings.js).
+import { register, t } from "/assets/app-i18n.js";
+
+register("hubChat", {
+  en: {
+    chats: "Chats", newChat: "New chat", search: "Search chats", noChats: "No chats yet", noChatsHint: "Start one with New chat: it lists the agents someone allowed you to ask.",
+    noMatch: "No chat matches.", waiting: "Waiting for an answer", represents: "Answers for {0}",
+    pickTitle: "New chat", pickSearch: "Search agents or owners", pickHint: "Only the agents someone allowed you to ask are listed.",
+    pickUntil: "Answers for {0} · you can ask until {1}", pickAsk: "Ask", pickOpen: "Open", pickNone: "No agent matches.", pickEmpty: "No agents you can ask yet",
+    choose: "Pick a chat", chooseHint: "Or start one with New chat.",
+    emptyRoom: "Ask {0} your first question", emptyRoomHint: "It answers for {0}. An answer can take a few minutes.",
+    composer: "Ask {0}", composerHint: "You ask as yourself; {0} sees that it was you.", send: "Send", stop: "Stop",
+    working: "{0} is working on it", elapsed: "Time since it started",
+    tick_queued: "Waiting for the owner's fleet", tick_processing: "At the owner's fleet", tick_delivered: "Answered",
+    tick_failed: "Not answered", tick_cancelled: "Outcome unknown",
+    notAnswered: "Not answered: {0}", uncertain: "Outcome unknown: it may or may not have been answered.",
+    reason_expired: "the question expired before an answer", reason_revoked: "your permission ended", reason_frozen: "the owner paused questions",
+    reason_withdrawn: "the agent is no longer shared", reason_unknown: "no reason given",
+    closed: "This chat has closed: your permission ended, or the agent is no longer shared.",
+    frozen: "The owner has paused questions to {0}. What is here stays readable.",
+    tagCanAsk: "Can ask", tagFrozen: "Paused", tagClosed: "Closed",
+    info: "Info", infoLabel: "About this chat", showInfo: "Show info", hideInfo: "Hide",
+    answersFor: "Answers for {0}", yourAccess: "Your access", canDo: "May", canDoValue: "Ask, and read your own chat",
+    until: "Until", daysLeft: "{0} days left", dayLeft: "1 day left", endsToday: "Ends today",
+    whoSees: "Who sees this chat", you: "You", youSee: "Only you see this chat's history, while your permission lasts.",
+    ownerSees: "Your questions show in {0}'s own fleet chat, marked with your Hub identity.",
+    agentShares: "It shares one conversation with everyone allowed to ask it, so it may remember what others asked. Keep out what others mustn't know.",
+    adminTitle: "Hub administrator", adminSees: "Can't see the content.",
+    notHere: "Not here", notHereText: "{0}'s files and changes, its terminal (View) and its tool progress: only {1} sees them, in their own fleet.",
+    oneToOne: "A chat has only you and this agent.",
+    menu: "Menu", mine: "My shared agents", mineHint: "Who may ask them, until when", admin: "Administration", adminHint: "Pair fleets",
+    back: "Chats",
+  },
+  "zh-TW": {
+    chats: "對話", newChat: "新對話", search: "搜尋對話", noChats: "還沒有對話", noChatsHint: "用「新對話」開始：會列出有人允許你提問的 Agent。",
+    noMatch: "沒有符合的對話。", waiting: "等待回答", represents: "代表 {0} 回答",
+    pickTitle: "新對話", pickSearch: "搜尋 Agent 或擁有者", pickHint: "只列出有人允許你提問的 Agent。",
+    pickUntil: "代表 {0} · 你可以問到 {1}", pickAsk: "提問", pickOpen: "開啟", pickNone: "沒有符合的 Agent。", pickEmpty: "還沒有可以提問的 Agent",
+    choose: "選一個對話", chooseHint: "或用「新對話」開始一個。",
+    emptyRoom: "問 {0} 第一個問題", emptyRoomHint: "它代表 {0} 回答；回答可能要幾分鐘。",
+    composer: "問 {0}", composerHint: "你以自己的 Hub 身分提問；{0} 會看到是你問的。", send: "送出", stop: "停止",
+    working: "{0} 正在處理", elapsed: "開始處理後經過的時間",
+    tick_queued: "等待擁有者的 fleet", tick_processing: "已送達擁有者的 fleet", tick_delivered: "已回答",
+    tick_failed: "未回答", tick_cancelled: "結果未知",
+    notAnswered: "未回答：{0}", uncertain: "結果未知：可能已回答，也可能沒有。",
+    reason_expired: "問題在回答前就過期了", reason_revoked: "你的權限已結束", reason_frozen: "擁有者暫停了提問",
+    reason_withdrawn: "這個 Agent 不再分享", reason_unknown: "沒有說明原因",
+    closed: "這個對話已關閉：你的權限已結束，或這個 Agent 不再分享。",
+    frozen: "擁有者暫停了 {0} 的提問。這裡的內容仍然看得到。",
+    tagCanAsk: "可提問", tagFrozen: "已暫停", tagClosed: "已關閉",
+    info: "資訊", infoLabel: "這段對話的資訊", showInfo: "顯示資訊", hideInfo: "關閉",
+    answersFor: "代表 {0} 回答", yourAccess: "你的權限", canDo: "可以", canDoValue: "提問、看自己的紀錄",
+    until: "期限", daysLeft: "還有 {0} 天", dayLeft: "還有 1 天", endsToday: "今天到期",
+    whoSees: "誰看得到這段對話", you: "你", youSee: "這個聊天室的紀錄只有你看得到，而且只在權限有效期間。",
+    ownerSees: "你的問題會出現在 {0} 的 fleet 聊天裡，標示你的 Hub 身分。",
+    agentShares: "它和其他有權限的人共用同一段對話，可能記得別人問過的事。別放不想讓別人知道的內容。",
+    adminTitle: "Hub 管理員", adminSees: "看不到內容。",
+    notHere: "這裡沒有", notHereText: "{0} 的檔案與變更、終端機畫面（View）、工具進度：只有 {1} 在自己的 fleet 看得到。",
+    oneToOne: "一個聊天室只有你和這個 Agent。",
+    menu: "選單", mine: "我分享的 Agent", mineHint: "誰可以提問、到什麼時候", admin: "管理", adminHint: "配對 fleet",
+    back: "對話",
+  },
+});
+/** hubChat.* words. */
+export const hc = (key, ...values) => t(`hubChat.${key}`, ...values);
+
+/** The Hub chat's stylesheet, linked once (an older hub.css or app.css lacks these rules). */
+export function linkHubChatCss(doc = typeof document !== "undefined" ? document : null) {
+  try {
+    if (!doc || !doc.head || doc.querySelector('link[data-hub-chat-css="1"]')) return;
+    const link = doc.createElement("link");
+    link.setAttribute("rel", "stylesheet"); link.setAttribute("href", "/assets/hub-chat.css"); link.setAttribute("data-hub-chat-css", "1");
+    doc.head.appendChild(link);
+  } catch { /* the chat still works without it */ }
+}