@yanzc/claude-pro 0.4.6 → 0.5.1

package/src/peers.js

@@ -1,9 +1,12 @@
 // Peers: the other interactive claude-pro sessions on this machine. Each session registers itself in
 // CONFIG_DIR/peers/<id>.json (name, directory, pid, and a port and token of a small HTTP server on 127.0.0.1)
-// so that sessions can send each other tasks: the user with `@name task` in the input box, the model with the
+// so that sessions can send each other tasks: the user with `&name task` in the input box, the model with the
 // MessagePeer tool. A task is answered automatically with the final text of the turn that handled it.
+// Sessions on the user's other computers are reached through the gateway instead (see remote.js): they are
+// listed as {id, name, machine, cwd, remote: true, label: 'machine/name'} and addressed by that label.
 
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import http from 'node:http';
 import crypto from 'node:crypto';
@@ -20,7 +23,7 @@ function alive(pid) {
   try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
 }
 
-export const cleanName = (s) => String(s || '').replace(/[^\w.-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'agent';
+export const cleanName = (s) => String(s || '').replace(/[^\p{L}\p{M}\p{N}_.-]+/gu, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'agent';
 
 // The sessions that are running now (stale entries of sessions that died are removed).
 export function listPeers({ excludeId } = {}) {
@@ -37,8 +40,34 @@ export function listPeers({ excludeId } = {}) {
   return peers.sort((a, b) => a.startedAt - b.startedAt);
 }
 
+// The name of this computer for sessions on the other computers: CLAUDE_PRO_MACHINE_NAME (公司, home...), else
+// the host name. Letters of any script, digits, _ . and -.
+export function machineName(env = process.env) {
+  const raw = env.CLAUDE_PRO_MACHINE_NAME || os.hostname() || 'computer';
+  return String(raw).replace(/[^\p{L}\p{M}\p{N}_.-]+/gu, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'computer';
+}
+
+// Find the session `ref` (with or without @) names among the local ones and those on other computers: a local
+// name (or id prefix); else machine/name, a name only one remote session has, a computer with only one session
+// (`&公司`), or an id prefix. `ids: false` leaves the id prefixes out (for what the user types).
+// Returns {peer}, {error, ambiguous: true} when several match, or {error: null} when none does.
+export function resolvePeer(local, remote, ref, { ids = true } = {}) {
+  const q = String(ref || '').replace(/^[@&＆]/, '').toLowerCase();
+  if (!q) return { error: null };
+  const near = ids ? findPeer(local, q) : local.find((p) => p.name.toLowerCase() === q);
+  if (near) return { peer: near };
+  const same = (v) => String(v || '').toLowerCase() === q;
+  let hits = remote.filter((p) => same(p.label));
+  if (!hits.length) hits = remote.filter((p) => same(p.name));
+  if (!hits.length) hits = remote.filter((p) => same(p.machine));
+  if (!hits.length && ids && q.length >= 4) hits = remote.filter((p) => p.id.toLowerCase().startsWith(q));
+  if (hits.length === 1) return { peer: hits[0] };
+  if (hits.length > 1) return { error: `"&${String(ref).replace(/^[@&＆]/, '')}" could be ${hits.map((p) => '&' + p.label).join(', ')}: say which.`, ambiguous: true };
+  return { error: null };
+}
+
 export function findPeer(peers, ref) {
-  const q = String(ref || '').replace(/^@/, '').toLowerCase();
+  const q = String(ref || '').replace(/^[@&＆]/, '').toLowerCase();
   if (!q) return null;
   return peers.find((p) => p.name.toLowerCase() === q) || peers.find((p) => p.id.startsWith(q)) || null;
 }
@@ -116,15 +145,18 @@ export class PeerNode {
       if (typeof msg?.text !== 'string' || !msg.from?.name) return reply(400, { error: 'text and from are required' });
       const id = crypto.randomBytes(4).toString('hex');
       reply(200, { ok: true, id, name: this.name });
-      try { this.onMessage?.({ id, kind: msg.kind === 'reply' ? 'reply' : 'task', text: msg.text, inReplyTo: msg.inReplyTo || null, from: msg.from }); } catch { /* the receiver's problem */ }
+      // files on this computer: [{path, name, size}] (the receiver copies them where it keeps what it is sent)
+      const files = (Array.isArray(msg.files) ? msg.files : []).filter((f) => f && typeof f.path === 'string' && path.isAbsolute(f.path))
+        .map((f) => ({ path: f.path, name: String(f.name || path.basename(f.path)), size: Number(f.size) || 0 }));
+      try { this.onMessage?.({ id, kind: msg.kind === 'reply' ? 'reply' : 'task', text: msg.text, inReplyTo: msg.inReplyTo || null, from: msg.from, ...(files.length ? { files } : {}) }); } catch { /* the receiver's problem */ }
     });
   }
 
   // Send to a peer (an entry of peers(), or its name). Resolves with {id} (the id the receiver gave the message).
-  async send(target, { text, kind = 'task', inReplyTo = null }) {
+  async send(target, { text, kind = 'task', inReplyTo = null, files = [] }) {
     const peer = typeof target === 'string' ? findPeer(this.peers(), target) : target;
     if (!peer) throw new Error(`No running session called "${target}". /peers lists them.`);
-    const body = JSON.stringify({ kind, text, inReplyTo, from: { id: this.id, name: this.name, cwd: this.cwd } });
+    const body = JSON.stringify({ kind, text, inReplyTo, from: { id: this.id, name: this.name, cwd: this.cwd }, ...(files.length ? { files } : {}) });
     return await new Promise((resolve, reject) => {
       const req = http.request({
         host: '127.0.0.1', port: peer.port, path: '/message', method: 'POST', timeout: 10_000,
@@ -149,7 +181,8 @@ export class PeerNode {
 
 // What the model is given for a message from another session.
 export function peerMessagePrompt(msg) {
-  const from = `${msg.from.name}${msg.from.cwd ? ` (working in ${msg.from.cwd})` : ''}`;
+  const where = msg.from.machine ? ` on the computer "${msg.from.machine}"` : '';
+  const from = `${msg.from.name}${msg.from.cwd ? ` (working in ${msg.from.cwd}${where})` : where}`;
   if (msg.kind === 'reply') {
     return `<peer-message from="${msg.from.name}" kind="reply">\n${msg.text}\n</peer-message>\n<system-reminder>This is the answer of another ${'claude-pro'} session, ${from}, to a message you sent it with MessagePeer. Carry on with your task using it.</system-reminder>`;
   }

package/src/prompts.js

@@ -151,6 +151,23 @@ Write the summary in the same language the user has been using.
 Do NOT call any tools. Respond with text only.${instructions ? `\n\nAdditional instructions from the user for this summary:\n${instructions}` : ''}`;
 }
 
+// The instruction for /rewind's "Summarize from here" (part 'after') and "Summarize up to here" ('before'): only
+// that part of the conversation is summarized, the rest stays in it word for word.
+export function partialCompactPrompt(part, label, instructions = '') {
+  const at = label ? `the user's message that begins "${String(label).slice(0, 200)}"` : 'the point the user chose';
+  const scope = part === 'before'
+    ? `Summarize ONLY the part of the conversation BEFORE ${at}. That message and everything after it stay in the conversation word for word: do not summarize them. The summary replaces only what comes before that message, so it has to carry everything from that earlier part that the rest of the conversation builds on.`
+    : `Summarize ONLY the part of the conversation that starts with ${at} (that message included) and goes on to the end. Everything before that message stays in the conversation word for word: do not summarize it. The summary replaces only that later part.`;
+  return compactPrompt(`${scope}${instructions ? `\n${instructions}` : ''}`);
+}
+
+// The message that stands in the conversation for the part a partial summary replaced.
+export function partialSummaryMessage(part, summary) {
+  return part === 'before'
+    ? `[Summarized conversation] The earlier part of this conversation was summarized at the user's request; the messages after this one are as they were. The summary of the earlier part:\n${summary}`
+    : `[Summarized conversation] The later part of this conversation, from the user's message where this summary stands to where it was, was summarized at the user's request. The summary of that part:\n${summary}`;
+}
+
 export function continuationMessage(summary, { auto }) {
   return `This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:
 ${summary}${auto ? '\n\nPlease continue the conversation from where we left it off without asking the user any further questions. Continue with the last task that you were asked to work on.' : ''}`;

package/src/qr.js

@@ -0,0 +1,206 @@
+// QR codes in the terminal: /remote-control prints one, so that a phone opens the session by pointing its camera
+// at the screen. Byte mode, error correction level L, versions 1-6 (up to 134 bytes, which a URL with a token
+// fits in easily); the mask is chosen with the standard penalty rules.
+
+// [EC codewords per block, blocks, data codewords per block] at level L, by version.
+const EC_L = [null, [7, 1, 19], [10, 1, 34], [15, 1, 55], [20, 1, 80], [26, 1, 108], [18, 2, 68]];
+const MAX_VERSION = 6;
+
+// GF(256) with the polynomial 0x11d.
+const EXP = new Uint8Array(512);
+const LOG = new Uint8Array(256);
+for (let i = 0, x = 1; i < 255; i++) {
+  EXP[i] = x;
+  LOG[x] = i;
+  x <<= 1;
+  if (x & 0x100) x ^= 0x11d;
+}
+for (let i = 255; i < 512; i++) EXP[i] = EXP[i - 255];
+const mul = (a, b) => (a && b ? EXP[LOG[a] + LOG[b]] : 0);
+
+function rsRemainder(data, n) {
+  let gen = [1]; // (x - a^0)(x - a^1)...(x - a^(n-1)), highest degree first
+  for (let i = 0; i < n; i++) {
+    const next = new Array(gen.length + 1).fill(0);
+    for (let j = 0; j < gen.length; j++) { next[j] ^= gen[j]; next[j + 1] ^= mul(gen[j], EXP[i]); }
+    gen = next;
+  }
+  const rem = new Array(n).fill(0);
+  for (const byte of data) {
+    const factor = byte ^ rem.shift();
+    rem.push(0);
+    for (let i = 0; i < n; i++) rem[i] ^= mul(gen[i + 1], factor);
+  }
+  return rem;
+}
+
+function codewords(bytes, version) {
+  const [ecLen, blocks, dataLen] = EC_L[version];
+  const capacity = blocks * dataLen;
+  const bits = [];
+  const put = (value, len) => { for (let i = len - 1; i >= 0; i--) bits.push((value >>> i) & 1); };
+  put(0b0100, 4);
+  put(bytes.length, 8);
+  for (const b of bytes) put(b, 8);
+  put(0, Math.min(4, capacity * 8 - bits.length));
+  while (bits.length % 8) bits.push(0);
+  const data = [];
+  for (let i = 0; i < bits.length; i += 8) data.push(bits.slice(i, i + 8).reduce((v, b) => (v << 1) | b, 0));
+  for (let pad = 0xec; data.length < capacity; pad ^= 0xec ^ 0x11) data.push(pad);
+  const dataBlocks = [];
+  const ecBlocks = [];
+  for (let b = 0; b < blocks; b++) {
+    const d = data.slice(b * dataLen, (b + 1) * dataLen);
+    dataBlocks.push(d);
+    ecBlocks.push(rsRemainder(d, ecLen));
+  }
+  const out = [];
+  for (let i = 0; i < dataLen; i++) for (const d of dataBlocks) out.push(d[i]);
+  for (let i = 0; i < ecLen; i++) for (const e of ecBlocks) out.push(e[i]);
+  return out;
+}
+
+const MASKS = [
+  (x, y) => (x + y) % 2 === 0,
+  (x, y) => y % 2 === 0,
+  (x) => x % 3 === 0,
+  (x, y) => (x + y) % 3 === 0,
+  (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+  (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+  (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+  (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+];
+
+function penalty(m) {
+  const n = m.length;
+  let score = 0;
+  let dark = 0;
+  const lines = [];
+  for (let i = 0; i < n; i++) {
+    lines.push(m[i]);
+    lines.push(m.map((row) => row[i]));
+  }
+  for (const line of lines) {
+    for (let i = 0; i < n;) {
+      let j = i;
+      while (j < n && line[j] === line[i]) j++;
+      if (j - i >= 5) score += 3 + (j - i - 5);
+      i = j;
+    }
+    const s = line.map((v) => (v ? 1 : 0)).join('');
+    for (const p of ['10111010000', '00001011101']) for (let k = s.indexOf(p); k >= 0; k = s.indexOf(p, k + 1)) score += 40;
+  }
+  for (let y = 0; y < n; y++) {
+    for (let x = 0; x < n; x++) {
+      if (m[y][x]) dark++;
+      if (x < n - 1 && y < n - 1 && m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1]) score += 3;
+    }
+  }
+  return score + 10 * Math.floor(Math.abs((dark * 100) / (n * n) - 50) / 5);
+}
+
+// The modules of the QR code for `text` (rows of booleans, true = dark), or null when it is too long.
+// `mask`: use this mask (0-7) instead of the best one.
+export function qrMatrix(text, { mask: forcedMask } = {}) {
+  const bytes = [...Buffer.from(String(text), 'utf8')];
+  let version = 1;
+  while (version <= MAX_VERSION && EC_L[version][1] * EC_L[version][2] * 8 < 12 + 8 * bytes.length) version++;
+  if (version > MAX_VERSION) return null;
+  const size = 17 + 4 * version;
+  const base = Array.from({ length: size }, () => new Array(size).fill(false));
+  const fn = Array.from({ length: size }, () => new Array(size).fill(false));
+  const set = (m, x, y, dark) => { m[y][x] = dark; fn[y][x] = true; };
+
+  for (const [cx, cy] of [[3, 3], [size - 4, 3], [3, size - 4]]) {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const x = cx + dx;
+        const y = cy + dy;
+        if (x < 0 || y < 0 || x >= size || y >= size) continue;
+        const d = Math.max(Math.abs(dx), Math.abs(dy));
+        set(base, x, y, d !== 2 && d !== 4);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (!fn[6][i]) set(base, i, 6, i % 2 === 0);
+    if (!fn[i][6]) set(base, 6, i, i % 2 === 0);
+  }
+  if (version >= 2) {
+    const c = size - 7;
+    for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) set(base, c + dx, c + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+  }
+  const drawFormat = (m, mask) => {
+    const data = (1 << 3) | mask; // level L = 01
+    let rem = data;
+    for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+    const bits = ((data << 10) | rem) ^ 0x5412;
+    const bit = (i) => ((bits >>> i) & 1) === 1;
+    for (let i = 0; i <= 5; i++) set(m, 8, i, bit(i));
+    set(m, 8, 7, bit(6));
+    set(m, 8, 8, bit(7));
+    set(m, 7, 8, bit(8));
+    for (let i = 9; i < 15; i++) set(m, 14 - i, 8, bit(i));
+    for (let i = 0; i < 8; i++) set(m, size - 1 - i, 8, bit(i));
+    for (let i = 8; i < 15; i++) set(m, 8, size - 15 + i, bit(i));
+    set(m, 8, size - 8, true);
+  };
+  drawFormat(base, 0); // reserves the format areas before the data goes in
+
+  const data = codewords(bytes, version);
+  let bitIndex = 0;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let vert = 0; vert < size; vert++) {
+      for (let j = 0; j < 2; j++) {
+        const x = right - j;
+        const upward = ((right + 1) & 2) === 0;
+        const y = upward ? size - 1 - vert : vert;
+        if (fn[y][x]) continue;
+        if (bitIndex < data.length * 8) base[y][x] = ((data[bitIndex >>> 3] >>> (7 - (bitIndex & 7))) & 1) === 1;
+        bitIndex++;
+      }
+    }
+  }
+
+  let best = null;
+  for (let mask = 0; mask < 8; mask++) {
+    if (forcedMask !== undefined && mask !== forcedMask) continue;
+    const m = base.map((row, y) => row.map((v, x) => (fn[y][x] ? v : v !== MASKS[mask](x, y))));
+    drawFormat(m, mask);
+    const score = forcedMask !== undefined ? 0 : penalty(m);
+    if (!best || score < best.score) best = { m, score };
+  }
+  return best.m;
+}
+
+// The QR code as terminal lines, two rows of modules per line. With colors it is drawn black on white whatever the
+// terminal's theme; without, it assumes a dark background (light modules are the drawn ones). Null when too long.
+export function qrLines(text, { color = true, quiet = 2 } = {}) {
+  const m = qrMatrix(text);
+  if (!m) return null;
+  const n = m.length + quiet * 2;
+  const dark = (x, y) => {
+    const mx = x - quiet;
+    const my = y - quiet;
+    return mx >= 0 && my >= 0 && mx < m.length && my < m.length && m[my][mx];
+  };
+  const lines = [];
+  for (let y = 0; y < n; y += 2) {
+    let line = '';
+    let last = null;
+    for (let x = 0; x < n; x++) {
+      const top = dark(x, y);
+      const bottom = y + 1 < n && dark(x, y + 1);
+      if (color) {
+        const sgr = `\x1b[${top ? 30 : 97};${bottom ? 40 : 107}m`;
+        if (sgr !== last) { line += sgr; last = sgr; }
+        line += '▀';
+      } else {
+        line += !top && !bottom ? '█' : !top ? '▀' : !bottom ? '▄' : ' ';
+      }
+    }
+    lines.push(color ? `${line}\x1b[0m` : line);
+  }
+  return lines;
+}