jaitus 0.3.22 → 0.3.24

package/src/serviceNotice.js

@@ -75,6 +75,15 @@ export function lineFor(item, where = statusAddress()) {
     if (until) return `Jaitus is down for maintenance until ${until}. Updates: ${where}`;
     return `Jaitus is down for maintenance. Updates: ${where}`;
   }
+  if (item.kind === 'offer') {
+    // An offer from Admin → Offers: its headline, the short line under it, the code if it
+    // has one, and where to take it.
+    if (!title) return null;
+    const details = dropStop(clean(item.details, 90));
+    const code = clean(item.code, 30);
+    const billing = where.replace(/\/status$/, '/billing');
+    return `${title}${details ? ` — ${details}` : ''}.${code ? ` Code ${code}.` : ''} ${billing}`;
+  }
   if (item.kind === 'maintenance' && item.phase === 'upcoming') {
     const when = clean(item.window, 60);
     if (!when) return null;

package/src/tui-ink.js

@@ -39,6 +39,7 @@ import { badgeText, badgeTop, turnShareText } from './planView.js';
 
 const h = React.createElement;
 const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
 const ascii = () => process.env.JAITUS_ASCII === '1';
 const g = (uni, plainText) => (ascii() ? plainText : uni);
 
@@ -419,8 +420,9 @@ function layoutTranscript(state, width, height, top) {
 
   // The drag handler needs the text under the pointer, and it must be the text actually
   // on screen rather than the transcript's idea of it.
-  state.screen = { top: screenTop, left: 2, rows: visible };
+  state.screen = { top: screenTop, left: 2, rows: visible, first, all: rows, height };
   state.totalRows = rows.length;
+  anchorSelection(state);
 
   // The sticky header names the prompt whose answer you are looking at — the last one
   // that has scrolled off the top. Scroll far enough that the prompt itself is back on
@@ -554,6 +556,41 @@ const URL_IN_TEXT = /https?:\/\/[^\s<>"'`]+/g;
 // background colour, then CSI ? … c device attributes — alone or run together.
 export const TERMINAL_REPLY = /^(?=[\x1b\][])(?:\x1b?\]11;rgb:[0-9a-f]{1,4}\/[0-9a-f]{1,4}\/[0-9a-f]{1,4}(?:\x07|\x1b\\)?)?(?:\x1b?\[\?[0-9;]*c)?$/i;
 
+/**
+ * Keep a drag selection on the TEXT while the view scrolls.
+ *
+ * A selection that starts in the transcript records the row of the whole transcript it
+ * started on, so scrolling (the wheel, or holding the pointer past an edge) moves the
+ * highlight with the text instead of leaving it on the same screen cells over different
+ * text. While the button is held the other end follows the pointer: whichever row is under
+ * it now, clamped to what is on screen — so with the pointer above the conversation it is
+ * the top row, and the selection grows as more scrolls in. Screen positions are derived
+ * from rows here, every frame, so painting and copying read the same thing.
+ */
+function selectionFirstRow(state) {
+  const s = state.screen;
+  if (!s?.all) return 0;
+  const total = s.all.length;
+  const offset = state.viewingTranscript ? clamp(state.transcriptOffset || 0, 0, Math.max(0, total - s.height)) : 0;
+  return Math.max(0, total - offset - s.height);
+}
+
+function anchorSelection(state) {
+  const sel = state.selection;
+  const s = state.screen;
+  if (!sel?.anchor || !sel.focus || sel.anchor.row == null || !s?.all) return;
+  const first = selectionFirstRow(state);
+  const shown = Math.min(s.height, s.all.length - first);
+  if (sel.dragging && sel.pointer) {
+    const lastRow = first + Math.max(0, shown - 1);
+    const row = clamp(first + (sel.pointer.y - s.top), first, lastRow);
+    const x = sel.pointer.y < s.top ? s.left : sel.pointer.y > s.top + shown - 1 ? 1e4 : sel.pointer.x;
+    sel.focus = { x, row };
+  }
+  sel.anchor.y = s.top + sel.anchor.row - first;
+  if (sel.focus.row != null) sel.focus.y = s.top + sel.focus.row - first;
+}
+
 /**
  * Draw the drag selection.
  *
@@ -1772,6 +1809,43 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     notifyNow();
   }
 
+  /** The row of the whole transcript at screen line `y`, or null off the transcript. */
+  function transcriptRowAt(y) {
+    const s = state.screen;
+    if (!s?.all || state.dialog || state.panel) return null;
+    if (y < s.top || y > s.top + s.rows.length - 1) return null;
+    return selectionFirstRow(state) + (y - s.top);
+  }
+
+  // Holding a drag past the top or bottom of the conversation scrolls it, faster the
+  // further out the pointer is, until the button is released or the pointer comes back —
+  // what every terminal does. Terminals only report the mouse when it moves, so a pointer
+  // held still past the edge needs this timer to keep going.
+  let edgeTimer = null;
+  function stopEdgeScroll() { if (edgeTimer) { clearInterval(edgeTimer); edgeTimer = null; } }
+  function edgeOut() {
+    const sel = state.selection;
+    const s = state.screen;
+    if (!sel?.dragging || !sel.pointer || !s?.rows?.length) return 0;
+    const bottom = s.top + s.rows.length - 1;
+    if (sel.pointer.y < s.top) return s.top - sel.pointer.y;          // above: positive = back into history
+    if (sel.pointer.y > bottom) return -(sel.pointer.y - bottom);     // below: towards the newest
+    return 0;
+  }
+  function edgeScroll() {
+    if (!edgeOut()) return stopEdgeScroll();
+    if (edgeTimer) return;
+    edgeTimer = setInterval(() => {
+      const out = edgeOut();
+      if (!out) return stopEdgeScroll();
+      const step = Math.min(4, Math.abs(out));
+      scroll(out > 0 ? step : -step);
+      anchorSelection(state);
+      notifyNow();
+    }, 60);
+    edgeTimer.unref?.();
+  }
+
   // ── selecting text in the composer ──
   //
   // The composer is a text field, so it selects like one: drag with the mouse (copied on
@@ -1857,15 +1931,28 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // out or replaced by what it stands for, and a wrapped line rejoins the line it was
     // wrapped from (tui/ansi.js copyText / softJoin).
     const pieces = [];
-    screen.rows.forEach((row, index) => {
-      const y = screen.top + index;
-      if (y < from.y || y > to.y) return;
+    // `startX` / `endX` are screen columns of the first and last selected row (or null for
+    // "the whole row").
+    const take = (row, startX, endX) => {
       if (isDecorationRow(row)) return;
       const len = rowText(row).length;
-      const start = y === from.y ? Math.max(0, from.x - screen.left) : 0;
-      const end = y === to.y ? Math.max(0, to.x - screen.left + 1) : len;
+      const start = startX == null ? 0 : Math.max(0, startX - screen.left);
+      const end = endX == null ? len : Math.min(len, Math.max(0, endX - screen.left + 1));
       pieces.push({ text: copyText(row, start, end), join: pieces.length ? softJoin(row) : null });
-    });
+    };
+    if (a.row != null && b.row != null && screen.all) {
+      // Anchored to the text: everything selected, including what has scrolled off screen.
+      const [f, t] = (a.row < b.row || (a.row === b.row && a.x <= b.x)) ? [a, b] : [b, a];
+      for (let r = f.row; r <= t.row; r++) {
+        if (screen.all[r]) take(screen.all[r], r === f.row ? f.x : null, r === t.row ? t.x : null);
+      }
+    } else {
+      screen.rows.forEach((row, index) => {
+        const y = screen.top + index;
+        if (y < from.y || y > to.y) return;
+        take(row, y === from.y ? from.x : null, y === to.y ? to.x : null);
+      });
+    }
     let out = '';
     pieces.forEach((piece, i) => {
       // A word cut mid-way (join '') keeps every character on both sides; anywhere else
@@ -1912,6 +1999,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   }
 
   function clearSelection() {
+    stopEdgeScroll();
     if (!state.selection) return;
     state.selection = null;
     notifyNow();
@@ -2141,20 +2229,33 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         // A press starts a possible drag AND a possible click. Which it was is only
         // known on release, so nothing is dispatched yet — dispatching here made every
         // attempt to select text also press whatever was under the cursor.
-        pressedAt = { x: event.x, y: event.y };
+        pressedAt = { x: event.x, y: event.y, row: transcriptRowAt(event.y) };
         dragged = false;
         clearSelection();
         return;
       }
       if (event.kind === 'drag' && pressedAt) {
         if (event.x !== pressedAt.x || event.y !== pressedAt.y) dragged = true;
-        state.selection = { anchor: pressedAt, focus: { x: event.x, y: event.y } };
+        if (pressedAt.row == null) {
+          state.selection = { anchor: { x: pressedAt.x, y: pressedAt.y }, focus: { x: event.x, y: event.y } };
+          return notifyNow();
+        }
+        // Anchored to the text, the other end on the pointer (anchorSelection), and the
+        // view scrolls on its own while the pointer is held past either edge.
+        const sel = state.selection?.dragging ? state.selection
+          : { anchor: { x: pressedAt.x, y: pressedAt.y, row: pressedAt.row }, focus: { x: event.x, y: event.y }, dragging: true };
+        sel.pointer = { x: event.x, y: event.y };
+        state.selection = sel;
+        anchorSelection(state);
+        edgeScroll();
         return notifyNow();
       }
       if (event.kind === 'up') {
         const start = pressedAt;
         pressedAt = null;
+        stopEdgeScroll();
         if (!start) return;
+        if (state.selection?.dragging) { anchorSelection(state); state.selection.dragging = false; }
         if (dragged) { dragged = false; void finishSelection(); return; }
         const now = Date.now();
         const again = lastClick && now - lastClick.at < 450 && lastClick.y === start.y && Math.abs(lastClick.x - start.x) <= 1;

package/src/updatePolicy.js

@@ -0,0 +1,54 @@
+// ─── "Update Jaitus to continue", even mid-task ─────────────────────────────────
+//
+// The admin can require a newer CLI (backend services/cliUpdate.js). Every request is
+// checked there, but a CLI sitting idle — or deep in a long tool run — would not hear about
+// it until its next request. So the CLI asks once at start and every two minutes while it
+// is open. The question goes through the same gate: a CLI that is too old is refused with
+// jaitus_update_required, and that refusal is the answer. When it comes, the running task
+// is stopped and the reason is shown once, short.
+//
+// Any failure (offline, timeout, an older server) means "nothing to say": this never
+// blocks or slows the CLI on its own.
+
+import { endpoints, version } from './config.js';
+
+const EVERY_MS = 2 * 60 * 1000;
+const TIMEOUT_MS = 6000;
+
+/** null when this CLI may keep working; otherwise { message } to show. */
+export async function checkPolicy({ fetchImpl = fetch, baseUrl = endpoints().baseUrl } = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(`${baseUrl}/api/public/cli-policy`, {
+      headers: { accept: 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window plan-expired update-required' },
+      signal: ctrl.signal,
+    });
+    if (res.status !== 426) return null;
+    const body = await res.json().catch(() => null);
+    if (body?.error?.code !== 'jaitus_update_required') return null;
+    return { message: String(body.error.message || '').replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 240) };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Check now and every two minutes; call onBlocked({ message }) once, the first time this
+ * CLI is refused. Returns a stop function. The timer never keeps the process alive.
+ */
+export function watchPolicy(onBlocked, { everyMs = EVERY_MS, check = checkPolicy } = {}) {
+  let done = false;
+  let timer = null;
+  const run = async () => {
+    if (done) return;
+    const r = await check();
+    if (r && !done) { done = true; clearInterval(timer); onBlocked(r); }
+  };
+  void run();
+  timer = setInterval(() => { void run(); }, everyMs);
+  timer.unref?.();
+  return () => { done = true; clearInterval(timer); };
+}