jaitus 0.3.0 → 0.3.2

package/src/index.js

@@ -41,7 +41,7 @@ const createTui = process.env.JAITUS_RENDERER === 'classic' ? createClassicTui :
 import login from './commands/login.js';
 import logout from './commands/logout.js';
 import doctor from './commands/doctor.js';
-import update from './commands/update.js';
+import update, { updateNotice, autoUpdate } from './commands/update.js';
 import init from './commands/init.js';
 import research from './commands/research.js';
 import explain from './commands/explain.js';
@@ -522,6 +522,12 @@ export function ensureUtf8Codepage() {
 }
 
 async function session({ flags }) {
+  // Signed out: sign in here, in this window, and go straight on into the session —
+  // rather than stopping to tell someone to run another command first.
+  if (!signedIn() && process.stdin.isTTY && process.stdout.isTTY) {
+    const code = await login([], { then: 'continue' });
+    if (code !== 0) return code;
+  }
   const client = requireAuth();
   // Classic conhost speaks an OEM codepage by default, so every ›•─│ the CLI
   // paints arrives as mojibake (the whole UI looks broken, not old). One
@@ -786,9 +792,11 @@ async function session({ flags }) {
         spent.turns += 1;
         // opencode assistant metadata: ▣ Mode · model · duration.
         const secs = ((Date.now() - turnStarted) / 1000).toFixed(1);
-        const posture = permissions.mode === 'plan' ? 'Read-only'
+        // The same words the header uses for the mode. "Off" on its own read as though
+        // something was broken; it meant approvals were off.
+        const posture = permissions.mode === 'plan' ? 'Plan'
           : permissions.mode === 'acceptEdits' ? 'Auto-edit'
-          : permissions.mode === 'bypassPermissions' ? 'Off' : 'Ask';
+          : permissions.mode === 'bypassPermissions' ? 'Bypass' : 'Ask';
         const meta = `  ${c.brand(glyph('▣', '*'))} ${posture} ${c.dim(`· ${model} · ${secs}s`)}`;
         if (tui) tui.print(meta);
         else out(meta);
@@ -1039,6 +1047,9 @@ async function session({ flags }) {
     : true;
   if (process.stdout.isTTY && wantFullscreen) {
     tui.start({ onLine: handleLine, history: sessionHistory() });
+    // 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(() => {});
     // Fresh sessions open on the home moment, opencode-style: the centered
     // two-tone mark, then a tip — the composer below is the whole welcome.
     // The mark is vertically centered in the free space above the pinned
@@ -1122,7 +1133,7 @@ async function session({ flags }) {
     const { columns: termColumns } = await import('./ui.js');
     const approval = permissions.mode === 'plan' ? 'read-only'
       : permissions.mode === 'acceptEdits' ? 'auto-edit'
-      : permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+      : permissions.mode === 'bypassPermissions' ? 'bypass' : 'ask';
     for (const line of renderClassicOpen({
       version: VERSION, model, approval, cwd: flags.cwd,
       account: creds?.user?.email ? `${creds.user.email}${creds.user.isPaid ? '' : ' (free plan)'}` : null,
@@ -1992,9 +2003,24 @@ async function slashCommand(verb, args, ctx) {
       return null;
     }
 
-    case '/login':
-      await login(['--force']);
+    case '/login': {
+      // In the app view the steps go to the transcript; the session carries on after,
+      // on the new account — every request reads the saved sign-in fresh.
+      const t = ctx.tui;
+      if (!t) { await login(['--force'], { then: 'none' }); return null; }
+      const { signIn } = await import('./commands/login.js');
+      const result = await signIn({
+        onUrl: (url) => {
+          t.notice('Opening your browser to sign in. If it does not open, paste this link:', 'info');
+          t.notice(url, 'dim');
+        },
+        onStatus: (s) => t.setStatus(s === 'waiting' ? 'Waiting for you to approve in the browser… (Esc does not cancel; close the tab to give up)' : 'Finishing sign-in…'),
+      });
+      t.clearStatus?.();
+      if (result.ok) t.notice(`Signed in as ${result.user?.email || 'your account'}${result.user?.isPaid ? '' : ' (free plan)'}.`, 'ok');
+      else t.notice(result.message, 'warn');
       return null;
+    }
 
     case '/logout': {
       const { default: logout } = await import('./commands/logout.js');
@@ -2031,14 +2057,14 @@ async function slashCommand(verb, args, ctx) {
       return null;
 
     case '/update':
-      await commands.update.run([], { json: false });
+      await update([], { json: false, interactive: false });
       return null;
 
     case '/banner': {
       // Session header on demand, codex-style.
       const modeApproval = ctx.permissions.mode === 'plan' ? 'read-only'
         : ctx.permissions.mode === 'acceptEdits' ? 'auto-edit'
-        : ctx.permissions.mode === 'bypassPermissions' ? 'off' : 'ask';
+        : ctx.permissions.mode === 'bypassPermissions' ? 'bypass' : 'ask';
       ctx.tui.print(`  ${c.dim(`jaitus v${VERSION}`)}`);
       ctx.tui.print(`  ${c.dim(`model ${ctx.model} · approval ${modeApproval} · ${ctx.flags.cwd}`)}`);
       return null;
@@ -2288,7 +2314,7 @@ const commands = {
     run: (argv, { json }) => {
       const [key, value] = argv;
       const settings = loadSettings();
-      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'mouse'];
+      const ONOFF = ['copyOnSelect', 'wheelAccel', 'autoScroll', 'animations', 'autoCompact', 'mouse', 'autoUpdate'];
       const SECRET = ['braveSearchKey', 'tavilyKey', 'serperKey'];
       if (!key) {
         const e = endpoints();
@@ -2321,7 +2347,7 @@ const commands = {
           ['Auto-scroll', data.autoScroll ? 'on' : 'off'],
           ['Animations', data.animations ? 'on' : 'off'],
           ['Auto-compact', data.autoCompact ? 'on (summarises near the context limit)' : 'off'],
-          ['Mouse', data.mouse ? 'on (wheel scrolls, clicks act; shift+drag selects)' : 'off'],
+          ['Mouse', data.mouse ? 'on (wheel scrolls, clicks act, drag or double-click copies)' : 'off (the terminal selects text itself)'],
           ['Search API', data.searchApi ? `${data.searchApi} (set)` : 'none — using free engines + npm/GitHub/MDN/Stack Overflow'],
           ['Status line', data.statusLine || '(unset — set a command to render one)'],
           ['Config', data.configDir],
@@ -2456,6 +2482,10 @@ export default async function main(argv) {
 
   if (flags.version) { out(VERSION); return 0; }
 
+  // Always on the newest version: install it and reopen before doing anything else.
+  const relaunched = await autoUpdate({ argv, settings: loadSettings() }).catch(() => null);
+  if (relaunched !== null) return relaunched;
+
   const [first, ...others] = rest;
   const cmd = commands[first];
 

package/src/tui/mouse.js

@@ -1,125 +1,150 @@
-// ─── Mouse ──────────────────────────────────────────────────────────────────────
-//
-// Ink has no mouse support, so this is the whole of it: turn the terminal's reporting
-// on, recognise the sequences when they arrive through the ordinary key handler, and
-// turn it off again on the way out.
-//
-// Two things make that safe to do:
-//
-//   • **SGR extended mode (1006) or nothing.** The original X10 encoding packs the
-//     coordinates into single bytes offset by 32, so it cannot report a click past
-//     column 223 — on a wide terminal the right-hand half of the screen silently stops
-//     responding. Every terminal worth enabling this for has supported 1006 for a
-//     decade; the ones that do not simply get no mouse, which is the honest outcome.
-//   • **The sequences arrive as ordinary input.** Ink's key parser does not recognise
-//     them, so it hands them through as a plain string with the leading escape stripped.
-//     That is lucky rather than designed, and it is why the guard below runs before
-//     anything can insert them into the composer — without it, scrolling the wheel types
-//     `[<64;10;5M` into your prompt.
-//
-// Enabling mouse reporting takes over the terminal's own text selection. That is a real
-// cost, not a detail: people select and copy out of a terminal constantly. Hold Shift to
-// get the native behaviour back in every terminal that supports this, and `/mouse off`
-// turns it off for good.
-
-// Button-event tracking (1002) rather than any-event (1003): 1003 reports every pixel of
-// pointer motion, which on a busy screen is thousands of writes a second for information
-// nothing here uses.
-const ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
-const OFF = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
-
-// Ink strips the leading escape, so both spellings have to match.
-const SGR = /^\x1b?\[<(\d+);(\d+);(\d+)([Mm])$/;
-
-// The X10 encoding: `CSI M` followed by three raw bytes. A terminal that does not
-// understand the 1006 request still honours 1000 and reports in this form — and those
-// bytes are unprintable garbage that would otherwise be typed into the composer. It is
-// recognised only to be swallowed: its coordinates top out at column 223, which makes
-// it useless for anything but ignoring.
-const X10 = /^\x1b?\[M[\s\S]{3}$/;
-
-/** True once, per process: never write the disable sequence for something never enabled. */
-let enabled = false;
-
-export function enableMouse(stream = process.stdout) {
-  if (enabled || !stream?.isTTY) return false;
-  try { stream.write(ON); enabled = true; } catch { /* not a real terminal */ }
-  return enabled;
-}
-
-export function disableMouse(stream = process.stdout) {
-  if (!enabled) return;
-  try { stream.write(OFF); } catch { /* going away anyway */ }
-  enabled = false;
-}
-
-export const mouseEnabled = () => enabled;
-
-/**
- * One input string → a mouse event, or null.
- *
- * The button field is a bitfield: the low two bits are which button, bit 5 (32) means
- * the pointer was moving with a button held, and bit 6 (64) means the wheel. Shift, Alt
- * and Ctrl ride in bits 2–4 and are reported so a Shift-click can mean something
- * different from a click.
- */
-export function parseMouse(input) {
-  const m = SGR.exec(String(input ?? ''));
-  if (!m) return null;
-  const code = Number(m[1]);
-  const x = Number(m[2]);
-  const y = Number(m[3]);
-  const pressed = m[4] === 'M';
-
-  const wheel = (code & 64) !== 0;
-  const motion = (code & 32) !== 0;
-  const button = code & 3;
-
-  return {
-    x,
-    y,
-    shift: (code & 4) !== 0,
-    meta: (code & 8) !== 0,
-    ctrl: (code & 16) !== 0,
-    // A wheel "button" of 0 is up and 1 is down; 2 and 3 are horizontal tilt, which is
-    // reported so a future horizontal scroll has somewhere to go rather than being
-    // silently read as a vertical one.
-    kind: wheel
-      ? (button === 0 ? 'wheelUp' : button === 1 ? 'wheelDown' : button === 2 ? 'wheelLeft' : 'wheelRight')
-      : motion ? 'drag'
-        : pressed ? 'down' : 'up',
-    button: wheel ? null : button === 0 ? 'left' : button === 1 ? 'middle' : button === 2 ? 'right' : null,
-  };
-}
-
-/** Does this input look like a mouse report we should swallow rather than type? */
-export const isMouse = (input) => {
-  const s = String(input ?? '');
-  return SGR.test(s) || X10.test(s);
-};
-
-/**
- * A hit map for one frame.
- *
- * The layout is computed in one place, so the regions can be computed there too rather
- * than measured afterwards. Rows and columns are 1-based to match what the terminal
- * reports, and later registrations win — which is what makes an overlay's buttons
- * reachable while the header underneath it is not.
- */
-export function createHitMap() {
-  let regions = [];
-  return {
-    reset() { regions = []; },
-    add(region) { if (region && region.action) regions.push(region); },
-    /** The topmost region containing this cell, or null. */
-    at(x, y) {
-      for (let i = regions.length - 1; i >= 0; i--) {
-        const r = regions[i];
-        if (x >= r.x1 && x <= r.x2 && y >= r.y1 && y <= r.y2) return r;
-      }
-      return null;
-    },
-    get size() { return regions.length; },
-    all() { return regions.slice(); },
-  };
-}
+// ─── Mouse ──────────────────────────────────────────────────────────────────────
+//
+// Ink has no mouse support, so this is the whole of it: turn the terminal's reporting
+// on, recognise the sequences when they arrive through the ordinary key handler, and
+// turn it off again on the way out.
+//
+// Two things make that safe to do:
+//
+//   • **SGR extended mode (1006) or nothing.** The original X10 encoding packs the
+//     coordinates into single bytes offset by 32, so it cannot report a click past
+//     column 223 — on a wide terminal the right-hand half of the screen silently stops
+//     responding. Every terminal worth enabling this for has supported 1006 for a
+//     decade; the ones that do not simply get no mouse, which is the honest outcome.
+//   • **The sequences arrive as ordinary input.** Ink's key parser does not recognise
+//     them, so it hands them through as a plain string with the leading escape stripped.
+//     That is lucky rather than designed, and it is why the guard below runs before
+//     anything can insert them into the composer — without it, scrolling the wheel types
+//     `[<64;10;5M` into your prompt.
+//
+// Enabling mouse reporting takes over the terminal's own text selection. That is a real
+// cost, not a detail: people select and copy out of a terminal constantly. Hold Shift to
+// get the native behaviour back in every terminal that supports this, and `/mouse off`
+// turns it off for good.
+
+// Button-event tracking (1002) rather than any-event (1003): 1003 reports every pixel of
+// pointer motion, which on a busy screen is thousands of writes a second for information
+// nothing here uses.
+const ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+const OFF = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+
+// Ink strips the leading escape, so both spellings have to match.
+const SGR = /^\x1b?\[<(\d+);(\d+);(\d+)([Mm])$/;
+
+// The X10 encoding: `CSI M` followed by three raw bytes, each offset by 32. A terminal
+// that does not understand the 1006 request still honours 1000 and reports in this
+// form. It is decoded rather than swallowed: its coordinates stop at column 223, but
+// below that it is a perfectly good report, and swallowing it meant a terminal without
+// 1006 had no selection at all AND no native one, because reporting was still on.
+const X10 = /^\x1b?\[M([\s\S])([\s\S])([\s\S])$/;
+
+// A report the input layer delivered in pieces. Ink holds an unfinished escape sequence
+// for only 20ms before passing it through as typed text, so a report split across two
+// reads — a busy machine, SSH, a fast trackpad drag — arrived as two halves: the drag
+// was lost and the second half was typed into the prompt as `[<32;15;13M`.
+const SGR_FRAGMENT = /^\x1b?\[<[\d;]*$/;
+const X10_FRAGMENT = /^\x1b?\[M[\s\S]{0,2}$/;
+
+/** True once, per process: never write the disable sequence for something never enabled. */
+let enabled = false;
+
+export function enableMouse(stream = process.stdout) {
+  if (enabled || !stream?.isTTY) return false;
+  try { stream.write(ON); enabled = true; } catch { /* not a real terminal */ }
+  return enabled;
+}
+
+export function disableMouse(stream = process.stdout) {
+  if (!enabled) return;
+  try { stream.write(OFF); } catch { /* going away anyway */ }
+  enabled = false;
+}
+
+export const mouseEnabled = () => enabled;
+
+/**
+ * One input string → a mouse event, or null.
+ *
+ * The button field is a bitfield: the low two bits are which button, bit 5 (32) means
+ * the pointer was moving with a button held, and bit 6 (64) means the wheel. Shift, Alt
+ * and Ctrl ride in bits 2–4 and are reported so a Shift-click can mean something
+ * different from a click.
+ */
+export function parseMouse(input) {
+  const s = String(input ?? '');
+  let code, x, y, pressed;
+  const m = SGR.exec(s);
+  if (m) {
+    code = Number(m[1]);
+    x = Number(m[2]);
+    y = Number(m[3]);
+    pressed = m[4] === 'M';
+  } else {
+    const o = X10.exec(s);
+    if (!o) return null;
+    code = o[1].charCodeAt(0) - 32;
+    x = o[2].charCodeAt(0) - 32;
+    y = o[3].charCodeAt(0) - 32;
+    // X10 has no release suffix: a release is button 3, and it does not say which.
+    pressed = (code & 3) !== 3 || (code & 64) !== 0;
+    if (x < 1 || y < 1) return null;
+  }
+
+  const wheel = (code & 64) !== 0;
+  const motion = (code & 32) !== 0;
+  const button = code & 3;
+
+  return {
+    x,
+    y,
+    shift: (code & 4) !== 0,
+    meta: (code & 8) !== 0,
+    ctrl: (code & 16) !== 0,
+    // A wheel "button" of 0 is up and 1 is down; 2 and 3 are horizontal tilt, which is
+    // reported so a future horizontal scroll has somewhere to go rather than being
+    // silently read as a vertical one.
+    kind: wheel
+      ? (button === 0 ? 'wheelUp' : button === 1 ? 'wheelDown' : button === 2 ? 'wheelLeft' : 'wheelRight')
+      : motion ? 'drag'
+        : pressed ? 'down' : 'up',
+    button: wheel ? null : button === 0 ? 'left' : button === 1 ? 'middle' : button === 2 ? 'right' : null,
+  };
+}
+
+/** The start of a mouse report whose remainder has not arrived yet. */
+export const isMouseFragment = (input) => {
+  const s = String(input ?? '');
+  return (SGR_FRAGMENT.test(s) || X10_FRAGMENT.test(s)) && !SGR.test(s) && !X10.test(s);
+};
+
+/** Does this input look like a mouse report we should swallow rather than type? */
+export const isMouse = (input) => {
+  const s = String(input ?? '');
+  return SGR.test(s) || X10.test(s);
+};
+
+/**
+ * A hit map for one frame.
+ *
+ * The layout is computed in one place, so the regions can be computed there too rather
+ * than measured afterwards. Rows and columns are 1-based to match what the terminal
+ * reports, and later registrations win — which is what makes an overlay's buttons
+ * reachable while the header underneath it is not.
+ */
+export function createHitMap() {
+  let regions = [];
+  return {
+    reset() { regions = []; },
+    add(region) { if (region && region.action) regions.push(region); },
+    /** The topmost region containing this cell, or null. */
+    at(x, y) {
+      for (let i = regions.length - 1; i >= 0; i--) {
+        const r = regions[i];
+        if (x >= r.x1 && x <= r.x2 && y >= r.y1 && y <= r.y2) return r;
+      }
+      return null;
+    },
+    get size() { return regions.length; },
+    all() { return regions.slice(); },
+  };
+}