clay-server 5.2.1-beta.2 → 5.3.0-beta.2

package/lib/public/modules/split-view-worker-activity.js

@@ -0,0 +1,94 @@
+import { clayToolDefinition } from './clay-tool-presentation.js';
+
+// These are recorded events, not live tool controllers or authority receipts.
+export function workerActivityNames(messages) {
+  var names = Object.create(null), ambiguous = Object.create(null);
+  messages.forEach(function (message) {
+    if (!message.toolId || (message.recordType !== 'tool_start' && message.recordType !== 'tool_use')) return;
+    if (names[message.toolId] && names[message.toolId].index !== message.recordIndex) ambiguous[message.toolId] = true;
+    names[message.toolId] = { index: message.recordIndex, name: message.toolName };
+  });
+  Object.keys(ambiguous).forEach(function (id) { delete names[id]; });
+  return names;
+}
+export function workerActivityLabel(message, names) {
+  var match = message.toolId && names[message.toolId];
+  var name = message.toolName || match && match.name;
+  var definition = clayToolDefinition(name);
+  var generic = { Read: 'Read file', read_file: 'Read file', Edit: 'Edit file', Write: 'Write file',
+    Bash: 'Run command', exec_command: 'Run command', Grep: 'Search files', Glob: 'Find files',
+    WebSearch: 'Search the web', WebFetch: 'Read web page' };
+  return definition ? definition.noun : (Object.prototype.hasOwnProperty.call(generic, name) ? generic[name] : null) || (typeof name === 'string' ? name.slice(0, 120) : 'Tool activity');
+}
+function workerActivityActionIcon(message, names) {
+  var match = message.toolId && names[message.toolId];
+  var name = message.toolName || match && match.name;
+  var definition = clayToolDefinition(name);
+  if (definition && typeof definition.icon === 'string' && definition.icon) return definition.icon;
+  var generic = { Read: 'file-text', read_file: 'file-text', Edit: 'pencil', Write: 'file-plus-2',
+    Bash: 'square-terminal', exec_command: 'square-terminal', Grep: 'search', Glob: 'search', WebSearch: 'globe', WebFetch: 'globe' };
+  return Object.prototype.hasOwnProperty.call(generic, name) ? generic[name] : null;
+}
+export function appendWorkerActivity(body, messages, names) {
+  var group = document.createElement('section'); group.className = 'worker-activity-group';
+  var key = String(messages[messages.length - 1].recordIndex);
+  group.dataset.activityKey = key;
+  var toggle = document.createElement('button'); toggle.type = 'button'; toggle.className = 'worker-activity-summary';
+  toggle.dataset.disclosureKey = 'activity-' + key;
+  var activityIcon = document.createElement('i'); activityIcon.setAttribute('data-lucide', 'activity'); activityIcon.setAttribute('aria-hidden', 'true');
+  var heading = document.createElement('span'); heading.className = 'worker-activity-heading'; heading.textContent = 'Activity';
+  var count = document.createElement('span'); count.className = 'worker-activity-count'; count.textContent = messages.length + (messages.length === 1 ? ' recorded step' : ' recorded steps');
+  var chevron = document.createElement('i'); chevron.className = 'worker-activity-chevron';
+  chevron.setAttribute('data-lucide', 'chevron-down'); chevron.setAttribute('aria-hidden', 'true');
+  toggle.append(activityIcon, heading, count, chevron);
+  toggle.setAttribute('aria-expanded', 'false'); toggle.disabled = messages.length <= 2;
+  var list = document.createElement('div'); list.className = 'worker-activity-list';
+  var items = [];
+  messages.forEach(function (message) {
+    var item = document.createElement('article'); item.className = 'worker-activity-item worker-tool-message';
+    item.dataset.recordIndex = String(message.recordIndex);
+    var phase = message.isError ? 'failed' : message.recordType === 'tool_result' ? 'returned' : 'recorded';
+    item.dataset.phase = phase;
+    var row = document.createElement('div'); row.className = 'worker-activity-row';
+    var actionIcon = workerActivityActionIcon(message, names);
+    var statusIcon = phase === 'failed' ? 'circle-alert' : phase === 'returned' ? 'corner-down-left' : 'circle-dot';
+    var glyph = document.createElement('i'); glyph.className = actionIcon ? 'worker-activity-glyph' : 'worker-activity-glyph worker-activity-status'; glyph.setAttribute('aria-hidden', 'true');
+    glyph.setAttribute('data-lucide', actionIcon || statusIcon);
+    var label = document.createElement('span'); label.className = 'worker-activity-label'; label.textContent = workerActivityLabel(message, names);
+    var detail = document.createElement('span'); detail.className = 'worker-activity-detail';
+    detail.textContent = phase === 'failed' ? 'Failed' : phase === 'returned' ? 'Result returned' : 'Call recorded';
+    row.append(glyph, label, detail);
+    if (actionIcon) {
+      var status = document.createElement('i'); status.className = 'worker-activity-status';
+      status.setAttribute('data-lucide', statusIcon); status.setAttribute('aria-hidden', 'true'); row.appendChild(status);
+    }
+    var evidence = document.createElement('details'); evidence.className = 'worker-activity-evidence'; evidence.dataset.disclosureKey = 'record-' + message.recordIndex;
+    var summary = document.createElement('summary'); summary.textContent = 'Technical details';
+    var output = document.createElement('pre'); output.textContent = message.text;
+    evidence.append(summary, output); item.append(row, evidence); items.push(item); list.appendChild(item);
+  });
+  function expand(open) {
+    toggle.setAttribute('aria-expanded', String(open));
+    items.forEach(function (item, index) { item.hidden = !open && index < items.length - 2; item.inert = item.hidden; });
+  }
+  toggle.addEventListener('click', function () { expand(toggle.getAttribute('aria-expanded') !== 'true'); });
+  expand(false); group.append(toggle, list); body.appendChild(group);
+}
+export function captureWorkerDisclosures(body) {
+  return {
+    open: Array.from(body.querySelectorAll('details[open]')).map(function (node) { return node.dataset.disclosureKey; }),
+    groups: Array.from(body.querySelectorAll('.worker-activity-summary[aria-expanded="true"]')).map(function (node) { return node.dataset.disclosureKey; }),
+    focus: document.activeElement && body.contains(document.activeElement) && (document.activeElement.dataset.disclosureKey || document.activeElement.parentElement && document.activeElement.parentElement.dataset.disclosureKey)
+  };
+}
+export function restoreWorkerDisclosures(body, saved) {
+  Array.from(body.querySelectorAll('[data-disclosure-key]')).forEach(function (node) {
+    var key = node.dataset.disclosureKey;
+    if (saved.groups.indexOf(key) >= 0 && node.getAttribute('aria-expanded') === 'false') node.click();
+    if (saved.open.indexOf(key) >= 0) node.open = true;
+    if (saved.focus === key) {
+      var target = node.tagName === 'DETAILS' ? node.querySelector('summary') : node;
+      if (target) target.focus({ preventScroll: true });
+    }
+  });
+}

package/lib/public/modules/split-view-worker-controls.js

@@ -0,0 +1,30 @@
+import { store } from './store.js';
+import { livePaneBinding } from './pane-binding.js';
+import { getCachedSessions } from './sidebar-sessions.js';
+import { showToast } from './utils.js';
+import { splitGroupRoles } from './split-group-helpers.js';
+
+export function initSplitViewWorkerControls(openGroup) {
+  document.addEventListener('clay-split-view-open-worker-controls', function (event) {
+    var detail = event.detail || {}, state = store.snap(), sessions = getCachedSessions() || [];
+    var driver = sessions.find(function (session) { return session.sessionOriginId === detail.driverOriginId && session.id === detail.driverId && session.sessionRole === 'driver'; });
+    var view = (state.projectSplitViews || []).find(function (item) { return item.id === state.projectSplitViewActiveId; });
+    var singleton = !view && state.projectSplitViewSingletonOrigin === detail.driverOriginId;
+    var frame = document.querySelector('.split-pane[data-session-origin="' + CSS.escape(String(detail.driverOriginId || '')) + '"] .split-pane-frame');
+    var live = frame && frame.clayPane && frame.clayPane.identity();
+    var group = (state.splitGroups || []).find(function (item) { return String(item.id) === String(detail.groupId); });
+    var roles = splitGroupRoles(group);
+    if (!driver || !(singleton || view && view.sessions.some(function (session) { return session.id === driver.id && session.sessionOriginId === driver.sessionOriginId; })) ||
+        detail.projectSlug !== state.currentSlug || state.splitGroupsProjectSlug !== state.currentSlug ||
+        detail.ownerId !== (state.myUserId || null) || (driver.ownerId || null) !== (state.myUserId || null) || !frame || frame.dataset.projectSlug !== state.currentSlug ||
+        !live || !live.ready || !livePaneBinding(frame) || live.sessionId !== driver.id || live.binding.sessionOriginId !== driver.sessionOriginId ||
+        !roles || roles.version !== 2 || roles.driverId !== driver.id || !Array.isArray(detail.workerOrigins) ||
+        detail.workerOrigins.length !== group.members.length) return;
+    for (var i = 0; i < roles.workerIds.length; i++) {
+      var worker = sessions.find(function (session) { return session.id === roles.workerIds[i]; });
+      if (!worker || worker.sessionRole !== 'worker' || worker.parentSessionId !== driver.id || worker.parentAvailable !== true ||
+          (worker.ownerId || null) !== (driver.ownerId || null) || detail.workerOrigins.indexOf(worker.sessionOriginId) === -1) return;
+    }
+    if (!openGroup(group)) showToast('Worker controls could not be opened. The Split view remains open.', 'warn');
+  });
+}

package/lib/public/modules/split-view-worker-removal.js

@@ -0,0 +1,137 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { getCachedSessions } from './sidebar-sessions.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { showConfirm, hideConfirm } from './app-misc.js';
+import { showToast } from './utils.js';
+import { spawnDustParticles } from './sidebar.js';
+import { workerRemovalTarget } from './split-view-workers.js';
+
+// Runtime resources belong to this module; the store contains only removal data.
+var removalResources = null;
+
+function state() { return store.get('splitViewWorkerRemoval'); }
+function same(left, right) { return !!left && !!right && JSON.stringify(left) === JSON.stringify(right); }
+function live(record) {
+  return record && removalResources && getWs() === removalResources.socket && same(record.target, workerRemovalTarget(removalResources.container, record.target.driverOriginId, record.target.workerOriginId, record.target.generation));
+}
+function paint(button, phase) {
+  button.classList.toggle('armed', phase === 'armed');
+  button.classList.toggle('pending', phase === 'pending' || phase === 'confirming');
+  button.disabled = phase === 'pending' || phase === 'confirming';
+  button.setAttribute('aria-label', phase === 'armed' ? 'Confirm Worker removal' : phase === 'pending' ? 'Removing Worker' : 'Remove Worker session');
+  button.setAttribute('aria-pressed', String(phase === 'armed'));
+  button.innerHTML = iconHtml(phase === 'armed' ? 'check' : 'x'); refreshIcons();
+}
+function send(record, action, token, resources) {
+  resources = resources || removalResources;
+  if (!resources || !resources.socket || resources.socket.readyState !== 1) return false;
+  resources.socket.send(JSON.stringify(Object.assign({}, record.target, { type: 'split_worker_remove', requestId: record.requestId, action: action, token: token || null })));
+  return true;
+}
+function clear(cancel, focus) {
+  var record = state(); if (!record) return;
+  var resources = removalResources;
+  removalResources = null;
+  store.set({ splitViewWorkerRemoval: null });
+  if (resources && resources.timer) clearTimeout(resources.timer);
+  if (cancel && record.requestId) send(record, 'cancel', null, resources);
+  if (record.phase === 'confirming') hideConfirm();
+  if (resources && resources.button.isConnected) { paint(resources.button, 'idle'); if (focus) resources.button.focus(); }
+}
+function request(record, token) {
+  if (!live(record)) { clear(true, false); return; }
+  var next = Object.assign({}, record, { phase: 'pending' });
+  if (removalResources.timer) clearTimeout(removalResources.timer);
+  removalResources.timer = setTimeout(function () {
+    if (!state() || state().requestId !== next.requestId || state().phase !== 'pending') return;
+    clear(true, true); showToast('Worker removal outcome is unknown. Check the session before trying again.', 'error');
+  }, 10000);
+  store.set({ splitViewWorkerRemoval: next }); paint(removalResources.button, 'pending');
+  try { if (!send(next, token ? 'confirm' : 'request', token)) throw new Error('Connection lost.'); }
+  catch (error) { clear(true, true); showToast('Worker removal could not be sent.', 'error'); }
+}
+export function reconcileWorkerRemoval(container) {
+  var record = state(); if (!record || !removalResources || removalResources.container !== container) return;
+  var frame = container.querySelector('.split-pane-frame');
+  var stillListed = (getCachedSessions() || []).some(function (session) { return session.sessionOriginId === record.target.workerOriginId; });
+  if (!live(record) && (record.phase !== 'pending' || stillListed) || container.hidden || container.inert || !container.isConnected || frame && (frame.hidden || frame.inert)) clear(true, false);
+}
+export function appendWorkerRemoval(pill, button, container, driver, worker) {
+  var remove = document.createElement('button'); remove.type = 'button'; remove.className = 'split-view-worker-remove';
+  remove.dataset.workerOrigin = worker.sessionOriginId; remove.dataset.workerGeneration = String(worker.workerGeneration);
+  paint(remove, 'idle'); pill.appendChild(remove);
+  var target = workerRemovalTarget(container, driver.sessionOriginId, worker.sessionOriginId, worker.workerGeneration);
+  remove.disabled = !target;
+  var existing = state();
+  if (existing && same(existing.target, target)) {
+    removalResources.button = remove; removalResources.container = container;
+    paint(remove, existing.phase);
+  }
+  remove.addEventListener('click', function (event) {
+    event.preventDefault(); event.stopPropagation();
+    var current = workerRemovalTarget(container, driver.sessionOriginId, worker.sessionOriginId, worker.workerGeneration);
+    if (!remove.isConnected || remove.disabled || !same(current, target)) { clear(true, false); return; }
+    var previous = state();
+    if (previous && same(previous.target, target) && previous.phase === 'armed') {
+      var rect = pill.getBoundingClientRect();
+      var record = Object.assign({}, previous, { requestId: 'remove_' + crypto.randomUUID().replace(/-/g, ''),
+        center: { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 } });
+      request(record); return;
+    }
+    clear(true, false);
+    removalResources = { socket: getWs(), container: container, button: remove, timer: null };
+    store.set({ splitViewWorkerRemoval: { phase: 'armed', target: target } });
+    paint(remove, 'armed');
+  });
+}
+export function handleWorkerRemovalResult(msg) {
+  var record = state();
+  if (!record || !removalResources || record.requestId !== msg.requestId || record.target.workerOriginId !== msg.workerOriginId ||
+      record.target.generation !== msg.generation || record.target.projectSlug !== msg.projectSlug || getWs() !== removalResources.socket) return;
+  if (msg.status === 'removed') {
+    var container = removalResources.container, center = record.center;
+    var visible = store.get('connected') && store.get('currentSlug') === record.target.projectSlug &&
+      (store.get('myUserId') || null) === record.target.ownerId && container.isConnected && !container.hidden && !container.inert;
+    clear(false, false);
+    if (visible) {
+      spawnDustParticles(center.x, center.y, { containerClass: 'worker-removal-particles' });
+      var focus = container.querySelector('.split-view-worker-chip') || container.querySelector('.split-pane-info');
+      if (focus) focus.focus();
+    }
+    return;
+  }
+  if (!live(record)) { clear(true, false); return; }
+  if (msg.status === 'confirmation_required' && record.phase === 'pending' && msg.token) {
+    clearTimeout(removalResources.timer); removalResources.timer = null;
+    var next = Object.assign({}, record, { phase: 'confirming' });
+    store.set({ splitViewWorkerRemoval: next }); paint(removalResources.button, 'confirming');
+    showConfirm('Stop and remove Worker? This deletes Split Worker #' + record.target.workerId + ' and its conversation.', function () {
+      if (state() && state().requestId === next.requestId) request(state(), msg.token);
+    }, 'Stop and remove Worker', true, function () { if (state() && state().phase === 'confirming') clear(true, true); });
+    var ok = document.getElementById('confirm-ok'); if (ok) ok.focus();
+    return;
+  }
+  clear(false, true); showToast(msg.error || 'Worker removal was not completed.', 'error');
+}
+document.addEventListener('keydown', function (event) {
+  if (event.key === 'Escape' && state()) { event.preventDefault(); event.stopImmediatePropagation(); clear(true, true); }
+}, true);
+document.addEventListener('click', function (event) {
+  var record = state(); if (!record || record.phase !== 'armed') return;
+  if (removalResources && (event.target === removalResources.button || removalResources.button.contains(event.target))) return;
+  clear(true, false);
+}, true);
+store.subscribe(function (next, previous) {
+  var record = state(); if (!record) return;
+  if (next.connected !== previous.connected || next.currentSlug !== previous.currentSlug || next.myUserId !== previous.myUserId ||
+      next.projectSplitViewRevision !== previous.projectSplitViewRevision || next.projectSplitViewActiveId !== previous.projectSplitViewActiveId ||
+      next.projectSplitViewSocketGeneration !== previous.projectSplitViewSocketGeneration ||
+      next.projectSplitViewFocusedOrigin !== previous.projectSplitViewFocusedOrigin) { clear(true, false); return; }
+  if (next.paneBindingSessions !== previous.paneBindingSessions && !live(record)) {
+    // Deletion broadcasts may precede their receipt. Retain only that pending
+    // receipt; absence from the list alone never claims removal or animates it.
+    var stillListed = (getCachedSessions() || []).some(function (session) { return session.sessionOriginId === record.target.workerOriginId; });
+    if (record.phase !== 'pending' || stillListed) clear(true, false);
+  }
+});

package/lib/public/modules/split-view-worker-scroll.js

@@ -0,0 +1,57 @@
+// Read-only transcript paging and viewport anchors. Request state lives in store.
+export function workerCursorKey(cursor) {
+  if (cursor == null) return 'latest';
+  if (Number.isInteger(cursor) && cursor >= 0) return String(cursor);
+  return cursor && Number.isInteger(cursor.index) && cursor.index >= 0 && Number.isInteger(cursor.offset) && cursor.offset >= 0 ? cursor.index + ':' + cursor.offset : null;
+}
+export function workerCursorAdvances(before, next) {
+  if (!next || workerCursorKey(next) === null) return false;
+  if (before == null) return true;
+  if (Number.isInteger(before)) return next.index < before;
+  return next.index < before.index || next.index === before.index && next.offset < before.offset;
+}
+export function shouldLoadWorkerPage(state, body, intentional) {
+  if (!state || !body || state.inFlight || !state.hasMore || state.nextBefore == null || !workerCursorKey(state.nextBefore)) return false;
+  if (state.status === 'error' && !intentional) return false;
+  if (state.status !== 'ready' && state.status !== 'error') return false;
+  return intentional ? body.scrollTop <= 96 : body.clientHeight > 0 && body.scrollHeight <= body.clientHeight + 1;
+}
+export function captureWorkerAnchor(body) {
+  var top = body.getBoundingClientRect().top;
+  var article = Array.from(body.querySelectorAll('article[data-record-index]')).find(function (item) { return !item.hidden && item.getBoundingClientRect().bottom > top; });
+  if (!article) return { scrollTop: body.scrollTop, height: body.scrollHeight };
+  var anchor = { index: article.dataset.recordIndex, bottom: article.getBoundingClientRect().bottom - top,
+    scrollTop: body.scrollTop, height: body.scrollHeight };
+  var content = article.querySelector('.message-body') || article.querySelector('pre');
+  var rect = body.getBoundingClientRect();
+  var range = document.caretRangeFromPoint && document.caretRangeFromPoint(rect.left + Math.min(45, rect.width / 2), top + 16);
+  if (range && content && content.contains(range.startContainer) && range.startContainer.nodeType === 3) {
+    var prefix = document.createRange(); prefix.selectNodeContents(content); prefix.setEnd(range.startContainer, range.startOffset);
+    var offset = prefix.toString().length, text = content.textContent;
+    var start = Math.max(0, offset - 24), end = Math.min(text.length, offset + 48);
+    anchor.text = text.slice(start, end); anchor.offset = offset - start;
+    var character = range.cloneRange(); character.setEnd(range.startContainer, Math.min(range.startOffset + 1, range.startContainer.length));
+    anchor.y = character.getBoundingClientRect().top - top;
+  }
+  return anchor;
+}
+export function restoreWorkerAnchor(body, anchor) {
+  if (!anchor) return;
+  var article = Array.from(body.querySelectorAll('article[data-record-index]')).find(function (item) { return item.dataset.recordIndex === anchor.index; });
+  if (!article) { body.scrollTop = anchor.scrollTop + body.scrollHeight - anchor.height; return; }
+  var content = article.querySelector('.message-body') || article.querySelector('pre');
+  var at = content && anchor.text ? content.textContent.lastIndexOf(anchor.text) : -1;
+  if (at >= 0 && document.createTreeWalker) {
+    var walker = document.createTreeWalker(content, 4), node, offset = at + anchor.offset;
+    while ((node = walker.nextNode())) {
+      if (offset < node.length) {
+        var range = document.createRange(); range.setStart(node, offset); range.setEnd(node, Math.min(offset + 1, node.length));
+        body.scrollTop += range.getBoundingClientRect().top - body.getBoundingClientRect().top - anchor.y;
+        return;
+      }
+      offset -= node.length;
+    }
+  }
+  // The last record key remains stable when earlier streaming fragments merge.
+  body.scrollTop += article.getBoundingClientRect().bottom - body.getBoundingClientRect().top - anchor.bottom;
+}

package/lib/public/modules/split-view-worker-transcript.js

@@ -0,0 +1,46 @@
+import { appendWorkerActivity, workerActivityNames } from './split-view-worker-activity.js';
+import { renderMarkdown } from './markdown.js';
+
+// Reassemble bounded record fragments and contiguous streaming deltas before
+// parsing Markdown, including fences and lists that cross a page boundary.
+export function workerTranscriptRows(messages) {
+  var rows = [];
+  (messages || []).forEach(function (message) {
+    if (!message || typeof message.text !== 'string' || ['user', 'assistant', 'tool'].indexOf(message.role) < 0) return;
+    var last = rows[rows.length - 1];
+    var fragment = last && Number.isInteger(message.recordIndex) && last.recordIndex === message.recordIndex && last.end === message.start;
+    var delta = last && message.recordType === 'delta' && last.recordType === 'delta' && message.start === 0 && message.recordIndex === last.recordIndex + 1;
+    if (last && last.role === message.role && (fragment || delta)) {
+      last.text += message.text; last.end = message.end; last.recordIndex = message.recordIndex;
+    } else rows.push(Object.assign({}, message));
+  });
+  return rows;
+}
+
+export function appendWorkerMessage(body, message) {
+  if (message.role === 'tool') { appendWorkerActivity(body, [message], workerActivityNames([message])); return; }
+  var article = document.createElement('article');
+  article.className = 'message worker-readonly-message ' + (message.role === 'user' ? 'msg-user' : 'msg-assistant');
+  if (Number.isInteger(message.recordIndex)) article.dataset.recordIndex = String(message.recordIndex);
+  var author = document.createElement('strong'); author.className = 'author';
+  author.textContent = message.role === 'user' ? 'You' : 'Worker';
+  var content = document.createElement('div'); content.className = 'message-body md-content';
+  // Recorded HTML must not create controls, scoped overlays or active embeds.
+  // Keep the shared Markdown parser and its sanitization, with a narrower
+  // read-only prose vocabulary for this secondary history surface.
+  content.innerHTML = DOMPurify.sanitize(renderMarkdown(message.text), {
+    ALLOWED_TAGS: ['p', 'br', 'strong', 'em', 'del', 's', 'blockquote', 'ul', 'ol', 'li', 'pre', 'code', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'a', 'wbr'],
+    ALLOWED_ATTR: ['href', 'title', 'target', 'rel', 'start'], ALLOW_DATA_ATTR: false
+  });
+  article.append(author, content); body.appendChild(article);
+}
+
+export function appendWorkerTranscript(body, messages) {
+  var rows = workerTranscriptRows(messages), names = workerActivityNames(rows), pending = [];
+  function flush() { if (pending.length) appendWorkerActivity(body, pending, names); pending = []; }
+  rows.forEach(function (message) {
+    if (message.role === 'tool') pending.push(message);
+    else { flush(); appendWorkerMessage(body, message); }
+  });
+  flush();
+}