jaitus 0.3.13 → 0.3.14

package/src/index.js

@@ -45,6 +45,7 @@ import login from './commands/login.js';
 import logout from './commands/logout.js';
 import doctor from './commands/doctor.js';
 import update, { updateNotice, autoUpdate } from './commands/update.js';
+import { startupNotice } from './serviceNotice.js';
 import init from './commands/init.js';
 import research from './commands/research.js';
 import explain from './commands/explain.js';
@@ -1436,6 +1437,9 @@ async function session({ flags }) {
     // A global install never updates itself; say so when there is something newer.
     // Background and cached for a day — the app never waits on the network for this.
     void updateNotice().then((line) => { if (line) tui.notice(line, 'info'); }).catch(() => {});
+    // An outage or maintenance on the Jaitus service, said once a day at most; the
+    // status page has the rest. Background, short timeout, silent on failure.
+    void startupNotice().then((line) => { if (line) tui.notice(line, 'warn'); }).catch(() => {});
     // A project's .mcp.json runs programs on this machine. Nothing in it starts until the
     // exact command is approved here — asked once, remembered per project and command.
     void (async () => {
@@ -2878,7 +2882,7 @@ const commands = {
       const unset = rest.length === 1 && /^(--unset|none|unset)$/i.test(rest[0]);
       const value = unset ? '' : rest.join(' ').trim();
       const settings = loadSettings();
-      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'trimToolResults', 'mouse', 'autoUpdate'];
+      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'trimToolResults', 'mouse'];
       const SECRET = ['braveSearchKey', 'tavilyKey', 'serperKey'];
       if (!key) {
         const e = endpoints();
@@ -3010,7 +3014,7 @@ const commands = {
   update: {
     summary: 'check whether a newer version is published',
     usage: ['jaitus update [--json]'],
-    detail: ['Checks npm for a newer version and, for a global npm install, offers to install it (--yes installs without asking). Launching jaitus also updates itself; turn that off with `jaitus config autoUpdate off`.'],
+    detail: ['Checks npm for a newer version and, for a global npm install, installs it with progress. Starting jaitus does the same every time, so this is rarely needed.'],
     run: (argv, { json }) => update(argv, { json }),
   },
 
@@ -3088,7 +3092,7 @@ export default async function main(argv) {
   }
 
   // Always on the newest version: install it and reopen before doing anything else.
-  const relaunched = await autoUpdate({ argv, settings: loadSettings() }).catch(() => null);
+  const relaunched = await autoUpdate({ argv }).catch(() => null);
   if (relaunched !== null) return relaunched;
 
   const [first, ...others] = rest;

package/src/serviceNotice.js

@@ -0,0 +1,151 @@
+// ─── Service notices in the CLI ─────────────────────────────────────────────────
+//
+// The status page (www.jaitus.com/status) is the record. The CLI only says something
+// when it affects using Jaitus right now, the way flyctl checks its status page:
+//
+//   - At start-up, in the background with a short timeout: one line for a major or
+//     critical incident on the Jaitus service, maintenance in progress, or maintenance
+//     starting within 24 hours. Each notice at most once a day on this machine.
+//   - When a request has finally failed (after the usual retries) as unavailable, timed
+//     out or down for maintenance: the error says which known problem it is, or when
+//     Jaitus will be back.
+//
+// The server decides which notices qualify (GET /api/status/notices), by its own clock.
+// Nothing here ever blocks, and any failure is silent. JAITUS_NO_STATUS_CHECK=1 or CI
+// turns the start-up line off.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME, endpoints } from './config.js';
+
+const TIMEOUT_MS = 2000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SHOWN_FILE = path.join(HOME, 'notice-check.json');
+
+/** Whether the start-up line may run at all. */
+export function noticeCheckEnabled(env = process.env) {
+  return !(env.JAITUS_NO_STATUS_CHECK || env.CI);
+}
+
+/** The public notices payload, or null. Never throws. */
+export async function fetchNotices({ baseUrl = endpoints().baseUrl, fetchImpl = fetch, timeoutMs = TIMEOUT_MS } = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(`${baseUrl}/api/status/notices`, { signal: ctrl.signal, headers: { accept: 'application/json' } });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body && typeof body === 'object' && body.data && typeof body.data === 'object' ? body.data : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** "www.jaitus.com/status", from the configured site. */
+export function statusAddress(siteUrl = endpoints().siteUrl) {
+  return `${String(siteUrl).replace(/^https?:\/\//, '').replace(/\/+$/, '')}/status`;
+}
+
+// Text from the server is printed into a terminal: no escape codes, no control
+// characters, one short line.
+const clean = (t, max = 100) => {
+  const s = String(t ?? '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+};
+const dropStop = (t) => t.replace(/[.!?…]+$/, '');
+
+/** The start-up line for one notice from the server's `cli` list. */
+export function lineFor(item, where = statusAddress()) {
+  if (!item || typeof item !== 'object') return null;
+  const title = dropStop(clean(item.title));
+  if (item.kind === 'incident') {
+    return `Jaitus is having problems${title ? `: ${title}` : ''}. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'in_progress') {
+    const until = clean(item.until, 40);
+    if (item.overrun && until) return `Jaitus is down for maintenance, running past its planned end (${until}). Updates: ${where}`;
+    if (until) return `Jaitus is down for maintenance until ${until}. Updates: ${where}`;
+    return `Jaitus is down for maintenance. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'upcoming') {
+    const when = clean(item.window, 60);
+    if (!when) return null;
+    return `Planned maintenance ${when}: Jaitus will not answer during it. Details: ${where}`;
+  }
+  return null;
+}
+
+function readShown(file) {
+  try {
+    const v = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return v && typeof v.shown === 'object' && v.shown ? v.shown : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The one line to show at start-up, or null. A notice is shown at most once a day per
+ * machine; a planned window and the same window in progress are separate notices.
+ */
+export async function startupNotice({ env = process.env, now = Date.now(), file = SHOWN_FILE, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!noticeCheckEnabled(env)) return null;
+  const data = await get().catch(() => null);
+  const items = Array.isArray(data?.cli) ? data.cli : [];
+  if (!items.length) return null;
+  const shown = readShown(file);
+  for (const item of items) {
+    const key = `${item?.id}:${item?.phase}`;
+    if (shown[key] != null && now - Number(shown[key]) < DAY_MS) continue;
+    const line = lineFor(item, where);
+    if (!line) continue;
+    shown[key] = now;
+    // Forget anything a week old, so the file never grows.
+    for (const k of Object.keys(shown)) if (now - Number(shown[k]) > 7 * DAY_MS) delete shown[k];
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, JSON.stringify({ shown }));
+    } catch { /* read-only home: it may show again next start */ }
+    return line;
+  }
+  return null;
+}
+
+const EXPLAINED = new Set(['maintenance', 'unavailable', 'timeout']);
+
+/**
+ * A request that finally failed: add what the status page knows to the error's hint —
+ * when Jaitus is back from maintenance, or which known problem this is. Mutates and
+ * returns `error`; leaves it alone when there is nothing to add or the check fails.
+ */
+export async function explainFailure(error, { baseUrl, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!error || !EXPLAINED.has(error.code)) return error;
+  const data = await get(baseUrl ? { baseUrl } : undefined).catch(() => null);
+  if (!data) return error;
+  const at = where || statusAddress();
+  const m = data.maintenance;
+  if (error.code === 'maintenance' || m?.enabled) {
+    const until = clean(m?.until, 40);
+    error.title = 'Down for maintenance';
+    error.hint = m?.enabled && until
+      ? (m.overrun
+        ? `It was planned to end at ${until} and is running late. Updates: ${at}`
+        : `Jaitus should be back by ${until}. Updates: ${at}`)
+      : `Try again shortly. Updates: ${at}`;
+    return error;
+  }
+  const incident = Array.isArray(data.incidents) ? data.incidents[0] : null;
+  const title = incident ? dropStop(clean(incident.title)) : '';
+  error.hint = title
+    ? `Known problem: ${title}. Updates: ${at}`
+    : `${error.hint ? `${dropStop(error.hint)}. ` : ''}Service status: ${at}`;
+  return error;
+}

package/src/sessions.js

@@ -9,6 +9,7 @@ import crypto from 'node:crypto';
 import { SESSIONS } from './config.js';
 import { c } from './ui.js';
 import { unifiedDiff } from './diff.js';
+import { TOOLS } from './agent/tools.js';
 
 function safeId(id) {
   return String(id || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 80);
@@ -195,6 +196,13 @@ export function replaySession(tui, messages) {
 /** The same one-line summary the live loop shows, without importing the tool table. */
 function summariseCall(call) {
   const input = call.input && typeof call.input === 'object' ? call.input : {};
+  // The same label the row had while the session ran. A second, guessed label here
+  // showed a resumed task list as `{"todos":[{"content":…` and a background read as
+  // `{"id":"bg1"}`.
+  const tool = TOOLS.find((t) => t.name === call.name);
+  if (tool?.summarise) {
+    try { const s = tool.summarise(input); if (s) return String(s); } catch { /* fall back below */ }
+  }
   if (input.command) return String(input.command);
   if (input.path) return String(input.path);
   if (input.pattern) return String(input.pattern);