openzoo 0.50.37 → 0.50.39

package/lib/grokbotAccount.js

@@ -1,10 +1,15 @@
 /**
- * Grok Bot tray/roster is per Cursor account, not per Mac.
+ * Grok Bot tray/roster.
  *
- * A second login on the same hijack was served ~/.openzoo/grokbot-agents.json
- * (or an empty stub) because pod + roster were machine-global. Historical
- * chats live on that account's cursorvm 1340 — never another account's cache.
+ * Electron hijack: a second Cursor login on the same Mac must not inherit the
+ * previous account's 1340 / tray (rosterForAccount still isolates that).
+ *
+ * Cafe/web: every visitor is a cookie identity on ONE house. They share the
+ * operator tray at ~/.openzoo/grokbot-agents.json plus any account agents.json
+ * under ~/.openzoo/grokbot/<id>/ -- not per-browser localStorage, not empty
+ * just because no Cursor account has logged in.
  */
+import fs from 'node:fs';
 import path from 'node:path';
 
 export function accountSlug(accountId) {
@@ -28,13 +33,134 @@ export function accountAgentsPath(home, accountId) {
   return dir ? path.join(dir, 'agents.json') : null;
 }
 
-/** Only serve a cached tray when it belongs to the live EnsureSandBox account. */
-export function rosterForAccount({ liveAccountId, cachedAccountId, cached }) {
-  if (!liveAccountId || !cachedAccountId) return [];
-  if (liveAccountId !== cachedAccountId) return [];
+export function houseAgentsPath(home) {
+  return path.join(home, '.openzoo', 'grokbot-agents.json');
+}
+
+function readJsonFile(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+/** First-seen id wins. Account file, then house file, then other account dirs. */
+export function mergeAgentRecords(piles) {
+  const seen = new Set();
+  const out = [];
+  for (const pile of piles) {
+    if (!Array.isArray(pile)) continue;
+    for (const a of pile) {
+      if (!a?.id || seen.has(a.id)) continue;
+      seen.add(a.id);
+      out.push(a);
+    }
+  }
+  return out;
+}
+
+/**
+ * Shared house tray from disk. Cafe visitors have no Cursor account — they
+ * still get this list. A live account's file is preferred, never required.
+ */
+export function readHouseRoster(home, liveAccountId) {
+  const piles = [];
+  const livePath = liveAccountId ? accountAgentsPath(home, liveAccountId) : null;
+  if (livePath) {
+    const scoped = readJsonFile(livePath);
+    if (Array.isArray(scoped)) piles.push(scoped);
+  }
+  const global = readJsonFile(houseAgentsPath(home));
+  if (Array.isArray(global)) piles.push(global);
+  try {
+    const dir = path.join(home, '.openzoo', 'grokbot');
+    for (const name of fs.readdirSync(dir)) {
+      const p = path.join(dir, name, 'agents.json');
+      if (livePath && p === livePath) continue;
+      const a = readJsonFile(p);
+      if (Array.isArray(a) && a.length) piles.push(a);
+    }
+  } catch { /* no grokbot dir yet */ }
+  return mergeAgentRecords(piles);
+}
+
+/**
+ * Isolate two Cursor logins. Cafe (no live account) gets the house fallback.
+ * `fallback` is the merged disk roster; never return [] just because oauth
+ * hasn't run — that emptied the public site's sidebar.
+ */
+export function rosterForAccount({ liveAccountId, cachedAccountId, cached, fallback }) {
+  if (liveAccountId && cachedAccountId && liveAccountId !== cachedAccountId) return [];
+  if (liveAccountId && cachedAccountId && liveAccountId === cachedAccountId) {
+    return Array.isArray(cached) ? cached : [];
+  }
+  if (Array.isArray(fallback) && fallback.length) return fallback;
   return Array.isArray(cached) ? cached : [];
 }
 
+function activityRec(agent, activity) {
+  if (!activity || !agent?.id) return null;
+  if (typeof activity.get === 'function') return activity.get(agent.id) || null;
+  return activity[agent.id] || null;
+}
+
+function activityTs(agent, activity) {
+  const rec = activityRec(agent, activity);
+  return (rec && rec.updatedAt) || agent.updatedAt || agent.createdAt || 0;
+}
+
+/**
+ * Grok Bot client persistence (Xkn) DROPS any row missing these booleans /
+ * nulls, then clears the whole persisted tray. That is how a group vanished
+ * after the first send: bumpAgent wrote a partial row, restore returned null.
+ */
+export function shapeAgent(raw = {}) {
+  const a = raw && typeof raw === 'object' ? raw : {};
+  const id = String(a.id || '');
+  const memberIds = Array.isArray(a.memberIds)
+    ? a.memberIds.map((x) => String(x)).filter(Boolean)
+    : (Array.isArray(a.memberAgentIds) ? a.memberAgentIds.map((x) => String(x)).filter(Boolean) : []);
+  const isGroup = a.isGroup === true || memberIds.length > 0;
+  const name = String(a.name || a.title || (isGroup ? 'group' : 'chat'));
+  return {
+    id,
+    name,
+    description: String(a.description || ''),
+    title: String(a.title || name),
+    origin: String(a.origin || 'user'),
+    path: String(a.path || (id ? `/local/${id}` : '/local')),
+    createdAt: Number(a.createdAt) || Date.now(),
+    updatedAt: Number(a.updatedAt) || Date.now(),
+    hasUnread: !!a.hasUnread,
+    unreadCount: Number(a.unreadCount) || 0,
+    notificationsEnabled: a.notificationsEnabled !== false,
+    notifyOnUpdatesEnabled: a.notifyOnUpdatesEnabled !== false,
+    isGroup,
+    memberIds: isGroup ? memberIds : [],
+    lastMessageId: a.lastMessageId == null ? null : String(a.lastMessageId),
+    lastEntry: a.lastEntry && typeof a.lastEntry === 'object' ? a.lastEntry : null,
+    awaitingUserResponse: a.awaitingUserResponse && typeof a.awaitingUserResponse === 'object'
+      ? a.awaitingUserResponse : null,
+    avatarShape: a.avatarShape ?? null,
+    avatarColor: a.avatarColor ?? null,
+  };
+}
+
+/**
+ * Full sidebar roster for SSE `agents` / listAgents. Sorts by activity and
+ * stamps unread -- does not slice. The old 80-cap hid agents past the tray.
+ */
+export function rosterForEvent(list, activity) {
+  const arr = Array.isArray(list) ? [...list] : [];
+  arr.sort((x, y) => activityTs(y, activity) - activityTs(x, activity));
+  return arr.map((agent) => {
+    const rec = activityRec(agent, activity) || {};
+    return shapeAgent({
+      ...agent,
+      updatedAt: rec.updatedAt || agent.updatedAt || agent.createdAt || 0,
+      hasUnread: !!rec.hasUnread,
+      unreadCount: rec.unreadCount || 0,
+    });
+  });
+}
+
 export function callerKeyFromAuth(authorization) {
   const a = String(authorization || '').trim();
   if (!a) return '';

package/lib/grokbotUploads.js

@@ -0,0 +1,168 @@
+/**
+ * Grok Bot paste/upload store.
+ *
+ * Electron stages bytes on disk, then commitStagedAttachments POSTs
+ * /api/uploadAttachment {filename, bytesBase64} and requires `.path` on the
+ * reply. A stub `{ok:true}` made commit return null → send/attachment-commit-failed
+ * → i18n wx1EG9 ("Couldn't send your message. Check your connection").
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp|heic|svg)$/i;
+const IMAGE_MAGIC = [
+  [Buffer.from([0x89, 0x50, 0x4e, 0x47]), 'image/png'],
+  [Buffer.from([0xff, 0xd8, 0xff]), 'image/jpeg'],
+  [Buffer.from('GIF8'), 'image/gif'],
+  [Buffer.from([0x52, 0x49, 0x46, 0x46]), 'image/webp'],
+];
+const MIME_BY_EXT = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.heic': 'image/heic',
+  '.svg': 'image/svg+xml',
+};
+function maxBytes() {
+  return Number(process.env.OZ_GROKBOT_UPLOAD_MAX || 20 * 1024 * 1024);
+}
+
+const store = new Map();
+
+export function uploadDir() {
+  return process.env.OZ_GROKBOT_UPLOAD_DIR
+    || path.join(os.homedir(), '.openzoo', 'grokbot-uploads');
+}
+
+export function mimeFromBytes(buf, p = '') {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf || []);
+  if (IMAGE_EXT.test(p)) {
+    const ext = path.extname(p).toLowerCase();
+    if (MIME_BY_EXT[ext]) return MIME_BY_EXT[ext];
+  }
+  for (const [magic, mime] of IMAGE_MAGIC) {
+    if (b.length >= magic.length && b.subarray(0, magic.length).equals(magic)) {
+      if (mime === 'image/webp' && b.length >= 12 && b.subarray(8, 12).toString('ascii') !== 'WEBP') {
+        continue;
+      }
+      return mime;
+    }
+  }
+  return null;
+}
+
+function safeName(filename) {
+  const base = path.basename(String(filename || 'image.png')) || 'image.png';
+  const cleaned = base.replace(/[^\w.\-]+/g, '_').replace(/^\.+/, '') || 'image.png';
+  return cleaned.slice(0, 120);
+}
+
+function asBuffer({ bytes, bytesBase64 } = {}) {
+  if (Buffer.isBuffer(bytes)) return bytes;
+  if (bytes instanceof Uint8Array) return Buffer.from(bytes);
+  if (ArrayBuffer.isView(bytes)) {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  if (bytes instanceof ArrayBuffer) return Buffer.from(bytes);
+  if (typeof bytesBase64 === 'string' && bytesBase64.length) {
+    return Buffer.from(bytesBase64, 'base64');
+  }
+  return null;
+}
+
+function remember(rec) {
+  store.set(rec.path, rec);
+  store.set(rec.abs, rec);
+  store.set(path.basename(rec.abs), rec);
+  return rec;
+}
+
+export function ingestUpload(input = {}) {
+  const buf = asBuffer(input);
+  if (!buf || !buf.length) return { ok: false, reason: 'failed' };
+  if (buf.length > maxBytes()) return { ok: false, reason: 'too-large' };
+  const filename = safeName(input.filename);
+  const id = randomUUID();
+  const rel = `${id}-${filename}`;
+  const dir = uploadDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const abs = path.join(dir, rel);
+  fs.writeFileSync(abs, buf);
+  const storedPath = `/openzoo-uploads/${rel}`;
+  const mime = mimeFromBytes(buf, filename) || 'application/octet-stream';
+  const rec = remember({
+    path: storedPath,
+    abs,
+    filename,
+    mime,
+    buf,
+    bytes: buf.length,
+  });
+  return { ok: true, path: rec.path, abs: rec.abs, mime: rec.mime, filename: rec.filename, bytes: rec.bytes };
+}
+
+export function lookupUpload(p) {
+  const s = String(p || '');
+  if (!s) return null;
+  if (store.has(s)) return store.get(s);
+  const base = s.split(/[/\\]/).pop();
+  if (base && store.has(base)) return store.get(base);
+  try {
+    if ((s.startsWith('/') || /^[A-Za-z]:[\\/]/.test(s)) && fs.existsSync(s) && fs.statSync(s).isFile()) {
+      const buf = fs.readFileSync(s);
+      return {
+        path: s,
+        abs: s,
+        filename: path.basename(s),
+        mime: mimeFromBytes(buf, s) || 'application/octet-stream',
+        buf,
+        bytes: buf.length,
+      };
+    }
+  } catch { /* */ }
+  return null;
+}
+
+export function readUploadChunk({ path: p, offset = 0, length = 0 } = {}) {
+  const rec = lookupUpload(p);
+  if (!rec) return null;
+  const totalSize = rec.buf.length;
+  const off = Math.max(0, Number(offset) || 0);
+  const want = Number(length);
+  const end = !Number.isFinite(want) || want <= 0 ? off : Math.min(totalSize, off + want);
+  const slice = rec.buf.subarray(Math.min(off, totalSize), end);
+  return {
+    bytesBase64: slice.toString('base64'),
+    totalSize,
+    mime: rec.mime || null,
+  };
+}
+
+export function readUploadText(p) {
+  const rec = lookupUpload(p);
+  if (!rec) return null;
+  return { text: rec.buf.toString('utf8') };
+}
+
+export function readUploadImage(p) {
+  const rec = lookupUpload(p);
+  if (!rec) return null;
+  const mime = rec.mime && rec.mime.startsWith('image/') ? rec.mime : mimeFromBytes(rec.buf, rec.filename);
+  if (!mime || !mime.startsWith('image/')) return null;
+  return {
+    dataUrl: `data:${mime};base64,${rec.buf.toString('base64')}`,
+    mime,
+    width: null,
+    height: null,
+  };
+}
+
+/** Test helper — does not delete files on disk. */
+export function resetUploadStore() {
+  store.clear();
+}