@yanzc/claude-pro 0.4.6 → 0.5.0

package/src/tools/peers.js

@@ -1,45 +1,52 @@
-// ListPeers and MessagePeer: talk to the other claude-pro sessions running on this machine (see peers.js).
+// ListPeers and MessagePeer: talk to the other claude-pro sessions, on this machine and, through the gateway, on the
+// user's other computers (see peers.js and remote.js).
+
+import { resolvePath } from '../utils/paths.js';
 
 const unavailable = { isError: true, content: 'Talking to other sessions is only available in an interactive session.' };
 
 export const ListPeersTool = {
   name: 'ListPeers',
-  description: 'List the other claude-pro sessions running on this machine (each is an agent with its own conversation, working in its own directory), with the name to send them a message with MessagePeer.',
+  description: 'List the other claude-pro sessions (each is an agent with its own conversation, working in its own directory): those running on this machine, and those on the user\'s other computers that are online at the gateway, with the name to send them a message with MessagePeer.',
   input_schema: { type: 'object', properties: {} },
   summarize() { return ''; },
   async call(input, ctx) {
-    const node = ctx.io?.peers;
-    if (!node) return unavailable;
-    const peers = node.peers();
-    const me = `You are "${node.name}" (${node.cwd}).`;
-    if (!peers.length) return { content: `${me}\nNo other session is running.`, display: { summary: 'No other session' } };
-    return {
-      content: `${me}\nOther sessions:\n${peers.map((p) => `- ${p.name}: working in ${p.cwd}`).join('\n')}`,
-      display: { summary: `${peers.length} other session${peers.length === 1 ? '' : 's'}` },
-    };
+    if (!ctx.io?.listAllPeers) return unavailable;
+    const { me, local, remote, online } = await ctx.io.listAllPeers();
+    const head = `You are "${me.name}" (${me.cwd})${online ? `; sessions on other computers know you as "${me.label}"` : ''}.`;
+    const count = local.length + remote.length;
+    if (!count) return { content: `${head}\nNo other session is running${online ? '' : ' on this machine (this session is not online at the gateway, so sessions on other computers are not listed)'}.`, display: { summary: 'No other session' } };
+    const lines = [head];
+    if (local.length) lines.push('On this machine:', ...local.map((p) => `- ${p.name}: working in ${p.cwd}`));
+    if (remote.length) lines.push('On the user\'s other computers (through the gateway):', ...remote.map((p) => `- ${p.label}: working in ${p.cwd} on the computer "${p.machine}"${p.busy ? ' (busy now)' : ''}`));
+    return { content: lines.join('\n'), display: { summary: `${count} other session${count === 1 ? '' : 's'}` } };
   },
 };
 
 export const MessagePeerTool = {
   name: 'MessagePeer',
-  description: `Send a task or a question to another claude-pro session running on this machine (ListPeers lists them). The other session's agent works on it in its own conversation and directory, and the final text of its answer comes back to you later as a <peer-message kind="reply"> message: you do not wait for it here. Use it to delegate work that belongs to another session's project or context, or to ask it something only it knows. Write the message so that it stands on its own: the other agent has not seen your conversation.
+  description: `Send a task or a question to another claude-pro session, on this machine or on one of the user's other computers (ListPeers lists them). The other session's agent works on it in its own conversation and directory, and the final text of its answer comes back to you later as a <peer-message kind="reply"> message: you do not wait for it here. Use it to delegate work that belongs to another session's project or context, or to ask it something only it knows. Write the message so that it stands on its own: the other agent has not seen your conversation.
 
 Send it once and wait for the answer: do not send reminders or "please report" follow-ups while the other session works. Messages that arrive while it is busy are handled together after what it is doing, so they only add to its work; the answer comes by itself when it is done.`,
   input_schema: {
     type: 'object',
     properties: {
-      to: { type: 'string', description: 'The name of the session (as ListPeers shows it)' },
-      message: { type: 'string', description: 'The task or question, self-contained' },
+      to: { type: 'string', description: 'The name of the session as ListPeers shows it (computer/name for one on another computer)' },
+      message: { type: 'string', description: 'The task or question, self-contained (may be left out when only sending files)' },
+      files: { type: 'array', items: { type: 'string' }, description: 'Paths of files on this computer to send along (at most 20, 5 GB each; large ones go in the background and continue after a network outage). The other session saves them in its computer\'s Downloads folder, and is told where. With files and no message it only saves them and confirms, without working on anything.' },
     },
-    required: ['to', 'message'],
+    required: ['to'],
   },
   summarize(input) { return `@${input.to}`; },
   async call(input, ctx) {
-    const node = ctx.io?.peers;
-    if (!node) return unavailable;
+    if (!ctx.io?.sendToPeer) return unavailable;
+    const files = (Array.isArray(input.files) ? input.files : []).map((p) => resolvePath(String(p), ctx.cwd));
+    if (!String(input.message || '').trim() && !files.length) return { isError: true, content: 'Give a message, or files to send.' };
     try {
-      const { peer } = await ctx.io.sendToPeer(input.to, input.message, { byModel: true });
-      return { content: `Sent to ${peer.name}. Its answer will arrive later as a message; carry on meanwhile, or end your turn if you need the answer first.`, display: { summary: `Sent to ${peer.name}` } };
+      const { peer, background } = await ctx.io.sendToPeer(input.to, String(input.message || ''), { byModel: true, files, background: true });
+      const name = peer.label || peer.name;
+      if (background) return { content: `Sending ${files.length} file${files.length === 1 ? '' : 's'} to ${name} in the background (the user sees the progress); the message goes out once they are uploaded, and the answer of ${name} comes back later as a message. Carry on meanwhile, or end your turn.`, display: { summary: `Sending ${files.length} file${files.length === 1 ? '' : 's'} to ${name}` } };
+      return { content: `Sent to ${name}. Its answer will arrive later as a message; carry on meanwhile, or end your turn if you need the answer first.`, display: { summary: `Sent to ${name}` } };
     } catch (e) {
       return { isError: true, content: e.message };
     }

package/src/transfer.js

@@ -0,0 +1,260 @@
+// Files between the sessions of a gateway account (see remote.js): resumable uploads in chunks, and downloads that
+// continue with Range requests, so that a 2 GB video survives a network outage. Nothing holds a whole file in
+// memory: uploads read a chunk at a time, downloads stream to a .part file in the target folder.
+//
+// Upload: POST /v1/remote/uploads {name, size, sha256} -> {id, received, chunkSize} (the same unfinished upload
+// again for the same file: sending it again later continues it), then PUT /v1/remote/uploads/:id with
+// x-upload-offset = received, one chunk at a time, until {complete: true, file}. A 409 says where the gateway is.
+// Download: GET /v1/remote/files/:id, with Range: bytes=N- to continue; checked against its sha256 at the end.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { safeFileName } from './utils/downloads.js';
+
+const CHUNK = 8 * 1024 * 1024;
+const MIN_CHUNK = 256 * 1024;
+const MAX_CHUNK = 16 * 1024 * 1024;
+export const RETRY_FOR_MS = 60 * 60 * 1000; // keep trying through a network outage this long
+const IDLE_MS = 60_000; // a download that receives nothing this long is cut, and continued
+
+const abortError = () => Object.assign(new Error('stopped'), { name: 'AbortError' });
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) { reject(abortError()); return; }
+    const timer = setTimeout(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, ms);
+    const onAbort = () => { clearTimeout(timer); reject(abortError()); };
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+// What is worth waiting out: no answer at all (the network), a timeout, the gateway overloaded or restarting. Not
+// a gateway out of disk space (507) or one that lacks the feature (501): waiting an hour would not change that.
+export const transient = (e) => e?.name !== 'AbortError' && (!e?.status || (e.status >= 500 && e.status !== 501 && e.status !== 507) || e.status === 429 || e.status === 408);
+
+const signalWith = (signal, ms) => (signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms));
+
+// One request to the gateway; a failure carries {status, data} (data: the JSON of the error, when there is one).
+async function api(client, method, route, { json, body, headers = {}, timeout = 30_000, signal } = {}) {
+  let res;
+  try {
+    res = await client.fetch(`${client.base}${route}`, {
+      method,
+      headers: { authorization: `Bearer ${client.apiKey}`, ...(json !== undefined ? { 'content-type': 'application/json' } : {}), ...headers },
+      body: json !== undefined ? JSON.stringify(json) : body,
+      signal: signalWith(signal, timeout),
+    });
+  } catch (e) {
+    if (signal?.aborted) throw abortError();
+    throw e;
+  }
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const message = data?.error?.message || (typeof data?.error === 'string' ? data.error : `HTTP ${res.status}`);
+    const missing = res.status === 404 && /\/uploads$/.test(route) ? `the gateway ${client.base} does not take files (yet)` : null;
+    throw Object.assign(new Error(missing || String(message)), { status: res.status, data });
+  }
+  return data;
+}
+
+export async function hashFile(file, { signal, onProgress } = {}) {
+  const hash = crypto.createHash('sha256');
+  let done = 0;
+  for await (const chunk of fs.createReadStream(file, { highWaterMark: 1 << 20, signal })) {
+    hash.update(chunk);
+    done += chunk.length;
+    onProgress?.(done);
+  }
+  return hash.digest('hex');
+}
+
+// Put the file `{path, name, size}` on the gateway: resolves with {id, name, size, sha256}, the id a message's
+// files refer to. onProgress({phase: 'hashing'|'sending'|'waiting', done, total, error, retryIn}).
+export async function uploadFile(client, file, { signal, onProgress = () => {}, retryForMs = RETRY_FOR_MS } = {}) {
+  const { size } = file;
+  onProgress({ phase: 'hashing', done: 0, total: size });
+  const sha256 = await hashFile(file.path, { signal, onProgress: (done) => onProgress({ phase: 'hashing', done, total: size }) });
+  let failingSince = 0;
+  let wait = 1000;
+  // A failure worth waiting out: wait (1 s, 2 s... 30 s), for an hour at most since the last thing that worked.
+  const waitOut = async (e, done) => {
+    if (signal?.aborted) throw abortError();
+    if (!transient(e)) throw e;
+    failingSince ||= Date.now();
+    if (Date.now() - failingSince > retryForMs) throw e;
+    onProgress({ phase: 'waiting', done, total: size, error: e.message, retryIn: wait });
+    await sleep(wait, signal);
+    wait = Math.min(wait * 2, 30_000);
+  };
+  const start = async () => {
+    for (;;) {
+      try { return await api(client, 'POST', '/v1/remote/uploads', { json: { name: file.name, size, sha256 }, signal }); } catch (e) { await waitOut(e, 0); }
+    }
+  };
+  let up = await start();
+  if (up.complete && up.file) return up.file;
+  const chunkSize = Math.max(MIN_CHUNK, Math.min(MAX_CHUNK, Number(up.chunkSize) || CHUNK));
+  let received = Number(up.received) || 0;
+  let restarts = 0;
+  const fd = fs.openSync(file.path, 'r');
+  try {
+    for (;;) {
+      if (signal?.aborted) throw abortError();
+      try {
+        const len = Math.max(0, Math.min(chunkSize, size - received));
+        const chunk = Buffer.alloc(len);
+        if (len) fs.readSync(fd, chunk, 0, len, received);
+        const r = await api(client, 'PUT', `/v1/remote/uploads/${encodeURIComponent(up.id)}`, {
+          body: chunk, headers: { 'content-type': 'application/octet-stream', 'x-upload-offset': String(received) },
+          timeout: 60_000 + Math.ceil(len / 50), signal, // at least 50 KB/s
+        });
+        received = Number(r.received) || received + len;
+        failingSince = 0;
+        wait = 1000;
+        onProgress({ phase: 'sending', done: received, total: size });
+        if (r.complete && r.file) return r.file;
+      } catch (e) {
+        if (e.status === 409 && Number.isFinite(Number(e.data?.received))) {
+          // the gateway has more (or less) than was thought: a chunk cut off midway counted in part
+          received = Number(e.data.received);
+          if (e.data.complete && e.data.file) return e.data.file;
+          if (received >= size) {
+            const st = await api(client, 'GET', `/v1/remote/uploads/${encodeURIComponent(up.id)}`, { signal });
+            if (st.complete && st.file) return st.file;
+          }
+          continue;
+        }
+        if (e.status === 404 && restarts < 3) { // the gateway dropped it (expired): start over
+          restarts++;
+          up = await start();
+          if (up.complete && up.file) return up.file;
+          received = Number(up.received) || 0;
+          continue;
+        }
+        if (e.status === 422) throw new Error(`${file.name} changed while it was being sent (checksum): send it again`);
+        await waitOut(e, received);
+      }
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// Move `part` into `dir` as `name`, or "name (1).ext"... when that is taken: never over an existing file.
+export function moveUnique(part, dir, name) {
+  const safe = safeFileName(name);
+  const ext = path.extname(safe);
+  const stem = safe.slice(0, safe.length - ext.length);
+  for (let i = 0; i < 1000; i++) {
+    const target = path.join(dir, i ? `${stem} (${i})${ext}` : safe);
+    try {
+      fs.linkSync(part, target); // fails when the name is taken, unlike a rename
+      fs.unlinkSync(part);
+      return target;
+    } catch (e) {
+      if (e.code === 'EEXIST') continue;
+      if (fs.existsSync(target)) continue;
+      fs.renameSync(part, target); // a file system without hard links
+      return target;
+    }
+  }
+  throw new Error(`too many files called ${safe} in ${dir}`);
+}
+
+// Copy a file of this computer into `dir` (a session on the same computer sent it), never over an existing file.
+export async function copyUnique(src, dir, name) {
+  fs.mkdirSync(dir, { recursive: true });
+  const safe = safeFileName(name);
+  const ext = path.extname(safe);
+  const stem = safe.slice(0, safe.length - ext.length);
+  for (let i = 0; i < 1000; i++) {
+    const target = path.join(dir, i ? `${stem} (${i})${ext}` : safe);
+    try {
+      await fs.promises.copyFile(src, target, fs.constants.COPYFILE_EXCL);
+      return target;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+    }
+  }
+  throw new Error(`too many files called ${safe} in ${dir}`);
+}
+
+// The file `{id, name, size, sha256}` from the gateway into `dir`: resolves with the path it was saved at. It
+// streams into a .part file named after the file's id, which a later attempt (after a restart too) continues.
+export async function downloadFile(client, file, dir, { signal, onProgress = () => {}, retryForMs = RETRY_FOR_MS } = {}) {
+  fs.mkdirSync(dir, { recursive: true });
+  const part = path.join(dir, `.${String(file.id).replace(/[^\w-]/g, '_')}.claude-pro-part`);
+  const total = Number(file.size) || 0;
+  try {
+    const { bavail, bsize } = fs.statfsSync(dir);
+    const have = fs.existsSync(part) ? fs.statSync(part).size : 0;
+    if (total - have > bavail * bsize) throw new Error(`not enough free space in ${dir} (${Math.round(total / 1048576)} MB needed)`);
+  } catch (e) {
+    if (/free space/.test(e.message)) throw e; // statfs itself not available: just try
+  }
+  let failingSince = 0;
+  let wait = 1000;
+  let fresh = false; // started over once after a checksum failure
+  for (;;) {
+    if (signal?.aborted) throw abortError();
+    let have = fs.existsSync(part) ? fs.statSync(part).size : 0;
+    if (have > total && total) { fs.truncateSync(part, 0); have = 0; }
+    try {
+      if (have < total || !fs.existsSync(part)) {
+        const idle = new AbortController();
+        let timer = setTimeout(() => idle.abort(), IDLE_MS);
+        const res = await client.fetch(`${client.base}/v1/remote/files/${encodeURIComponent(file.id)}`, {
+          headers: { authorization: `Bearer ${client.apiKey}`, ...(have ? { range: `bytes=${have}-` } : {}) },
+          signal: signal ? AbortSignal.any([signal, idle.signal]) : idle.signal,
+        });
+        if (!res.ok && res.status !== 206) {
+          const data = await res.json().catch(() => ({}));
+          throw Object.assign(new Error(data?.error?.message || `HTTP ${res.status}`), { status: res.status });
+        }
+        if (have && res.status !== 206) have = 0; // the range was not honoured: from the start
+        let done = have;
+        const count = new Transform({
+          transform(chunk, _enc, cb) {
+            clearTimeout(timer);
+            timer = setTimeout(() => idle.abort(), IDLE_MS);
+            done += chunk.length;
+            onProgress({ phase: 'receiving', done, total });
+            cb(null, chunk);
+          },
+        });
+        try {
+          await pipeline(Readable.fromWeb(res.body), count, fs.createWriteStream(part, { flags: have ? 'a' : 'w' }));
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      const got = fs.statSync(part).size;
+      if (total && got < total) throw Object.assign(new Error('the download stopped early'), { status: 0 });
+      if (file.sha256) {
+        onProgress({ phase: 'checking', done: got, total });
+        if ((await hashFile(part, { signal })) !== String(file.sha256).toLowerCase()) {
+          fs.rmSync(part, { force: true });
+          if (fresh) throw new Error(`${file.name} arrived damaged twice (checksum)`);
+          fresh = true;
+          continue;
+        }
+      }
+      return moveUnique(part, dir, file.name);
+    } catch (caught) {
+      if (signal?.aborted) throw abortError();
+      // cut for receiving nothing for a while: the network, not the user
+      const e = caught?.name === 'AbortError' ? Object.assign(new Error('nothing arrived for a minute'), { status: 0 }) : caught;
+      if (!transient(e)) throw e;
+      const now = fs.existsSync(part) ? fs.statSync(part).size : 0;
+      if (now > have) { failingSince = 0; wait = 1000; } // it got further: the hour starts again
+      failingSince ||= Date.now();
+      if (Date.now() - failingSince > retryForMs) throw e;
+      onProgress({ phase: 'waiting', done: now, total, error: e.message, retryIn: wait });
+      await sleep(wait, signal);
+      wait = Math.min(wait * 2, 30_000);
+    }
+  }
+}

package/src/ui/dialogs.js

@@ -19,7 +19,8 @@ function box(lines, width, color) {
 
 export class SelectDialog {
   // options: [{label, value, description?}]
-  constructor({ title, body = [], question, options, color = c.permission, multi = false, footer, onResolve, cancelValue = null, otherOption = false }) {
+  // selected: the option highlighted at first.
+  constructor({ title, body = [], question, options, color = c.permission, multi = false, footer, onResolve, cancelValue = null, otherOption = false, selected = 0 }) {
     this.title = title;
     this.body = body;
     this.question = question;
@@ -29,7 +30,7 @@ export class SelectDialog {
     this.footer = footer;
     this.onResolve = onResolve;
     this.cancelValue = cancelValue;
-    this.selected = 0;
+    this.selected = Math.max(0, Math.min(selected, this.options.length - 1));
     this.checked = new Set();
     this.other = null; // Editor when typing a custom answer
   }

package/src/ui/editor.js

@@ -53,6 +53,34 @@ function wordLeft(text, i) {
   return j;
 }
 
+// How `body` is shown in a box `textW` columns wide: its rows, each with the cursor stops on it ({i: index in
+// body, col}). A long line wraps onto more rows; every index has exactly one stop (one where a row wraps is at the
+// start of the next row, the end of a line is where its newline is). The input box draws these rows, and up and
+// down move between them, so that they move through a long wrapped line too.
+export function layoutRows(body, textW) {
+  const row = () => ({ text: '', width: 0, stops: [] });
+  const rows = [row()];
+  let idx = 0;
+  for (const g of graphemes(body)) {
+    let r = rows[rows.length - 1];
+    if (g === '\n') {
+      r.stops.push({ i: idx, col: r.width });
+      rows.push(row());
+    } else {
+      const w = graphemeWidth(g);
+      if (r.width && r.width + w > textW) { r = row(); rows.push(r); }
+      r.stops.push({ i: idx, col: r.width });
+      r.text += g === '\t' ? '    ' : g;
+      r.width += w;
+    }
+    idx += g.length;
+  }
+  let last = rows[rows.length - 1];
+  if (last.width >= textW) { last = row(); rows.push(last); }
+  last.stops.push({ i: body.length, col: last.width });
+  return rows;
+}
+
 function wordRight(text, i) {
   let j = i;
   while (j < text.length && /\s/.test(text[j])) j++;
@@ -61,7 +89,8 @@ function wordRight(text, i) {
 }
 
 export class Editor {
-  constructor({ history = [], onSubmit, getSuggestions, onChange, imageFromPath } = {}) {
+  // onDoubleEscape: esc esc on an empty prompt (the App opens the rewind menu, as Claude Code does).
+  constructor({ history = [], onSubmit, getSuggestions, onChange, imageFromPath, onDoubleEscape } = {}) {
     this.text = '';
     this.cursor = 0;
     this.history = history; // oldest first
@@ -82,6 +111,9 @@ export class Editor {
     this.pendingSubmit = null;
     this.lastEscape = 0;
     this.suggestionsDismissedFor = null;
+    this.onDoubleEscape = onDoubleEscape;
+    this.textW = 76; // the width of the text in the box, as last drawn: up and down move by the rows shown
+    this.goalCol = null; // the column up and down aim for, kept while they are pressed in a row
   }
 
   get mode() {
@@ -114,6 +146,29 @@ export class Editor {
     this.clear();
   }
 
+  // The rows the text is shown in (see layoutRows), and the row and column of the cursor among them.
+  place() {
+    const offset = this.mode === 'prompt' ? 0 : 1; // the ! or # is drawn as the prompt sign, not as text
+    const rows = layoutRows(this.text.slice(offset), this.textW);
+    const at = Math.max(0, this.cursor - offset);
+    let r = 0;
+    let col = 0;
+    rows.forEach((row, ri) => { for (const st of row.stops) if (st.i <= at) { r = ri; col = st.col; } });
+    return { rows, r, col, offset };
+  }
+
+  // Up (-1) or down (1) a row shown, towards the column it started from. False on the first / last row.
+  moveRow(dir) {
+    const { rows, r, col, offset } = this.place();
+    const target = r + dir;
+    if (target < 0 || target >= rows.length) return false;
+    this.goalCol ??= col;
+    let best = rows[target].stops[0];
+    for (const st of rows[target].stops) if (st.col <= this.goalCol) best = st;
+    this.set(this.text, best.i + offset);
+    return true;
+  }
+
   restoreCleared() {
     const d = this.cleared;
     if (!d || this.text || this.historyIndex !== null) return false;
@@ -209,6 +264,7 @@ export class Editor {
     }
 
     const name = key.name;
+    if (!(name === 'up' || name === 'down' || (key.ctrl && (name === 'p' || name === 'n')))) this.goalCol = null;
     if (name === 'return' && !key.meta && !key.shift) {
       if (this.suggestions) {
         const item = this.acceptSuggestion();
@@ -233,33 +289,25 @@ export class Editor {
     }
     if (name === 'escape') {
       if (this.suggestions) { this.suggestionsDismissedFor = this.text; this.suggestions = null; return true; }
-      if (key.meta && this.text) { this.discard(); return true; } // ESC ESC arriving in one chunk
       const now = Date.now();
-      if (this.text && now - this.lastEscape < 800) { this.discard(); this.lastEscape = 0; return true; }
+      const twice = key.meta || now - this.lastEscape < 800; // meta: ESC ESC arriving in one chunk
+      if (twice && this.text) { this.discard(); this.lastEscape = 0; return true; }
+      if (twice && this.onDoubleEscape) { this.lastEscape = 0; this.onDoubleEscape(); return true; }
       this.lastEscape = now;
       return false;
     }
+    // Up and down move through the rows shown, a long line's wrapped rows too. On the first row up goes to the
+    // start of the text first (when there is more than one row), and only from there to the history; down likewise.
     if (name === 'up' || (key.ctrl && name === 'p')) {
       if (this.suggestions) { this.selected = (this.selected - 1 + this.suggestions.items.length) % this.suggestions.items.length; this.onChange?.(); return true; }
-      const lineStart = lineStartOf(this.text, this.cursor);
-      if (lineStart > 0) {
-        const col = this.cursor - lineStart;
-        const prevStart = lineStartOf(this.text, lineStart - 1);
-        this.set(this.text, Math.min(prevStart + col, lineStart - 1));
-        return true;
-      }
+      if (this.moveRow(-1)) return true;
+      if (this.cursor > 0 && this.place().rows.length > 1) { this.set(this.text, 0); return true; }
       return this.restoreCleared() || this.historyPrev();
     }
     if (name === 'down' || (key.ctrl && name === 'n')) {
       if (this.suggestions) { this.selected = (this.selected + 1) % this.suggestions.items.length; this.onChange?.(); return true; }
-      const lineEnd = this.text.indexOf('\n', this.cursor);
-      if (lineEnd >= 0) {
-        const lineStart = lineStartOf(this.text, this.cursor);
-        const col = this.cursor - lineStart;
-        const nextEnd = this.text.indexOf('\n', lineEnd + 1);
-        this.set(this.text, Math.min(lineEnd + 1 + col, nextEnd < 0 ? this.text.length : nextEnd));
-        return true;
-      }
+      if (this.moveRow(1)) return true;
+      if (this.cursor < this.text.length && this.place().rows.length > 1) { this.set(this.text, this.text.length); return true; }
       return this.historyNext();
     }
     if (name === 'left' || (key.ctrl && name === 'b')) {
@@ -327,6 +375,7 @@ export class Editor {
   }
 
   historyPrev() {
+    this.goalCol = null;
     if (!this.history.length) return true;
     if (this.historyIndex === null) { this.draft = this.text; this.historyIndex = this.history.length; }
     if (this.historyIndex > 0) {
@@ -337,6 +386,7 @@ export class Editor {
   }
 
   historyNext() {
+    this.goalCol = null;
     if (this.historyIndex === null) return true;
     this.historyIndex++;
     if (this.historyIndex >= this.history.length) {
@@ -357,29 +407,10 @@ export class Editor {
     const color = borderColor || (mode === 'bash' ? c.magenta : mode === 'memory' ? c.blue : c.gray);
     const promptCh = mode === 'bash' ? '!' : mode === 'memory' ? '#' : '>';
     const body = mode === 'prompt' ? this.text : this.text.slice(1);
-    const offset = mode === 'prompt' ? 0 : 1;
-    const cursorIdx = Math.max(0, this.cursor - offset);
-
-    const rows = [''];
-    const widths = [0];
-    let cur = null;
-    let idx = 0;
-    for (const g of graphemes(body)) {
-      if (idx === cursorIdx) cur = { row: rows.length - 1, col: widths[widths.length - 1] };
-      if (g === '\n') {
-        rows.push(''); widths.push(0);
-      } else {
-        const w = graphemeWidth(g);
-        if (widths[widths.length - 1] + w > textW) { rows.push(''); widths.push(0); if (idx === cursorIdx) cur = { row: rows.length - 1, col: 0 }; }
-        rows[rows.length - 1] += g === '\t' ? '    ' : g;
-        widths[widths.length - 1] += w;
-      }
-      idx += g.length;
-    }
-    if (!cur) {
-      cur = { row: rows.length - 1, col: widths[widths.length - 1] };
-      if (cur.col >= textW) { rows.push(''); widths.push(0); cur = { row: rows.length - 1, col: 0 }; }
-    }
+    this.textW = textW;
+    const { rows: laid, r, col } = this.place();
+    const rows = laid.map((row) => row.text);
+    const cur = { row: r, col };
 
     const lines = [topBorder(boxW, color, title)];
     rows.forEach((r, i) => {